d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Vendor import of less v481.

Browse Source
This commit is contained in:
Xin LI 2016-01-04 00:22:34 +00:00
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
70 changed files with 2845 additions and 1755 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
LICENSE
View File

@ -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
View File

@ -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"; \

2
Makefile.wnm
View File

@ -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
View File

@ -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
View File

@ -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
View 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.

37
ch.c
View 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.
@ -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
View 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.
@ -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);
}
/*

2
charset.h
View 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.

3
cmd.h
View 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.
@ -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
View 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.
@ -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
View 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.
@ -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
View 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
View File

@ -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
View 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.
@ -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
View 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.
@ -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,

2
defines.ds
View 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.

5
defines.h.in
View 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

2
defines.o2
View 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.

2
defines.o9
View 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.

4
defines.wn
View 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
View 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.
@ -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
View 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.
@ -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
View 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.
@ -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
View File

@ -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
View File

@ -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
View 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.

28
input.c
View 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.
@ -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
View 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.
@ -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
View 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.
@ -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
View File

@ -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.

1147
less.man
View File

File diff suppressed because it is too large Load Diff

376
less.nro
View File

File diff suppressed because it is too large Load Diff

2
lessecho.c
View 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.

4
lessecho.man
View 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)

2
lessecho.nro
View File

@ -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

5
lesskey.c
View 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.
@ -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

2
lesskey.h
View 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.

38
lesskey.man
View File

@ -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)
COPYRIGHT
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.
AUTHOR
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
View File

@ -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
View 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.

34
line.c
View 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.
@ -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)
{

4
linenum.c
View 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.
@ -216,7 +216,7 @@ longloopmessage()
static int loopcount;
#if HAVE_TIME
static long startime;
static time_type startime;
#endif
static void

4
lsystem.c
View 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.
@ -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
View 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.
@ -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
View 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.
@ -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
View 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.

75
mkutable Executable file
View 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
View 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.
@ -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
View 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.
@ -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
View 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.

2
opttbl.c
View 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.

12
os.c
View 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.
@ -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
View 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.
@ -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
View 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.
@ -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)
{

3
pattern.h
View 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.
@ -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
View 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.

2
position.c
View 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.

2
position.h
View 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
View 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.
@ -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
View File

@ -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
View 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.

2
scrsize.c
View 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
View 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.
@ -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
View 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.

13
tags.c
View 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.
@ -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
View 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.

32
ubin.uni Normal file
View 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
View 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.
@ -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
View 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 */