Vendor import of less v481.
This commit is contained in:
parent
368ca3013f
commit
59d1fa4298
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/vendor/less/dist/; revision=293125 svn path=/vendor/less/v481/; revision=293126; tag=vendor/less/v481
2
LICENSE
2
LICENSE
@ -2,7 +2,7 @@
|
||||
------------
|
||||
|
||||
Less
|
||||
Copyright (C) 1984-2012 Mark Nudelman
|
||||
Copyright (C) 1984-2015 Mark Nudelman
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
|
25
Makefile.aut
25
Makefile.aut
@ -14,25 +14,29 @@ SRC = \
|
||||
help.c ifile.c input.c jump.c line.c linenum.c \
|
||||
lsystem.c mark.c optfunc.c option.c opttbl.c os.c \
|
||||
output.c pattern.c position.c prompt.c search.c signal.c \
|
||||
tags.c ttyin.c version.c
|
||||
tags.c ttyin.c version.c
|
||||
DISTFILES_W = \
|
||||
defines.ds Makefile.dsb Makefile.dsg Makefile.dsu \
|
||||
defines.o2 Makefile.o2e \
|
||||
defines.o9 Makefile.o9c Makefile.o9u \
|
||||
defines.wn Makefile.wnm Makefile.wnb
|
||||
defines.wn Makefile.wnm Makefile.wnb \
|
||||
configure
|
||||
UNICODE_FILES = \
|
||||
compose.uni ubin.uni wide.uni
|
||||
DISTFILES = \
|
||||
${SRC} regexp.c regexp.h \
|
||||
COPYING INSTALL LICENSE Makefile.in Makefile.aut NEWS README \
|
||||
configure configure.ac lesskey.c lessecho.c scrsize.c \
|
||||
configure.ac lesskey.c lessecho.c scrsize.c \
|
||||
charset.h cmd.h funcs.h lglob.h less.h lesskey.h option.h \
|
||||
pckeys.h pattern.h position.h \
|
||||
install.sh defines.h.in mkinstalldirs \
|
||||
less.nro less.man lesskey.nro lesskey.man lessecho.nro lessecho.man \
|
||||
less.hlp \
|
||||
mkfuncs.awk mkhelp.c \
|
||||
mkutable $(UNICODE_FILES) \
|
||||
${DISTFILES_W}
|
||||
|
||||
all: help.c funcs.h ${srcdir}/configure
|
||||
all: help.c funcs.h $(UNICODE_FILES) ${srcdir}/configure
|
||||
|
||||
release: .FORCE
|
||||
${MAKE} -f Makefile.aut tagall
|
||||
@ -46,7 +50,7 @@ help.c: less.hlp mkhelp
|
||||
-mv -f ${srcdir}/help.c ${srcdir}/help.c.old
|
||||
rm -rf help.c
|
||||
./mkhelp < less.hlp > help.c
|
||||
if cmp -s help.c help.c.old; then mv help.c.old help.c; fi
|
||||
if cmp -s help.c help.c.old; then mv -f help.c.old help.c; fi
|
||||
|
||||
mkhelp: mkhelp.c
|
||||
${CC} -o mkhelp mkhelp.c
|
||||
@ -58,7 +62,7 @@ ${srcdir}/configure: ${srcdir}/configure.ac \
|
||||
funcs.h: ${SRC:%=${srcdir}/%}
|
||||
-mv -f ${srcdir}/funcs.h ${srcdir}/funcs.h.old
|
||||
awk -f ${srcdir}/mkfuncs.awk ${SRC:%=${srcdir}/%} >${srcdir}/funcs.h
|
||||
if cmp -s funcs.h funcs.h.old; then mv funcs.h.old funcs.h; fi
|
||||
if cmp -s funcs.h funcs.h.old; then mv -f funcs.h.old funcs.h; fi
|
||||
|
||||
lint:
|
||||
lint -I. ${CPPFLAGS} ${SRC}
|
||||
@ -75,6 +79,7 @@ REPLACE_VERSION = \
|
||||
@REL=`sed -e '/char version/!d' -e 's/[^0-9.]*\([0-9.]*\).*/\1/' -e q ${srcdir}/version.c`; \
|
||||
DT=`date '+%d %h %Y'`; \
|
||||
echo "Stuffing version number $$REL into $@"; \
|
||||
rm -f $@; \
|
||||
sed \
|
||||
-e "s;@@VERSION@@;$$REL;" \
|
||||
-e "s;@@DATE@@;$$DT;" \
|
||||
@ -101,6 +106,12 @@ ${srcdir}/lesskey.man: ${srcdir}/lesskey.nro
|
||||
${srcdir}/lessecho.man: ${srcdir}/lessecho.nro
|
||||
${NROFF} ${srcdir}/lessecho.nro >${srcdir}/lessecho.man
|
||||
|
||||
compose.uni: unicode/UnicodeData.txt
|
||||
./mkutable -f2 Mn Me -- unicode/UnicodeData.txt > $@
|
||||
ubin.uni: unicode/UnicodeData.txt
|
||||
./mkutable -f2 Cc Cf Cs Co Zl Zp -- unicode/UnicodeData.txt > $@
|
||||
wide.uni: unicode/EastAsianWidth.txt
|
||||
./mkutable -f1 W -- unicode/EastAsianWidth.txt > $@
|
||||
|
||||
distfiles: ${DISTFILES}
|
||||
|
||||
@ -114,7 +125,7 @@ dist: ${DISTFILES}
|
||||
for file in ${DISTFILES}; do \
|
||||
./add_copyright $$file $$REL; \
|
||||
done; \
|
||||
cd $$REL; chmod +w ${DISTFILES_W}; cd ..; \
|
||||
cd $$REL; chmod -w *; chmod +w ${DISTFILES_W}; chmod +x configure; cd ..; \
|
||||
echo "Creating release/$$REL/$$REL.tar.gz"; \
|
||||
tar -cf - $$REL | gzip -c >release/$$REL/$$REL.tar.gz; \
|
||||
echo "Signing release/$$REL/$$REL.tar.gz"; \
|
||||
|
@ -6,7 +6,7 @@
|
||||
CC = cl
|
||||
|
||||
# Normal flags
|
||||
CFLAGS = /nologo /ML /W3 /GX /O2 /I "." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /c
|
||||
CFLAGS = /nologo /MD /W3 /EHsc /O2 /I "." /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /c
|
||||
LDFLAGS = /nologo /subsystem:console /incremental:no /machine:I386
|
||||
|
||||
# Debugging flags
|
||||
|
39
NEWS
39
NEWS
@ -7,7 +7,44 @@
|
||||
http://www.greenwoodsoftware.com/less
|
||||
You can also download the latest version of less from there.
|
||||
|
||||
To report bugs, suggestions or comments, send email to bug-less@gnu.org.
|
||||
To report bugs, suggestions or comments, send email to bug-less@gnu.org
|
||||
|
||||
======================================================================
|
||||
|
||||
Major changes between "less" versions 458 and 481
|
||||
|
||||
* Don't overwrite history file; just append to it.
|
||||
|
||||
* New command ESC-G goes to end of currently buffered data in a pipe.
|
||||
|
||||
* Disable history feature when compiled with LESSHISTFILE set to "-".
|
||||
|
||||
* In more-compatible mode, make the -p option apply to every file opened,
|
||||
not just the first one.
|
||||
|
||||
* In more-compatible mode, change the -e option to work like -E, not -EF.
|
||||
|
||||
* Treat multiple CRs before LF are like one CR (all the CRs are hidden).
|
||||
|
||||
* Allow "extra" string in lesskey file to append to a multi-char command
|
||||
(like a search pattern), without executing the command.
|
||||
|
||||
* Ignore -u/-U setting while viewing help file, so that
|
||||
underline and bold chars are displayed correctly.
|
||||
|
||||
* Improve detection of "binary" files in UTF-8 mode.
|
||||
|
||||
* Fix bug with ++ commands.
|
||||
|
||||
* Fix bug where prompt was sometimes not displayed with +G.
|
||||
|
||||
* Fix possible memory corruption
|
||||
|
||||
* Fix bugs and improve performance in ampersand filtering.
|
||||
|
||||
* Automate construction of Unicode tables from Unicode database.
|
||||
|
||||
* Allow %% escape sequence in LESSOPEN variable.
|
||||
|
||||
======================================================================
|
||||
|
||||
|
7
README
7
README
@ -1,7 +1,7 @@
|
||||
|
||||
Less, version 458
|
||||
Less, version 481
|
||||
|
||||
This is the distribution of less, version 458, released 04 Apr 2013.
|
||||
This is the distribution of less, version 481, released 31 Aug 2015.
|
||||
This program is part of the GNU project (http://www.gnu.org).
|
||||
|
||||
This program is free software. You may redistribute it and/or
|
||||
@ -45,8 +45,9 @@ INSTALLATION (Unix systems only):
|
||||
Specifies the regular expression library used by less for pattern
|
||||
matching. The default is "auto", which means the configure program
|
||||
finds a regular expression library automatically. Other values are:
|
||||
posix Use the POSIX-compatible regcomp.
|
||||
gnu Use the GNU regex library.
|
||||
pcre Use the PCRE library.
|
||||
posix Use the POSIX-compatible regcomp.
|
||||
regcmp Use the regcmp library.
|
||||
re_comp Use the re_comp library.
|
||||
regcomp Use the V8-compatible regcomp.
|
||||
|
2
brac.c
2
brac.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
37
ch.c
37
ch.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -54,7 +54,7 @@ struct buf {
|
||||
* The file state is maintained in a filestate structure.
|
||||
* A pointer to the filestate is kept in the ifile structure.
|
||||
*/
|
||||
#define BUFHASH_SIZE 64
|
||||
#define BUFHASH_SIZE 1024
|
||||
struct filestate {
|
||||
struct bufnode buflist;
|
||||
struct bufnode hashtbl[BUFHASH_SIZE];
|
||||
@ -323,13 +323,16 @@ ch_get()
|
||||
#if HAVE_STAT_INO
|
||||
if (follow_mode == FOLLOW_NAME)
|
||||
{
|
||||
/* See whether the file's i-number has changed.
|
||||
/* See whether the file's i-number has changed,
|
||||
* or the file has shrunk.
|
||||
* If so, force the file to be closed and
|
||||
* reopened. */
|
||||
struct stat st;
|
||||
POSITION curr_pos = ch_tell();
|
||||
int r = stat(get_filename(curr_ifile), &st);
|
||||
if (r == 0 && (st.st_ino != curr_ino ||
|
||||
st.st_dev != curr_dev))
|
||||
st.st_dev != curr_dev ||
|
||||
(curr_pos != NULL_POSITION && st.st_size < curr_pos)))
|
||||
{
|
||||
/* screen_trashed=2 causes
|
||||
* make_display to reopen the file. */
|
||||
@ -535,6 +538,32 @@ ch_end_seek()
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Seek to the last position in the file that is currently buffered.
|
||||
*/
|
||||
public int
|
||||
ch_end_buffer_seek()
|
||||
{
|
||||
register struct buf *bp;
|
||||
register struct bufnode *bn;
|
||||
POSITION buf_pos;
|
||||
POSITION end_pos;
|
||||
|
||||
if (thisfile == NULL || (ch_flags & CH_CANSEEK))
|
||||
return (ch_end_seek());
|
||||
|
||||
end_pos = 0;
|
||||
FOR_BUFS(bn)
|
||||
{
|
||||
bp = bufnode_buf(bn);
|
||||
buf_pos = (bp->block * LBUFSIZE) + bp->datasize;
|
||||
if (buf_pos > end_pos)
|
||||
end_pos = buf_pos;
|
||||
}
|
||||
|
||||
return (ch_seek(end_pos));
|
||||
}
|
||||
|
||||
/*
|
||||
* Seek to the beginning of the file, or as close to it as we can get.
|
||||
* We may not be able to seek there if input is a pipe and the
|
||||
|
487
charset.c
487
charset.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -466,36 +466,15 @@ prutfchar(ch)
|
||||
else
|
||||
SNPRINTF1(buf, sizeof(buf), binfmt, (char) ch);
|
||||
} else if (is_ubin_char(ch))
|
||||
SNPRINTF1(buf, sizeof(buf), utfbinfmt, ch);
|
||||
else
|
||||
{
|
||||
int len;
|
||||
SNPRINTF1(buf, sizeof(buf), utfbinfmt, ch);
|
||||
} else
|
||||
{
|
||||
char *p = buf;
|
||||
if (ch >= 0x80000000)
|
||||
{
|
||||
len = 3;
|
||||
ch = 0xFFFD;
|
||||
} else
|
||||
{
|
||||
len = (ch < 0x80) ? 1
|
||||
: (ch < 0x800) ? 2
|
||||
: (ch < 0x10000) ? 3
|
||||
: (ch < 0x200000) ? 4
|
||||
: (ch < 0x4000000) ? 5
|
||||
: 6;
|
||||
}
|
||||
buf[len] = '\0';
|
||||
if (len == 1)
|
||||
*buf = (char) ch;
|
||||
else
|
||||
{
|
||||
*buf = ((1 << len) - 1) << (8 - len);
|
||||
while (--len > 0)
|
||||
{
|
||||
buf[len] = (char) (0x80 | (ch & 0x3F));
|
||||
ch >>= 6;
|
||||
}
|
||||
*buf |= ch;
|
||||
}
|
||||
ch = 0xFFFD; /* REPLACEMENT CHARACTER */
|
||||
put_wchar(&p, ch);
|
||||
*p = '\0';
|
||||
}
|
||||
return (buf);
|
||||
}
|
||||
@ -524,11 +503,12 @@ utf_len(ch)
|
||||
}
|
||||
|
||||
/*
|
||||
* Is a UTF-8 character well-formed?
|
||||
* Does the parameter point to the lead byte of a well-formed UTF-8 character?
|
||||
*/
|
||||
public int
|
||||
is_utf8_well_formed(s)
|
||||
is_utf8_well_formed(s, slen)
|
||||
unsigned char *s;
|
||||
int slen;
|
||||
{
|
||||
int i;
|
||||
int len;
|
||||
@ -537,6 +517,8 @@ is_utf8_well_formed(s)
|
||||
return (0);
|
||||
|
||||
len = utf_len((char) s[0]);
|
||||
if (len > slen)
|
||||
return (0);
|
||||
if (len == 1)
|
||||
return (1);
|
||||
if (len == 2)
|
||||
@ -557,6 +539,35 @@ is_utf8_well_formed(s)
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return number of invalid UTF-8 sequences found in a buffer.
|
||||
*/
|
||||
public int
|
||||
utf_bin_count(data, len)
|
||||
unsigned char *data;
|
||||
int len;
|
||||
{
|
||||
int bin_count = 0;
|
||||
while (len > 0)
|
||||
{
|
||||
if (is_utf8_well_formed(data, len))
|
||||
{
|
||||
int clen = utf_len(*data);
|
||||
data += clen;
|
||||
len -= clen;
|
||||
} else
|
||||
{
|
||||
/* Skip to next lead byte. */
|
||||
bin_count++;
|
||||
do {
|
||||
++data;
|
||||
--len;
|
||||
} while (len > 0 && !IS_UTF8_LEAD(*data));
|
||||
}
|
||||
}
|
||||
return (bin_count);
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the value of a UTF-8 character.
|
||||
*/
|
||||
@ -706,411 +717,51 @@ step_char(pp, dir, limit)
|
||||
|
||||
/*
|
||||
* Unicode characters data
|
||||
* Actual data is in the generated *.uni files.
|
||||
*/
|
||||
struct wchar_range { LWCHAR first, last; };
|
||||
|
||||
/*
|
||||
* Characters with general category values
|
||||
* Mn: Mark, Nonspacing
|
||||
* Me: Mark, Enclosing
|
||||
* Last synched with
|
||||
* <http://www.unicode.org/Public/5.0.0/ucd/UnicodeData-5.0.0d7.txt>
|
||||
* dated 2005-11-30T00:58:48Z
|
||||
*/
|
||||
static struct wchar_range comp_table[] = {
|
||||
{ 0x0300, 0x036F} /* Mn */, { 0x0483, 0x0486} /* Mn */,
|
||||
{ 0x0488, 0x0489} /* Me */,
|
||||
{ 0x0591, 0x05BD} /* Mn */, { 0x05BF, 0x05BF} /* Mn */,
|
||||
{ 0x05C1, 0x05C2} /* Mn */, { 0x05C4, 0x05C5} /* Mn */,
|
||||
{ 0x05C7, 0x05C7} /* Mn */, { 0x0610, 0x0615} /* Mn */,
|
||||
{ 0x064B, 0x065E} /* Mn */, { 0x0670, 0x0670} /* Mn */,
|
||||
{ 0x06D6, 0x06DC} /* Mn */,
|
||||
{ 0x06DE, 0x06DE} /* Me */,
|
||||
{ 0x06DF, 0x06E4} /* Mn */, { 0x06E7, 0x06E8} /* Mn */,
|
||||
{ 0x06EA, 0x06ED} /* Mn */, { 0x0711, 0x0711} /* Mn */,
|
||||
{ 0x0730, 0x074A} /* Mn */, { 0x07A6, 0x07B0} /* Mn */,
|
||||
{ 0x07EB, 0x07F3} /* Mn */, { 0x0901, 0x0902} /* Mn */,
|
||||
{ 0x093C, 0x093C} /* Mn */, { 0x0941, 0x0948} /* Mn */,
|
||||
{ 0x094D, 0x094D} /* Mn */, { 0x0951, 0x0954} /* Mn */,
|
||||
{ 0x0962, 0x0963} /* Mn */, { 0x0981, 0x0981} /* Mn */,
|
||||
{ 0x09BC, 0x09BC} /* Mn */, { 0x09C1, 0x09C4} /* Mn */,
|
||||
{ 0x09CD, 0x09CD} /* Mn */, { 0x09E2, 0x09E3} /* Mn */,
|
||||
{ 0x0A01, 0x0A02} /* Mn */, { 0x0A3C, 0x0A3C} /* Mn */,
|
||||
{ 0x0A41, 0x0A42} /* Mn */, { 0x0A47, 0x0A48} /* Mn */,
|
||||
{ 0x0A4B, 0x0A4D} /* Mn */, { 0x0A70, 0x0A71} /* Mn */,
|
||||
{ 0x0A81, 0x0A82} /* Mn */, { 0x0ABC, 0x0ABC} /* Mn */,
|
||||
{ 0x0AC1, 0x0AC5} /* Mn */, { 0x0AC7, 0x0AC8} /* Mn */,
|
||||
{ 0x0ACD, 0x0ACD} /* Mn */, { 0x0AE2, 0x0AE3} /* Mn */,
|
||||
{ 0x0B01, 0x0B01} /* Mn */, { 0x0B3C, 0x0B3C} /* Mn */,
|
||||
{ 0x0B3F, 0x0B3F} /* Mn */, { 0x0B41, 0x0B43} /* Mn */,
|
||||
{ 0x0B4D, 0x0B4D} /* Mn */, { 0x0B56, 0x0B56} /* Mn */,
|
||||
{ 0x0B82, 0x0B82} /* Mn */, { 0x0BC0, 0x0BC0} /* Mn */,
|
||||
{ 0x0BCD, 0x0BCD} /* Mn */, { 0x0C3E, 0x0C40} /* Mn */,
|
||||
{ 0x0C46, 0x0C48} /* Mn */, { 0x0C4A, 0x0C4D} /* Mn */,
|
||||
{ 0x0C55, 0x0C56} /* Mn */, { 0x0CBC, 0x0CBC} /* Mn */,
|
||||
{ 0x0CBF, 0x0CBF} /* Mn */, { 0x0CC6, 0x0CC6} /* Mn */,
|
||||
{ 0x0CCC, 0x0CCD} /* Mn */, { 0x0CE2, 0x0CE3} /* Mn */,
|
||||
{ 0x0D41, 0x0D43} /* Mn */, { 0x0D4D, 0x0D4D} /* Mn */,
|
||||
{ 0x0DCA, 0x0DCA} /* Mn */, { 0x0DD2, 0x0DD4} /* Mn */,
|
||||
{ 0x0DD6, 0x0DD6} /* Mn */, { 0x0E31, 0x0E31} /* Mn */,
|
||||
{ 0x0E34, 0x0E3A} /* Mn */, { 0x0E47, 0x0E4E} /* Mn */,
|
||||
{ 0x0EB1, 0x0EB1} /* Mn */, { 0x0EB4, 0x0EB9} /* Mn */,
|
||||
{ 0x0EBB, 0x0EBC} /* Mn */, { 0x0EC8, 0x0ECD} /* Mn */,
|
||||
{ 0x0F18, 0x0F19} /* Mn */, { 0x0F35, 0x0F35} /* Mn */,
|
||||
{ 0x0F37, 0x0F37} /* Mn */, { 0x0F39, 0x0F39} /* Mn */,
|
||||
{ 0x0F71, 0x0F7E} /* Mn */, { 0x0F80, 0x0F84} /* Mn */,
|
||||
{ 0x0F86, 0x0F87} /* Mn */, { 0x0F90, 0x0F97} /* Mn */,
|
||||
{ 0x0F99, 0x0FBC} /* Mn */, { 0x0FC6, 0x0FC6} /* Mn */,
|
||||
{ 0x102D, 0x1030} /* Mn */, { 0x1032, 0x1032} /* Mn */,
|
||||
{ 0x1036, 0x1037} /* Mn */, { 0x1039, 0x1039} /* Mn */,
|
||||
{ 0x1058, 0x1059} /* Mn */, { 0x135F, 0x135F} /* Mn */,
|
||||
{ 0x1712, 0x1714} /* Mn */, { 0x1732, 0x1734} /* Mn */,
|
||||
{ 0x1752, 0x1753} /* Mn */, { 0x1772, 0x1773} /* Mn */,
|
||||
{ 0x17B7, 0x17BD} /* Mn */, { 0x17C6, 0x17C6} /* Mn */,
|
||||
{ 0x17C9, 0x17D3} /* Mn */, { 0x17DD, 0x17DD} /* Mn */,
|
||||
{ 0x180B, 0x180D} /* Mn */, { 0x18A9, 0x18A9} /* Mn */,
|
||||
{ 0x1920, 0x1922} /* Mn */, { 0x1927, 0x1928} /* Mn */,
|
||||
{ 0x1932, 0x1932} /* Mn */, { 0x1939, 0x193B} /* Mn */,
|
||||
{ 0x1A17, 0x1A18} /* Mn */, { 0x1B00, 0x1B03} /* Mn */,
|
||||
{ 0x1B34, 0x1B34} /* Mn */, { 0x1B36, 0x1B3A} /* Mn */,
|
||||
{ 0x1B3C, 0x1B3C} /* Mn */, { 0x1B42, 0x1B42} /* Mn */,
|
||||
{ 0x1B6B, 0x1B73} /* Mn */, { 0x1DC0, 0x1DCA} /* Mn */,
|
||||
{ 0x1DFE, 0x1DFF} /* Mn */, { 0x20D0, 0x20DC} /* Mn */,
|
||||
{ 0x20DD, 0x20E0} /* Me */,
|
||||
{ 0x20E1, 0x20E1} /* Mn */,
|
||||
{ 0x20E2, 0x20E4} /* Me */,
|
||||
{ 0x20E5, 0x20EF} /* Mn */, { 0x302A, 0x302F} /* Mn */,
|
||||
{ 0x3099, 0x309A} /* Mn */, { 0xA806, 0xA806} /* Mn */,
|
||||
{ 0xA80B, 0xA80B} /* Mn */, { 0xA825, 0xA826} /* Mn */,
|
||||
{ 0xFB1E, 0xFB1E} /* Mn */, { 0xFE00, 0xFE0F} /* Mn */,
|
||||
{ 0xFE20, 0xFE23} /* Mn */, { 0x10A01, 0x10A03} /* Mn */,
|
||||
{ 0x10A05, 0x10A06} /* Mn */, { 0x10A0C, 0x10A0F} /* Mn */,
|
||||
{ 0x10A38, 0x10A3A} /* Mn */, { 0x10A3F, 0x10A3F} /* Mn */,
|
||||
{ 0x1D167, 0x1D169} /* Mn */, { 0x1D17B, 0x1D182} /* Mn */,
|
||||
{ 0x1D185, 0x1D18B} /* Mn */, { 0x1D1AA, 0x1D1AD} /* Mn */,
|
||||
{ 0x1D242, 0x1D244} /* Mn */, { 0xE0100, 0xE01EF} /* Mn */,
|
||||
};
|
||||
#define DECLARE_RANGE_TABLE_START(name) \
|
||||
static struct wchar_range name##_array[] = {
|
||||
#define DECLARE_RANGE_TABLE_END(name) \
|
||||
}; struct wchar_range_table name##_table = { name##_array, sizeof(name##_array)/sizeof(*name##_array) };
|
||||
|
||||
/*
|
||||
* Special pairs, not ranges.
|
||||
*/
|
||||
DECLARE_RANGE_TABLE_START(compose)
|
||||
#include "compose.uni"
|
||||
DECLARE_RANGE_TABLE_END(compose)
|
||||
|
||||
DECLARE_RANGE_TABLE_START(ubin)
|
||||
#include "ubin.uni"
|
||||
DECLARE_RANGE_TABLE_END(ubin)
|
||||
|
||||
DECLARE_RANGE_TABLE_START(wide)
|
||||
#include "wide.uni"
|
||||
DECLARE_RANGE_TABLE_END(wide)
|
||||
|
||||
/* comb_table is special pairs, not ranges. */
|
||||
static struct wchar_range comb_table[] = {
|
||||
{0x0644,0x0622}, {0x0644,0x0623}, {0x0644,0x0625}, {0x0644,0x0627},
|
||||
};
|
||||
|
||||
/*
|
||||
* Characters with general category values
|
||||
* Cc: Other, Control
|
||||
* Cf: Other, Format
|
||||
* Cs: Other, Surrogate
|
||||
* Co: Other, Private Use
|
||||
* Cn: Other, Not Assigned
|
||||
* Zl: Separator, Line
|
||||
* Zp: Separator, Paragraph
|
||||
* Last synched with
|
||||
* <http://www.unicode.org/Public/5.0.0/ucd/UnicodeData-5.0.0d7.txt>
|
||||
* dated 2005-11-30T00:58:48Z
|
||||
*/
|
||||
static struct wchar_range ubin_table[] = {
|
||||
{ 0x0000, 0x0007} /* Cc */,
|
||||
{ 0x000B, 0x000C} /* Cc */,
|
||||
{ 0x000E, 0x001A} /* Cc */,
|
||||
{ 0x001C, 0x001F} /* Cc */,
|
||||
{ 0x007F, 0x009F} /* Cc */,
|
||||
#if 0
|
||||
{ 0x00AD, 0x00AD} /* Cf */,
|
||||
#endif
|
||||
{ 0x0370, 0x0373} /* Cn */, { 0x0376, 0x0379} /* Cn */,
|
||||
{ 0x037F, 0x0383} /* Cn */, { 0x038B, 0x038B} /* Cn */,
|
||||
{ 0x038D, 0x038D} /* Cn */, { 0x03A2, 0x03A2} /* Cn */,
|
||||
{ 0x03CF, 0x03CF} /* Cn */, { 0x0487, 0x0487} /* Cn */,
|
||||
{ 0x0514, 0x0530} /* Cn */, { 0x0557, 0x0558} /* Cn */,
|
||||
{ 0x0560, 0x0560} /* Cn */, { 0x0588, 0x0588} /* Cn */,
|
||||
{ 0x058B, 0x0590} /* Cn */, { 0x05C8, 0x05CF} /* Cn */,
|
||||
{ 0x05EB, 0x05EF} /* Cn */, { 0x05F5, 0x05FF} /* Cn */,
|
||||
#if 0
|
||||
{ 0x0600, 0x0603} /* Cf */,
|
||||
#endif
|
||||
{ 0x0604, 0x060A} /* Cn */, { 0x0616, 0x061A} /* Cn */,
|
||||
{ 0x061C, 0x061D} /* Cn */, { 0x0620, 0x0620} /* Cn */,
|
||||
{ 0x063B, 0x063F} /* Cn */, { 0x065F, 0x065F} /* Cn */,
|
||||
#if 0
|
||||
{ 0x06DD, 0x06DD} /* Cf */,
|
||||
#endif
|
||||
{ 0x070E, 0x070E} /* Cn */,
|
||||
#if 0
|
||||
{ 0x070F, 0x070F} /* Cf */,
|
||||
#endif
|
||||
{ 0x074B, 0x074C} /* Cn */, { 0x076E, 0x077F} /* Cn */,
|
||||
{ 0x07B2, 0x07BF} /* Cn */, { 0x07FB, 0x0900} /* Cn */,
|
||||
{ 0x093A, 0x093B} /* Cn */, { 0x094E, 0x094F} /* Cn */,
|
||||
{ 0x0955, 0x0957} /* Cn */, { 0x0971, 0x097A} /* Cn */,
|
||||
{ 0x0980, 0x0980} /* Cn */, { 0x0984, 0x0984} /* Cn */,
|
||||
{ 0x098D, 0x098E} /* Cn */, { 0x0991, 0x0992} /* Cn */,
|
||||
{ 0x09A9, 0x09A9} /* Cn */, { 0x09B1, 0x09B1} /* Cn */,
|
||||
{ 0x09B3, 0x09B5} /* Cn */, { 0x09BA, 0x09BB} /* Cn */,
|
||||
{ 0x09C5, 0x09C6} /* Cn */, { 0x09C9, 0x09CA} /* Cn */,
|
||||
{ 0x09CF, 0x09D6} /* Cn */, { 0x09D8, 0x09DB} /* Cn */,
|
||||
{ 0x09DE, 0x09DE} /* Cn */, { 0x09E4, 0x09E5} /* Cn */,
|
||||
{ 0x09FB, 0x0A00} /* Cn */, { 0x0A04, 0x0A04} /* Cn */,
|
||||
{ 0x0A0B, 0x0A0E} /* Cn */, { 0x0A11, 0x0A12} /* Cn */,
|
||||
{ 0x0A29, 0x0A29} /* Cn */, { 0x0A31, 0x0A31} /* Cn */,
|
||||
{ 0x0A34, 0x0A34} /* Cn */, { 0x0A37, 0x0A37} /* Cn */,
|
||||
{ 0x0A3A, 0x0A3B} /* Cn */, { 0x0A3D, 0x0A3D} /* Cn */,
|
||||
{ 0x0A43, 0x0A46} /* Cn */, { 0x0A49, 0x0A4A} /* Cn */,
|
||||
{ 0x0A4E, 0x0A58} /* Cn */, { 0x0A5D, 0x0A5D} /* Cn */,
|
||||
{ 0x0A5F, 0x0A65} /* Cn */, { 0x0A75, 0x0A80} /* Cn */,
|
||||
{ 0x0A84, 0x0A84} /* Cn */, { 0x0A8E, 0x0A8E} /* Cn */,
|
||||
{ 0x0A92, 0x0A92} /* Cn */, { 0x0AA9, 0x0AA9} /* Cn */,
|
||||
{ 0x0AB1, 0x0AB1} /* Cn */, { 0x0AB4, 0x0AB4} /* Cn */,
|
||||
{ 0x0ABA, 0x0ABB} /* Cn */, { 0x0AC6, 0x0AC6} /* Cn */,
|
||||
{ 0x0ACA, 0x0ACA} /* Cn */, { 0x0ACE, 0x0ACF} /* Cn */,
|
||||
{ 0x0AD1, 0x0ADF} /* Cn */, { 0x0AE4, 0x0AE5} /* Cn */,
|
||||
{ 0x0AF0, 0x0AF0} /* Cn */, { 0x0AF2, 0x0B00} /* Cn */,
|
||||
{ 0x0B04, 0x0B04} /* Cn */, { 0x0B0D, 0x0B0E} /* Cn */,
|
||||
{ 0x0B11, 0x0B12} /* Cn */, { 0x0B29, 0x0B29} /* Cn */,
|
||||
{ 0x0B31, 0x0B31} /* Cn */, { 0x0B34, 0x0B34} /* Cn */,
|
||||
{ 0x0B3A, 0x0B3B} /* Cn */, { 0x0B44, 0x0B46} /* Cn */,
|
||||
{ 0x0B49, 0x0B4A} /* Cn */, { 0x0B4E, 0x0B55} /* Cn */,
|
||||
{ 0x0B58, 0x0B5B} /* Cn */, { 0x0B5E, 0x0B5E} /* Cn */,
|
||||
{ 0x0B62, 0x0B65} /* Cn */, { 0x0B72, 0x0B81} /* Cn */,
|
||||
{ 0x0B84, 0x0B84} /* Cn */, { 0x0B8B, 0x0B8D} /* Cn */,
|
||||
{ 0x0B91, 0x0B91} /* Cn */, { 0x0B96, 0x0B98} /* Cn */,
|
||||
{ 0x0B9B, 0x0B9B} /* Cn */, { 0x0B9D, 0x0B9D} /* Cn */,
|
||||
{ 0x0BA0, 0x0BA2} /* Cn */, { 0x0BA5, 0x0BA7} /* Cn */,
|
||||
{ 0x0BAB, 0x0BAD} /* Cn */, { 0x0BBA, 0x0BBD} /* Cn */,
|
||||
{ 0x0BC3, 0x0BC5} /* Cn */, { 0x0BC9, 0x0BC9} /* Cn */,
|
||||
{ 0x0BCE, 0x0BD6} /* Cn */, { 0x0BD8, 0x0BE5} /* Cn */,
|
||||
{ 0x0BFB, 0x0C00} /* Cn */, { 0x0C04, 0x0C04} /* Cn */,
|
||||
{ 0x0C0D, 0x0C0D} /* Cn */, { 0x0C11, 0x0C11} /* Cn */,
|
||||
{ 0x0C29, 0x0C29} /* Cn */, { 0x0C34, 0x0C34} /* Cn */,
|
||||
{ 0x0C3A, 0x0C3D} /* Cn */, { 0x0C45, 0x0C45} /* Cn */,
|
||||
{ 0x0C49, 0x0C49} /* Cn */, { 0x0C4E, 0x0C54} /* Cn */,
|
||||
{ 0x0C57, 0x0C5F} /* Cn */, { 0x0C62, 0x0C65} /* Cn */,
|
||||
{ 0x0C70, 0x0C81} /* Cn */, { 0x0C84, 0x0C84} /* Cn */,
|
||||
{ 0x0C8D, 0x0C8D} /* Cn */, { 0x0C91, 0x0C91} /* Cn */,
|
||||
{ 0x0CA9, 0x0CA9} /* Cn */, { 0x0CB4, 0x0CB4} /* Cn */,
|
||||
{ 0x0CBA, 0x0CBB} /* Cn */, { 0x0CC5, 0x0CC5} /* Cn */,
|
||||
{ 0x0CC9, 0x0CC9} /* Cn */, { 0x0CCE, 0x0CD4} /* Cn */,
|
||||
{ 0x0CD7, 0x0CDD} /* Cn */, { 0x0CDF, 0x0CDF} /* Cn */,
|
||||
{ 0x0CE4, 0x0CE5} /* Cn */, { 0x0CF0, 0x0CF0} /* Cn */,
|
||||
{ 0x0CF3, 0x0D01} /* Cn */, { 0x0D04, 0x0D04} /* Cn */,
|
||||
{ 0x0D0D, 0x0D0D} /* Cn */, { 0x0D11, 0x0D11} /* Cn */,
|
||||
{ 0x0D29, 0x0D29} /* Cn */, { 0x0D3A, 0x0D3D} /* Cn */,
|
||||
{ 0x0D44, 0x0D45} /* Cn */, { 0x0D49, 0x0D49} /* Cn */,
|
||||
{ 0x0D4E, 0x0D56} /* Cn */, { 0x0D58, 0x0D5F} /* Cn */,
|
||||
{ 0x0D62, 0x0D65} /* Cn */, { 0x0D70, 0x0D81} /* Cn */,
|
||||
{ 0x0D84, 0x0D84} /* Cn */, { 0x0D97, 0x0D99} /* Cn */,
|
||||
{ 0x0DB2, 0x0DB2} /* Cn */, { 0x0DBC, 0x0DBC} /* Cn */,
|
||||
{ 0x0DBE, 0x0DBF} /* Cn */, { 0x0DC7, 0x0DC9} /* Cn */,
|
||||
{ 0x0DCB, 0x0DCE} /* Cn */, { 0x0DD5, 0x0DD5} /* Cn */,
|
||||
{ 0x0DD7, 0x0DD7} /* Cn */, { 0x0DE0, 0x0DF1} /* Cn */,
|
||||
{ 0x0DF5, 0x0E00} /* Cn */, { 0x0E3B, 0x0E3E} /* Cn */,
|
||||
{ 0x0E5C, 0x0E80} /* Cn */, { 0x0E83, 0x0E83} /* Cn */,
|
||||
{ 0x0E85, 0x0E86} /* Cn */, { 0x0E89, 0x0E89} /* Cn */,
|
||||
{ 0x0E8B, 0x0E8C} /* Cn */, { 0x0E8E, 0x0E93} /* Cn */,
|
||||
{ 0x0E98, 0x0E98} /* Cn */, { 0x0EA0, 0x0EA0} /* Cn */,
|
||||
{ 0x0EA4, 0x0EA4} /* Cn */, { 0x0EA6, 0x0EA6} /* Cn */,
|
||||
{ 0x0EA8, 0x0EA9} /* Cn */, { 0x0EAC, 0x0EAC} /* Cn */,
|
||||
{ 0x0EBA, 0x0EBA} /* Cn */, { 0x0EBE, 0x0EBF} /* Cn */,
|
||||
{ 0x0EC5, 0x0EC5} /* Cn */, { 0x0EC7, 0x0EC7} /* Cn */,
|
||||
{ 0x0ECE, 0x0ECF} /* Cn */, { 0x0EDA, 0x0EDB} /* Cn */,
|
||||
{ 0x0EDE, 0x0EFF} /* Cn */, { 0x0F48, 0x0F48} /* Cn */,
|
||||
{ 0x0F6B, 0x0F70} /* Cn */, { 0x0F8C, 0x0F8F} /* Cn */,
|
||||
{ 0x0F98, 0x0F98} /* Cn */, { 0x0FBD, 0x0FBD} /* Cn */,
|
||||
{ 0x0FCD, 0x0FCE} /* Cn */, { 0x0FD2, 0x0FFF} /* Cn */,
|
||||
{ 0x1022, 0x1022} /* Cn */, { 0x1028, 0x1028} /* Cn */,
|
||||
{ 0x102B, 0x102B} /* Cn */, { 0x1033, 0x1035} /* Cn */,
|
||||
{ 0x103A, 0x103F} /* Cn */, { 0x105A, 0x109F} /* Cn */,
|
||||
{ 0x10C6, 0x10CF} /* Cn */, { 0x10FD, 0x10FF} /* Cn */,
|
||||
{ 0x115A, 0x115E} /* Cn */, { 0x11A3, 0x11A7} /* Cn */,
|
||||
{ 0x11FA, 0x11FF} /* Cn */, { 0x1249, 0x1249} /* Cn */,
|
||||
{ 0x124E, 0x124F} /* Cn */, { 0x1257, 0x1257} /* Cn */,
|
||||
{ 0x1259, 0x1259} /* Cn */, { 0x125E, 0x125F} /* Cn */,
|
||||
{ 0x1289, 0x1289} /* Cn */, { 0x128E, 0x128F} /* Cn */,
|
||||
{ 0x12B1, 0x12B1} /* Cn */, { 0x12B6, 0x12B7} /* Cn */,
|
||||
{ 0x12BF, 0x12BF} /* Cn */, { 0x12C1, 0x12C1} /* Cn */,
|
||||
{ 0x12C6, 0x12C7} /* Cn */, { 0x12D7, 0x12D7} /* Cn */,
|
||||
{ 0x1311, 0x1311} /* Cn */, { 0x1316, 0x1317} /* Cn */,
|
||||
{ 0x135B, 0x135E} /* Cn */, { 0x137D, 0x137F} /* Cn */,
|
||||
{ 0x139A, 0x139F} /* Cn */, { 0x13F5, 0x1400} /* Cn */,
|
||||
{ 0x1677, 0x167F} /* Cn */, { 0x169D, 0x169F} /* Cn */,
|
||||
{ 0x16F1, 0x16FF} /* Cn */, { 0x170D, 0x170D} /* Cn */,
|
||||
{ 0x1715, 0x171F} /* Cn */, { 0x1737, 0x173F} /* Cn */,
|
||||
{ 0x1754, 0x175F} /* Cn */, { 0x176D, 0x176D} /* Cn */,
|
||||
{ 0x1771, 0x1771} /* Cn */, { 0x1774, 0x177F} /* Cn */,
|
||||
#if 0
|
||||
{ 0x17B4, 0x17B5} /* Cf */,
|
||||
#endif
|
||||
{ 0x17DE, 0x17DF} /* Cn */, { 0x17EA, 0x17EF} /* Cn */,
|
||||
{ 0x17FA, 0x17FF} /* Cn */, { 0x180F, 0x180F} /* Cn */,
|
||||
{ 0x181A, 0x181F} /* Cn */, { 0x1878, 0x187F} /* Cn */,
|
||||
{ 0x18AA, 0x18FF} /* Cn */, { 0x191D, 0x191F} /* Cn */,
|
||||
{ 0x192C, 0x192F} /* Cn */, { 0x193C, 0x193F} /* Cn */,
|
||||
{ 0x1941, 0x1943} /* Cn */, { 0x196E, 0x196F} /* Cn */,
|
||||
{ 0x1975, 0x197F} /* Cn */, { 0x19AA, 0x19AF} /* Cn */,
|
||||
{ 0x19CA, 0x19CF} /* Cn */, { 0x19DA, 0x19DD} /* Cn */,
|
||||
{ 0x1A1C, 0x1A1D} /* Cn */, { 0x1A20, 0x1AFF} /* Cn */,
|
||||
{ 0x1B4C, 0x1B4F} /* Cn */, { 0x1B7D, 0x1CFF} /* Cn */,
|
||||
{ 0x1DCB, 0x1DFD} /* Cn */, { 0x1E9C, 0x1E9F} /* Cn */,
|
||||
{ 0x1EFA, 0x1EFF} /* Cn */, { 0x1F16, 0x1F17} /* Cn */,
|
||||
{ 0x1F1E, 0x1F1F} /* Cn */, { 0x1F46, 0x1F47} /* Cn */,
|
||||
{ 0x1F4E, 0x1F4F} /* Cn */, { 0x1F58, 0x1F58} /* Cn */,
|
||||
{ 0x1F5A, 0x1F5A} /* Cn */, { 0x1F5C, 0x1F5C} /* Cn */,
|
||||
{ 0x1F5E, 0x1F5E} /* Cn */, { 0x1F7E, 0x1F7F} /* Cn */,
|
||||
{ 0x1FB5, 0x1FB5} /* Cn */, { 0x1FC5, 0x1FC5} /* Cn */,
|
||||
{ 0x1FD4, 0x1FD5} /* Cn */, { 0x1FDC, 0x1FDC} /* Cn */,
|
||||
{ 0x1FF0, 0x1FF1} /* Cn */, { 0x1FF5, 0x1FF5} /* Cn */,
|
||||
{ 0x1FFF, 0x1FFF} /* Cn */,
|
||||
{ 0x200B, 0x200F} /* Cf */,
|
||||
{ 0x2028, 0x2028} /* Zl */,
|
||||
{ 0x2029, 0x2029} /* Zp */,
|
||||
{ 0x202A, 0x202E} /* Cf */,
|
||||
{ 0x2060, 0x2063} /* Cf */,
|
||||
{ 0x2064, 0x2069} /* Cn */,
|
||||
{ 0x206A, 0x206F} /* Cf */,
|
||||
{ 0x2072, 0x2073} /* Cn */, { 0x208F, 0x208F} /* Cn */,
|
||||
{ 0x2095, 0x209F} /* Cn */, { 0x20B6, 0x20CF} /* Cn */,
|
||||
{ 0x20F0, 0x20FF} /* Cn */, { 0x214F, 0x2152} /* Cn */,
|
||||
{ 0x2185, 0x218F} /* Cn */, { 0x23E8, 0x23FF} /* Cn */,
|
||||
{ 0x2427, 0x243F} /* Cn */, { 0x244B, 0x245F} /* Cn */,
|
||||
{ 0x269D, 0x269F} /* Cn */, { 0x26B3, 0x2700} /* Cn */,
|
||||
{ 0x2705, 0x2705} /* Cn */, { 0x270A, 0x270B} /* Cn */,
|
||||
{ 0x2728, 0x2728} /* Cn */, { 0x274C, 0x274C} /* Cn */,
|
||||
{ 0x274E, 0x274E} /* Cn */, { 0x2753, 0x2755} /* Cn */,
|
||||
{ 0x2757, 0x2757} /* Cn */, { 0x275F, 0x2760} /* Cn */,
|
||||
{ 0x2795, 0x2797} /* Cn */, { 0x27B0, 0x27B0} /* Cn */,
|
||||
{ 0x27BF, 0x27BF} /* Cn */, { 0x27CB, 0x27CF} /* Cn */,
|
||||
{ 0x27EC, 0x27EF} /* Cn */, { 0x2B1B, 0x2B1F} /* Cn */,
|
||||
{ 0x2B24, 0x2BFF} /* Cn */, { 0x2C2F, 0x2C2F} /* Cn */,
|
||||
{ 0x2C5F, 0x2C5F} /* Cn */, { 0x2C6D, 0x2C73} /* Cn */,
|
||||
{ 0x2C78, 0x2C7F} /* Cn */, { 0x2CEB, 0x2CF8} /* Cn */,
|
||||
{ 0x2D26, 0x2D2F} /* Cn */, { 0x2D66, 0x2D6E} /* Cn */,
|
||||
{ 0x2D70, 0x2D7F} /* Cn */, { 0x2D97, 0x2D9F} /* Cn */,
|
||||
{ 0x2DA7, 0x2DA7} /* Cn */, { 0x2DAF, 0x2DAF} /* Cn */,
|
||||
{ 0x2DB7, 0x2DB7} /* Cn */, { 0x2DBF, 0x2DBF} /* Cn */,
|
||||
{ 0x2DC7, 0x2DC7} /* Cn */, { 0x2DCF, 0x2DCF} /* Cn */,
|
||||
{ 0x2DD7, 0x2DD7} /* Cn */, { 0x2DDF, 0x2DFF} /* Cn */,
|
||||
{ 0x2E18, 0x2E1B} /* Cn */, { 0x2E1E, 0x2E7F} /* Cn */,
|
||||
{ 0x2E9A, 0x2E9A} /* Cn */, { 0x2EF4, 0x2EFF} /* Cn */,
|
||||
{ 0x2FD6, 0x2FEF} /* Cn */, { 0x2FFC, 0x2FFF} /* Cn */,
|
||||
{ 0x3040, 0x3040} /* Cn */, { 0x3097, 0x3098} /* Cn */,
|
||||
{ 0x3100, 0x3104} /* Cn */, { 0x312D, 0x3130} /* Cn */,
|
||||
{ 0x318F, 0x318F} /* Cn */, { 0x31B8, 0x31BF} /* Cn */,
|
||||
{ 0x31D0, 0x31EF} /* Cn */, { 0x321F, 0x321F} /* Cn */,
|
||||
{ 0x3244, 0x324F} /* Cn */, { 0x32FF, 0x32FF} /* Cn */,
|
||||
{ 0x4DB6, 0x4DBF} /* Cn */, { 0x9FBC, 0x9FFF} /* Cn */,
|
||||
{ 0xA48D, 0xA48F} /* Cn */, { 0xA4C7, 0xA6FF} /* Cn */,
|
||||
{ 0xA71B, 0xA71F} /* Cn */, { 0xA722, 0xA7FF} /* Cn */,
|
||||
{ 0xA82C, 0xA83F} /* Cn */, { 0xA878, 0xABFF} /* Cn */,
|
||||
{ 0xD7A4, 0xD7FF} /* Cn */,
|
||||
{ 0xD800, 0xDFFF} /* Cs */,
|
||||
{ 0xE000, 0xF8FF} /* Co */,
|
||||
{ 0xFA2E, 0xFA2F} /* Cn */, { 0xFA6B, 0xFA6F} /* Cn */,
|
||||
{ 0xFADA, 0xFAFF} /* Cn */, { 0xFB07, 0xFB12} /* Cn */,
|
||||
{ 0xFB18, 0xFB1C} /* Cn */, { 0xFB37, 0xFB37} /* Cn */,
|
||||
{ 0xFB3D, 0xFB3D} /* Cn */, { 0xFB3F, 0xFB3F} /* Cn */,
|
||||
{ 0xFB42, 0xFB42} /* Cn */, { 0xFB45, 0xFB45} /* Cn */,
|
||||
{ 0xFBB2, 0xFBD2} /* Cn */, { 0xFD40, 0xFD4F} /* Cn */,
|
||||
{ 0xFD90, 0xFD91} /* Cn */, { 0xFDC8, 0xFDEF} /* Cn */,
|
||||
{ 0xFDFE, 0xFDFF} /* Cn */, { 0xFE1A, 0xFE1F} /* Cn */,
|
||||
{ 0xFE24, 0xFE2F} /* Cn */, { 0xFE53, 0xFE53} /* Cn */,
|
||||
{ 0xFE67, 0xFE67} /* Cn */, { 0xFE6C, 0xFE6F} /* Cn */,
|
||||
{ 0xFE75, 0xFE75} /* Cn */, { 0xFEFD, 0xFEFE} /* Cn */,
|
||||
{ 0xFEFF, 0xFEFF} /* Cf */,
|
||||
{ 0xFF00, 0xFF00} /* Cn */, { 0xFFBF, 0xFFC1} /* Cn */,
|
||||
{ 0xFFC8, 0xFFC9} /* Cn */, { 0xFFD0, 0xFFD1} /* Cn */,
|
||||
{ 0xFFD8, 0xFFD9} /* Cn */, { 0xFFDD, 0xFFDF} /* Cn */,
|
||||
{ 0xFFE7, 0xFFE7} /* Cn */, { 0xFFEF, 0xFFF8} /* Cn */,
|
||||
{ 0xFFF9, 0xFFFB} /* Cf */,
|
||||
{ 0xFFFE, 0xFFFF} /* Cn */, { 0x1000C, 0x1000C} /* Cn */,
|
||||
{ 0x10027, 0x10027} /* Cn */, { 0x1003B, 0x1003B} /* Cn */,
|
||||
{ 0x1003E, 0x1003E} /* Cn */, { 0x1004E, 0x1004F} /* Cn */,
|
||||
{ 0x1005E, 0x1007F} /* Cn */, { 0x100FB, 0x100FF} /* Cn */,
|
||||
{ 0x10103, 0x10106} /* Cn */, { 0x10134, 0x10136} /* Cn */,
|
||||
{ 0x1018B, 0x102FF} /* Cn */, { 0x1031F, 0x1031F} /* Cn */,
|
||||
{ 0x10324, 0x1032F} /* Cn */, { 0x1034B, 0x1037F} /* Cn */,
|
||||
{ 0x1039E, 0x1039E} /* Cn */, { 0x103C4, 0x103C7} /* Cn */,
|
||||
{ 0x103D6, 0x103FF} /* Cn */,
|
||||
{ 0x1049E, 0x1049F} /* Cn */, { 0x104AA, 0x107FF} /* Cn */,
|
||||
{ 0x10806, 0x10807} /* Cn */, { 0x10809, 0x10809} /* Cn */,
|
||||
{ 0x10836, 0x10836} /* Cn */, { 0x10839, 0x1083B} /* Cn */,
|
||||
{ 0x1083D, 0x1083E} /* Cn */, { 0x10840, 0x108FF} /* Cn */,
|
||||
{ 0x1091A, 0x1091E} /* Cn */, { 0x10920, 0x109FF} /* Cn */,
|
||||
{ 0x10A04, 0x10A04} /* Cn */, { 0x10A07, 0x10A0B} /* Cn */,
|
||||
{ 0x10A14, 0x10A14} /* Cn */, { 0x10A18, 0x10A18} /* Cn */,
|
||||
{ 0x10A34, 0x10A37} /* Cn */, { 0x10A3B, 0x10A3E} /* Cn */,
|
||||
{ 0x10A48, 0x10A4F} /* Cn */, { 0x10A59, 0x11FFF} /* Cn */,
|
||||
{ 0x1236F, 0x123FF} /* Cn */, { 0x12463, 0x1246F} /* Cn */,
|
||||
{ 0x12474, 0x1CFFF} /* Cn */, { 0x1D0F6, 0x1D0FF} /* Cn */,
|
||||
{ 0x1D127, 0x1D129} /* Cn */,
|
||||
{ 0x1D173, 0x1D17A} /* Cf */,
|
||||
{ 0x1D1DE, 0x1D1FF} /* Cn */, { 0x1D246, 0x1D2FF} /* Cn */,
|
||||
{ 0x1D357, 0x1D35F} /* Cn */, { 0x1D372, 0x1D3FF} /* Cn */,
|
||||
{ 0x1D455, 0x1D455} /* Cn */, { 0x1D49D, 0x1D49D} /* Cn */,
|
||||
{ 0x1D4A0, 0x1D4A1} /* Cn */, { 0x1D4A3, 0x1D4A4} /* Cn */,
|
||||
{ 0x1D4A7, 0x1D4A8} /* Cn */, { 0x1D4AD, 0x1D4AD} /* Cn */,
|
||||
{ 0x1D4BA, 0x1D4BA} /* Cn */, { 0x1D4BC, 0x1D4BC} /* Cn */,
|
||||
{ 0x1D4C4, 0x1D4C4} /* Cn */, { 0x1D506, 0x1D506} /* Cn */,
|
||||
{ 0x1D50B, 0x1D50C} /* Cn */, { 0x1D515, 0x1D515} /* Cn */,
|
||||
{ 0x1D51D, 0x1D51D} /* Cn */, { 0x1D53A, 0x1D53A} /* Cn */,
|
||||
{ 0x1D53F, 0x1D53F} /* Cn */, { 0x1D545, 0x1D545} /* Cn */,
|
||||
{ 0x1D547, 0x1D549} /* Cn */, { 0x1D551, 0x1D551} /* Cn */,
|
||||
{ 0x1D6A6, 0x1D6A7} /* Cn */, { 0x1D7CC, 0x1D7CD} /* Cn */,
|
||||
{ 0x1D800, 0x1FFFF} /* Cn */, { 0x2A6D7, 0x2F7FF} /* Cn */,
|
||||
{ 0x2FA1E, 0xE0000} /* Cn */,
|
||||
{ 0xE0001, 0xE0001} /* Cf */,
|
||||
{ 0xE0002, 0xE001F} /* Cn */,
|
||||
{ 0xE0020, 0xE007F} /* Cf */,
|
||||
{ 0xE0080, 0xE00FF} /* Cn */, { 0xE01F0, 0xEFFFF} /* Cn */,
|
||||
{ 0xF0000, 0xFFFFD} /* Co */,
|
||||
{ 0xFFFFE, 0xFFFFF} /* Cn */,
|
||||
{0x100000,0x10FFFD} /* Co */,
|
||||
{0x10FFFE,0x10FFFF} /* Cn */,
|
||||
{0x110000,0x7FFFFFFF} /* ISO 10646?? */
|
||||
};
|
||||
|
||||
/*
|
||||
* Double width characters
|
||||
* W: East Asian Wide
|
||||
* F: East Asian Full-width
|
||||
* Unassigned code points may be included when they allow ranges to be merged.
|
||||
* Last synched with
|
||||
* <http://www.unicode.org/Public/5.0.0/ucd/EastAsianWidth-5.0.0d2.txt>
|
||||
* dated 2005-11-08T01:32:56Z
|
||||
*/
|
||||
static struct wchar_range wide_table[] = {
|
||||
{ 0x1100, 0x115F} /* W */, { 0x2329, 0x232A} /* W */,
|
||||
{ 0x2E80, 0x2FFB} /* W */,
|
||||
{ 0x3000, 0x3000} /* F */,
|
||||
{ 0x3001, 0x303E} /* W */, { 0x3041, 0x4DB5} /* W */,
|
||||
{ 0x4E00, 0x9FBB} /* W */, { 0xA000, 0xA4C6} /* W */,
|
||||
{ 0xAC00, 0xD7A3} /* W */, { 0xF900, 0xFAD9} /* W */,
|
||||
{ 0xFE10, 0xFE19} /* W */, { 0xFE30, 0xFE6B} /* W */,
|
||||
{ 0xFF01, 0xFF60} /* F */, { 0xFFE0, 0xFFE6} /* F */,
|
||||
{ 0x20000, 0x2FFFD} /* W */, { 0x30000, 0x3FFFD} /* W */,
|
||||
};
|
||||
|
||||
static int
|
||||
is_in_table(ch, table, tsize)
|
||||
is_in_table(ch, table)
|
||||
LWCHAR ch;
|
||||
struct wchar_range table[];
|
||||
int tsize;
|
||||
struct wchar_range_table *table;
|
||||
{
|
||||
int hi;
|
||||
int lo;
|
||||
|
||||
/* Binary search in the table. */
|
||||
if (ch < table[0].first)
|
||||
if (ch < table->table[0].first)
|
||||
return 0;
|
||||
lo = 0;
|
||||
hi = tsize - 1;
|
||||
hi = table->count - 1;
|
||||
while (lo <= hi)
|
||||
{
|
||||
int mid = (lo + hi) / 2;
|
||||
if (ch > table[mid].last)
|
||||
if (ch > table->table[mid].last)
|
||||
lo = mid + 1;
|
||||
else if (ch < table[mid].first)
|
||||
else if (ch < table->table[mid].first)
|
||||
hi = mid - 1;
|
||||
else
|
||||
return 1;
|
||||
@ -1126,7 +777,7 @@ is_in_table(ch, table, tsize)
|
||||
is_composing_char(ch)
|
||||
LWCHAR ch;
|
||||
{
|
||||
return is_in_table(ch, comp_table, (sizeof(comp_table) / sizeof(*comp_table)));
|
||||
return is_in_table(ch, &compose_table);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1136,7 +787,7 @@ is_composing_char(ch)
|
||||
is_ubin_char(ch)
|
||||
LWCHAR ch;
|
||||
{
|
||||
return is_in_table(ch, ubin_table, (sizeof(ubin_table) / sizeof(*ubin_table)));
|
||||
return is_in_table(ch, &ubin_table);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1146,7 +797,7 @@ is_ubin_char(ch)
|
||||
is_wide_char(ch)
|
||||
LWCHAR ch;
|
||||
{
|
||||
return is_in_table(ch, wide_table, (sizeof(wide_table) / sizeof(*wide_table)));
|
||||
return is_in_table(ch, &wide_table);
|
||||
}
|
||||
|
||||
/*
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
3
cmd.h
3
cmd.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -66,6 +66,7 @@
|
||||
#define A_PREV_TAG 54
|
||||
#define A_FILTER 55
|
||||
#define A_F_UNTIL_HILITE 56
|
||||
#define A_GOEND_BUF 57
|
||||
|
||||
#define A_INVALID 100
|
||||
#define A_NOACTION 101
|
||||
|
306
cmdbuf.c
306
cmdbuf.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -203,7 +203,7 @@ cmd_step_common(p, ch, len, pwidth, bswidth)
|
||||
pr = prchar((int) ch);
|
||||
if (pwidth != NULL || bswidth != NULL)
|
||||
{
|
||||
int len = strlen(pr);
|
||||
int len = (int) strlen(pr);
|
||||
if (pwidth != NULL)
|
||||
*pwidth = len;
|
||||
if (bswidth != NULL)
|
||||
@ -222,7 +222,7 @@ cmd_step_common(p, ch, len, pwidth, bswidth)
|
||||
*bswidth = 0;
|
||||
} else if (is_ubin_char(ch))
|
||||
{
|
||||
int len = strlen(pr);
|
||||
int len = (int) strlen(pr);
|
||||
if (pwidth != NULL)
|
||||
*pwidth = len;
|
||||
if (bswidth != NULL)
|
||||
@ -375,7 +375,7 @@ cmd_lshift()
|
||||
s = ns;
|
||||
}
|
||||
|
||||
cmd_offset = s - cmdbuf;
|
||||
cmd_offset = (int) (s - cmdbuf);
|
||||
save_cp = cp;
|
||||
cmd_home();
|
||||
cmd_repaint(save_cp);
|
||||
@ -405,7 +405,7 @@ cmd_rshift()
|
||||
cols += width;
|
||||
}
|
||||
|
||||
cmd_offset = s - cmdbuf;
|
||||
cmd_offset = (int) (s - cmdbuf);
|
||||
save_cp = cp;
|
||||
cmd_home();
|
||||
cmd_repaint(save_cp);
|
||||
@ -535,7 +535,7 @@ cmd_erase()
|
||||
*/
|
||||
s = cp;
|
||||
cmd_left();
|
||||
clen = s - cp;
|
||||
clen = (int) (s - cp);
|
||||
|
||||
/*
|
||||
* Remove the char from the buffer (shift the buffer left).
|
||||
@ -701,7 +701,7 @@ cmd_updown(action)
|
||||
|
||||
if (updown_match < 0)
|
||||
{
|
||||
updown_match = cp - cmdbuf;
|
||||
updown_match = (int) (cp - cmdbuf);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -744,12 +744,13 @@ cmd_updown(action)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Add a string to a history list.
|
||||
* Add a string to an mlist.
|
||||
*/
|
||||
public void
|
||||
cmd_addhist(mlist, cmd)
|
||||
cmd_addhist(mlist, cmd, modified)
|
||||
struct mlist *mlist;
|
||||
char *cmd;
|
||||
int modified;
|
||||
{
|
||||
#if CMD_HISTORY
|
||||
struct mlist *ml;
|
||||
@ -773,6 +774,7 @@ cmd_addhist(mlist, cmd)
|
||||
*/
|
||||
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;
|
||||
@ -799,7 +801,7 @@ cmd_accept()
|
||||
*/
|
||||
if (curr_mlist == NULL)
|
||||
return;
|
||||
cmd_addhist(curr_mlist, cmdbuf);
|
||||
cmd_addhist(curr_mlist, cmdbuf, 1);
|
||||
curr_mlist->modified = 1;
|
||||
#endif
|
||||
}
|
||||
@ -965,7 +967,7 @@ delimit_word()
|
||||
int delim_quoted = 0;
|
||||
int meta_quoted = 0;
|
||||
char *esc = get_meta_escape();
|
||||
int esclen = strlen(esc);
|
||||
int esclen = (int) strlen(esc);
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -1262,7 +1264,7 @@ cmd_char(c)
|
||||
cmd_mbc_buf[cmd_mbc_buf_index++] = c;
|
||||
if (cmd_mbc_buf_index < cmd_mbc_buf_len)
|
||||
return (CC_OK);
|
||||
if (!is_utf8_well_formed(cmd_mbc_buf))
|
||||
if (!is_utf8_well_formed(cmd_mbc_buf, cmd_mbc_buf_index))
|
||||
{
|
||||
/* complete, but not well formed (non-shortest form), sequence */
|
||||
cmd_mbc_buf_len = 0;
|
||||
@ -1358,6 +1360,18 @@ cmd_lastpattern()
|
||||
#endif
|
||||
|
||||
#if CMD_HISTORY
|
||||
/*
|
||||
*/
|
||||
static int
|
||||
mlist_size(ml)
|
||||
struct mlist *ml;
|
||||
{
|
||||
int size = 0;
|
||||
for (ml = ml->next; ml->string != NULL; ml = ml->next)
|
||||
++size;
|
||||
return size;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the name of the history file.
|
||||
*/
|
||||
@ -1378,6 +1392,10 @@ histfile_name()
|
||||
return (save(name));
|
||||
}
|
||||
|
||||
/* See if history file is disabled in the build. */
|
||||
if (strcmp(LESSHISTFILE, "") == 0 || strcmp(LESSHISTFILE, "-") == 0)
|
||||
return (NULL);
|
||||
|
||||
/* Otherwise, file is in $HOME. */
|
||||
home = lgetenv("HOME");
|
||||
if (home == NULL || *home == '\0')
|
||||
@ -1388,25 +1406,28 @@ histfile_name()
|
||||
#endif
|
||||
return (NULL);
|
||||
}
|
||||
len = strlen(home) + strlen(LESSHISTFILE) + 2;
|
||||
len = (int) (strlen(home) + strlen(LESSHISTFILE) + 2);
|
||||
name = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF2(name, len, "%s/%s", home, LESSHISTFILE);
|
||||
return (name);
|
||||
}
|
||||
#endif /* CMD_HISTORY */
|
||||
|
||||
/*
|
||||
* Initialize history from a .lesshist file.
|
||||
* Read a .lesshst file and call a callback for each line in the file.
|
||||
*/
|
||||
public void
|
||||
init_cmdhist()
|
||||
static void
|
||||
read_cmdhist2(action, uparam, skip_search, skip_shell)
|
||||
void (*action)(void*,struct mlist*,char*);
|
||||
void *uparam;
|
||||
int skip_search;
|
||||
int skip_shell;
|
||||
{
|
||||
#if CMD_HISTORY
|
||||
struct mlist *ml = NULL;
|
||||
char line[CMDBUF_SIZE];
|
||||
char *filename;
|
||||
FILE *f;
|
||||
char *p;
|
||||
int *skip = NULL;
|
||||
|
||||
filename = histfile_name();
|
||||
if (filename == NULL)
|
||||
@ -1432,84 +1453,170 @@ init_cmdhist()
|
||||
}
|
||||
}
|
||||
if (strcmp(line, HISTFILE_SEARCH_SECTION) == 0)
|
||||
{
|
||||
ml = &mlist_search;
|
||||
else if (strcmp(line, HISTFILE_SHELL_SECTION) == 0)
|
||||
skip = &skip_search;
|
||||
} else if (strcmp(line, HISTFILE_SHELL_SECTION) == 0)
|
||||
{
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
ml = &mlist_shell;
|
||||
skip = &skip_shell;
|
||||
#else
|
||||
ml = NULL;
|
||||
skip = NULL;
|
||||
#endif
|
||||
} else if (*line == '"')
|
||||
{
|
||||
if (ml != NULL)
|
||||
cmd_addhist(ml, line+1);
|
||||
{
|
||||
if (skip != NULL && *skip > 0)
|
||||
--(*skip);
|
||||
else
|
||||
(*action)(uparam, ml, line+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
static void
|
||||
read_cmdhist(action, uparam, skip_search, skip_shell)
|
||||
void (*action)(void*,struct mlist*,char*);
|
||||
void *uparam;
|
||||
int skip_search;
|
||||
int skip_shell;
|
||||
{
|
||||
read_cmdhist2(action, uparam, skip_search, skip_shell);
|
||||
(*action)(uparam, NULL, NULL); /* signal end of file */
|
||||
}
|
||||
|
||||
static void
|
||||
addhist_init(void *uparam, struct mlist *ml, char *string)
|
||||
{
|
||||
if (ml == NULL || string == NULL)
|
||||
return;
|
||||
cmd_addhist(ml, string, 0);
|
||||
}
|
||||
#endif /* CMD_HISTORY */
|
||||
|
||||
/*
|
||||
* Initialize history from a .lesshist file.
|
||||
*/
|
||||
public void
|
||||
init_cmdhist()
|
||||
{
|
||||
#if CMD_HISTORY
|
||||
read_cmdhist(&addhist_init, NULL, 0, 0);
|
||||
#endif /* CMD_HISTORY */
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Write the header for a section of the history file.
|
||||
*/
|
||||
#if CMD_HISTORY
|
||||
static void
|
||||
save_mlist(ml, f)
|
||||
write_mlist_header(ml, f)
|
||||
struct mlist *ml;
|
||||
FILE *f;
|
||||
{
|
||||
int histsize = 0;
|
||||
int n;
|
||||
char *s;
|
||||
if (ml == &mlist_search)
|
||||
fprintf(f, "%s\n", HISTFILE_SEARCH_SECTION);
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
else if (ml == &mlist_shell)
|
||||
fprintf(f, "%s\n", HISTFILE_SHELL_SECTION);
|
||||
#endif
|
||||
}
|
||||
|
||||
s = lgetenv("LESSHISTSIZE");
|
||||
if (s != NULL)
|
||||
histsize = atoi(s);
|
||||
if (histsize == 0)
|
||||
histsize = 100;
|
||||
|
||||
ml = ml->prev;
|
||||
for (n = 0; n < histsize; n++)
|
||||
{
|
||||
if (ml->string == NULL)
|
||||
break;
|
||||
ml = ml->prev;
|
||||
}
|
||||
/*
|
||||
* Write all modified entries in an mlist to the history file.
|
||||
*/
|
||||
static void
|
||||
write_mlist(ml, f)
|
||||
struct mlist *ml;
|
||||
FILE *f;
|
||||
{
|
||||
for (ml = ml->next; ml->string != NULL; ml = ml->next)
|
||||
{
|
||||
if (!ml->modified)
|
||||
continue;
|
||||
fprintf(f, "\"%s\n", ml->string);
|
||||
ml->modified = 0;
|
||||
}
|
||||
ml->modified = 0; /* entire mlist is now unmodified */
|
||||
}
|
||||
|
||||
/*
|
||||
* Make a temp name in the same directory as filename.
|
||||
*/
|
||||
static char *
|
||||
make_tempname(filename)
|
||||
char *filename;
|
||||
{
|
||||
char lastch;
|
||||
char *tempname = ecalloc(1, strlen(filename)+1);
|
||||
strcpy(tempname, filename);
|
||||
lastch = tempname[strlen(tempname)-1];
|
||||
tempname[strlen(tempname)-1] = (lastch == 'Q') ? 'Z' : 'Q';
|
||||
return tempname;
|
||||
}
|
||||
|
||||
struct save_ctx
|
||||
{
|
||||
struct mlist *mlist;
|
||||
FILE *fout;
|
||||
};
|
||||
|
||||
/*
|
||||
* Copy entries from the saved history file to a new file.
|
||||
* At the end of each mlist, append any new entries
|
||||
* created during this session.
|
||||
*/
|
||||
static void
|
||||
copy_hist(void *uparam, struct mlist *ml, char *string)
|
||||
{
|
||||
struct save_ctx *ctx = (struct save_ctx *) uparam;
|
||||
|
||||
if (ml != ctx->mlist) {
|
||||
/* We're changing mlists. */
|
||||
if (ctx->mlist)
|
||||
/* Append any new entries to the end of the current mlist. */
|
||||
write_mlist(ctx->mlist, ctx->fout);
|
||||
/* Write the header for the new 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 */
|
||||
{
|
||||
/* Write any sections that were not in the original file. */
|
||||
if (mlist_search.modified)
|
||||
{
|
||||
write_mlist_header(&mlist_search, ctx->fout);
|
||||
write_mlist(&mlist_search, ctx->fout);
|
||||
}
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
if (mlist_shell.modified)
|
||||
{
|
||||
write_mlist_header(&mlist_shell, ctx->fout);
|
||||
write_mlist(&mlist_shell, ctx->fout);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
#endif /* CMD_HISTORY */
|
||||
|
||||
/*
|
||||
*
|
||||
* Make a file readable only by its owner.
|
||||
*/
|
||||
public void
|
||||
save_cmdhist()
|
||||
{
|
||||
#if CMD_HISTORY
|
||||
char *filename;
|
||||
static void
|
||||
make_file_private(f)
|
||||
FILE *f;
|
||||
int modified = 0;
|
||||
|
||||
if (mlist_search.modified)
|
||||
modified = 1;
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
if (mlist_shell.modified)
|
||||
modified = 1;
|
||||
#endif
|
||||
if (!modified)
|
||||
return;
|
||||
filename = histfile_name();
|
||||
if (filename == NULL)
|
||||
return;
|
||||
f = fopen(filename, "w");
|
||||
free(filename);
|
||||
if (f == NULL)
|
||||
return;
|
||||
#if HAVE_FCHMOD
|
||||
{
|
||||
/* Make history file readable only by owner. */
|
||||
#if HAVE_FCHMOD
|
||||
int do_chmod = 1;
|
||||
#if HAVE_STAT
|
||||
struct stat statbuf;
|
||||
@ -1520,19 +1627,74 @@ save_cmdhist()
|
||||
#endif
|
||||
if (do_chmod)
|
||||
fchmod(fileno(f), 0600);
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
|
||||
fprintf(f, "%s\n", HISTFILE_FIRST_LINE);
|
||||
|
||||
fprintf(f, "%s\n", HISTFILE_SEARCH_SECTION);
|
||||
save_mlist(&mlist_search, f);
|
||||
|
||||
/*
|
||||
* Does the history file need to be updated?
|
||||
*/
|
||||
static int
|
||||
histfile_modified()
|
||||
{
|
||||
if (mlist_search.modified)
|
||||
return 1;
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
fprintf(f, "%s\n", HISTFILE_SHELL_SECTION);
|
||||
save_mlist(&mlist_shell, f);
|
||||
if (mlist_shell.modified)
|
||||
return 1;
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
fclose(f);
|
||||
/*
|
||||
* Update the .lesshst file.
|
||||
*/
|
||||
public void
|
||||
save_cmdhist()
|
||||
{
|
||||
#if CMD_HISTORY
|
||||
char *histname;
|
||||
char *tempname;
|
||||
int skip_search;
|
||||
int skip_shell;
|
||||
struct save_ctx ctx;
|
||||
char *s;
|
||||
FILE *fout = NULL;
|
||||
int histsize = 0;
|
||||
|
||||
if (!histfile_modified())
|
||||
return;
|
||||
histname = histfile_name();
|
||||
if (histname == NULL)
|
||||
return;
|
||||
tempname = make_tempname(histname);
|
||||
fout = fopen(tempname, "w");
|
||||
if (fout != NULL)
|
||||
{
|
||||
make_file_private(fout);
|
||||
s = lgetenv("LESSHISTSIZE");
|
||||
if (s != NULL)
|
||||
histsize = atoi(s);
|
||||
if (histsize <= 0)
|
||||
histsize = 100;
|
||||
skip_search = mlist_size(&mlist_search) - histsize;
|
||||
#if SHELL_ESCAPE || PIPEC
|
||||
skip_shell = mlist_size(&mlist_shell) - histsize;
|
||||
#endif
|
||||
fprintf(fout, "%s\n", HISTFILE_FIRST_LINE);
|
||||
ctx.fout = fout;
|
||||
ctx.mlist = NULL;
|
||||
read_cmdhist(copy_hist, &ctx, skip_search, skip_shell);
|
||||
fclose(fout);
|
||||
#if MSDOS_COMPILER==WIN32C
|
||||
/*
|
||||
* Windows rename doesn't remove an existing file,
|
||||
* making it useless for atomic operations. Sigh.
|
||||
*/
|
||||
remove(histname);
|
||||
#endif
|
||||
rename(tempname, histname);
|
||||
}
|
||||
free(tempname);
|
||||
free(histname);
|
||||
#endif /* CMD_HISTORY */
|
||||
}
|
||||
|
106
command.c
106
command.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -34,6 +34,7 @@ extern int top_scroll;
|
||||
extern int ignore_eoi;
|
||||
extern int secure;
|
||||
extern int hshift;
|
||||
extern int bs_mode;
|
||||
extern int show_attn;
|
||||
extern POSITION highest_hilite;
|
||||
extern char *every_first_cmd;
|
||||
@ -54,6 +55,7 @@ extern int screen_trashed; /* The screen has been overwritten */
|
||||
extern int shift_count;
|
||||
extern int oldbot;
|
||||
extern int forw_prompt;
|
||||
extern int same_pos_bell;
|
||||
|
||||
#if SHELL_ESCAPE
|
||||
static char *shellcmd = NULL; /* For holding last shell command for "!!" */
|
||||
@ -68,6 +70,7 @@ static int optflag;
|
||||
static int optgetname;
|
||||
static POSITION bottompos;
|
||||
static int save_hshift;
|
||||
static int save_bs_mode;
|
||||
#if PIPEC
|
||||
static char pipec;
|
||||
#endif
|
||||
@ -75,9 +78,9 @@ static char pipec;
|
||||
struct ungot {
|
||||
struct ungot *ug_next;
|
||||
char ug_char;
|
||||
char ug_end_command;
|
||||
};
|
||||
static struct ungot* ungot = NULL;
|
||||
static int unget_end = 0;
|
||||
|
||||
static void multi_search();
|
||||
|
||||
@ -158,6 +161,7 @@ mca_search()
|
||||
cmd_putstr("/");
|
||||
else
|
||||
cmd_putstr("?");
|
||||
forw_prompt = 0;
|
||||
set_mlist(ml_search, 0);
|
||||
}
|
||||
|
||||
@ -192,6 +196,7 @@ mca_opt_toggle()
|
||||
cmd_putstr("!");
|
||||
break;
|
||||
}
|
||||
forw_prompt = 0;
|
||||
set_mlist(NULL, 0);
|
||||
}
|
||||
|
||||
@ -210,7 +215,7 @@ exec_mca()
|
||||
{
|
||||
case A_F_SEARCH:
|
||||
case A_B_SEARCH:
|
||||
multi_search(cbuf, (int) number);
|
||||
multi_search(cbuf, (int) number, 0);
|
||||
break;
|
||||
#if HILITE_SEARCH
|
||||
case A_FILTER:
|
||||
@ -682,7 +687,7 @@ prompt()
|
||||
{
|
||||
register constant char *p;
|
||||
|
||||
if (ungot != NULL)
|
||||
if (ungot != NULL && !ungot->ug_end_command)
|
||||
{
|
||||
/*
|
||||
* No prompt necessary if commands are from
|
||||
@ -772,40 +777,6 @@ dispversion()
|
||||
public int
|
||||
getcc()
|
||||
{
|
||||
if (unget_end)
|
||||
{
|
||||
/*
|
||||
* We have just run out of ungotten chars.
|
||||
*/
|
||||
unget_end = 0;
|
||||
if (len_cmdbuf() == 0 || !empty_screen())
|
||||
return (getchr());
|
||||
/*
|
||||
* Command is incomplete, so try to complete it.
|
||||
*/
|
||||
switch (mca)
|
||||
{
|
||||
case A_DIGIT:
|
||||
/*
|
||||
* We have a number but no command. Treat as #g.
|
||||
*/
|
||||
return ('g');
|
||||
|
||||
case A_F_SEARCH:
|
||||
case A_B_SEARCH:
|
||||
/*
|
||||
* We have "/string" but no newline. Add the \n.
|
||||
*/
|
||||
return ('\n');
|
||||
|
||||
default:
|
||||
/*
|
||||
* Some other incomplete command. Let user complete it.
|
||||
*/
|
||||
return (getchr());
|
||||
}
|
||||
}
|
||||
|
||||
if (ungot == NULL)
|
||||
{
|
||||
/*
|
||||
@ -820,9 +791,36 @@ getcc()
|
||||
{
|
||||
struct ungot *ug = ungot;
|
||||
char c = ug->ug_char;
|
||||
int end_command = ug->ug_end_command;
|
||||
ungot = ug->ug_next;
|
||||
free(ug);
|
||||
unget_end = (ungot == NULL);
|
||||
if (end_command)
|
||||
{
|
||||
/*
|
||||
* Command is incomplete, so try to complete it.
|
||||
*/
|
||||
switch (mca)
|
||||
{
|
||||
case A_DIGIT:
|
||||
/*
|
||||
* We have a number but no command. Treat as #g.
|
||||
*/
|
||||
return ('g');
|
||||
|
||||
case A_F_SEARCH:
|
||||
case A_B_SEARCH:
|
||||
/*
|
||||
* We have "/string" but no newline. Add the \n.
|
||||
*/
|
||||
return ('\n');
|
||||
|
||||
default:
|
||||
/*
|
||||
* Some other incomplete command. Let user complete it.
|
||||
*/
|
||||
return (getchr());
|
||||
}
|
||||
}
|
||||
return (c);
|
||||
}
|
||||
}
|
||||
@ -837,10 +835,10 @@ ungetcc(c)
|
||||
{
|
||||
struct ungot *ug = (struct ungot *) ecalloc(1, sizeof(struct ungot));
|
||||
|
||||
ug->ug_char = c;
|
||||
ug->ug_char = (char) c;
|
||||
ug->ug_end_command = (c == CHAR_END_COMMAND);
|
||||
ug->ug_next = ungot;
|
||||
ungot = ug;
|
||||
unget_end = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -863,9 +861,10 @@ ungetsc(s)
|
||||
* If SRCH_PAST_EOF is set, continue the search thru multiple files.
|
||||
*/
|
||||
static void
|
||||
multi_search(pattern, n)
|
||||
multi_search(pattern, n, silent)
|
||||
char *pattern;
|
||||
int n;
|
||||
int silent;
|
||||
{
|
||||
register int nomore;
|
||||
IFILE save_ifile;
|
||||
@ -940,7 +939,7 @@ multi_search(pattern, n)
|
||||
* Didn't find it.
|
||||
* Print an error message if we haven't already.
|
||||
*/
|
||||
if (n > 0)
|
||||
if (n > 0 && !silent)
|
||||
error("Pattern not found", NULL_PARG);
|
||||
|
||||
if (changed_file)
|
||||
@ -968,7 +967,7 @@ forw_loop(until_hilite)
|
||||
return (A_NOACTION);
|
||||
|
||||
cmd_exec();
|
||||
jump_forw();
|
||||
jump_forw_buffered();
|
||||
curr_len = ch_length();
|
||||
highest_hilite = until_hilite ? curr_len : NULL_POSITION;
|
||||
ignore_eoi = 1;
|
||||
@ -1013,7 +1012,6 @@ commands()
|
||||
IFILE old_ifile;
|
||||
IFILE new_ifile;
|
||||
char *tagfile;
|
||||
int until_hilite = 0;
|
||||
|
||||
search_type = SRCH_FORW;
|
||||
wscroll = (sc_height + 1) / 2;
|
||||
@ -1241,6 +1239,8 @@ commands()
|
||||
/*
|
||||
* Forward forever, ignoring EOF.
|
||||
*/
|
||||
if (show_attn)
|
||||
set_attnpos(bottompos);
|
||||
newaction = forw_loop(0);
|
||||
break;
|
||||
|
||||
@ -1326,6 +1326,17 @@ commands()
|
||||
jump_back(number);
|
||||
break;
|
||||
|
||||
case A_GOEND_BUF:
|
||||
/*
|
||||
* Go to line N, default last buffered byte.
|
||||
*/
|
||||
cmd_exec();
|
||||
if (number <= 0)
|
||||
jump_forw_buffered();
|
||||
else
|
||||
jump_back(number);
|
||||
break;
|
||||
|
||||
case A_GOPOS:
|
||||
/*
|
||||
* Go to a specified byte position in the file.
|
||||
@ -1368,6 +1379,7 @@ commands()
|
||||
* previous file.
|
||||
*/
|
||||
hshift = save_hshift;
|
||||
bs_mode = save_bs_mode;
|
||||
if (edit_prev(1) == 0)
|
||||
break;
|
||||
}
|
||||
@ -1383,7 +1395,7 @@ commands()
|
||||
if (number <= 0) number = 1; \
|
||||
mca_search(); \
|
||||
cmd_exec(); \
|
||||
multi_search((char *)NULL, (int) number);
|
||||
multi_search((char *)NULL, (int) number, 0);
|
||||
|
||||
|
||||
case A_F_SEARCH:
|
||||
@ -1471,6 +1483,8 @@ commands()
|
||||
cmd_exec();
|
||||
save_hshift = hshift;
|
||||
hshift = 0;
|
||||
save_bs_mode = bs_mode;
|
||||
bs_mode = BS_SPECIAL;
|
||||
(void) edit(FAKE_HELPFILE);
|
||||
break;
|
||||
|
||||
|
261
compose.uni
Normal file
261
compose.uni
Normal file
@ -0,0 +1,261 @@
|
||||
/* Generated by "./mkutable -f2 Mn Me -- unicode/UnicodeData.txt" on Mon Jul 14 16:21:21 PDT 2014 */
|
||||
{ 0x0300, 0x036f }, /* Mn */
|
||||
{ 0x0483, 0x0487 }, /* Mn */
|
||||
{ 0x0488, 0x0489 }, /* Me */
|
||||
{ 0x0591, 0x05bd }, /* Mn */
|
||||
{ 0x05bf, 0x05bf }, /* Mn */
|
||||
{ 0x05c1, 0x05c2 }, /* Mn */
|
||||
{ 0x05c4, 0x05c5 }, /* Mn */
|
||||
{ 0x05c7, 0x05c7 }, /* Mn */
|
||||
{ 0x0610, 0x061a }, /* Mn */
|
||||
{ 0x064b, 0x065f }, /* Mn */
|
||||
{ 0x0670, 0x0670 }, /* Mn */
|
||||
{ 0x06d6, 0x06dc }, /* Mn */
|
||||
{ 0x06df, 0x06e4 }, /* Mn */
|
||||
{ 0x06e7, 0x06e8 }, /* Mn */
|
||||
{ 0x06ea, 0x06ed }, /* Mn */
|
||||
{ 0x0711, 0x0711 }, /* Mn */
|
||||
{ 0x0730, 0x074a }, /* Mn */
|
||||
{ 0x07a6, 0x07b0 }, /* Mn */
|
||||
{ 0x07eb, 0x07f3 }, /* Mn */
|
||||
{ 0x0816, 0x0819 }, /* Mn */
|
||||
{ 0x081b, 0x0823 }, /* Mn */
|
||||
{ 0x0825, 0x0827 }, /* Mn */
|
||||
{ 0x0829, 0x082d }, /* Mn */
|
||||
{ 0x0859, 0x085b }, /* Mn */
|
||||
{ 0x08e4, 0x0902 }, /* Mn */
|
||||
{ 0x093a, 0x093a }, /* Mn */
|
||||
{ 0x093c, 0x093c }, /* Mn */
|
||||
{ 0x0941, 0x0948 }, /* Mn */
|
||||
{ 0x094d, 0x094d }, /* Mn */
|
||||
{ 0x0951, 0x0957 }, /* Mn */
|
||||
{ 0x0962, 0x0963 }, /* Mn */
|
||||
{ 0x0981, 0x0981 }, /* Mn */
|
||||
{ 0x09bc, 0x09bc }, /* Mn */
|
||||
{ 0x09c1, 0x09c4 }, /* Mn */
|
||||
{ 0x09cd, 0x09cd }, /* Mn */
|
||||
{ 0x09e2, 0x09e3 }, /* Mn */
|
||||
{ 0x0a01, 0x0a02 }, /* Mn */
|
||||
{ 0x0a3c, 0x0a3c }, /* Mn */
|
||||
{ 0x0a41, 0x0a42 }, /* Mn */
|
||||
{ 0x0a47, 0x0a48 }, /* Mn */
|
||||
{ 0x0a4b, 0x0a4d }, /* Mn */
|
||||
{ 0x0a51, 0x0a51 }, /* Mn */
|
||||
{ 0x0a70, 0x0a71 }, /* Mn */
|
||||
{ 0x0a75, 0x0a75 }, /* Mn */
|
||||
{ 0x0a81, 0x0a82 }, /* Mn */
|
||||
{ 0x0abc, 0x0abc }, /* Mn */
|
||||
{ 0x0ac1, 0x0ac5 }, /* Mn */
|
||||
{ 0x0ac7, 0x0ac8 }, /* Mn */
|
||||
{ 0x0acd, 0x0acd }, /* Mn */
|
||||
{ 0x0ae2, 0x0ae3 }, /* Mn */
|
||||
{ 0x0b01, 0x0b01 }, /* Mn */
|
||||
{ 0x0b3c, 0x0b3c }, /* Mn */
|
||||
{ 0x0b3f, 0x0b3f }, /* Mn */
|
||||
{ 0x0b41, 0x0b44 }, /* Mn */
|
||||
{ 0x0b4d, 0x0b4d }, /* Mn */
|
||||
{ 0x0b56, 0x0b56 }, /* Mn */
|
||||
{ 0x0b62, 0x0b63 }, /* Mn */
|
||||
{ 0x0b82, 0x0b82 }, /* Mn */
|
||||
{ 0x0bc0, 0x0bc0 }, /* Mn */
|
||||
{ 0x0bcd, 0x0bcd }, /* Mn */
|
||||
{ 0x0c00, 0x0c00 }, /* Mn */
|
||||
{ 0x0c3e, 0x0c40 }, /* Mn */
|
||||
{ 0x0c46, 0x0c48 }, /* Mn */
|
||||
{ 0x0c4a, 0x0c4d }, /* Mn */
|
||||
{ 0x0c55, 0x0c56 }, /* Mn */
|
||||
{ 0x0c62, 0x0c63 }, /* Mn */
|
||||
{ 0x0c81, 0x0c81 }, /* Mn */
|
||||
{ 0x0cbc, 0x0cbc }, /* Mn */
|
||||
{ 0x0cbf, 0x0cbf }, /* Mn */
|
||||
{ 0x0cc6, 0x0cc6 }, /* Mn */
|
||||
{ 0x0ccc, 0x0ccd }, /* Mn */
|
||||
{ 0x0ce2, 0x0ce3 }, /* Mn */
|
||||
{ 0x0d01, 0x0d01 }, /* Mn */
|
||||
{ 0x0d41, 0x0d44 }, /* Mn */
|
||||
{ 0x0d4d, 0x0d4d }, /* Mn */
|
||||
{ 0x0d62, 0x0d63 }, /* Mn */
|
||||
{ 0x0dca, 0x0dca }, /* Mn */
|
||||
{ 0x0dd2, 0x0dd4 }, /* Mn */
|
||||
{ 0x0dd6, 0x0dd6 }, /* Mn */
|
||||
{ 0x0e31, 0x0e31 }, /* Mn */
|
||||
{ 0x0e34, 0x0e3a }, /* Mn */
|
||||
{ 0x0e47, 0x0e4e }, /* Mn */
|
||||
{ 0x0eb1, 0x0eb1 }, /* Mn */
|
||||
{ 0x0eb4, 0x0eb9 }, /* Mn */
|
||||
{ 0x0ebb, 0x0ebc }, /* Mn */
|
||||
{ 0x0ec8, 0x0ecd }, /* Mn */
|
||||
{ 0x0f18, 0x0f19 }, /* Mn */
|
||||
{ 0x0f35, 0x0f35 }, /* Mn */
|
||||
{ 0x0f37, 0x0f37 }, /* Mn */
|
||||
{ 0x0f39, 0x0f39 }, /* Mn */
|
||||
{ 0x0f71, 0x0f7e }, /* Mn */
|
||||
{ 0x0f80, 0x0f84 }, /* Mn */
|
||||
{ 0x0f86, 0x0f87 }, /* Mn */
|
||||
{ 0x0f8d, 0x0f97 }, /* Mn */
|
||||
{ 0x0f99, 0x0fbc }, /* Mn */
|
||||
{ 0x0fc6, 0x0fc6 }, /* Mn */
|
||||
{ 0x102d, 0x1030 }, /* Mn */
|
||||
{ 0x1032, 0x1037 }, /* Mn */
|
||||
{ 0x1039, 0x103a }, /* Mn */
|
||||
{ 0x103d, 0x103e }, /* Mn */
|
||||
{ 0x1058, 0x1059 }, /* Mn */
|
||||
{ 0x105e, 0x1060 }, /* Mn */
|
||||
{ 0x1071, 0x1074 }, /* Mn */
|
||||
{ 0x1082, 0x1082 }, /* Mn */
|
||||
{ 0x1085, 0x1086 }, /* Mn */
|
||||
{ 0x108d, 0x108d }, /* Mn */
|
||||
{ 0x109d, 0x109d }, /* Mn */
|
||||
{ 0x135d, 0x135f }, /* Mn */
|
||||
{ 0x1712, 0x1714 }, /* Mn */
|
||||
{ 0x1732, 0x1734 }, /* Mn */
|
||||
{ 0x1752, 0x1753 }, /* Mn */
|
||||
{ 0x1772, 0x1773 }, /* Mn */
|
||||
{ 0x17b4, 0x17b5 }, /* Mn */
|
||||
{ 0x17b7, 0x17bd }, /* Mn */
|
||||
{ 0x17c6, 0x17c6 }, /* Mn */
|
||||
{ 0x17c9, 0x17d3 }, /* Mn */
|
||||
{ 0x17dd, 0x17dd }, /* Mn */
|
||||
{ 0x180b, 0x180d }, /* Mn */
|
||||
{ 0x18a9, 0x18a9 }, /* Mn */
|
||||
{ 0x1920, 0x1922 }, /* Mn */
|
||||
{ 0x1927, 0x1928 }, /* Mn */
|
||||
{ 0x1932, 0x1932 }, /* Mn */
|
||||
{ 0x1939, 0x193b }, /* Mn */
|
||||
{ 0x1a17, 0x1a18 }, /* Mn */
|
||||
{ 0x1a1b, 0x1a1b }, /* Mn */
|
||||
{ 0x1a56, 0x1a56 }, /* Mn */
|
||||
{ 0x1a58, 0x1a5e }, /* Mn */
|
||||
{ 0x1a60, 0x1a60 }, /* Mn */
|
||||
{ 0x1a62, 0x1a62 }, /* Mn */
|
||||
{ 0x1a65, 0x1a6c }, /* Mn */
|
||||
{ 0x1a73, 0x1a7c }, /* Mn */
|
||||
{ 0x1a7f, 0x1a7f }, /* Mn */
|
||||
{ 0x1ab0, 0x1abd }, /* Mn */
|
||||
{ 0x1abe, 0x1abe }, /* Me */
|
||||
{ 0x1b00, 0x1b03 }, /* Mn */
|
||||
{ 0x1b34, 0x1b34 }, /* Mn */
|
||||
{ 0x1b36, 0x1b3a }, /* Mn */
|
||||
{ 0x1b3c, 0x1b3c }, /* Mn */
|
||||
{ 0x1b42, 0x1b42 }, /* Mn */
|
||||
{ 0x1b6b, 0x1b73 }, /* Mn */
|
||||
{ 0x1b80, 0x1b81 }, /* Mn */
|
||||
{ 0x1ba2, 0x1ba5 }, /* Mn */
|
||||
{ 0x1ba8, 0x1ba9 }, /* Mn */
|
||||
{ 0x1bab, 0x1bad }, /* Mn */
|
||||
{ 0x1be6, 0x1be6 }, /* Mn */
|
||||
{ 0x1be8, 0x1be9 }, /* Mn */
|
||||
{ 0x1bed, 0x1bed }, /* Mn */
|
||||
{ 0x1bef, 0x1bf1 }, /* Mn */
|
||||
{ 0x1c2c, 0x1c33 }, /* Mn */
|
||||
{ 0x1c36, 0x1c37 }, /* Mn */
|
||||
{ 0x1cd0, 0x1cd2 }, /* Mn */
|
||||
{ 0x1cd4, 0x1ce0 }, /* Mn */
|
||||
{ 0x1ce2, 0x1ce8 }, /* Mn */
|
||||
{ 0x1ced, 0x1ced }, /* Mn */
|
||||
{ 0x1cf4, 0x1cf4 }, /* Mn */
|
||||
{ 0x1cf8, 0x1cf9 }, /* Mn */
|
||||
{ 0x1dc0, 0x1df5 }, /* Mn */
|
||||
{ 0x1dfc, 0x1dff }, /* Mn */
|
||||
{ 0x20d0, 0x20dc }, /* Mn */
|
||||
{ 0x20dd, 0x20e0 }, /* Me */
|
||||
{ 0x20e1, 0x20e1 }, /* Mn */
|
||||
{ 0x20e2, 0x20e4 }, /* Me */
|
||||
{ 0x20e5, 0x20f0 }, /* Mn */
|
||||
{ 0x2cef, 0x2cf1 }, /* Mn */
|
||||
{ 0x2d7f, 0x2d7f }, /* Mn */
|
||||
{ 0x2de0, 0x2dff }, /* Mn */
|
||||
{ 0x302a, 0x302d }, /* Mn */
|
||||
{ 0x3099, 0x309a }, /* Mn */
|
||||
{ 0xa66f, 0xa66f }, /* Mn */
|
||||
{ 0xa670, 0xa672 }, /* Me */
|
||||
{ 0xa674, 0xa67d }, /* Mn */
|
||||
{ 0xa69f, 0xa69f }, /* Mn */
|
||||
{ 0xa6f0, 0xa6f1 }, /* Mn */
|
||||
{ 0xa802, 0xa802 }, /* Mn */
|
||||
{ 0xa806, 0xa806 }, /* Mn */
|
||||
{ 0xa80b, 0xa80b }, /* Mn */
|
||||
{ 0xa825, 0xa826 }, /* Mn */
|
||||
{ 0xa8c4, 0xa8c4 }, /* Mn */
|
||||
{ 0xa8e0, 0xa8f1 }, /* Mn */
|
||||
{ 0xa926, 0xa92d }, /* Mn */
|
||||
{ 0xa947, 0xa951 }, /* Mn */
|
||||
{ 0xa980, 0xa982 }, /* Mn */
|
||||
{ 0xa9b3, 0xa9b3 }, /* Mn */
|
||||
{ 0xa9b6, 0xa9b9 }, /* Mn */
|
||||
{ 0xa9bc, 0xa9bc }, /* Mn */
|
||||
{ 0xa9e5, 0xa9e5 }, /* Mn */
|
||||
{ 0xaa29, 0xaa2e }, /* Mn */
|
||||
{ 0xaa31, 0xaa32 }, /* Mn */
|
||||
{ 0xaa35, 0xaa36 }, /* Mn */
|
||||
{ 0xaa43, 0xaa43 }, /* Mn */
|
||||
{ 0xaa4c, 0xaa4c }, /* Mn */
|
||||
{ 0xaa7c, 0xaa7c }, /* Mn */
|
||||
{ 0xaab0, 0xaab0 }, /* Mn */
|
||||
{ 0xaab2, 0xaab4 }, /* Mn */
|
||||
{ 0xaab7, 0xaab8 }, /* Mn */
|
||||
{ 0xaabe, 0xaabf }, /* Mn */
|
||||
{ 0xaac1, 0xaac1 }, /* Mn */
|
||||
{ 0xaaec, 0xaaed }, /* Mn */
|
||||
{ 0xaaf6, 0xaaf6 }, /* Mn */
|
||||
{ 0xabe5, 0xabe5 }, /* Mn */
|
||||
{ 0xabe8, 0xabe8 }, /* Mn */
|
||||
{ 0xabed, 0xabed }, /* Mn */
|
||||
{ 0xfb1e, 0xfb1e }, /* Mn */
|
||||
{ 0xfe00, 0xfe0f }, /* Mn */
|
||||
{ 0xfe20, 0xfe2d }, /* Mn */
|
||||
{ 0x101fd, 0x101fd }, /* Mn */
|
||||
{ 0x102e0, 0x102e0 }, /* Mn */
|
||||
{ 0x10376, 0x1037a }, /* Mn */
|
||||
{ 0x10a01, 0x10a03 }, /* Mn */
|
||||
{ 0x10a05, 0x10a06 }, /* Mn */
|
||||
{ 0x10a0c, 0x10a0f }, /* Mn */
|
||||
{ 0x10a38, 0x10a3a }, /* Mn */
|
||||
{ 0x10a3f, 0x10a3f }, /* Mn */
|
||||
{ 0x10ae5, 0x10ae6 }, /* Mn */
|
||||
{ 0x11001, 0x11001 }, /* Mn */
|
||||
{ 0x11038, 0x11046 }, /* Mn */
|
||||
{ 0x1107f, 0x11081 }, /* Mn */
|
||||
{ 0x110b3, 0x110b6 }, /* Mn */
|
||||
{ 0x110b9, 0x110ba }, /* Mn */
|
||||
{ 0x11100, 0x11102 }, /* Mn */
|
||||
{ 0x11127, 0x1112b }, /* Mn */
|
||||
{ 0x1112d, 0x11134 }, /* Mn */
|
||||
{ 0x11173, 0x11173 }, /* Mn */
|
||||
{ 0x11180, 0x11181 }, /* Mn */
|
||||
{ 0x111b6, 0x111be }, /* Mn */
|
||||
{ 0x1122f, 0x11231 }, /* Mn */
|
||||
{ 0x11234, 0x11234 }, /* Mn */
|
||||
{ 0x11236, 0x11237 }, /* Mn */
|
||||
{ 0x112df, 0x112df }, /* Mn */
|
||||
{ 0x112e3, 0x112ea }, /* Mn */
|
||||
{ 0x11301, 0x11301 }, /* Mn */
|
||||
{ 0x1133c, 0x1133c }, /* Mn */
|
||||
{ 0x11340, 0x11340 }, /* Mn */
|
||||
{ 0x11366, 0x1136c }, /* Mn */
|
||||
{ 0x11370, 0x11374 }, /* Mn */
|
||||
{ 0x114b3, 0x114b8 }, /* Mn */
|
||||
{ 0x114ba, 0x114ba }, /* Mn */
|
||||
{ 0x114bf, 0x114c0 }, /* Mn */
|
||||
{ 0x114c2, 0x114c3 }, /* Mn */
|
||||
{ 0x115b2, 0x115b5 }, /* Mn */
|
||||
{ 0x115bc, 0x115bd }, /* Mn */
|
||||
{ 0x115bf, 0x115c0 }, /* Mn */
|
||||
{ 0x11633, 0x1163a }, /* Mn */
|
||||
{ 0x1163d, 0x1163d }, /* Mn */
|
||||
{ 0x1163f, 0x11640 }, /* Mn */
|
||||
{ 0x116ab, 0x116ab }, /* Mn */
|
||||
{ 0x116ad, 0x116ad }, /* Mn */
|
||||
{ 0x116b0, 0x116b5 }, /* Mn */
|
||||
{ 0x116b7, 0x116b7 }, /* Mn */
|
||||
{ 0x16af0, 0x16af4 }, /* Mn */
|
||||
{ 0x16b30, 0x16b36 }, /* Mn */
|
||||
{ 0x16f8f, 0x16f92 }, /* Mn */
|
||||
{ 0x1bc9d, 0x1bc9e }, /* Mn */
|
||||
{ 0x1d167, 0x1d169 }, /* Mn */
|
||||
{ 0x1d17b, 0x1d182 }, /* Mn */
|
||||
{ 0x1d185, 0x1d18b }, /* Mn */
|
||||
{ 0x1d1aa, 0x1d1ad }, /* Mn */
|
||||
{ 0x1d242, 0x1d244 }, /* Mn */
|
||||
{ 0x1e8d0, 0x1e8d6 }, /* Mn */
|
||||
{ 0xe0100, 0xe01ef }, /* Mn */
|
232
configure
vendored
232
configure
vendored
@ -1,11 +1,9 @@
|
||||
#! /bin/sh
|
||||
# Guess values for system-dependent variables and create Makefiles.
|
||||
# Generated by GNU Autoconf 2.68 for less 1.
|
||||
# Generated by GNU Autoconf 2.69 for less 1.
|
||||
#
|
||||
#
|
||||
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
|
||||
# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
|
||||
# Foundation, Inc.
|
||||
# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
|
||||
#
|
||||
#
|
||||
# This configure script is free software; the Free Software Foundation
|
||||
@ -134,6 +132,31 @@ export LANGUAGE
|
||||
# CDPATH.
|
||||
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
|
||||
|
||||
# Use a proper internal environment variable to ensure we don't fall
|
||||
# into an infinite loop, continuously re-executing ourselves.
|
||||
if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
|
||||
_as_can_reexec=no; export _as_can_reexec;
|
||||
# We cannot yet assume a decent shell, so we have to provide a
|
||||
# neutralization value for shells without unset; and this also
|
||||
# works around shells that cannot unset nonexistent variables.
|
||||
# Preserve -v and -x to the replacement shell.
|
||||
BASH_ENV=/dev/null
|
||||
ENV=/dev/null
|
||||
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
||||
case $- in # ((((
|
||||
*v*x* | *x*v* ) as_opts=-vx ;;
|
||||
*v* ) as_opts=-v ;;
|
||||
*x* ) as_opts=-x ;;
|
||||
* ) as_opts= ;;
|
||||
esac
|
||||
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
|
||||
# Admittedly, this is quite paranoid, since all the known shells bail
|
||||
# out after a failed `exec'.
|
||||
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
|
||||
as_fn_exit 255
|
||||
fi
|
||||
# We don't want this to propagate to other subprocesses.
|
||||
{ _as_can_reexec=; unset _as_can_reexec;}
|
||||
if test "x$CONFIG_SHELL" = x; then
|
||||
as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
|
||||
emulate sh
|
||||
@ -167,7 +190,8 @@ if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
|
||||
else
|
||||
exitcode=1; echo positional parameters were not saved.
|
||||
fi
|
||||
test x\$exitcode = x0 || exit 1"
|
||||
test x\$exitcode = x0 || exit 1
|
||||
test -x / || exit 1"
|
||||
as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
|
||||
as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
|
||||
eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
|
||||
@ -212,21 +236,25 @@ IFS=$as_save_IFS
|
||||
|
||||
|
||||
if test "x$CONFIG_SHELL" != x; then :
|
||||
# We cannot yet assume a decent shell, so we have to provide a
|
||||
# neutralization value for shells without unset; and this also
|
||||
# works around shells that cannot unset nonexistent variables.
|
||||
# Preserve -v and -x to the replacement shell.
|
||||
BASH_ENV=/dev/null
|
||||
ENV=/dev/null
|
||||
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
||||
export CONFIG_SHELL
|
||||
case $- in # ((((
|
||||
*v*x* | *x*v* ) as_opts=-vx ;;
|
||||
*v* ) as_opts=-v ;;
|
||||
*x* ) as_opts=-x ;;
|
||||
* ) as_opts= ;;
|
||||
esac
|
||||
exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
|
||||
export CONFIG_SHELL
|
||||
# We cannot yet assume a decent shell, so we have to provide a
|
||||
# neutralization value for shells without unset; and this also
|
||||
# works around shells that cannot unset nonexistent variables.
|
||||
# Preserve -v and -x to the replacement shell.
|
||||
BASH_ENV=/dev/null
|
||||
ENV=/dev/null
|
||||
(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
|
||||
case $- in # ((((
|
||||
*v*x* | *x*v* ) as_opts=-vx ;;
|
||||
*v* ) as_opts=-v ;;
|
||||
*x* ) as_opts=-x ;;
|
||||
* ) as_opts= ;;
|
||||
esac
|
||||
exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
|
||||
# Admittedly, this is quite paranoid, since all the known shells bail
|
||||
# out after a failed `exec'.
|
||||
$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
|
||||
exit 255
|
||||
fi
|
||||
|
||||
if test x$as_have_required = xno; then :
|
||||
@ -328,6 +356,14 @@ $as_echo X"$as_dir" |
|
||||
|
||||
|
||||
} # as_fn_mkdir_p
|
||||
|
||||
# as_fn_executable_p FILE
|
||||
# -----------------------
|
||||
# Test if FILE is an executable regular file.
|
||||
as_fn_executable_p ()
|
||||
{
|
||||
test -f "$1" && test -x "$1"
|
||||
} # as_fn_executable_p
|
||||
# as_fn_append VAR VALUE
|
||||
# ----------------------
|
||||
# Append the text in VALUE to the end of the definition contained in VAR. Take
|
||||
@ -449,6 +485,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
|
||||
chmod +x "$as_me.lineno" ||
|
||||
{ $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
|
||||
|
||||
# If we had to re-execute with $CONFIG_SHELL, we're ensured to have
|
||||
# already done that, so ensure we don't try to do so again and fall
|
||||
# in an infinite loop. This has already happened in practice.
|
||||
_as_can_reexec=no; export _as_can_reexec
|
||||
# Don't try to exec as it changes $[0], causing all sort of problems
|
||||
# (the dirname of $[0] is not the place where we might find the
|
||||
# original and so on. Autoconf is especially sensitive to this).
|
||||
@ -483,16 +523,16 @@ if (echo >conf$$.file) 2>/dev/null; then
|
||||
# ... but there are two gotchas:
|
||||
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
|
||||
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
|
||||
# In both cases, we have to default to `cp -p'.
|
||||
# In both cases, we have to default to `cp -pR'.
|
||||
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
elif ln conf$$.file conf$$ 2>/dev/null; then
|
||||
as_ln_s=ln
|
||||
else
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
fi
|
||||
else
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
fi
|
||||
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
|
||||
rmdir conf$$.dir 2>/dev/null
|
||||
@ -504,28 +544,8 @@ else
|
||||
as_mkdir_p=false
|
||||
fi
|
||||
|
||||
if test -x / >/dev/null 2>&1; then
|
||||
as_test_x='test -x'
|
||||
else
|
||||
if ls -dL / >/dev/null 2>&1; then
|
||||
as_ls_L_option=L
|
||||
else
|
||||
as_ls_L_option=
|
||||
fi
|
||||
as_test_x='
|
||||
eval sh -c '\''
|
||||
if test -d "$1"; then
|
||||
test -d "$1/.";
|
||||
else
|
||||
case $1 in #(
|
||||
-*)set "./$1";;
|
||||
esac;
|
||||
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
|
||||
???[sx]*):;;*)false;;esac;fi
|
||||
'\'' sh
|
||||
'
|
||||
fi
|
||||
as_executable_p=$as_test_x
|
||||
as_test_x='test -x'
|
||||
as_executable_p=as_fn_executable_p
|
||||
|
||||
# Sed expression to map a string onto a valid CPP name.
|
||||
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
|
||||
@ -1126,8 +1146,6 @@ target=$target_alias
|
||||
if test "x$host_alias" != x; then
|
||||
if test "x$build_alias" = x; then
|
||||
cross_compiling=maybe
|
||||
$as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
|
||||
If a cross compiler is detected then cross compile mode will be used" >&2
|
||||
elif test "x$build_alias" != "x$host_alias"; then
|
||||
cross_compiling=yes
|
||||
fi
|
||||
@ -1369,9 +1387,9 @@ test -n "$ac_init_help" && exit $ac_status
|
||||
if $ac_init_version; then
|
||||
cat <<\_ACEOF
|
||||
less configure 1
|
||||
generated by GNU Autoconf 2.68
|
||||
generated by GNU Autoconf 2.69
|
||||
|
||||
Copyright (C) 2010 Free Software Foundation, Inc.
|
||||
Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
This configure script is free software; the Free Software Foundation
|
||||
gives unlimited permission to copy, distribute and modify it.
|
||||
_ACEOF
|
||||
@ -1447,7 +1465,7 @@ $as_echo "$ac_try_echo"; } >&5
|
||||
test ! -s conftest.err
|
||||
} && test -s conftest$ac_exeext && {
|
||||
test "$cross_compiling" = yes ||
|
||||
$as_test_x conftest$ac_exeext
|
||||
test -x conftest$ac_exeext
|
||||
}; then :
|
||||
ac_retval=0
|
||||
else
|
||||
@ -1788,7 +1806,7 @@ This file contains any messages produced by compilers while
|
||||
running configure, to aid debugging if configure makes a mistake.
|
||||
|
||||
It was created by less $as_me 1, which was
|
||||
generated by GNU Autoconf 2.68. Invocation command line was
|
||||
generated by GNU Autoconf 2.69. Invocation command line was
|
||||
|
||||
$ $0 $@
|
||||
|
||||
@ -2046,7 +2064,7 @@ $as_echo "$as_me: loading site script $ac_site_file" >&6;}
|
||||
|| { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "failed to load site script $ac_site_file
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
fi
|
||||
done
|
||||
|
||||
@ -2162,7 +2180,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
ac_cv_prog_CC="${ac_tool_prefix}gcc"
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
||||
break 2
|
||||
@ -2202,7 +2220,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
ac_cv_prog_ac_ct_CC="gcc"
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
||||
break 2
|
||||
@ -2255,7 +2273,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
ac_cv_prog_CC="${ac_tool_prefix}cc"
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
||||
break 2
|
||||
@ -2296,7 +2314,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
|
||||
ac_prog_rejected=yes
|
||||
continue
|
||||
@ -2354,7 +2372,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
||||
break 2
|
||||
@ -2398,7 +2416,7 @@ do
|
||||
IFS=$as_save_IFS
|
||||
test -z "$as_dir" && as_dir=.
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
|
||||
ac_cv_prog_ac_ct_CC="$ac_prog"
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
|
||||
break 2
|
||||
@ -2441,7 +2459,7 @@ fi
|
||||
test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "no acceptable C compiler found in \$PATH
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
|
||||
# Provide some information about the compiler.
|
||||
$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
|
||||
@ -2556,7 +2574,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
|
||||
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error 77 "C compiler cannot create executables
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
else
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
|
||||
$as_echo "yes" >&6; }
|
||||
@ -2599,7 +2617,7 @@ else
|
||||
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "cannot compute suffix of executables: cannot compile and link
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
fi
|
||||
rm -f conftest conftest$ac_cv_exeext
|
||||
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
|
||||
@ -2658,7 +2676,7 @@ $as_echo "$ac_try_echo"; } >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "cannot run C compiled programs.
|
||||
If you meant to cross compile, use \`--host'.
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
@ -2710,7 +2728,7 @@ sed 's/^/| /' conftest.$ac_ext >&5
|
||||
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "cannot compute suffix of object files: cannot compile
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
fi
|
||||
rm -f conftest.$ac_cv_objext conftest.$ac_ext
|
||||
fi
|
||||
@ -2844,8 +2862,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
|
||||
/* end confdefs.h. */
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
struct stat;
|
||||
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */
|
||||
struct buf { int x; };
|
||||
FILE * (*rcsopen) (struct buf *, struct stat *, int);
|
||||
@ -3115,7 +3132,7 @@ else
|
||||
{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
|
||||
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
|
||||
as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
|
||||
See \`config.log' for more details" "$LINENO" 5 ; }
|
||||
See \`config.log' for more details" "$LINENO" 5; }
|
||||
fi
|
||||
|
||||
ac_ext=c
|
||||
@ -3141,7 +3158,7 @@ do
|
||||
for ac_prog in grep ggrep; do
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
|
||||
{ test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
|
||||
as_fn_executable_p "$ac_path_GREP" || continue
|
||||
# Check for GNU ac_path_GREP and select it if it is found.
|
||||
# Check for GNU $ac_path_GREP
|
||||
case `"$ac_path_GREP" --version 2>&1` in
|
||||
@ -3207,7 +3224,7 @@ do
|
||||
for ac_prog in egrep; do
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
|
||||
{ test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
|
||||
as_fn_executable_p "$ac_path_EGREP" || continue
|
||||
# Check for GNU ac_path_EGREP and select it if it is found.
|
||||
# Check for GNU $ac_path_EGREP
|
||||
case `"$ac_path_EGREP" --version 2>&1` in
|
||||
@ -3363,7 +3380,7 @@ case $as_dir/ in #((
|
||||
# by default.
|
||||
for ac_prog in ginstall scoinst install; do
|
||||
for ac_exec_ext in '' $ac_executable_extensions; do
|
||||
if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
|
||||
if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
|
||||
if test $ac_prog = install &&
|
||||
grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
|
||||
# AIX install. It has an incompatible calling convention.
|
||||
@ -3617,6 +3634,8 @@ _ACEOF
|
||||
esac
|
||||
rm -rf conftest*
|
||||
fi
|
||||
|
||||
|
||||
fi
|
||||
|
||||
|
||||
@ -4434,11 +4453,11 @@ else
|
||||
int
|
||||
main ()
|
||||
{
|
||||
/* FIXME: Include the comments suggested by Paul. */
|
||||
|
||||
#ifndef __cplusplus
|
||||
/* Ultrix mips cc rejects this. */
|
||||
/* Ultrix mips cc rejects this sort of thing. */
|
||||
typedef int charset[2];
|
||||
const charset cs;
|
||||
const charset cs = { 0, 0 };
|
||||
/* SunOS 4.1.1 cc rejects this. */
|
||||
char const *const *pcpcc;
|
||||
char **ppc;
|
||||
@ -4455,8 +4474,9 @@ main ()
|
||||
++pcpcc;
|
||||
ppc = (char**) pcpcc;
|
||||
pcpcc = (char const *const *) ppc;
|
||||
{ /* SCO 3.2v4 cc rejects this. */
|
||||
char *t;
|
||||
{ /* SCO 3.2v4 cc rejects this sort of thing. */
|
||||
char tx;
|
||||
char *t = &tx;
|
||||
char const *s = 0 ? (char *) 0 : (char const *) 0;
|
||||
|
||||
*t++ = 0;
|
||||
@ -4472,10 +4492,10 @@ main ()
|
||||
iptr p = 0;
|
||||
++p;
|
||||
}
|
||||
{ /* AIX XL C 1.02.0.0 rejects this saying
|
||||
{ /* AIX XL C 1.02.0.0 rejects this sort of thing, saying
|
||||
"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
|
||||
struct s { int j; const int *ap[3]; };
|
||||
struct s *b; b->j = 5;
|
||||
struct s { int j; const int *ap[3]; } bx;
|
||||
struct s *b = &bx; b->j = 5;
|
||||
}
|
||||
{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
|
||||
const int foo = 10;
|
||||
@ -5862,16 +5882,16 @@ if (echo >conf$$.file) 2>/dev/null; then
|
||||
# ... but there are two gotchas:
|
||||
# 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
|
||||
# 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
|
||||
# In both cases, we have to default to `cp -p'.
|
||||
# In both cases, we have to default to `cp -pR'.
|
||||
ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
elif ln conf$$.file conf$$ 2>/dev/null; then
|
||||
as_ln_s=ln
|
||||
else
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
fi
|
||||
else
|
||||
as_ln_s='cp -p'
|
||||
as_ln_s='cp -pR'
|
||||
fi
|
||||
rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
|
||||
rmdir conf$$.dir 2>/dev/null
|
||||
@ -5931,28 +5951,16 @@ else
|
||||
as_mkdir_p=false
|
||||
fi
|
||||
|
||||
if test -x / >/dev/null 2>&1; then
|
||||
as_test_x='test -x'
|
||||
else
|
||||
if ls -dL / >/dev/null 2>&1; then
|
||||
as_ls_L_option=L
|
||||
else
|
||||
as_ls_L_option=
|
||||
fi
|
||||
as_test_x='
|
||||
eval sh -c '\''
|
||||
if test -d "$1"; then
|
||||
test -d "$1/.";
|
||||
else
|
||||
case $1 in #(
|
||||
-*)set "./$1";;
|
||||
esac;
|
||||
case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
|
||||
???[sx]*):;;*)false;;esac;fi
|
||||
'\'' sh
|
||||
'
|
||||
fi
|
||||
as_executable_p=$as_test_x
|
||||
|
||||
# as_fn_executable_p FILE
|
||||
# -----------------------
|
||||
# Test if FILE is an executable regular file.
|
||||
as_fn_executable_p ()
|
||||
{
|
||||
test -f "$1" && test -x "$1"
|
||||
} # as_fn_executable_p
|
||||
as_test_x='test -x'
|
||||
as_executable_p=as_fn_executable_p
|
||||
|
||||
# Sed expression to map a string onto a valid CPP name.
|
||||
as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
|
||||
@ -5974,7 +5982,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
|
||||
# values after options handling.
|
||||
ac_log="
|
||||
This file was extended by less $as_me 1, which was
|
||||
generated by GNU Autoconf 2.68. Invocation command line was
|
||||
generated by GNU Autoconf 2.69. Invocation command line was
|
||||
|
||||
CONFIG_FILES = $CONFIG_FILES
|
||||
CONFIG_HEADERS = $CONFIG_HEADERS
|
||||
@ -6036,10 +6044,10 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
||||
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
|
||||
ac_cs_version="\\
|
||||
less config.status 1
|
||||
configured by $0, generated by GNU Autoconf 2.68,
|
||||
configured by $0, generated by GNU Autoconf 2.69,
|
||||
with options \\"\$ac_cs_config\\"
|
||||
|
||||
Copyright (C) 2010 Free Software Foundation, Inc.
|
||||
Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
This config.status script is free software; the Free Software Foundation
|
||||
gives unlimited permission to copy, distribute and modify it."
|
||||
|
||||
@ -6128,7 +6136,7 @@ fi
|
||||
_ACEOF
|
||||
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
|
||||
if \$ac_cs_recheck; then
|
||||
set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
|
||||
set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
|
||||
shift
|
||||
\$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
|
||||
CONFIG_SHELL='$SHELL'
|
||||
@ -6160,7 +6168,7 @@ do
|
||||
"defines.h") CONFIG_HEADERS="$CONFIG_HEADERS defines.h" ;;
|
||||
"Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
|
||||
|
||||
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;;
|
||||
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
|
||||
esac
|
||||
done
|
||||
|
||||
@ -6477,7 +6485,7 @@ do
|
||||
esac
|
||||
case $ac_mode$ac_tag in
|
||||
:[FHL]*:*);;
|
||||
:L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;;
|
||||
:L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
|
||||
:[FH]-) ac_tag=-:-;;
|
||||
:[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
|
||||
esac
|
||||
@ -6505,7 +6513,7 @@ do
|
||||
[\\/$]*) false;;
|
||||
*) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
|
||||
esac ||
|
||||
as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;;
|
||||
as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
|
||||
esac
|
||||
case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
|
||||
as_fn_append ac_file_inputs " '$ac_f'"
|
||||
@ -6532,7 +6540,7 @@ $as_echo "$as_me: creating $ac_file" >&6;}
|
||||
|
||||
case $ac_tag in
|
||||
*:-:* | *:-) cat >"$ac_tmp/stdin" \
|
||||
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
|
||||
|| as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
|
||||
esac
|
||||
;;
|
||||
esac
|
||||
|
8
cvt.c
8
cvt.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -75,8 +75,8 @@ cvt_text(odst, osrc, chpos, lenp, ops)
|
||||
|
||||
for (src = osrc, dst = odst; src < src_end; )
|
||||
{
|
||||
int src_pos = src - osrc;
|
||||
int dst_pos = dst - odst;
|
||||
int src_pos = (int) (src - osrc);
|
||||
int dst_pos = (int) (dst - odst);
|
||||
ch = step_char(&src, +1, src_end);
|
||||
if ((ops & CVT_BS) && ch == '\b' && dst > odst)
|
||||
{
|
||||
@ -109,6 +109,6 @@ cvt_text(odst, osrc, chpos, lenp, ops)
|
||||
edst--;
|
||||
*edst = '\0';
|
||||
if (lenp != NULL)
|
||||
*lenp = edst - odst;
|
||||
*lenp = (int) (edst - odst);
|
||||
/* FIXME: why was this here? if (chpos != NULL) chpos[dst - odst] = src - osrc; */
|
||||
}
|
||||
|
3
decode.c
3
decode.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -105,6 +105,7 @@ static unsigned char cmdtable[] =
|
||||
ESC,CONTROL('F'),0, A_F_BRACKET,
|
||||
ESC,CONTROL('B'),0, A_B_BRACKET,
|
||||
'G',0, A_GOEND,
|
||||
ESC,'G',0, A_GOEND_BUF,
|
||||
ESC,'>',0, A_GOEND,
|
||||
'>',0, A_GOEND,
|
||||
SK(SK_END),0, A_GOEND,
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -416,6 +416,11 @@
|
||||
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
|
||||
#undef TIME_WITH_SYS_TIME
|
||||
|
||||
/* Enable large inode numbers on Mac OS X 10.5. */
|
||||
#ifndef _DARWIN_USE_64_BIT_INODE
|
||||
# define _DARWIN_USE_64_BIT_INODE 1
|
||||
#endif
|
||||
|
||||
/* Number of bits in a file offset, on hosts where this is settable. */
|
||||
#undef _FILE_OFFSET_BITS
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -345,6 +345,8 @@
|
||||
|
||||
#define popen _popen
|
||||
#define pclose _pclose
|
||||
#if !defined(_MSC_VER) || (_MSC_VER < 1900)
|
||||
#define snprintf _snprintf
|
||||
#endif
|
||||
|
||||
#pragma warning(disable:4996)
|
||||
|
13
edit.c
13
edit.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -64,7 +64,7 @@ init_textlist(tlist, str)
|
||||
int meta_quoted = 0;
|
||||
int delim_quoted = 0;
|
||||
char *esc = get_meta_escape();
|
||||
int esclen = strlen(esc);
|
||||
int esclen = (int) strlen(esc);
|
||||
#endif
|
||||
|
||||
tlist->string = skipsp(str);
|
||||
@ -411,7 +411,10 @@ edit_ifile(ifile)
|
||||
}
|
||||
#endif
|
||||
if (every_first_cmd != NULL)
|
||||
{
|
||||
ungetcc(CHAR_END_COMMAND);
|
||||
ungetsc(every_first_cmd);
|
||||
}
|
||||
}
|
||||
|
||||
free(qopen_filename);
|
||||
@ -433,7 +436,8 @@ edit_ifile(ifile)
|
||||
#if HILITE_SEARCH
|
||||
clr_hilite();
|
||||
#endif
|
||||
cmd_addhist(ml_examine, filename);
|
||||
if (strcmp(filename, FAKE_HELPFILE) && strcmp(filename, FAKE_EMPTYFILE))
|
||||
cmd_addhist(ml_examine, filename, 1);
|
||||
if (no_display && errmsgs > 0)
|
||||
{
|
||||
/*
|
||||
@ -745,7 +749,8 @@ use_logfile(filename)
|
||||
*/
|
||||
filename = shell_unquote(filename);
|
||||
exists = open(filename, OPEN_READ);
|
||||
close(exists);
|
||||
if (exists >= 0)
|
||||
close(exists);
|
||||
exists = (exists >= 0);
|
||||
|
||||
/*
|
||||
|
75
filename.c
75
filename.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -86,7 +86,7 @@ shell_unquote(str)
|
||||
} else
|
||||
{
|
||||
char *esc = get_meta_escape();
|
||||
int esclen = strlen(esc);
|
||||
int esclen = (int) strlen(esc);
|
||||
while (*str != '\0')
|
||||
{
|
||||
if (esclen > 0 && strncmp(str, esc, esclen) == 0)
|
||||
@ -150,7 +150,7 @@ shell_quote(s)
|
||||
char *newstr;
|
||||
int len;
|
||||
char *esc = get_meta_escape();
|
||||
int esclen = strlen(esc);
|
||||
int esclen = (int) strlen(esc);
|
||||
int use_quotes = 0;
|
||||
int have_quotes = 0;
|
||||
|
||||
@ -188,7 +188,7 @@ shell_quote(s)
|
||||
* We can't quote a string that contains quotes.
|
||||
*/
|
||||
return (NULL);
|
||||
len = strlen(s) + 3;
|
||||
len = (int) strlen(s) + 3;
|
||||
}
|
||||
/*
|
||||
* Allocate and construct the new string.
|
||||
@ -235,7 +235,7 @@ dirfile(dirname, filename)
|
||||
/*
|
||||
* Construct the full pathname.
|
||||
*/
|
||||
len= strlen(dirname) + strlen(filename) + 2;
|
||||
len = (int) (strlen(dirname) + strlen(filename) + 2);
|
||||
pathname = (char *) calloc(len, sizeof(char));
|
||||
if (pathname == NULL)
|
||||
return (NULL);
|
||||
@ -350,7 +350,7 @@ fexpand(s)
|
||||
if (ifile == NULL_IFILE)
|
||||
n++;
|
||||
else
|
||||
n += strlen(get_filename(ifile));
|
||||
n += (int) strlen(get_filename(ifile));
|
||||
}
|
||||
/*
|
||||
* Else it is the first char in a string of
|
||||
@ -432,7 +432,7 @@ fcomplete(s)
|
||||
for (slash = s+strlen(s)-1; slash > s; slash--)
|
||||
if (*slash == *PATHNAME_SEP || *slash == '/')
|
||||
break;
|
||||
len = strlen(s) + 4;
|
||||
len = (int) strlen(s) + 4;
|
||||
fpat = (char *) ecalloc(len, sizeof(char));
|
||||
if (strchr(slash, '.') == NULL)
|
||||
SNPRINTF1(fpat, len, "%s*.*", s);
|
||||
@ -441,7 +441,7 @@ fcomplete(s)
|
||||
}
|
||||
#else
|
||||
{
|
||||
int len = strlen(s) + 2;
|
||||
int len = (int) strlen(s) + 2;
|
||||
fpat = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF1(fpat, len, "%s*", s);
|
||||
}
|
||||
@ -481,17 +481,25 @@ bin_file(f)
|
||||
if (lseek(f, (off_t)0, SEEK_SET) == BAD_LSEEK)
|
||||
return (0);
|
||||
n = read(f, data, sizeof(data));
|
||||
pend = &data[n];
|
||||
for (p = data; p < pend; )
|
||||
if (n <= 0)
|
||||
return (0);
|
||||
if (utf_mode)
|
||||
{
|
||||
LWCHAR c = step_char(&p, +1, pend);
|
||||
if (ctldisp == OPT_ONPLUS && IS_CSI_START(c))
|
||||
bin_count = utf_bin_count(data, n);
|
||||
} else
|
||||
{
|
||||
pend = &data[n];
|
||||
for (p = data; p < pend; )
|
||||
{
|
||||
do {
|
||||
c = step_char(&p, +1, pend);
|
||||
} while (p < pend && is_ansi_middle(c));
|
||||
} else if (binary_char(c))
|
||||
bin_count++;
|
||||
LWCHAR c = step_char(&p, +1, pend);
|
||||
if (ctldisp == OPT_ONPLUS && IS_CSI_START(c))
|
||||
{
|
||||
do {
|
||||
c = step_char(&p, +1, pend);
|
||||
} while (p < pend && is_ansi_middle(c));
|
||||
} else if (binary_char(c))
|
||||
bin_count++;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Call it a binary file if there are more than 5 binary characters
|
||||
@ -593,7 +601,7 @@ shellcmd(cmd)
|
||||
fd = popen(cmd, "r");
|
||||
} else
|
||||
{
|
||||
int len = strlen(shell) + strlen(esccmd) + 5;
|
||||
int len = (int) (strlen(shell) + strlen(esccmd) + 5);
|
||||
scmd = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF3(scmd, len, "%s %s %s", shell, shell_coption(), esccmd);
|
||||
free(esccmd);
|
||||
@ -701,14 +709,14 @@ lglob(filename)
|
||||
gfilename = (char *) ecalloc(len, sizeof(char));
|
||||
p = gfilename;
|
||||
do {
|
||||
n = strlen(drive) + strlen(dir) + strlen(fnd.GLOB_NAME) + 1;
|
||||
n = (int) (strlen(drive) + strlen(dir) + strlen(fnd.GLOB_NAME) + 1);
|
||||
pathname = (char *) ecalloc(n, sizeof(char));
|
||||
SNPRINTF3(pathname, n, "%s%s%s", drive, dir, fnd.GLOB_NAME);
|
||||
qpathname = shell_quote(pathname);
|
||||
free(pathname);
|
||||
if (qpathname != NULL)
|
||||
{
|
||||
n = strlen(qpathname);
|
||||
n = (int) strlen(qpathname);
|
||||
while (p - gfilename + n + 2 >= len)
|
||||
{
|
||||
/*
|
||||
@ -765,7 +773,7 @@ lglob(filename)
|
||||
/*
|
||||
* Invoke lessecho, and read its output (a globbed list of filenames).
|
||||
*/
|
||||
len = strlen(lessecho) + strlen(ofilename) + (7*strlen(metachars())) + 24;
|
||||
len = (int) (strlen(lessecho) + strlen(ofilename) + (7*strlen(metachars())) + 24);
|
||||
cmd = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF4(cmd, len, "%s -p0x%x -d0x%x -e%s ", lessecho, openquote, closequote, esc);
|
||||
free(esc);
|
||||
@ -813,15 +821,20 @@ lglob(filename)
|
||||
num_pct_s(lessopen)
|
||||
char *lessopen;
|
||||
{
|
||||
int num;
|
||||
int num = 0;
|
||||
|
||||
for (num = 0;; num++)
|
||||
while (*lessopen != '\0')
|
||||
{
|
||||
lessopen = strchr(lessopen, '%');
|
||||
if (lessopen == NULL)
|
||||
break;
|
||||
if (*++lessopen != 's')
|
||||
return (999);
|
||||
if (*lessopen == '%')
|
||||
{
|
||||
if (lessopen[1] == '%')
|
||||
++lessopen;
|
||||
else if (lessopen[1] == 's')
|
||||
++num;
|
||||
else
|
||||
return (999);
|
||||
}
|
||||
++lessopen;
|
||||
}
|
||||
return (num);
|
||||
}
|
||||
@ -881,7 +894,7 @@ open_altfile(filename, pf, pfd)
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
len = strlen(lessopen) + strlen(filename) + 2;
|
||||
len = (int) (strlen(lessopen) + strlen(filename) + 2);
|
||||
cmd = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF1(cmd, len, lessopen, filename);
|
||||
fd = shellcmd(cmd);
|
||||
@ -971,10 +984,10 @@ close_altfile(altfilename, filename, pipefd)
|
||||
return;
|
||||
if (num_pct_s(lessclose) > 2)
|
||||
{
|
||||
error("Invalid LESSCLOSE variable");
|
||||
error("Invalid LESSCLOSE variable", NULL_PARG);
|
||||
return;
|
||||
}
|
||||
len = strlen(lessclose) + strlen(filename) + strlen(altfilename) + 2;
|
||||
len = (int) (strlen(lessclose) + strlen(filename) + strlen(altfilename) + 2);
|
||||
cmd = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF2(cmd, len, lessclose, filename, altfilename);
|
||||
fd = shellcmd(cmd);
|
||||
|
33
forwback.c
33
forwback.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -20,6 +20,7 @@ public int screen_trashed;
|
||||
public int squished;
|
||||
public int no_back_scroll = 0;
|
||||
public int forw_prompt;
|
||||
public int same_pos_bell = 1;
|
||||
|
||||
extern int sigs;
|
||||
extern int top_scroll;
|
||||
@ -32,6 +33,11 @@ extern int ignore_eoi;
|
||||
extern int clear_bg;
|
||||
extern int final_attr;
|
||||
extern int oldbot;
|
||||
#if HILITE_SEARCH
|
||||
extern int size_linebuf;
|
||||
extern int hilite_search;
|
||||
extern int status_col;
|
||||
#endif
|
||||
#if TAGS
|
||||
extern char *tagoption;
|
||||
#endif
|
||||
@ -124,7 +130,6 @@ forw(n, pos, force, only_last, nblank)
|
||||
int only_last;
|
||||
int nblank;
|
||||
{
|
||||
int eof = 0;
|
||||
int nlines = 0;
|
||||
int do_repaint;
|
||||
static int first_time = 1;
|
||||
@ -143,6 +148,13 @@ forw(n, pos, force, only_last, nblank)
|
||||
do_repaint = (only_last && n > sc_height-1) ||
|
||||
(forw_scroll >= 0 && n > forw_scroll && n != sc_height-1);
|
||||
|
||||
#if HILITE_SEARCH
|
||||
if (hilite_search == OPT_ONPLUS || is_filtering() || status_col) {
|
||||
prep_hilite(pos, pos + 4*size_linebuf, ignore_eoi ? 1 : -1);
|
||||
pos = next_unfiltered(pos);
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!do_repaint)
|
||||
{
|
||||
if (top_scroll && n >= sc_height - 1 && pos != ch_length())
|
||||
@ -202,6 +214,9 @@ forw(n, pos, force, only_last, nblank)
|
||||
* Get the next line from the file.
|
||||
*/
|
||||
pos = forw_line(pos);
|
||||
#if HILITE_SEARCH
|
||||
pos = next_unfiltered(pos);
|
||||
#endif
|
||||
if (pos == NULL_POSITION)
|
||||
{
|
||||
/*
|
||||
@ -210,7 +225,6 @@ forw(n, pos, force, only_last, nblank)
|
||||
* Even if force is true, stop when the last
|
||||
* line in the file reaches the top of screen.
|
||||
*/
|
||||
eof = 1;
|
||||
if (!force && position(TOP) != NULL_POSITION)
|
||||
break;
|
||||
if (!empty_lines(0, 0) &&
|
||||
@ -271,7 +285,7 @@ forw(n, pos, force, only_last, nblank)
|
||||
forw_prompt = 1;
|
||||
}
|
||||
|
||||
if (nlines == 0)
|
||||
if (nlines == 0 && same_pos_bell)
|
||||
eof_bell();
|
||||
else if (do_repaint)
|
||||
repaint();
|
||||
@ -294,11 +308,20 @@ back(n, pos, force, only_last)
|
||||
|
||||
squish_check();
|
||||
do_repaint = (n > get_back_scroll() || (only_last && n > sc_height-1));
|
||||
#if HILITE_SEARCH
|
||||
if (hilite_search == OPT_ONPLUS || is_filtering() || status_col) {
|
||||
prep_hilite((pos < 3*size_linebuf) ? 0 : pos - 3*size_linebuf, pos, -1);
|
||||
}
|
||||
#endif
|
||||
while (--n >= 0)
|
||||
{
|
||||
/*
|
||||
* Get the previous line of input.
|
||||
*/
|
||||
#if HILITE_SEARCH
|
||||
pos = prev_unfiltered(pos);
|
||||
#endif
|
||||
|
||||
pos = back_line(pos);
|
||||
if (pos == NULL_POSITION)
|
||||
{
|
||||
@ -322,7 +345,7 @@ back(n, pos, force, only_last)
|
||||
}
|
||||
}
|
||||
|
||||
if (nlines == 0)
|
||||
if (nlines == 0 && same_pos_bell)
|
||||
eof_bell();
|
||||
else if (do_repaint)
|
||||
repaint();
|
||||
|
8
funcs.h
8
funcs.h
@ -38,6 +38,7 @@
|
||||
public void sync_logfile ();
|
||||
public int ch_seek ();
|
||||
public int ch_end_seek ();
|
||||
public int ch_end_buffer_seek ();
|
||||
public int ch_beg_seek ();
|
||||
public POSITION ch_length ();
|
||||
public POSITION ch_tell ();
|
||||
@ -58,6 +59,7 @@
|
||||
public char * prutfchar ();
|
||||
public int utf_len ();
|
||||
public int is_utf8_well_formed ();
|
||||
public int utf_bin_count ();
|
||||
public LWCHAR get_wchar ();
|
||||
public void put_wchar ();
|
||||
public LWCHAR step_char ();
|
||||
@ -158,6 +160,7 @@
|
||||
public POSITION back_line ();
|
||||
public void set_attnpos ();
|
||||
public void jump_forw ();
|
||||
public void jump_forw_buffered ();
|
||||
public void jump_back ();
|
||||
public void repaint ();
|
||||
public void jump_percent ();
|
||||
@ -227,7 +230,7 @@
|
||||
public struct loption * findopt_name ();
|
||||
public int iread ();
|
||||
public void intread ();
|
||||
public long get_time ();
|
||||
public time_type get_time ();
|
||||
public char * errno_message ();
|
||||
public int percentage ();
|
||||
public POSITION percent_pos ();
|
||||
@ -242,6 +245,7 @@
|
||||
public int query ();
|
||||
public int compile_pattern ();
|
||||
public void uncompile_pattern ();
|
||||
public int valid_pattern ();
|
||||
public int is_null_pattern ();
|
||||
public int match_pattern ();
|
||||
public POSITION position ();
|
||||
@ -267,6 +271,8 @@
|
||||
public void clr_hilite ();
|
||||
public void clr_filter ();
|
||||
public int is_filtered ();
|
||||
public POSITION next_unfiltered ();
|
||||
public POSITION prev_unfiltered ();
|
||||
public int is_hilited ();
|
||||
public void chg_caseless ();
|
||||
public void chg_hilite ();
|
||||
|
35
help.c
35
help.c
@ -26,6 +26,7 @@ constant char helpdata[] = {
|
||||
' ',' ','E','S','C','-',')',' ',' ','R','i','g','h','t','A','r','r','o','w',' ','*',' ',' ','L','e','f','t',' ',' ','o','n','e',' ','h','a','l','f',' ','s','c','r','e','e','n',' ','w','i','d','t','h',' ','(','o','r',' ','_','\b','N',' ','p','o','s','i','t','i','o','n','s',')','.','\n',
|
||||
' ',' ','E','S','C','-','(',' ',' ','L','e','f','t','A','r','r','o','w',' ',' ','*',' ',' ','R','i','g','h','t',' ','o','n','e',' ','h','a','l','f',' ','s','c','r','e','e','n',' ','w','i','d','t','h',' ','(','o','r',' ','_','\b','N',' ','p','o','s','i','t','i','o','n','s',')','.','\n',
|
||||
' ',' ','F',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','F','o','r','w','a','r','d',' ','f','o','r','e','v','e','r',';',' ','l','i','k','e',' ','"','t','a','i','l',' ','-','f','"','.','\n',
|
||||
' ',' ','E','S','C','-','F',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','L','i','k','e',' ','F',' ','b','u','t',' ','s','t','o','p',' ','w','h','e','n',' ','s','e','a','r','c','h',' ','p','a','t','t','e','r','n',' ','i','s',' ','f','o','u','n','d','.','\n',
|
||||
' ',' ','r',' ',' ','^','R',' ',' ','^','L',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','R','e','p','a','i','n','t',' ','s','c','r','e','e','n','.','\n',
|
||||
' ',' ','R',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','R','e','p','a','i','n','t',' ','s','c','r','e','e','n',',',' ','d','i','s','c','a','r','d','i','n','g',' ','b','u','f','f','e','r','e','d',' ','i','n','p','u','t','.','\n',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','\n',
|
||||
@ -204,6 +205,8 @@ constant char helpdata[] = {
|
||||
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','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',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','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',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','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',
|
||||
'\n',
|
||||
'\n',
|
||||
' ','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','-','\n',
|
||||
@ -213,22 +216,22 @@ constant char helpdata[] = {
|
||||
' ',' ',' ',' ',' ',' ',' ',' ','T','h','e','s','e',' ','k','e','y','s',' ','c','a','n',' ','b','e',' ','u','s','e','d',' ','t','o',' ','e','d','i','t',' ','t','e','x','t',' ','b','e','i','n','g',' ','e','n','t','e','r','e','d',' ','\n',
|
||||
' ',' ',' ',' ',' ',' ',' ',' ','o','n',' ','t','h','e',' ','"','c','o','m','m','a','n','d',' ','l','i','n','e','"',' ','a','t',' ','t','h','e',' ','b','o','t','t','o','m',' ','o','f',' ','t','h','e',' ','s','c','r','e','e','n','.','\n',
|
||||
'\n',
|
||||
' ','R','i','g','h','t','A','r','r','o','w',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','l',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','r','i','g','h','t',' ','o','n','e',' ','c','h','a','r','a','c','t','e','r','.','\n',
|
||||
' ','L','e','f','t','A','r','r','o','w',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','h',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','l','e','f','t',' ','o','n','e',' ','c','h','a','r','a','c','t','e','r','.','\n',
|
||||
' ','c','t','r','l','-','R','i','g','h','t','A','r','r','o','w',' ',' ','E','S','C','-','R','i','g','h','t','A','r','r','o','w',' ',' ','E','S','C','-','w',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','r','i','g','h','t',' ','o','n','e',' ','w','o','r','d','.','\n',
|
||||
' ','c','t','r','l','-','L','e','f','t','A','r','r','o','w',' ',' ',' ','E','S','C','-','L','e','f','t','A','r','r','o','w',' ',' ',' ','E','S','C','-','b',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','l','e','f','t',' ','o','n','e',' ','w','o','r','d','.','\n',
|
||||
' ','H','O','M','E',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','0',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','t','o',' ','s','t','a','r','t',' ','o','f',' ','l','i','n','e','.','\n',
|
||||
' ','E','N','D',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','$',' ',' ',' ',' ',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','t','o',' ','e','n','d',' ','o','f',' ','l','i','n','e','.','\n',
|
||||
' ','B','A','C','K','S','P','A','C','E',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','e','l','e','t','e',' ','c','h','a','r',' ','t','o',' ','l','e','f','t',' ','o','f',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','D','E','L','E','T','E',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','x',' ',' ',' ',' ',' ','D','e','l','e','t','e',' ','c','h','a','r',' ','u','n','d','e','r',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','B','A','C','K','S','P','A','C','E',' ',' ',' ','E','S','C','-','B','A','C','K','S','P','A','C','E',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','e','l','e','t','e',' ','w','o','r','d',' ','t','o',' ','l','e','f','t',' ','o','f',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','D','E','L','E','T','E',' ',' ',' ',' ',' ',' ','E','S','C','-','D','E','L','E','T','E',' ',' ',' ',' ',' ',' ','E','S','C','-','X',' ',' ',' ',' ',' ','D','e','l','e','t','e',' ','w','o','r','d',' ','u','n','d','e','r',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','U',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C',' ','(','M','S','-','D','O','S',' ','o','n','l','y',')',' ',' ',' ',' ',' ',' ',' ',' ',' ','D','e','l','e','t','e',' ','e','n','t','i','r','e',' ','l','i','n','e','.','\n',
|
||||
' ','U','p','A','r','r','o','w',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','k',' ',' ',' ',' ',' ','R','e','t','r','i','e','v','e',' ','p','r','e','v','i','o','u','s',' ','c','o','m','m','a','n','d',' ','l','i','n','e','.','\n',
|
||||
' ','D','o','w','n','A','r','r','o','w',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','j',' ',' ',' ',' ',' ','R','e','t','r','i','e','v','e',' ','n','e','x','t',' ','c','o','m','m','a','n','d',' ','l','i','n','e','.','\n',
|
||||
' ','T','A','B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',' ','&',' ','c','y','c','l','e','.','\n',
|
||||
' ','S','H','I','F','T','-','T','A','B',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','E','S','C','-','T','A','B',' ',' ',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',' ','&',' ','r','e','v','e','r','s','e',' ','c','y','c','l','e','.','\n',
|
||||
' ','c','t','r','l','-','L',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',',',' ','l','i','s','t',' ','a','l','l','.','\n',
|
||||
' ','R','i','g','h','t','A','r','r','o','w',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','l',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','r','i','g','h','t',' ','o','n','e',' ','c','h','a','r','a','c','t','e','r','.','\n',
|
||||
' ','L','e','f','t','A','r','r','o','w',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','h',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','l','e','f','t',' ','o','n','e',' ','c','h','a','r','a','c','t','e','r','.','\n',
|
||||
' ','c','t','r','l','-','R','i','g','h','t','A','r','r','o','w',' ',' ','E','S','C','-','R','i','g','h','t','A','r','r','o','w',' ',' ','E','S','C','-','w',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','r','i','g','h','t',' ','o','n','e',' ','w','o','r','d','.','\n',
|
||||
' ','c','t','r','l','-','L','e','f','t','A','r','r','o','w',' ',' ',' ','E','S','C','-','L','e','f','t','A','r','r','o','w',' ',' ',' ','E','S','C','-','b',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','l','e','f','t',' ','o','n','e',' ','w','o','r','d','.','\n',
|
||||
' ','H','O','M','E',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','0',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','t','o',' ','s','t','a','r','t',' ','o','f',' ','l','i','n','e','.','\n',
|
||||
' ','E','N','D',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','$',' ','.','.','.',' ','M','o','v','e',' ','c','u','r','s','o','r',' ','t','o',' ','e','n','d',' ','o','f',' ','l','i','n','e','.','\n',
|
||||
' ','B','A','C','K','S','P','A','C','E',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','D','e','l','e','t','e',' ','c','h','a','r',' ','t','o',' ','l','e','f','t',' ','o','f',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','D','E','L','E','T','E',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','x',' ','.','.','.',' ','D','e','l','e','t','e',' ','c','h','a','r',' ','u','n','d','e','r',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','B','A','C','K','S','P','A','C','E',' ',' ',' ','E','S','C','-','B','A','C','K','S','P','A','C','E',' ','.','.','.','.','.','.','.','.','.','.','.',' ','D','e','l','e','t','e',' ','w','o','r','d',' ','t','o',' ','l','e','f','t',' ','o','f',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','D','E','L','E','T','E',' ','.','.','.','.',' ','E','S','C','-','D','E','L','E','T','E',' ','.','.','.','.',' ','E','S','C','-','X',' ','.','.','.',' ','D','e','l','e','t','e',' ','w','o','r','d',' ','u','n','d','e','r',' ','c','u','r','s','o','r','.','\n',
|
||||
' ','c','t','r','l','-','U',' ','.','.','.','.','.','.','.','.','.',' ','E','S','C',' ','(','M','S','-','D','O','S',' ','o','n','l','y',')',' ','.','.','.','.','.','.','.',' ','D','e','l','e','t','e',' ','e','n','t','i','r','e',' ','l','i','n','e','.','\n',
|
||||
' ','U','p','A','r','r','o','w',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','k',' ','.','.','.',' ','R','e','t','r','i','e','v','e',' ','p','r','e','v','i','o','u','s',' ','c','o','m','m','a','n','d',' ','l','i','n','e','.','\n',
|
||||
' ','D','o','w','n','A','r','r','o','w',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','j',' ','.','.','.',' ','R','e','t','r','i','e','v','e',' ','n','e','x','t',' ','c','o','m','m','a','n','d',' ','l','i','n','e','.','\n',
|
||||
' ','T','A','B',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',' ','&',' ','c','y','c','l','e','.','\n',
|
||||
' ','S','H','I','F','T','-','T','A','B',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','E','S','C','-','T','A','B',' ',' ',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',' ','&',' ','r','e','v','e','r','s','e',' ','c','y','c','l','e','.','\n',
|
||||
' ','c','t','r','l','-','L',' ','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.',' ','C','o','m','p','l','e','t','e',' ','f','i','l','e','n','a','m','e',',',' ','l','i','s','t',' ','a','l','l','.','\n',
|
||||
'\n',
|
||||
'\n',
|
||||
0 };
|
||||
|
2
ifile.c
2
ifile.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
28
input.c
28
input.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -60,6 +60,7 @@ forw_line(curr_pos)
|
||||
}
|
||||
#if HILITE_SEARCH
|
||||
if (hilite_search == OPT_ONPLUS || is_filtering() || status_col)
|
||||
{
|
||||
/*
|
||||
* If we are ignoring EOI (command F), only prepare
|
||||
* one line ahead, to avoid getting stuck waiting for
|
||||
@ -69,6 +70,8 @@ forw_line(curr_pos)
|
||||
*/
|
||||
prep_hilite(curr_pos, curr_pos + 3*size_linebuf,
|
||||
ignore_eoi ? 1 : -1);
|
||||
curr_pos = next_unfiltered(curr_pos);
|
||||
}
|
||||
#endif
|
||||
if (ch_seek(curr_pos))
|
||||
{
|
||||
@ -439,19 +442,22 @@ set_attnpos(pos)
|
||||
{
|
||||
c = ch_forw_get();
|
||||
if (c == EOI)
|
||||
return;
|
||||
if (c != '\n' && c != '\r')
|
||||
break;
|
||||
if (c == '\n' || c == '\r')
|
||||
{
|
||||
(void) ch_back_get();
|
||||
break;
|
||||
}
|
||||
pos++;
|
||||
}
|
||||
end_attnpos = pos;
|
||||
for (;;)
|
||||
{
|
||||
c = ch_back_get();
|
||||
if (c == EOI || c == '\n' || c == '\r')
|
||||
break;
|
||||
pos--;
|
||||
}
|
||||
}
|
||||
start_attnpos = pos;
|
||||
for (;;)
|
||||
{
|
||||
c = ch_forw_get();
|
||||
pos++;
|
||||
if (c == EOI || c == '\n' || c == '\r')
|
||||
break;
|
||||
}
|
||||
end_attnpos = pos;
|
||||
}
|
||||
|
23
jump.c
23
jump.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -60,6 +60,24 @@ jump_forw()
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Jump to the last buffered line in the file.
|
||||
*/
|
||||
public void
|
||||
jump_forw_buffered()
|
||||
{
|
||||
POSITION end;
|
||||
|
||||
if (ch_end_buffer_seek())
|
||||
{
|
||||
error("Cannot seek to end of buffers", NULL_PARG);
|
||||
return;
|
||||
}
|
||||
end = ch_tell();
|
||||
if (end != NULL_POSITION && end > 0)
|
||||
jump_line_loc(end-1, sc_height-1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Jump to line n in the file.
|
||||
*/
|
||||
@ -281,6 +299,9 @@ jump_loc(pos, sline)
|
||||
*/
|
||||
break;
|
||||
}
|
||||
#if HILITE_SEARCH
|
||||
pos = next_unfiltered(pos);
|
||||
#endif
|
||||
if (pos >= tpos)
|
||||
{
|
||||
/*
|
||||
|
29
less.h
29
less.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -295,6 +295,15 @@ struct scrpos
|
||||
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;
|
||||
@ -310,6 +319,17 @@ struct textlist
|
||||
char *endstring;
|
||||
};
|
||||
|
||||
struct wchar_range
|
||||
{
|
||||
LWCHAR first, last;
|
||||
};
|
||||
|
||||
struct wchar_range_table
|
||||
{
|
||||
struct wchar_range *table;
|
||||
int count;
|
||||
};
|
||||
|
||||
#define EOI (-1)
|
||||
|
||||
#define READ_INTR (-2)
|
||||
@ -445,6 +465,7 @@ struct textlist
|
||||
|
||||
#define ESC CONTROL('[')
|
||||
#define CSI ((unsigned char)'\233')
|
||||
#define CHAR_END_COMMAND 0x40000000
|
||||
|
||||
#if _OSK_MWC32
|
||||
#define LSIGNAL(sig,func) os9_signal(sig,func)
|
||||
@ -498,6 +519,12 @@ struct textlist
|
||||
#define CVT_CRLF 04 /* Remove CR after LF */
|
||||
#define CVT_ANSI 010 /* Remove ANSI escape sequences */
|
||||
|
||||
#if HAVE_TIME_T
|
||||
#define time_type time_t
|
||||
#else
|
||||
#define time_type long
|
||||
#endif
|
||||
|
||||
#include "funcs.h"
|
||||
|
||||
/* Functions not included in funcs.h */
|
||||
|
35
less.hlp
35
less.hlp
@ -23,6 +23,7 @@
|
||||
ESC-) RightArrow * Left one half screen width (or _N positions).
|
||||
ESC-( LeftArrow * Right one half screen width (or _N positions).
|
||||
F Forward forever; like "tail -f".
|
||||
ESC-F Like F but stop when search pattern is found.
|
||||
r ^R ^L Repaint screen.
|
||||
R Repaint screen, discarding buffered input.
|
||||
---------------------------------------------------
|
||||
@ -201,6 +202,8 @@
|
||||
Don't send termcap keypad init/deinit strings.
|
||||
........ --follow-name
|
||||
The F command changes files if the input file is renamed.
|
||||
........ --use-backslash
|
||||
Subsequent options use backslash as escape char.
|
||||
|
||||
|
||||
---------------------------------------------------------------------------
|
||||
@ -210,21 +213,21 @@
|
||||
These keys can be used to edit text being entered
|
||||
on the "command line" at the bottom of the screen.
|
||||
|
||||
RightArrow ESC-l Move cursor right one character.
|
||||
LeftArrow ESC-h Move cursor left one character.
|
||||
ctrl-RightArrow ESC-RightArrow ESC-w Move cursor right one word.
|
||||
ctrl-LeftArrow ESC-LeftArrow ESC-b Move cursor left one word.
|
||||
HOME ESC-0 Move cursor to start of line.
|
||||
END ESC-$ Move cursor to end of line.
|
||||
BACKSPACE Delete char to left of cursor.
|
||||
DELETE ESC-x Delete char under cursor.
|
||||
ctrl-BACKSPACE ESC-BACKSPACE Delete word to left of cursor.
|
||||
ctrl-DELETE ESC-DELETE ESC-X Delete word under cursor.
|
||||
ctrl-U ESC (MS-DOS only) Delete entire line.
|
||||
UpArrow ESC-k Retrieve previous command line.
|
||||
DownArrow ESC-j Retrieve next command line.
|
||||
TAB Complete filename & cycle.
|
||||
SHIFT-TAB ESC-TAB Complete filename & reverse cycle.
|
||||
ctrl-L Complete filename, list all.
|
||||
RightArrow ..................... ESC-l ... Move cursor right one character.
|
||||
LeftArrow ...................... ESC-h ... Move cursor left one character.
|
||||
ctrl-RightArrow ESC-RightArrow ESC-w ... Move cursor right one word.
|
||||
ctrl-LeftArrow ESC-LeftArrow ESC-b ... Move cursor left one word.
|
||||
HOME ........................... ESC-0 ... Move cursor to start of line.
|
||||
END ............................ ESC-$ ... Move cursor to end of line.
|
||||
BACKSPACE ................................ Delete char to left of cursor.
|
||||
DELETE ......................... ESC-x ... Delete char under cursor.
|
||||
ctrl-BACKSPACE ESC-BACKSPACE ........... Delete word to left of cursor.
|
||||
ctrl-DELETE .... ESC-DELETE .... ESC-X ... Delete word under cursor.
|
||||
ctrl-U ......... ESC (MS-DOS only) ....... Delete entire line.
|
||||
UpArrow ........................ ESC-k ... Retrieve previous command line.
|
||||
DownArrow ...................... ESC-j ... Retrieve next command line.
|
||||
TAB ...................................... Complete filename & cycle.
|
||||
SHIFT-TAB ...................... ESC-TAB Complete filename & reverse cycle.
|
||||
ctrl-L ................................... Complete filename, list all.
|
||||
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,4 +1,4 @@
|
||||
LESSECHO(1) LESSECHO(1)
|
||||
LESSECHO(1) General Commands Manual LESSECHO(1)
|
||||
|
||||
|
||||
|
||||
@ -51,4 +51,4 @@ LESSECHO(1) LESSECHO(1)
|
||||
|
||||
|
||||
|
||||
Version 458: 04 Apr 2013 LESSECHO(1)
|
||||
Version 481: 31 Aug 2015 LESSECHO(1)
|
||||
|
@ -1,4 +1,4 @@
|
||||
.TH LESSECHO 1 "Version 458: 04 Apr 2013"
|
||||
.TH LESSECHO 1 "Version 481: 31 Aug 2015"
|
||||
.SH NAME
|
||||
lessecho \- expand metacharacters
|
||||
.SH SYNOPSIS
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -120,6 +120,7 @@ struct cmdname cmdnames[] =
|
||||
{ "forw-search", A_F_SEARCH },
|
||||
{ "forw-window", A_F_WINDOW },
|
||||
{ "goto-end", A_GOEND },
|
||||
{ "goto-end-buffered", A_GOEND_BUF },
|
||||
{ "goto-line", A_GOLINE },
|
||||
{ "goto-mark", A_GOMARK },
|
||||
{ "help", A_HELP },
|
||||
@ -647,7 +648,7 @@ parse_cmdline(p)
|
||||
do
|
||||
{
|
||||
s = tstr(&p, 1);
|
||||
cmdlen += strlen(s);
|
||||
cmdlen += (int) strlen(s);
|
||||
if (cmdlen > MAX_CMDLEN)
|
||||
error("command too long");
|
||||
else
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
38
lesskey.man
38
lesskey.man
@ -1,4 +1,4 @@
|
||||
LESSKEY(1) LESSKEY(1)
|
||||
LESSKEY(1) General Commands Manual LESSKEY(1)
|
||||
|
||||
|
||||
|
||||
@ -161,6 +161,8 @@ LESSKEY(1) LESSKEY(1)
|
||||
\e] right-scroll
|
||||
\e( left-scroll
|
||||
\e) right-scroll
|
||||
\kl left-scroll
|
||||
\kr right-scroll
|
||||
{ forw-bracket {}
|
||||
} back-bracket {}
|
||||
( forw-bracket ()
|
||||
@ -173,6 +175,7 @@ LESSKEY(1) LESSKEY(1)
|
||||
\e> goto-end
|
||||
> goto-end
|
||||
\ke goto-end
|
||||
\eG goto-end-buffered
|
||||
= status
|
||||
^G status
|
||||
:f status
|
||||
@ -330,27 +333,28 @@ LESSKEY(1) LESSKEY(1)
|
||||
|
||||
|
||||
[1mCOPYRIGHT[0m
|
||||
Copyright (C) 2000-2012 Mark Nudelman
|
||||
Copyright (C) 1984-2015 Mark Nudelman
|
||||
|
||||
lesskey is part of the GNU project and is free software; you can redis-
|
||||
tribute it and/or modify it under the terms of the GNU General Public
|
||||
License as published by the Free Software Foundation; either version 2,
|
||||
or (at your option) any later version.
|
||||
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
|
||||
have received a copy of the Less License; see the file LICENSE.
|
||||
|
||||
lesskey is distributed in the hope that it will be useful, but WITHOUT
|
||||
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
||||
for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with lesskey; see the file COPYING. If not, write to the Free Software
|
||||
Foundation, 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
||||
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
|
||||
more details.
|
||||
|
||||
|
||||
[1mAUTHOR[0m
|
||||
Mark Nudelman <bug-less@gnu.org>
|
||||
Send bug reports or comments to bug-less@gnu.org.
|
||||
Mark Nudelman
|
||||
Send bug reports or comments to <bug-less@gnu.org>.
|
||||
|
||||
|
||||
|
||||
Version 458: 04 Apr 2013 LESSKEY(1)
|
||||
Version 481: 31 Aug 2015 LESSKEY(1)
|
||||
|
36
lesskey.nro
36
lesskey.nro
@ -1,4 +1,4 @@
|
||||
.TH LESSKEY 1 "Version 458: 04 Apr 2013"
|
||||
.TH LESSKEY 1 "Version 481: 31 Aug 2015"
|
||||
.SH NAME
|
||||
lesskey \- specify key bindings for less
|
||||
.SH SYNOPSIS
|
||||
@ -178,6 +178,8 @@ default command keys used by less:
|
||||
\ee] right-scroll
|
||||
\ee( left-scroll
|
||||
\ee) right-scroll
|
||||
\ekl left-scroll
|
||||
\ekr right-scroll
|
||||
{ forw-bracket {}
|
||||
} back-bracket {}
|
||||
( forw-bracket ()
|
||||
@ -190,6 +192,7 @@ default command keys used by less:
|
||||
\ee> goto-end
|
||||
> goto-end
|
||||
\eke goto-end
|
||||
\eeG goto-end-buffered
|
||||
= status
|
||||
^G status
|
||||
:f status
|
||||
@ -356,26 +359,29 @@ which start with a NUL character (0).
|
||||
This NUL character should be represented as \e340 in a lesskey file.
|
||||
|
||||
.SH COPYRIGHT
|
||||
Copyright (C) 2000-2012 Mark Nudelman
|
||||
Copyright (C) 1984-2015 Mark Nudelman
|
||||
.PP
|
||||
lesskey is part of the GNU project and is free software;
|
||||
you can redistribute it and/or modify it
|
||||
under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation;
|
||||
either version 2, or (at your option) any later version.
|
||||
less is part of the GNU project and is free software.
|
||||
You can redistribute it and/or modify it
|
||||
under the terms of either
|
||||
(1) the GNU General 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 have received a copy of the Less License;
|
||||
see the file LICENSE.
|
||||
.PP
|
||||
lesskey is distributed in the hope that it will be useful, but
|
||||
less is distributed in the hope that it will be useful, but
|
||||
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
||||
or FITNESS FOR A PARTICULAR PURPOSE.
|
||||
See the GNU General Public License for more details.
|
||||
.PP
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with lesskey; see the file COPYING.
|
||||
If not, write to the Free Software Foundation, 59 Temple Place,
|
||||
Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
.SH AUTHOR
|
||||
.PP
|
||||
Mark Nudelman <bug-less@gnu.org>
|
||||
Mark Nudelman
|
||||
.br
|
||||
Send bug reports or comments to bug-less@gnu.org.
|
||||
Send bug reports or comments to <bug-less@gnu.org>.
|
||||
|
2
lglob.h
2
lglob.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
34
line.c
34
line.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -35,7 +35,7 @@ static int overstrike; /* Next char should overstrike previous char */
|
||||
static int last_overstrike = AT_NORMAL;
|
||||
static int is_null_line; /* There is no current line */
|
||||
static int lmargin; /* Left margin */
|
||||
static char pendc;
|
||||
static LWCHAR pendc;
|
||||
static POSITION pendpos;
|
||||
static char *end_ansi_chars;
|
||||
static char *mid_ansi_chars;
|
||||
@ -78,7 +78,7 @@ init_line()
|
||||
|
||||
mid_ansi_chars = lgetenv("LESSANSIMIDCHARS");
|
||||
if (mid_ansi_chars == NULL || *mid_ansi_chars == '\0')
|
||||
mid_ansi_chars = "0123456789;[?!\"'#%()*+ ";
|
||||
mid_ansi_chars = "0123456789:;[?!\"'#%()*+ ";
|
||||
|
||||
linebuf = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
|
||||
attr = (char *) ecalloc(LINEBUF_SIZE, sizeof(char));
|
||||
@ -209,7 +209,7 @@ plinenum(pos)
|
||||
int n;
|
||||
|
||||
linenumtoa(linenum, buf);
|
||||
n = strlen(buf);
|
||||
n = (int) strlen(buf);
|
||||
if (n < MIN_LINENUM_WIDTH)
|
||||
n = MIN_LINENUM_WIDTH;
|
||||
sprintf(linebuf+curr, "%*s ", n, buf);
|
||||
@ -491,7 +491,7 @@ backc()
|
||||
&& column > lmargin
|
||||
&& (!(attr[curr - 1] & (AT_ANSI|AT_BINARY))))
|
||||
{
|
||||
curr = p - linebuf;
|
||||
curr = (int) (p - linebuf);
|
||||
prev_ch = step_char(&p, -1, linebuf + lmargin);
|
||||
width = pwidth(ch, attr[curr], prev_ch);
|
||||
column -= width;
|
||||
@ -604,7 +604,7 @@ store_char(ch, a, rep, pos)
|
||||
do {
|
||||
bch = step_char(&p, -1, linebuf);
|
||||
} while (p > linebuf && !IS_CSI_START(bch));
|
||||
curr = p - linebuf;
|
||||
curr = (int) (p - linebuf);
|
||||
return 0;
|
||||
}
|
||||
a = AT_ANSI; /* Will force re-AT_'ing around it. */
|
||||
@ -697,7 +697,7 @@ store_tab(attr, pos)
|
||||
|
||||
static int
|
||||
store_prchar(c, pos)
|
||||
char c;
|
||||
LWCHAR c;
|
||||
POSITION pos;
|
||||
{
|
||||
char *s;
|
||||
@ -741,13 +741,15 @@ flush_mbc_buf(pos)
|
||||
*/
|
||||
public int
|
||||
pappend(c, pos)
|
||||
char c;
|
||||
unsigned char c;
|
||||
POSITION pos;
|
||||
{
|
||||
int r;
|
||||
|
||||
if (pendc)
|
||||
{
|
||||
if (c == '\r' && pendc == '\r')
|
||||
return (0);
|
||||
if (do_append(pendc, NULL, pendpos))
|
||||
/*
|
||||
* Oops. We've probably lost the char which
|
||||
@ -781,7 +783,7 @@ pappend(c, pos)
|
||||
|
||||
if (!utf_mode)
|
||||
{
|
||||
r = do_append((LWCHAR) c, NULL, pos);
|
||||
r = do_append(c, NULL, pos);
|
||||
} else
|
||||
{
|
||||
/* Perform strict validation in all possible cases. */
|
||||
@ -791,7 +793,7 @@ pappend(c, pos)
|
||||
mbc_buf_index = 1;
|
||||
*mbc_buf = c;
|
||||
if (IS_ASCII_OCTET(c))
|
||||
r = do_append((LWCHAR) c, NULL, pos);
|
||||
r = do_append(c, NULL, pos);
|
||||
else if (IS_UTF8_LEAD(c))
|
||||
{
|
||||
mbc_buf_len = utf_len(c);
|
||||
@ -805,7 +807,7 @@ pappend(c, pos)
|
||||
mbc_buf[mbc_buf_index++] = c;
|
||||
if (mbc_buf_index < mbc_buf_len)
|
||||
return (0);
|
||||
if (is_utf8_well_formed(mbc_buf))
|
||||
if (is_utf8_well_formed(mbc_buf, mbc_buf_index))
|
||||
r = do_append(get_wchar(mbc_buf), mbc_buf, mbc_pos);
|
||||
else
|
||||
/* Complete, but not shortest form, sequence. */
|
||||
@ -885,8 +887,14 @@ do_append(ch, rep, pos)
|
||||
* or just deletion of the character in the buffer.
|
||||
*/
|
||||
overstrike = utf_mode ? -1 : 0;
|
||||
/* To be correct, this must be a base character. */
|
||||
prev_ch = get_wchar(linebuf + curr);
|
||||
if (utf_mode)
|
||||
{
|
||||
/* To be correct, this must be a base character. */
|
||||
prev_ch = get_wchar(linebuf + curr);
|
||||
} else
|
||||
{
|
||||
prev_ch = (unsigned char) linebuf[curr];
|
||||
}
|
||||
a = attr[curr];
|
||||
if (ch == prev_ch)
|
||||
{
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -216,7 +216,7 @@ longloopmessage()
|
||||
|
||||
static int loopcount;
|
||||
#if HAVE_TIME
|
||||
static long startime;
|
||||
static time_type startime;
|
||||
#endif
|
||||
|
||||
static void
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -137,7 +137,7 @@ lsystem(cmd, donemsg)
|
||||
char *esccmd = shell_quote(cmd);
|
||||
if (esccmd != NULL)
|
||||
{
|
||||
int len = strlen(shell) + strlen(esccmd) + 5;
|
||||
int len = (int) (strlen(shell) + strlen(esccmd) + 5);
|
||||
p = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF3(p, len, "%s %s %s", shell, shell_coption(), esccmd);
|
||||
free(esccmd);
|
||||
|
6
main.c
6
main.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -56,7 +56,6 @@ static char consoleTitle[256];
|
||||
extern int less_is_more;
|
||||
extern int missing_cap;
|
||||
extern int know_dumb;
|
||||
extern int quit_if_one_screen;
|
||||
extern int pr_type;
|
||||
|
||||
|
||||
@ -158,9 +157,6 @@ main(argc, argv)
|
||||
quit(QUIT_OK);
|
||||
}
|
||||
|
||||
if (less_is_more && get_quit_at_eof())
|
||||
quit_if_one_screen = TRUE;
|
||||
|
||||
#if EDITOR
|
||||
editor = lgetenv("VISUAL");
|
||||
if (editor == NULL || *editor == '\0')
|
||||
|
10
mark.c
10
mark.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -14,14 +14,6 @@ extern IFILE curr_ifile;
|
||||
extern int sc_height;
|
||||
extern int jump_sline;
|
||||
|
||||
/*
|
||||
* A mark is an ifile (input file) plus a position within the file.
|
||||
*/
|
||||
struct mark {
|
||||
IFILE m_ifile;
|
||||
struct scrpos m_scrpos;
|
||||
};
|
||||
|
||||
/*
|
||||
* The table of marks.
|
||||
* Each mark is identified by a lowercase or uppercase letter.
|
||||
|
2
mkhelp.c
2
mkhelp.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
75
mkutable
Executable file
75
mkutable
Executable file
@ -0,0 +1,75 @@
|
||||
#! /usr/bin/perl
|
||||
use strict;
|
||||
|
||||
my $USAGE = <<__EOF__;
|
||||
usage: mkutable [-n] [-f#] type... [--] [<] UnicodeData.txt
|
||||
-n = take non-matching types
|
||||
-f = zero-based type field (default 2)
|
||||
__EOF__
|
||||
|
||||
use vars qw( $opt_f $opt_n );
|
||||
use Getopt::Std;
|
||||
my $type_field = 2;
|
||||
|
||||
exit (main() ? 1 : 0);
|
||||
|
||||
sub main {
|
||||
my $date = `date`;
|
||||
chomp $date;
|
||||
my $args = join ' ', @ARGV;
|
||||
my $header = "/* Generated by \"$0 $args\" on $date */\n";
|
||||
|
||||
die $USAGE if not getopts('f:n');
|
||||
$type_field = $opt_f if $opt_f;
|
||||
my %types;
|
||||
my $arg;
|
||||
while ($arg = shift @ARGV) {
|
||||
last if $arg eq '--';
|
||||
$types{$arg} = 1;
|
||||
}
|
||||
my %out = ( 'types' => \%types );
|
||||
my $last_code = 0;
|
||||
|
||||
print $header;
|
||||
while (<>) {
|
||||
chomp;
|
||||
s/#.*//;
|
||||
my @fields = split /;/;
|
||||
next if not @fields;
|
||||
my $code = hex $fields[0];
|
||||
my $type = $fields[$type_field];
|
||||
$type =~ s/\s//g;
|
||||
while (++$last_code < $code) {
|
||||
output(\%out, $last_code, '?');
|
||||
}
|
||||
output(\%out, $code, $type);
|
||||
}
|
||||
output(\%out, $last_code+1, '?');
|
||||
}
|
||||
|
||||
sub output {
|
||||
my ($out, $code, $type) = @_;
|
||||
my $match = ${${$out}{types}}{$type};
|
||||
my $type_change = (not $$out{start_type} or $type ne $$out{start_type});
|
||||
$match = not $match if $opt_n;
|
||||
if ($match and (not $$out{in_run} or $type_change)) {
|
||||
end_run($out, $code-1);
|
||||
start_run($out, $code, $type);
|
||||
} elsif (not $match and $$out{in_run}) {
|
||||
end_run($out, $code-1);
|
||||
}
|
||||
}
|
||||
|
||||
sub start_run {
|
||||
my ($out, $code, $type) = @_;
|
||||
$$out{start_code} = $code;
|
||||
$$out{start_type} = $type;
|
||||
$$out{in_run} = 1;
|
||||
}
|
||||
|
||||
sub end_run {
|
||||
my ($out, $code) = @_;
|
||||
return if not $$out{in_run};
|
||||
printf "\t{ 0x%04x, 0x%04x }, /* %s */\n", $$out{start_code}, $code, $$out{start_type};
|
||||
$$out{in_run} = 0;
|
||||
}
|
48
optfunc.c
48
optfunc.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -43,6 +43,7 @@ extern char *prproto[];
|
||||
extern char *eqproto;
|
||||
extern char *hproto;
|
||||
extern char *wproto;
|
||||
extern char *every_first_cmd;
|
||||
extern IFILE curr_ifile;
|
||||
extern char version[];
|
||||
extern int jump_sline;
|
||||
@ -58,6 +59,7 @@ extern int logfile;
|
||||
#if TAGS
|
||||
public char *tagoption = NULL;
|
||||
extern char *tags;
|
||||
extern char ztags[];
|
||||
#endif
|
||||
#if MSDOS_COMPILER
|
||||
extern int nm_fg_color, nm_bg_color;
|
||||
@ -87,7 +89,7 @@ opt_o(type, s)
|
||||
switch (type)
|
||||
{
|
||||
case INIT:
|
||||
namelogfile = s;
|
||||
namelogfile = save(s);
|
||||
break;
|
||||
case TOGGLE:
|
||||
if (ch_getflags() & CH_CANSEEK)
|
||||
@ -101,6 +103,8 @@ opt_o(type, s)
|
||||
return;
|
||||
}
|
||||
s = skipsp(s);
|
||||
if (namelogfile != NULL)
|
||||
free(namelogfile);
|
||||
namelogfile = lglob(s);
|
||||
use_logfile(namelogfile);
|
||||
sync_logfile();
|
||||
@ -176,7 +180,7 @@ opt_j(type, s)
|
||||
{
|
||||
|
||||
sprintf(buf, ".%06d", jump_sline_fraction);
|
||||
len = strlen(buf);
|
||||
len = (int) strlen(buf);
|
||||
while (len > 2 && buf[len-1] == '0')
|
||||
len--;
|
||||
buf[len] = '\0';
|
||||
@ -241,7 +245,7 @@ opt_shift(type, s)
|
||||
{
|
||||
|
||||
sprintf(buf, ".%06d", shift_count_fraction);
|
||||
len = strlen(buf);
|
||||
len = (int) strlen(buf);
|
||||
while (len > 2 && buf[len-1] == '0')
|
||||
len--;
|
||||
buf[len] = '\0';
|
||||
@ -295,7 +299,7 @@ opt_t(type, s)
|
||||
switch (type)
|
||||
{
|
||||
case INIT:
|
||||
tagoption = s;
|
||||
tagoption = save(s);
|
||||
/* Do the rest in main() */
|
||||
break;
|
||||
case TOGGLE:
|
||||
@ -335,10 +339,12 @@ opt__T(type, s)
|
||||
switch (type)
|
||||
{
|
||||
case INIT:
|
||||
tags = s;
|
||||
tags = save(s);
|
||||
break;
|
||||
case TOGGLE:
|
||||
s = skipsp(s);
|
||||
if (tags != NULL && tags != ztags)
|
||||
free(tags);
|
||||
tags = lglob(s);
|
||||
break;
|
||||
case QUERY:
|
||||
@ -361,18 +367,26 @@ opt_p(type, s)
|
||||
{
|
||||
case INIT:
|
||||
/*
|
||||
* Unget a search command for the specified string.
|
||||
* {{ This won't work if the "/" command is
|
||||
* changed or invalidated by a .lesskey file. }}
|
||||
* Unget a command for the specified string.
|
||||
*/
|
||||
plusoption = TRUE;
|
||||
ungetsc(s);
|
||||
/*
|
||||
* In "more" mode, the -p argument is a command,
|
||||
* not a search string, so we don't need a slash.
|
||||
*/
|
||||
if (!less_is_more)
|
||||
if (less_is_more)
|
||||
{
|
||||
/*
|
||||
* In "more" mode, the -p argument is a command,
|
||||
* not a search string, so we don't need a slash.
|
||||
*/
|
||||
every_first_cmd = save(s);
|
||||
} else
|
||||
{
|
||||
plusoption = TRUE;
|
||||
ungetcc(CHAR_END_COMMAND);
|
||||
ungetsc(s);
|
||||
/*
|
||||
* {{ This won't work if the "/" command is
|
||||
* changed or invalidated by a .lesskey file. }}
|
||||
*/
|
||||
ungetsc("/");
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -503,7 +517,7 @@ opt__V(type, s)
|
||||
putstr("no ");
|
||||
#endif
|
||||
putstr("regular expressions)\n");
|
||||
putstr("Copyright (C) 1984-2012 Mark Nudelman\n\n");
|
||||
putstr("Copyright (C) 1984-2015 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");
|
||||
|
7
option.c
7
option.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -152,7 +152,10 @@ scan_option(s)
|
||||
if (*str == '+')
|
||||
every_first_cmd = save(str+1);
|
||||
else
|
||||
{
|
||||
ungetcc(CHAR_END_COMMAND);
|
||||
ungetsc(str);
|
||||
}
|
||||
free(str);
|
||||
continue;
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
@ -701,5 +704,5 @@ get_quit_at_eof()
|
||||
if (!less_is_more)
|
||||
return quit_at_eof;
|
||||
/* When less_is_more is set, the -e flag semantics are different. */
|
||||
return quit_at_eof ? OPT_ON : OPT_ONPLUS;
|
||||
return quit_at_eof ? OPT_ONPLUS : OPT_ON;
|
||||
}
|
||||
|
2
option.h
2
option.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
2
opttbl.c
2
opttbl.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
12
os.c
12
os.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -33,12 +33,6 @@
|
||||
#include <values.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_TIME_T
|
||||
#define time_type time_t
|
||||
#else
|
||||
#define time_type long
|
||||
#endif
|
||||
|
||||
/*
|
||||
* BSD setjmp() saves (and longjmp() restores) the signal mask.
|
||||
* This costs a system call or two per setjmp(), so if possible we clear the
|
||||
@ -191,7 +185,7 @@ intread()
|
||||
* Return the current time.
|
||||
*/
|
||||
#if HAVE_TIME
|
||||
public long
|
||||
public time_type
|
||||
get_time()
|
||||
{
|
||||
time_type t;
|
||||
@ -243,7 +237,7 @@ errno_message(filename)
|
||||
#else
|
||||
p = "cannot open";
|
||||
#endif
|
||||
len = strlen(filename) + strlen(p) + 3;
|
||||
len = (int) (strlen(filename) + strlen(p) + 3);
|
||||
m = (char *) ecalloc(len, sizeof(char));
|
||||
SNPRINTF2(m, len, "%s: %s", filename, p);
|
||||
return (m);
|
||||
|
10
output.c
10
output.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -98,7 +98,7 @@ flush()
|
||||
register int n;
|
||||
register int fd;
|
||||
|
||||
n = ob - obuf;
|
||||
n = (int) (ob - obuf);
|
||||
if (n == 0)
|
||||
return;
|
||||
|
||||
@ -197,7 +197,7 @@ flush()
|
||||
* Leave it unprocessed
|
||||
* in the buffer.
|
||||
*/
|
||||
int slop = q - anchor;
|
||||
int slop = (int) (q - anchor);
|
||||
/* {{ strcpy args overlap! }} */
|
||||
strcpy(obuf, anchor);
|
||||
ob = &obuf[slop];
|
||||
@ -423,7 +423,7 @@ iprint_int(num)
|
||||
|
||||
inttoa(num, buf);
|
||||
putstr(buf);
|
||||
return (strlen(buf));
|
||||
return ((int) strlen(buf));
|
||||
}
|
||||
|
||||
/*
|
||||
@ -437,7 +437,7 @@ iprint_linenum(num)
|
||||
|
||||
linenumtoa(num, buf);
|
||||
putstr(buf);
|
||||
return (strlen(buf));
|
||||
return ((int) strlen(buf));
|
||||
}
|
||||
|
||||
/*
|
||||
|
70
pattern.c
70
pattern.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -20,10 +20,11 @@ extern int caseless;
|
||||
* Compile a search pattern, for future use by match_pattern.
|
||||
*/
|
||||
static int
|
||||
compile_pattern2(pattern, search_type, comp_pattern)
|
||||
compile_pattern2(pattern, search_type, comp_pattern, show_error)
|
||||
char *pattern;
|
||||
int search_type;
|
||||
void **comp_pattern;
|
||||
int show_error;
|
||||
{
|
||||
if (search_type & SRCH_NO_REGEX)
|
||||
return (0);
|
||||
@ -37,7 +38,8 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
if (re_compile_pattern(pattern, strlen(pattern), comp))
|
||||
{
|
||||
free(comp);
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
if (show_error)
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
return (-1);
|
||||
}
|
||||
if (*pcomp != NULL)
|
||||
@ -50,7 +52,8 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
if (regcomp(comp, pattern, REGCOMP_FLAG))
|
||||
{
|
||||
free(comp);
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
if (show_error)
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
return (-1);
|
||||
}
|
||||
if (*pcomp != NULL)
|
||||
@ -68,7 +71,8 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
if (comp == NULL)
|
||||
{
|
||||
parg.p_string = (char *) errstring;
|
||||
error("%s", &parg);
|
||||
if (show_error)
|
||||
error("%s", &parg);
|
||||
return (-1);
|
||||
}
|
||||
*pcomp = comp;
|
||||
@ -78,7 +82,8 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
int *pcomp = (int *) comp_pattern;
|
||||
if ((parg.p_string = re_comp(pattern)) != NULL)
|
||||
{
|
||||
error("%s", &parg);
|
||||
if (show_error)
|
||||
error("%s", &parg);
|
||||
return (-1);
|
||||
}
|
||||
*pcomp = 1;
|
||||
@ -88,7 +93,8 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
char **pcomp = (char **) comp_pattern;
|
||||
if ((comp = regcmp(pattern, 0)) == NULL)
|
||||
{
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
if (show_error)
|
||||
error("Invalid pattern", NULL_PARG);
|
||||
return (-1);
|
||||
}
|
||||
if (pcomp != NULL)
|
||||
@ -98,7 +104,10 @@ compile_pattern2(pattern, search_type, comp_pattern)
|
||||
#if HAVE_V8_REGCOMP
|
||||
struct regexp *comp;
|
||||
struct regexp **pcomp = (struct regexp **) comp_pattern;
|
||||
if ((comp = regcomp(pattern)) == NULL)
|
||||
reg_show_error = show_error;
|
||||
comp = regcomp(pattern);
|
||||
reg_show_error = 1;
|
||||
if (comp == NULL)
|
||||
{
|
||||
/*
|
||||
* regcomp has already printed an error message
|
||||
@ -133,7 +142,7 @@ compile_pattern(pattern, search_type, comp_pattern)
|
||||
cvt_pattern = (char*) ecalloc(1, cvt_length(strlen(pattern), CVT_TO_LC));
|
||||
cvt_text(cvt_pattern, pattern, (int *)NULL, (int *)NULL, CVT_TO_LC);
|
||||
}
|
||||
result = compile_pattern2(cvt_pattern, search_type, comp_pattern);
|
||||
result = compile_pattern2(cvt_pattern, search_type, comp_pattern, 1);
|
||||
if (cvt_pattern != pattern)
|
||||
free(cvt_pattern);
|
||||
return (result);
|
||||
@ -182,6 +191,24 @@ uncompile_pattern(pattern)
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Can a pattern be successfully compiled?
|
||||
*/
|
||||
public int
|
||||
valid_pattern(pattern)
|
||||
char *pattern;
|
||||
{
|
||||
void *comp_pattern;
|
||||
int result;
|
||||
|
||||
CLEAR_PATTERN(comp_pattern);
|
||||
result = compile_pattern2(pattern, 0, &comp_pattern, 0);
|
||||
if (result != 0)
|
||||
return (0);
|
||||
uncompile_pattern(&comp_pattern);
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Is a compiled pattern null?
|
||||
*/
|
||||
@ -207,6 +234,9 @@ is_null_pattern(pattern)
|
||||
#if HAVE_V8_REGCOMP
|
||||
return (pattern == NULL);
|
||||
#endif
|
||||
#if NO_REGEX
|
||||
return (pattern == NULL);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
@ -227,9 +257,17 @@ match(pattern, pattern_len, buf, buf_len, pfound, pend)
|
||||
|
||||
for ( ; buf < buf_end; buf++)
|
||||
{
|
||||
for (pp = pattern, lp = buf; *pp == *lp; pp++, lp++)
|
||||
for (pp = pattern, lp = buf; ; pp++, lp++)
|
||||
{
|
||||
char cp = *pp;
|
||||
char cl = *lp;
|
||||
if (caseless == OPT_ONPLUS && ASCII_IS_UPPER(cp))
|
||||
cp = ASCII_TO_LOWER(cp);
|
||||
if (cp != cl)
|
||||
break;
|
||||
if (pp == pattern_end || lp == buf_end)
|
||||
break;
|
||||
}
|
||||
if (pp == pattern_end)
|
||||
{
|
||||
if (pfound != NULL)
|
||||
@ -277,6 +315,7 @@ match_pattern(pattern, tpattern, line, line_len, sp, ep, notbol, search_type)
|
||||
struct regexp *spattern = (struct regexp *) pattern;
|
||||
#endif
|
||||
|
||||
*sp = *ep = NULL;
|
||||
#if NO_REGEX
|
||||
search_type |= SRCH_NO_REGEX;
|
||||
#endif
|
||||
@ -287,24 +326,25 @@ match_pattern(pattern, tpattern, line, line_len, sp, ep, notbol, search_type)
|
||||
#if HAVE_GNU_REGEX
|
||||
{
|
||||
struct re_registers search_regs;
|
||||
regoff_t *starts = (regoff_t *) ecalloc(1, sizeof (regoff_t));
|
||||
regoff_t *ends = (regoff_t *) ecalloc(1, sizeof (regoff_t));
|
||||
spattern->not_bol = notbol;
|
||||
re_set_registers(spattern, &search_regs, 1, starts, ends);
|
||||
spattern->regs_allocated = REGS_UNALLOCATED;
|
||||
matched = re_search(spattern, line, line_len, 0, line_len, &search_regs) >= 0;
|
||||
if (matched)
|
||||
{
|
||||
*sp = line + search_regs.start[0];
|
||||
*ep = line + search_regs.end[0];
|
||||
}
|
||||
free(starts);
|
||||
free(ends);
|
||||
}
|
||||
#endif
|
||||
#if HAVE_POSIX_REGCOMP
|
||||
{
|
||||
regmatch_t rm;
|
||||
int flags = (notbol) ? REG_NOTBOL : 0;
|
||||
#ifdef REG_STARTEND
|
||||
flags |= REG_STARTEND;
|
||||
rm.rm_so = 0;
|
||||
rm.rm_eo = line_len;
|
||||
#endif
|
||||
matched = !regexec(spattern, line, 1, &rm, flags);
|
||||
if (matched)
|
||||
{
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -48,6 +48,7 @@ extern char *__loc1;
|
||||
|
||||
#if HAVE_V8_REGCOMP
|
||||
#include "regexp.h"
|
||||
extern int reg_show_error;
|
||||
#define DEFINE_PATTERN(name) struct regexp *name
|
||||
#define CLEAR_PATTERN(name) name = NULL
|
||||
#endif
|
||||
|
2
pckeys.h
2
pckeys.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
6
prompt.c
6
prompt.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -85,9 +85,9 @@ ap_str(s)
|
||||
{
|
||||
int len;
|
||||
|
||||
len = strlen(s);
|
||||
len = (int) strlen(s);
|
||||
if (mp + len >= message + PROMPT_SIZE)
|
||||
len = message + PROMPT_SIZE - mp - 1;
|
||||
len = (int) (message + PROMPT_SIZE - mp - 1);
|
||||
strncpy(mp, s, len);
|
||||
mp += len;
|
||||
*mp = '\0';
|
||||
|
15
regexp.c
15
regexp.c
@ -243,7 +243,10 @@ char *exp;
|
||||
regcode = r->program;
|
||||
regc(MAGIC);
|
||||
if (reg(0, &flags) == NULL)
|
||||
{
|
||||
free(r);
|
||||
return(NULL);
|
||||
}
|
||||
|
||||
/* Dig out information for optimizations. */
|
||||
r->regstart = '\0'; /* Worst-case defaults. */
|
||||
@ -274,7 +277,7 @@ char *exp;
|
||||
for (; scan != NULL; scan = regnext(scan))
|
||||
if (OP(scan) == EXACTLY && ((int) strlen(OPERAND(scan))) >= len) {
|
||||
longest = OPERAND(scan);
|
||||
len = strlen(OPERAND(scan));
|
||||
len = (int) strlen(OPERAND(scan));
|
||||
}
|
||||
r->regmust = longest;
|
||||
r->regmlen = len;
|
||||
@ -554,7 +557,7 @@ int *flagp;
|
||||
register char ender;
|
||||
|
||||
regparse--;
|
||||
len = strcspn(regparse, META);
|
||||
len = (int) strcspn(regparse, META);
|
||||
if (len <= 0)
|
||||
FAIL("internal disaster");
|
||||
ender = *(regparse+len);
|
||||
@ -670,9 +673,9 @@ char *val;
|
||||
}
|
||||
|
||||
if (OP(scan) == BACK)
|
||||
offset = scan - val;
|
||||
offset = (int) (scan - val);
|
||||
else
|
||||
offset = val - scan;
|
||||
offset = (int) (val - scan);
|
||||
*(scan+1) = (offset>>8)&0377;
|
||||
*(scan+2) = offset&0377;
|
||||
}
|
||||
@ -870,7 +873,7 @@ char *prog;
|
||||
/* Inline the first character, for speed. */
|
||||
if (*opnd != *reginput)
|
||||
return(0);
|
||||
len = strlen(opnd);
|
||||
len = (int) strlen(opnd);
|
||||
if (len > 1 && strncmp(opnd, reginput, len) != 0)
|
||||
return(0);
|
||||
reginput += len;
|
||||
@ -1034,7 +1037,7 @@ char *p;
|
||||
opnd = OPERAND(p);
|
||||
switch (OP(p)) {
|
||||
case ANY:
|
||||
count = strlen(scan);
|
||||
count = (int) strlen(scan);
|
||||
scan += count;
|
||||
break;
|
||||
case EXACTLY:
|
||||
|
2
screen.c
2
screen.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
685
search.c
685
search.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -45,15 +45,57 @@ static POSITION prep_endpos;
|
||||
static int is_caseless;
|
||||
static int is_ucase_pattern;
|
||||
|
||||
/*
|
||||
* Structures for maintaining a set of ranges for hilites and filtered-out
|
||||
* lines. Each range is stored as a node within a red-black tree, and we
|
||||
* try to extend existing ranges (without creating overlaps) rather than
|
||||
* create new nodes if possible. We remember the last node found by a
|
||||
* search for constant-time lookup if the next search is near enough to
|
||||
* the previous. To aid that, we overlay a secondary doubly-linked list
|
||||
* on top of the red-black tree so we can find the preceding/succeeding
|
||||
* nodes also in constant time.
|
||||
*
|
||||
* Each node is allocated from a series of pools, each pool double the size
|
||||
* of the previous (for amortised constant time allocation). Since our only
|
||||
* tree operations are clear and node insertion, not node removal, we don't
|
||||
* need to maintain a usage bitmap or freelist and can just return nodes
|
||||
* from the pool in-order until capacity is reached.
|
||||
*/
|
||||
struct hilite
|
||||
{
|
||||
struct hilite *hl_next;
|
||||
POSITION hl_startpos;
|
||||
POSITION hl_endpos;
|
||||
};
|
||||
static struct hilite hilite_anchor = { NULL, NULL_POSITION, NULL_POSITION };
|
||||
static struct hilite filter_anchor = { NULL, NULL_POSITION, NULL_POSITION };
|
||||
#define hl_first hl_next
|
||||
struct hilite_node
|
||||
{
|
||||
struct hilite_node *parent;
|
||||
struct hilite_node *left;
|
||||
struct hilite_node *right;
|
||||
struct hilite_node *prev;
|
||||
struct hilite_node *next;
|
||||
int red;
|
||||
struct hilite r;
|
||||
};
|
||||
struct hilite_storage
|
||||
{
|
||||
int capacity;
|
||||
int used;
|
||||
struct hilite_storage *next;
|
||||
struct hilite_node *nodes;
|
||||
};
|
||||
struct hilite_tree
|
||||
{
|
||||
struct hilite_storage *first;
|
||||
struct hilite_storage *current;
|
||||
struct hilite_node *root;
|
||||
struct hilite_node *lookaside;
|
||||
};
|
||||
#define HILITE_INITIALIZER() { NULL, NULL, NULL, NULL }
|
||||
#define HILITE_LOOKASIDE_STEPS 2
|
||||
|
||||
static struct hilite_tree hilite_anchor = HILITE_INITIALIZER();
|
||||
static struct hilite_tree filter_anchor = HILITE_INITIALIZER();
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
@ -219,7 +261,6 @@ repaint_hilite(on)
|
||||
{
|
||||
int slinenum;
|
||||
POSITION pos;
|
||||
POSITION epos;
|
||||
int save_hide_hilite;
|
||||
|
||||
if (squished)
|
||||
@ -245,7 +286,6 @@ repaint_hilite(on)
|
||||
pos = position(slinenum);
|
||||
if (pos == NULL_POSITION)
|
||||
continue;
|
||||
epos = position(slinenum+1);
|
||||
(void) forw_line(pos);
|
||||
goto_line(slinenum);
|
||||
put_line();
|
||||
@ -324,17 +364,23 @@ undo_search()
|
||||
*/
|
||||
public void
|
||||
clr_hlist(anchor)
|
||||
struct hilite *anchor;
|
||||
struct hilite_tree *anchor;
|
||||
{
|
||||
struct hilite *hl;
|
||||
struct hilite *nexthl;
|
||||
struct hilite_storage *hls;
|
||||
struct hilite_storage *nexthls;
|
||||
|
||||
for (hl = anchor->hl_first; hl != NULL; hl = nexthl)
|
||||
for (hls = anchor->first; hls != NULL; hls = nexthls)
|
||||
{
|
||||
nexthl = hl->hl_next;
|
||||
free((void*)hl);
|
||||
nexthls = hls->next;
|
||||
free((void*)hls->nodes);
|
||||
free((void*)hls);
|
||||
}
|
||||
anchor->hl_first = NULL;
|
||||
anchor->first = NULL;
|
||||
anchor->current = NULL;
|
||||
anchor->root = NULL;
|
||||
|
||||
anchor->lookaside = NULL;
|
||||
|
||||
prep_startpos = prep_endpos = NULL_POSITION;
|
||||
}
|
||||
|
||||
@ -350,6 +396,126 @@ clr_filter()
|
||||
clr_hlist(&filter_anchor);
|
||||
}
|
||||
|
||||
struct hilite_node*
|
||||
hlist_last(anchor)
|
||||
struct hilite_tree *anchor;
|
||||
{
|
||||
struct hilite_node *n = anchor->root;
|
||||
while (n != NULL && n->right != NULL)
|
||||
n = n->right;
|
||||
return n;
|
||||
}
|
||||
|
||||
struct hilite_node*
|
||||
hlist_next(n)
|
||||
struct hilite_node *n;
|
||||
{
|
||||
return n->next;
|
||||
}
|
||||
|
||||
struct hilite_node*
|
||||
hlist_prev(n)
|
||||
struct hilite_node *n;
|
||||
{
|
||||
return n->prev;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the node covering pos, or the node after it if no node covers it,
|
||||
* or return NULL if pos is after the last range. Remember the found node,
|
||||
* to speed up subsequent searches for the same or similar positions (if
|
||||
* we return NULL, remember the last node.)
|
||||
*/
|
||||
struct hilite_node*
|
||||
hlist_find(anchor, pos)
|
||||
struct hilite_tree *anchor;
|
||||
POSITION pos;
|
||||
{
|
||||
struct hilite_node *n, *m;
|
||||
|
||||
if (anchor->lookaside)
|
||||
{
|
||||
int steps = 0;
|
||||
int hit = 0;
|
||||
|
||||
n = anchor->lookaside;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
if (pos < n->r.hl_endpos)
|
||||
{
|
||||
if (n->prev == NULL || pos >= n->prev->r.hl_endpos)
|
||||
{
|
||||
hit = 1;
|
||||
break;
|
||||
}
|
||||
} else if (n->next == NULL)
|
||||
{
|
||||
n = NULL;
|
||||
hit = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we don't find the right node within a small
|
||||
* distance, don't keep doing a linear search!
|
||||
*/
|
||||
if (steps >= HILITE_LOOKASIDE_STEPS)
|
||||
break;
|
||||
steps++;
|
||||
|
||||
if (pos < n->r.hl_endpos)
|
||||
anchor->lookaside = n = n->prev;
|
||||
else
|
||||
anchor->lookaside = n = n->next;
|
||||
}
|
||||
|
||||
if (hit)
|
||||
return n;
|
||||
}
|
||||
|
||||
n = anchor->root;
|
||||
m = NULL;
|
||||
|
||||
while (n != NULL)
|
||||
{
|
||||
if (pos < n->r.hl_startpos)
|
||||
{
|
||||
if (n->left != NULL)
|
||||
{
|
||||
m = n;
|
||||
n = n->left;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (pos >= n->r.hl_endpos)
|
||||
{
|
||||
if (n->right != NULL)
|
||||
{
|
||||
n = n->right;
|
||||
continue;
|
||||
}
|
||||
if (m != NULL)
|
||||
{
|
||||
n = m;
|
||||
} else
|
||||
{
|
||||
m = n;
|
||||
n = NULL;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
if (n != NULL)
|
||||
anchor->lookaside = n;
|
||||
else if (m != NULL)
|
||||
anchor->lookaside = m;
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Should any characters in a specified range be highlighted?
|
||||
*/
|
||||
@ -358,18 +524,8 @@ is_hilited_range(pos, epos)
|
||||
POSITION pos;
|
||||
POSITION epos;
|
||||
{
|
||||
struct hilite *hl;
|
||||
|
||||
/*
|
||||
* Look at each highlight and see if any part of it falls in the range.
|
||||
*/
|
||||
for (hl = hilite_anchor.hl_first; hl != NULL; hl = hl->hl_next)
|
||||
{
|
||||
if (hl->hl_endpos > pos &&
|
||||
(epos == NULL_POSITION || epos > hl->hl_startpos))
|
||||
return (1);
|
||||
}
|
||||
return (0);
|
||||
struct hilite_node *n = hlist_find(&hilite_anchor, pos);
|
||||
return (n != NULL && (epos == NULL_POSITION || epos > n->r.hl_startpos));
|
||||
}
|
||||
|
||||
/*
|
||||
@ -379,23 +535,63 @@ is_hilited_range(pos, epos)
|
||||
is_filtered(pos)
|
||||
POSITION pos;
|
||||
{
|
||||
struct hilite *hl;
|
||||
struct hilite_node *n;
|
||||
|
||||
if (ch_getflags() & CH_HELPFILE)
|
||||
return (0);
|
||||
|
||||
/*
|
||||
* Look at each filter and see if the start position
|
||||
* equals the start position of the line.
|
||||
*/
|
||||
for (hl = filter_anchor.hl_first; hl != NULL; hl = hl->hl_next)
|
||||
{
|
||||
if (hl->hl_startpos == pos)
|
||||
return (1);
|
||||
}
|
||||
return (0);
|
||||
n = hlist_find(&filter_anchor, pos);
|
||||
return (n != NULL && pos >= n->r.hl_startpos);
|
||||
}
|
||||
|
||||
/*
|
||||
* If pos is hidden, return the next position which isn't, otherwise
|
||||
* just return pos.
|
||||
*/
|
||||
public POSITION
|
||||
next_unfiltered(pos)
|
||||
POSITION pos;
|
||||
{
|
||||
struct hilite_node *n;
|
||||
|
||||
if (ch_getflags() & CH_HELPFILE)
|
||||
return (pos);
|
||||
|
||||
n = hlist_find(&filter_anchor, pos);
|
||||
while (n != NULL && pos >= n->r.hl_startpos)
|
||||
{
|
||||
pos = n->r.hl_endpos;
|
||||
n = n->next;
|
||||
}
|
||||
return (pos);
|
||||
}
|
||||
|
||||
/*
|
||||
* If pos is hidden, return the previous position which isn't or 0 if
|
||||
* we're filtered right to the beginning, otherwise just return pos.
|
||||
*/
|
||||
public POSITION
|
||||
prev_unfiltered(pos)
|
||||
POSITION pos;
|
||||
{
|
||||
struct hilite_node *n;
|
||||
|
||||
if (ch_getflags() & CH_HELPFILE)
|
||||
return (pos);
|
||||
|
||||
n = hlist_find(&filter_anchor, pos);
|
||||
while (n != NULL && pos >= n->r.hl_startpos)
|
||||
{
|
||||
pos = n->r.hl_startpos;
|
||||
if (pos == 0)
|
||||
break;
|
||||
pos--;
|
||||
n = n->prev;
|
||||
}
|
||||
return (pos);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Should any characters in a specified range be highlighted?
|
||||
* If nohide is nonzero, don't consider hide_hilite.
|
||||
@ -446,44 +642,289 @@ is_hilited(pos, epos, nohide, p_matches)
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Tree node storage: get the current block of nodes if it has spare
|
||||
* capacity, or create a new one if not.
|
||||
*/
|
||||
static struct hilite_storage*
|
||||
hlist_getstorage(anchor)
|
||||
struct hilite_tree *anchor;
|
||||
{
|
||||
int capacity = 1;
|
||||
struct hilite_storage *s;
|
||||
|
||||
if (anchor->current)
|
||||
{
|
||||
if (anchor->current->used < anchor->current->capacity)
|
||||
return anchor->current;
|
||||
capacity = anchor->current->capacity * 2;
|
||||
}
|
||||
|
||||
s = (struct hilite_storage *) ecalloc(1, sizeof(struct hilite_storage));
|
||||
s->nodes = (struct hilite_node *) ecalloc(capacity, sizeof(struct hilite_node));
|
||||
s->capacity = capacity;
|
||||
s->used = 0;
|
||||
s->next = NULL;
|
||||
if (anchor->current)
|
||||
anchor->current->next = s;
|
||||
else
|
||||
anchor->first = s;
|
||||
anchor->current = s;
|
||||
return s;
|
||||
}
|
||||
|
||||
/*
|
||||
* Tree node storage: retrieve a new empty node to be inserted into the
|
||||
* tree.
|
||||
*/
|
||||
static struct hilite_node*
|
||||
hlist_getnode(anchor)
|
||||
struct hilite_tree *anchor;
|
||||
{
|
||||
struct hilite_storage *s = hlist_getstorage(anchor);
|
||||
return &s->nodes[s->used++];
|
||||
}
|
||||
|
||||
/*
|
||||
* Rotate the tree left around a pivot node.
|
||||
*/
|
||||
static void
|
||||
hlist_rotate_left(anchor, n)
|
||||
struct hilite_tree *anchor;
|
||||
struct hilite_node *n;
|
||||
{
|
||||
struct hilite_node *np = n->parent;
|
||||
struct hilite_node *nr = n->right;
|
||||
struct hilite_node *nrl = n->right->left;
|
||||
|
||||
if (np != NULL)
|
||||
{
|
||||
if (n == np->left)
|
||||
np->left = nr;
|
||||
else
|
||||
np->right = nr;
|
||||
} else
|
||||
{
|
||||
anchor->root = nr;
|
||||
}
|
||||
nr->left = n;
|
||||
n->right = nrl;
|
||||
|
||||
nr->parent = np;
|
||||
n->parent = nr;
|
||||
if (nrl != NULL)
|
||||
nrl->parent = n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Rotate the tree right around a pivot node.
|
||||
*/
|
||||
static void
|
||||
hlist_rotate_right(anchor, n)
|
||||
struct hilite_tree *anchor;
|
||||
struct hilite_node *n;
|
||||
{
|
||||
struct hilite_node *np = n->parent;
|
||||
struct hilite_node *nl = n->left;
|
||||
struct hilite_node *nlr = n->left->right;
|
||||
|
||||
if (np != NULL)
|
||||
{
|
||||
if (n == np->right)
|
||||
np->right = nl;
|
||||
else
|
||||
np->left = nl;
|
||||
} else
|
||||
{
|
||||
anchor->root = nl;
|
||||
}
|
||||
nl->right = n;
|
||||
n->left = nlr;
|
||||
|
||||
nl->parent = np;
|
||||
n->parent = nl;
|
||||
if (nlr != NULL)
|
||||
nlr->parent = n;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add a new hilite to a hilite list.
|
||||
*/
|
||||
static void
|
||||
add_hilite(anchor, hl)
|
||||
struct hilite *anchor;
|
||||
struct hilite_tree *anchor;
|
||||
struct hilite *hl;
|
||||
{
|
||||
struct hilite *ihl;
|
||||
struct hilite_node *p, *n, *u;
|
||||
|
||||
/*
|
||||
* Hilites are sorted in the list; find where new one belongs.
|
||||
* Insert new one after ihl.
|
||||
*/
|
||||
for (ihl = anchor; ihl->hl_next != NULL; ihl = ihl->hl_next)
|
||||
{
|
||||
if (ihl->hl_next->hl_startpos > hl->hl_startpos)
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Truncate hilite so it doesn't overlap any existing ones
|
||||
* above and below it.
|
||||
*/
|
||||
if (ihl != anchor)
|
||||
hl->hl_startpos = MAXPOS(hl->hl_startpos, ihl->hl_endpos);
|
||||
if (ihl->hl_next != NULL)
|
||||
hl->hl_endpos = MINPOS(hl->hl_endpos, ihl->hl_next->hl_startpos);
|
||||
/* Ignore empty ranges. */
|
||||
if (hl->hl_startpos >= hl->hl_endpos)
|
||||
return;
|
||||
|
||||
p = anchor->root;
|
||||
|
||||
/* Inserting the very first node is trivial. */
|
||||
if (p == NULL)
|
||||
{
|
||||
/*
|
||||
* Hilite was truncated out of existence.
|
||||
*/
|
||||
free(hl);
|
||||
n = hlist_getnode(anchor);
|
||||
n->r = *hl;
|
||||
anchor->root = n;
|
||||
anchor->lookaside = n;
|
||||
return;
|
||||
}
|
||||
hl->hl_next = ihl->hl_next;
|
||||
ihl->hl_next = hl;
|
||||
|
||||
/*
|
||||
* Find our insertion point. If we come across any overlapping
|
||||
* or adjoining existing ranges, shrink our range and discard
|
||||
* if it become empty.
|
||||
*/
|
||||
for (;;)
|
||||
{
|
||||
if (hl->hl_startpos < p->r.hl_startpos)
|
||||
{
|
||||
if (hl->hl_endpos > p->r.hl_startpos)
|
||||
hl->hl_endpos = p->r.hl_startpos;
|
||||
if (p->left != NULL)
|
||||
{
|
||||
p = p->left;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (hl->hl_startpos < p->r.hl_endpos) {
|
||||
hl->hl_startpos = p->r.hl_endpos;
|
||||
if (hl->hl_startpos >= hl->hl_endpos)
|
||||
return;
|
||||
}
|
||||
if (p->right != NULL)
|
||||
{
|
||||
p = p->right;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Now we're at the right leaf, again check for contiguous ranges
|
||||
* and extend the existing node if possible to avoid the
|
||||
* insertion. Otherwise insert a new node at the leaf.
|
||||
*/
|
||||
if (hl->hl_startpos < p->r.hl_startpos) {
|
||||
if (hl->hl_endpos == p->r.hl_startpos)
|
||||
{
|
||||
p->r.hl_startpos = hl->hl_startpos;
|
||||
return;
|
||||
}
|
||||
if (p->prev != NULL && p->prev->r.hl_endpos == hl->hl_startpos)
|
||||
{
|
||||
p->prev->r.hl_endpos = hl->hl_endpos;
|
||||
return;
|
||||
}
|
||||
|
||||
p->left = n = hlist_getnode(anchor);
|
||||
n->next = p;
|
||||
if (p->prev != NULL)
|
||||
{
|
||||
n->prev = p->prev;
|
||||
p->prev->next = n;
|
||||
}
|
||||
p->prev = n;
|
||||
} else {
|
||||
if (p->r.hl_endpos == hl->hl_startpos)
|
||||
{
|
||||
p->r.hl_endpos = hl->hl_endpos;
|
||||
return;
|
||||
}
|
||||
if (p->next != NULL && hl->hl_endpos == p->next->r.hl_startpos) {
|
||||
p->next->r.hl_startpos = hl->hl_startpos;
|
||||
return;
|
||||
}
|
||||
|
||||
p->right = n = hlist_getnode(anchor);
|
||||
n->prev = p;
|
||||
if (p->next != NULL)
|
||||
{
|
||||
n->next = p->next;
|
||||
p->next->prev = n;
|
||||
}
|
||||
p->next = n;
|
||||
}
|
||||
n->parent = p;
|
||||
n->red = 1;
|
||||
n->r = *hl;
|
||||
|
||||
/*
|
||||
* The tree is in the correct order and covers the right ranges
|
||||
* now, but may have become unbalanced. Rebalance it using the
|
||||
* standard red-black tree constraints and operations.
|
||||
*/
|
||||
for (;;)
|
||||
{
|
||||
/* case 1 - current is root, root is always black */
|
||||
if (n->parent == NULL)
|
||||
{
|
||||
n->red = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
/* case 2 - parent is black, we can always be red */
|
||||
if (!n->parent->red)
|
||||
break;
|
||||
|
||||
/*
|
||||
* constraint: because the root must be black, if our
|
||||
* parent is red it cannot be the root therefore we must
|
||||
* have a grandparent
|
||||
*/
|
||||
|
||||
/*
|
||||
* case 3 - parent and uncle are red, repaint them black,
|
||||
* the grandparent red, and start again at the grandparent.
|
||||
*/
|
||||
u = n->parent->parent->left;
|
||||
if (n->parent == u)
|
||||
u = n->parent->parent->right;
|
||||
if (u != NULL && u->red)
|
||||
{
|
||||
n->parent->red = 0;
|
||||
u->red = 0;
|
||||
n = n->parent->parent;
|
||||
n->red = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* case 4 - parent is red but uncle is black, parent and
|
||||
* grandparent on opposite sides. We need to start
|
||||
* changing the structure now. This and case 5 will shorten
|
||||
* our branch and lengthen the sibling, between them
|
||||
* restoring balance.
|
||||
*/
|
||||
if (n == n->parent->right &&
|
||||
n->parent == n->parent->parent->left)
|
||||
{
|
||||
hlist_rotate_left(anchor, n->parent);
|
||||
n = n->left;
|
||||
} else if (n == n->parent->left &&
|
||||
n->parent == n->parent->parent->right)
|
||||
{
|
||||
hlist_rotate_right(anchor, n->parent);
|
||||
n = n->right;
|
||||
}
|
||||
|
||||
/*
|
||||
* case 5 - parent is red but uncle is black, parent and
|
||||
* grandparent on same side
|
||||
*/
|
||||
n->parent->red = 0;
|
||||
n->parent->parent->red = 1;
|
||||
if (n == n->parent->left)
|
||||
hlist_rotate_right(anchor, n->parent->parent);
|
||||
else
|
||||
hlist_rotate_left(anchor, n->parent->parent);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
@ -496,12 +937,11 @@ create_hilites(linepos, start_index, end_index, chpos)
|
||||
int end_index;
|
||||
int *chpos;
|
||||
{
|
||||
struct hilite *hl;
|
||||
struct hilite hl;
|
||||
int i;
|
||||
|
||||
/* Start the first hilite. */
|
||||
hl = (struct hilite *) ecalloc(1, sizeof(struct hilite));
|
||||
hl->hl_startpos = linepos + chpos[start_index];
|
||||
hl.hl_startpos = linepos + chpos[start_index];
|
||||
|
||||
/*
|
||||
* Step through the displayed chars.
|
||||
@ -515,13 +955,12 @@ create_hilites(linepos, start_index, end_index, chpos)
|
||||
{
|
||||
if (chpos[i] != chpos[i-1] + 1 || i == end_index)
|
||||
{
|
||||
hl->hl_endpos = linepos + chpos[i-1] + 1;
|
||||
add_hilite(&hilite_anchor, hl);
|
||||
hl.hl_endpos = linepos + chpos[i-1] + 1;
|
||||
add_hilite(&hilite_anchor, &hl);
|
||||
/* Start new hilite unless this is the last char. */
|
||||
if (i < end_index)
|
||||
{
|
||||
hl = (struct hilite *) ecalloc(1, sizeof(struct hilite));
|
||||
hl->hl_startpos = linepos + chpos[i];
|
||||
hl.hl_startpos = linepos + chpos[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -545,8 +984,6 @@ hilite_line(linepos, line, line_len, chpos, sp, ep, cvt_ops)
|
||||
char *searchp;
|
||||
char *line_end = line + line_len;
|
||||
|
||||
if (sp == NULL || ep == NULL)
|
||||
return;
|
||||
/*
|
||||
* sp and ep delimit the first match in the line.
|
||||
* Mark the corresponding file positions, then
|
||||
@ -559,6 +996,8 @@ hilite_line(linepos, line, line_len, chpos, sp, ep, cvt_ops)
|
||||
*/
|
||||
searchp = line;
|
||||
do {
|
||||
if (sp == NULL || ep == NULL)
|
||||
return;
|
||||
create_hilites(linepos, sp-line, ep-line, chpos);
|
||||
/*
|
||||
* If we matched more than zero characters,
|
||||
@ -694,11 +1133,10 @@ search_pos(search_type)
|
||||
* It starts at the jump target (if searching backwards),
|
||||
* or at the jump target plus one (if forwards).
|
||||
*/
|
||||
linenum = jump_sline;
|
||||
linenum = adjsline(jump_sline);
|
||||
if (search_type & SRCH_FORW)
|
||||
add_one = 1;
|
||||
add_one = 1;
|
||||
}
|
||||
linenum = adjsline(linenum);
|
||||
pos = position(linenum);
|
||||
if (add_one)
|
||||
pos = forw_raw_line(pos, (char **)NULL, (int *)NULL);
|
||||
@ -709,20 +1147,20 @@ search_pos(search_type)
|
||||
*/
|
||||
if (search_type & SRCH_FORW)
|
||||
{
|
||||
while (pos == NULL_POSITION)
|
||||
{
|
||||
if (++linenum >= sc_height)
|
||||
break;
|
||||
pos = position(linenum);
|
||||
}
|
||||
while (pos == NULL_POSITION)
|
||||
{
|
||||
if (++linenum >= sc_height)
|
||||
break;
|
||||
pos = position(linenum);
|
||||
}
|
||||
} else
|
||||
{
|
||||
while (pos == NULL_POSITION)
|
||||
{
|
||||
if (--linenum < 0)
|
||||
break;
|
||||
pos = position(linenum);
|
||||
}
|
||||
while (pos == NULL_POSITION)
|
||||
{
|
||||
if (--linenum < 0)
|
||||
break;
|
||||
pos = position(linenum);
|
||||
}
|
||||
}
|
||||
return (pos);
|
||||
}
|
||||
@ -842,16 +1280,19 @@ search_range(pos, endpos, search_type, matches, maxlines, plinepos, pendpos)
|
||||
* Check to see if the line matches the filter pattern.
|
||||
* If so, add an entry to the filter list.
|
||||
*/
|
||||
if ((search_type & SRCH_FIND_ALL) && prev_pattern(&filter_info)) {
|
||||
if (((search_type & SRCH_FIND_ALL) ||
|
||||
prep_startpos == NULL_POSITION ||
|
||||
linepos < prep_startpos || linepos >= prep_endpos) &&
|
||||
prev_pattern(&filter_info)) {
|
||||
int line_filter = match_pattern(info_compiled(&filter_info), filter_info.text,
|
||||
cline, line_len, &sp, &ep, 0, filter_info.search_type);
|
||||
if (line_filter)
|
||||
{
|
||||
struct hilite *hl = (struct hilite *)
|
||||
ecalloc(1, sizeof(struct hilite));
|
||||
hl->hl_startpos = linepos;
|
||||
hl->hl_endpos = pos;
|
||||
add_hilite(&filter_anchor, hl);
|
||||
struct hilite hl;
|
||||
hl.hl_startpos = linepos;
|
||||
hl.hl_endpos = pos;
|
||||
add_hilite(&filter_anchor, &hl);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@ -1107,6 +1548,12 @@ prep_hilite(spos, epos, maxlines)
|
||||
if (!prev_pattern(&search_info) && !is_filtering())
|
||||
return;
|
||||
|
||||
/*
|
||||
* Make sure our prep region always starts at the beginning of
|
||||
* a line. (search_range takes care of the end boundary below.)
|
||||
*/
|
||||
spos = back_raw_line(spos+1, (char **)NULL, (int *)NULL);
|
||||
|
||||
/*
|
||||
* If we're limited to a max number of lines, figure out the
|
||||
* file position we should stop at.
|
||||
@ -1199,12 +1646,48 @@ prep_hilite(spos, epos, maxlines)
|
||||
{
|
||||
int search_type = SRCH_FORW | SRCH_FIND_ALL;
|
||||
search_type |= (search_info.search_type & SRCH_NO_REGEX);
|
||||
result = search_range(spos, epos, search_type, 0,
|
||||
maxlines, (POSITION*)NULL, &new_epos);
|
||||
if (result < 0)
|
||||
return;
|
||||
if (prep_endpos == NULL_POSITION || new_epos > prep_endpos)
|
||||
nprep_endpos = new_epos;
|
||||
for (;;)
|
||||
{
|
||||
result = search_range(spos, epos, search_type, 0, maxlines, (POSITION*)NULL, &new_epos);
|
||||
if (result < 0)
|
||||
return;
|
||||
if (prep_endpos == NULL_POSITION || new_epos > prep_endpos)
|
||||
nprep_endpos = new_epos;
|
||||
|
||||
/*
|
||||
* Check both ends of the resulting prep region to
|
||||
* make sure they're not filtered. If they are,
|
||||
* keep going at least one more line until we find
|
||||
* something that isn't filtered, or hit the end.
|
||||
*/
|
||||
if (prep_endpos == NULL_POSITION || nprep_endpos > prep_endpos)
|
||||
{
|
||||
if (new_epos >= nprep_endpos && is_filtered(new_epos-1))
|
||||
{
|
||||
spos = nprep_endpos;
|
||||
epos = forw_raw_line(nprep_endpos, (char **)NULL, (int *)NULL);
|
||||
if (epos == NULL_POSITION)
|
||||
break;
|
||||
maxlines = 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (prep_startpos == NULL_POSITION || nprep_startpos < prep_startpos)
|
||||
{
|
||||
if (nprep_startpos > 0 && is_filtered(nprep_startpos))
|
||||
{
|
||||
epos = nprep_startpos;
|
||||
spos = back_raw_line(nprep_startpos, (char **)NULL, (int *)NULL);
|
||||
if (spos == NULL_POSITION)
|
||||
break;
|
||||
nprep_startpos = spos;
|
||||
maxlines = 1;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
prep_startpos = nprep_startpos;
|
||||
prep_endpos = nprep_endpos;
|
||||
@ -1243,12 +1726,16 @@ is_filtering()
|
||||
* This function is called by the V8 regcomp to report
|
||||
* errors in regular expressions.
|
||||
*/
|
||||
public int reg_show_error = 1;
|
||||
|
||||
void
|
||||
regerror(s)
|
||||
char *s;
|
||||
{
|
||||
PARG parg;
|
||||
|
||||
if (!reg_show_error)
|
||||
return;
|
||||
parg.p_string = s;
|
||||
error("%s", &parg);
|
||||
}
|
||||
|
2
signal.c
2
signal.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
13
tags.c
13
tags.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -14,7 +14,8 @@
|
||||
|
||||
#if TAGS
|
||||
|
||||
public char *tags = "tags";
|
||||
public char ztags[] = "tags";
|
||||
public char *tags = ztags;
|
||||
|
||||
static int total;
|
||||
static int curseq;
|
||||
@ -287,7 +288,7 @@ findctag(tag)
|
||||
|
||||
cleantags();
|
||||
total = 0;
|
||||
taglen = strlen(tag);
|
||||
taglen = (int) strlen(tag);
|
||||
|
||||
/*
|
||||
* Search the tags file for the desired tag.
|
||||
@ -445,7 +446,7 @@ ctagsearch()
|
||||
* If tagendline is set, make sure we match all
|
||||
* the way to end of line (no extra chars after the match).
|
||||
*/
|
||||
len = strlen(curtag->tag_pattern);
|
||||
len = (int) strlen(curtag->tag_pattern);
|
||||
if (strncmp(curtag->tag_pattern, line, len) == 0 &&
|
||||
(!curtag->tag_endline || line[len] == '\0' || line[len] == '\r'))
|
||||
{
|
||||
@ -491,7 +492,7 @@ findgtag(tag, type)
|
||||
{
|
||||
fp = stdin;
|
||||
/* Set tag default because we cannot read stdin again. */
|
||||
tags = "tags";
|
||||
tags = ztags;
|
||||
} else
|
||||
{
|
||||
#if !HAVE_POPEN
|
||||
@ -551,7 +552,7 @@ findgtag(tag, type)
|
||||
#endif
|
||||
return TAG_INTR;
|
||||
}
|
||||
len = strlen(buf);
|
||||
len = (int) strlen(buf);
|
||||
if (len > 0 && buf[len-1] == '\n')
|
||||
buf[len-1] = '\0';
|
||||
else
|
||||
|
2
ttyin.c
2
ttyin.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
|
32
ubin.uni
Normal file
32
ubin.uni
Normal file
@ -0,0 +1,32 @@
|
||||
/* Generated by "./mkutable -f2 Cc Cf Cs Co Zl Zp -- unicode/UnicodeData.txt" on Mon Jul 14 16:21:22 PDT 2014 */
|
||||
{ 0x0000, 0x001f }, /* Cc */
|
||||
{ 0x007f, 0x009f }, /* Cc */
|
||||
{ 0x00ad, 0x00ad }, /* Cf */
|
||||
{ 0x0600, 0x0605 }, /* Cf */
|
||||
{ 0x061c, 0x061c }, /* Cf */
|
||||
{ 0x06dd, 0x06dd }, /* Cf */
|
||||
{ 0x070f, 0x070f }, /* Cf */
|
||||
{ 0x180e, 0x180e }, /* Cf */
|
||||
{ 0x200b, 0x200f }, /* Cf */
|
||||
{ 0x2028, 0x2028 }, /* Zl */
|
||||
{ 0x2029, 0x2029 }, /* Zp */
|
||||
{ 0x202a, 0x202e }, /* Cf */
|
||||
{ 0x2060, 0x2064 }, /* Cf */
|
||||
{ 0x2066, 0x206f }, /* Cf */
|
||||
{ 0xd800, 0xd800 }, /* Cs */
|
||||
{ 0xdb7f, 0xdb80 }, /* Cs */
|
||||
{ 0xdbff, 0xdc00 }, /* Cs */
|
||||
{ 0xdfff, 0xdfff }, /* Cs */
|
||||
{ 0xe000, 0xe000 }, /* Co */
|
||||
{ 0xf8ff, 0xf8ff }, /* Co */
|
||||
{ 0xfeff, 0xfeff }, /* Cf */
|
||||
{ 0xfff9, 0xfffb }, /* Cf */
|
||||
{ 0x110bd, 0x110bd }, /* Cf */
|
||||
{ 0x1bca0, 0x1bca3 }, /* Cf */
|
||||
{ 0x1d173, 0x1d17a }, /* Cf */
|
||||
{ 0xe0001, 0xe0001 }, /* Cf */
|
||||
{ 0xe0020, 0xe007f }, /* Cf */
|
||||
{ 0xf0000, 0xf0000 }, /* Co */
|
||||
{ 0xffffd, 0xffffd }, /* Co */
|
||||
{ 0x100000, 0x100000 }, /* Co */
|
||||
{ 0x10fffd, 0x10fffd }, /* Co */
|
33
version.c
33
version.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (C) 1984-2012 Mark Nudelman
|
||||
* Copyright (C) 1984-2015 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.
|
||||
@ -762,6 +762,35 @@ v455 11/5/12 Fix typo.
|
||||
v456 11/8/12 Fix option string incompatibility.
|
||||
v457 12/8/12 Use new option string syntax only after --use-backslash.
|
||||
v458 4/4/13 Fix display bug in using up/down in cmd buffer.
|
||||
-----------------------------------------------------------------
|
||||
v459 5/6/13 Fix ++ bug.
|
||||
v460 6/19/13 Automate construction of Unicode tables.
|
||||
v461 6/21/13 Collapse multiple CRs before LF.
|
||||
v462 11/26/13 Don't overwrite history file, just append to it.
|
||||
v463 7/13/14 Misc. fixes.
|
||||
v464 7/19/14 Fix bugs & improve performance in & filtering
|
||||
(thanks to John Sullivan).
|
||||
v465 8/9/14 More fixes from John Sullivan.
|
||||
v466 8/23/14 Add colon to LESSANSIMIDCHARS.
|
||||
v467 9/18/14 Misc. fixes.
|
||||
v468 9/18/14 Fix typo
|
||||
v469 10/2/14 Allow extra string in command to append to a multichar
|
||||
cmd without executing it; fix bug using GNU regex.
|
||||
v470 10/5/14 Fix some compiler warnings.
|
||||
v471 12/14/14 Fix unget issues with prompt. Allow disabling history
|
||||
when compiled value of LESSHISTFILE = "-".
|
||||
v473 12/19/14 Fix prompt bug with stdin and -^P in lesskey extra string.
|
||||
v474 1/30/15 Fix bug in backwards search with match on bottom line.
|
||||
Make follow mode reopen file if file shrinks.
|
||||
v475 3/2/15 Fix possible buffer overrun with invalid UTF-8;
|
||||
fix bug when compiled with no regex; fix non-match search.
|
||||
v476 5/3/15 Update man pages.
|
||||
v477 5/19/15 Fix off-by-one in jump_forw_buffered;
|
||||
don't add FAKE_* files to cmd history.
|
||||
v478 5/21/15 Fix nonportable pointer usage in hilite tree.
|
||||
v479 7/6/15 Allow %% escapes in LESSOPEN variable.
|
||||
v480 7/24/15 Fix bug in no-regex searches; support MSVC v1900.
|
||||
v481 8/20/15 Fix broken -g option.
|
||||
*/
|
||||
|
||||
char version[] = "458";
|
||||
char version[] = "481";
|
||||
|
81
wide.uni
Normal file
81
wide.uni
Normal file
@ -0,0 +1,81 @@
|
||||
/* Generated by "./mkutable -f1 W -- unicode/EastAsianWidth.txt" on Mon Jul 14 16:21:23 PDT 2014 */
|
||||
{ 0x1100, 0x1100 }, /* W */
|
||||
{ 0x2329, 0x232a }, /* W */
|
||||
{ 0x2e80, 0x2e80 }, /* W */
|
||||
{ 0x2e9b, 0x2e9b }, /* W */
|
||||
{ 0x2f00, 0x2f00 }, /* W */
|
||||
{ 0x2ff0, 0x2ff0 }, /* W */
|
||||
{ 0x3001, 0x3001 }, /* W */
|
||||
{ 0x3004, 0x3012 }, /* W */
|
||||
{ 0x3014, 0x301e }, /* W */
|
||||
{ 0x3020, 0x3021 }, /* W */
|
||||
{ 0x302a, 0x302a }, /* W */
|
||||
{ 0x302e, 0x302e }, /* W */
|
||||
{ 0x3030, 0x3031 }, /* W */
|
||||
{ 0x3036, 0x3036 }, /* W */
|
||||
{ 0x3038, 0x3038 }, /* W */
|
||||
{ 0x303b, 0x303e }, /* W */
|
||||
{ 0x3041, 0x3041 }, /* W */
|
||||
{ 0x3099, 0x3099 }, /* W */
|
||||
{ 0x309b, 0x309b }, /* W */
|
||||
{ 0x309d, 0x309d }, /* W */
|
||||
{ 0x309f, 0x30a1 }, /* W */
|
||||
{ 0x30fb, 0x30fc }, /* W */
|
||||
{ 0x30ff, 0x30ff }, /* W */
|
||||
{ 0x3105, 0x3105 }, /* W */
|
||||
{ 0x3131, 0x3131 }, /* W */
|
||||
{ 0x3190, 0x3190 }, /* W */
|
||||
{ 0x3192, 0x3192 }, /* W */
|
||||
{ 0x3196, 0x3196 }, /* W */
|
||||
{ 0x31a0, 0x31a0 }, /* W */
|
||||
{ 0x31c0, 0x31c0 }, /* W */
|
||||
{ 0x31f0, 0x31f0 }, /* W */
|
||||
{ 0x3200, 0x3200 }, /* W */
|
||||
{ 0x3220, 0x3220 }, /* W */
|
||||
{ 0x322a, 0x322a }, /* W */
|
||||
{ 0x3250, 0x3251 }, /* W */
|
||||
{ 0x3260, 0x3260 }, /* W */
|
||||
{ 0x3280, 0x3280 }, /* W */
|
||||
{ 0x328a, 0x328a }, /* W */
|
||||
{ 0x32b1, 0x32b1 }, /* W */
|
||||
{ 0x32c0, 0x32c0 }, /* W */
|
||||
{ 0x3300, 0x3300 }, /* W */
|
||||
{ 0x3400, 0x3400 }, /* W */
|
||||
{ 0x4db6, 0x4db6 }, /* W */
|
||||
{ 0x4e00, 0x4e00 }, /* W */
|
||||
{ 0x9fcd, 0x9fcd }, /* W */
|
||||
{ 0xa000, 0xa000 }, /* W */
|
||||
{ 0xa015, 0xa016 }, /* W */
|
||||
{ 0xa490, 0xa490 }, /* W */
|
||||
{ 0xa960, 0xa960 }, /* W */
|
||||
{ 0xac00, 0xac00 }, /* W */
|
||||
{ 0xf900, 0xf900 }, /* W */
|
||||
{ 0xfa6e, 0xfa6e }, /* W */
|
||||
{ 0xfa70, 0xfa70 }, /* W */
|
||||
{ 0xfada, 0xfada }, /* W */
|
||||
{ 0xfe10, 0xfe10 }, /* W */
|
||||
{ 0xfe17, 0xfe19 }, /* W */
|
||||
{ 0xfe30, 0xfe31 }, /* W */
|
||||
{ 0xfe33, 0xfe33 }, /* W */
|
||||
{ 0xfe35, 0xfe45 }, /* W */
|
||||
{ 0xfe47, 0xfe49 }, /* W */
|
||||
{ 0xfe4d, 0xfe4d }, /* W */
|
||||
{ 0xfe50, 0xfe50 }, /* W */
|
||||
{ 0xfe54, 0xfe54 }, /* W */
|
||||
{ 0xfe58, 0xfe5f }, /* W */
|
||||
{ 0xfe62, 0xfe64 }, /* W */
|
||||
{ 0xfe68, 0xfe6a }, /* W */
|
||||
{ 0x1b000, 0x1b000 }, /* W */
|
||||
{ 0x1f200, 0x1f200 }, /* W */
|
||||
{ 0x1f210, 0x1f210 }, /* W */
|
||||
{ 0x1f240, 0x1f240 }, /* W */
|
||||
{ 0x1f250, 0x1f250 }, /* W */
|
||||
{ 0x20000, 0x20000 }, /* W */
|
||||
{ 0x2a6d7, 0x2a6d7 }, /* W */
|
||||
{ 0x2a700, 0x2a700 }, /* W */
|
||||
{ 0x2b735, 0x2b735 }, /* W */
|
||||
{ 0x2b740, 0x2b740 }, /* W */
|
||||
{ 0x2b81e, 0x2b81e }, /* W */
|
||||
{ 0x2f800, 0x2f800 }, /* W */
|
||||
{ 0x2fa1e, 0x2fa1e }, /* W */
|
||||
{ 0x30000, 0x30000 }, /* W */
|
Loading…
Reference in New Issue
Block a user