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

MFhead @ r293815

Browse Source
This commit is contained in:
ngie 2016-01-13 07:44:58 +00:00
commit 662bdc54fa
863 changed files with 25891 additions and 9339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -205,7 +205,7 @@ _TARGET_ARCH?= ${MACHINE_ARCH}
# The user can define ALWAYS_CHECK_MAKE to have this check performed
# for all targets.
#
.if defined(ALWAYS_CHECK_MAKE)
.if defined(ALWAYS_CHECK_MAKE) || !defined(.PARSEDIR)
${TGTS}: upgrade_checks
.else
buildworld: upgrade_checks

47
Makefile.inc1
View File

@ -569,10 +569,9 @@ _worldtmp: .PHONY
.endif
.else
rm -rf ${WORLDTMP}/legacy/usr/include
# XXX - These three can depend on any header file.
rm -f ${OBJTREE}${.CURDIR}/usr.bin/kdump/ioctl.c
# XXX - These can depend on any header file.
rm -f ${OBJTREE}${.CURDIR}/lib/libsysdecode/ioctl.c
rm -f ${OBJTREE}${.CURDIR}/usr.bin/kdump/kdump_subr.c
rm -f ${OBJTREE}${.CURDIR}/usr.bin/truss/ioctl.c
.endif
.for _dir in \
lib usr legacy/bin legacy/usr
@ -1230,7 +1229,7 @@ reinstallkernel reinstallkernel.debug: _installcheck_kernel
${CROSSENV} PATH=${TMPPATH} \
${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME} ${.TARGET:S/kernel//}
.endif
.if ${BUILDKERNELS:[#]} > 1
.if ${BUILDKERNELS:[#]} > 1 && !defined(NO_INSTALLEXTRAKERNELS)
.for _kernel in ${BUILDKERNELS:[2..-1]}
@echo "--------------------------------------------------------------"
@echo ">>> Installing kernel ${_kernel}"
@ -1261,7 +1260,7 @@ distributekernel distributekernel.debug:
${DESTDIR}/${DISTDIR}/kernel.meta
.endif
.endif
.if ${BUILDKERNELS:[#]} > 1
.if ${BUILDKERNELS:[#]} > 1 && !defined(NO_INSTALLEXTRAKERNELS)
.for _kernel in ${BUILDKERNELS:[2..-1]}
.if defined(NO_ROOT)
echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta
@ -1284,27 +1283,43 @@ packagekernel:
.if defined(NO_ROOT)
.if !defined(NO_INSTALLKERNEL)
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - @${DESTDIR}/${DISTDIR}/kernel.meta | \
tar cvf - --exclude '*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.meta | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
.endif
.if ${BUILDKERNELS:[#]} > 1
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.meta | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.if ${BUILDKERNELS:[#]} > 1 && !defined(NO_INSTALLEXTRAKERNELS)
.for _kernel in ${BUILDKERNELS:[2..-1]}
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - @${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
tar cvf - --exclude '*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --include '*/*/*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
.endfor
.endif
.else
.if !defined(NO_INSTALLKERNEL)
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - . | \
tar cvf - --exclude '*.debug' . | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
.endif
.if ${BUILDKERNELS:[#]} > 1
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' $$(eval find .) | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.if ${BUILDKERNELS:[#]} > 1 && !defined(NO_INSTALLEXTRAKERNELS)
.for _kernel in ${BUILDKERNELS:[2..-1]}
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - . | \
tar cvf - --exclude '*.debug' . | \
${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
tar cvf - --include '*/*/*.debug' $$(eval find .) | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
.endfor
.endif
.endif
@ -1409,11 +1424,13 @@ _vtfontcvt= usr.bin/vtfontcvt
_sed= usr.bin/sed
.endif
.if ${BOOTSTRAPPING} < 1000002
.if ${BOOTSTRAPPING} < 1000033
_libopenbsd= lib/libopenbsd
_m4= usr.bin/m4
_lex= usr.bin/lex
${_bt}-usr.bin/m4: ${_bt}-lib/libopenbsd
${_bt}-usr.bin/lex: ${_bt}-usr.bin/m4
.endif
.if ${BOOTSTRAPPING} < 1000026
@ -1427,12 +1444,6 @@ ${_bt}-usr.sbin/nmtree: ${_bt}-lib/libnetbsd
_cat= bin/cat
.endif
.if ${BOOTSTRAPPING} < 1000033
_lex= usr.bin/lex
${_bt}-usr.bin/lex: ${_bt}-usr.bin/m4
.endif
# r277259 crunchide: Correct 64-bit section header offset
# r281674 crunchide: always include both 32- and 64-bit ELF support
# r285986 crunchen: use STRIPBIN rather than STRIP

5
UPDATING
View File

@ -31,6 +31,11 @@ NOTE TO PEOPLE WHO THINK THAT FreeBSD 11.x IS SLOW:
disable the most expensive debugging functionality run
"ln -s 'abort:false,junk:false' /etc/malloc.conf".)
20160113:
With the addition of ypldap(8), a new _ypldap user is now required
during installworld. "mergemaster -p" can be used to add the user
prior to installworld, as documented in the handbook.
20151216:
The tftp loader (pxeboot) now uses the option root-path directive. As a
consequence it no longer looks for a pxeboot.4th file on the tftp

11
bin/sh/eval.c
View File

@ -496,10 +496,12 @@ exphere(union node *redir, struct arglist *fn)
struct jmploc *savehandler;
struct localvar *savelocalvars;
int need_longjmp = 0;
unsigned char saveoptreset;
redir->nhere.expdoc = "";
savelocalvars = localvars;
localvars = NULL;
saveoptreset = shellparam.reset;
forcelocal++;
savehandler = handler;
if (setjmp(jmploc.loc))
@ -514,6 +516,7 @@ exphere(union node *redir, struct arglist *fn)
forcelocal--;
poplocalvars();
localvars = savelocalvars;
shellparam.reset = saveoptreset;
if (need_longjmp)
longjmp(handler->loc, 1);
INTON;
@ -647,6 +650,7 @@ evalbackcmd(union node *n, struct backcmd *result)
struct jmploc jmploc;
struct jmploc *savehandler;
struct localvar *savelocalvars;
unsigned char saveoptreset;
result->fd = -1;
result->buf = NULL;
@ -661,6 +665,7 @@ evalbackcmd(union node *n, struct backcmd *result)
if (is_valid_fast_cmdsubst(n)) {
savelocalvars = localvars;
localvars = NULL;
saveoptreset = shellparam.reset;
forcelocal++;
savehandler = handler;
if (setjmp(jmploc.loc)) {
@ -671,6 +676,7 @@ evalbackcmd(union node *n, struct backcmd *result)
forcelocal--;
poplocalvars();
localvars = savelocalvars;
shellparam.reset = saveoptreset;
longjmp(handler->loc, 1);
}
} else {
@ -681,6 +687,7 @@ evalbackcmd(union node *n, struct backcmd *result)
forcelocal--;
poplocalvars();
localvars = savelocalvars;
shellparam.reset = saveoptreset;
} else {
if (pipe(pip) < 0)
error("Pipe call failed: %s", strerror(errno));
@ -1032,12 +1039,12 @@ evalcommand(union node *cmd, int flags, struct backcmd *backcmd)
reffunc(cmdentry.u.func);
savehandler = handler;
if (setjmp(jmploc.loc)) {
freeparam(&shellparam);
shellparam = saveparam;
popredir();
unreffunc(cmdentry.u.func);
poplocalvars();
localvars = savelocalvars;
freeparam(&shellparam);
shellparam = saveparam;
funcnest--;
handler = savehandler;
longjmp(handler->loc, 1);

12
bin/sh/exec.c
View File

@ -439,12 +439,14 @@ find_command(const char *name, struct cmdentry *entry, int act,
int
find_builtin(const char *name, int *special)
{
const struct builtincmd *bp;
const unsigned char *bp;
size_t len;
for (bp = builtincmd ; bp->name ; bp++) {
if (*bp->name == *name && equal(bp->name, name)) {
*special = bp->special;
return bp->code;
len = strlen(name);
for (bp = builtincmd ; *bp ; bp += 2 + bp[0]) {
if (bp[0] == len && memcmp(bp + 2, name, len) == 0) {
*special = (bp[1] & BUILTIN_SPECIAL) != 0;
return bp[1] & ~BUILTIN_SPECIAL;
}
}
return -1;

4
bin/sh/expand.c
View File

@ -951,8 +951,8 @@ varvalue(const char *name, int quoted, int subtype, int flag,
case '-':
p = buf;
for (i = 0 ; i < NSHORTOPTS ; i++) {
if (optlist[i].val)
*p++ = optlist[i].letter;
if (optval[i])
*p++ = optletter[i];
}
*p = '\0';
strtodest(buf, flag, subtype, quoted, dst);

15
bin/sh/mkbuiltins
View File

@ -62,17 +62,16 @@ echo 'int (*const builtinfunc[])(int, char **) = {'
awk '/^[^#]/ { printf "\t%s,\n", $1}' $temp
echo '};
const struct builtincmd builtincmd[] = {'
const unsigned char builtincmd[] = {'
awk '{ for (i = 2 ; i <= NF ; i++) {
if ($i == "-s") {
spc = 1;
} else {
printf "\t{ \"%s\", %d, %d },\n", $i, NR-1, spc
printf "\t\"\\%03o\\%03o%s\"\n", length($i), (spc ? 128 : 0) + NR-1, $i
spc = 0;
}
}}' $temp
echo ' { NULL, 0, 0 }
};'
echo '};'
exec > builtins.h
cat <<\!
@ -85,14 +84,10 @@ cat <<\!
tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ < $temp |
awk '{ printf "#define %s %d\n", $1, NR-1}'
echo '
struct builtincmd {
const char *name;
int code;
int special;
};
#define BUILTIN_SPECIAL 0x80
extern int (*const builtinfunc[])(int, char **);
extern const struct builtincmd builtincmd[];
extern const unsigned char builtincmd[];
'
awk '{ printf "int %s(int, char **);\n", $1}' $temp
rm -f $temp

37
bin/sh/options.c
View File

@ -91,7 +91,7 @@ procargs(int argc, char **argv)
if (argc > 0)
argptr++;
for (i = 0; i < NOPTS; i++)
optlist[i].val = 2;
optval[i] = 2;
privileged = (getuid() != geteuid() || getgid() != getegid());
options(1);
if (*argptr == NULL && minusc == NULL)
@ -104,8 +104,8 @@ procargs(int argc, char **argv)
if (mflag == 2)
mflag = iflag;
for (i = 0; i < NOPTS; i++)
if (optlist[i].val == 2)
optlist[i].val = 0;
if (optval[i] == 2)
optval[i] = 0;
arg0 = argv[0];
if (sflag == 0 && minusc == NULL) {
scriptname = *argptr++;
@ -250,26 +250,29 @@ static void
minus_o(char *name, int val)
{
int i;
const unsigned char *on;
size_t len;
if (name == NULL) {
if (val) {
/* "Pretty" output. */
out1str("Current option settings\n");
for (i = 0; i < NOPTS; i++)
out1fmt("%-16s%s\n", optlist[i].name,
optlist[i].val ? "on" : "off");
for (i = 0, on = optname; i < NOPTS; i++, on += *on + 1)
out1fmt("%-16.*s%s\n", *on, on + 1,
optval[i] ? "on" : "off");
} else {
/* Output suitable for re-input to shell. */
for (i = 0; i < NOPTS; i++)
out1fmt("%s %co %s%s",
for (i = 0, on = optname; i < NOPTS; i++, on += *on + 1)
out1fmt("%s %co %.*s%s",
i % 6 == 0 ? "set" : "",
optlist[i].val ? '-' : '+',
optlist[i].name,
optval[i] ? '-' : '+',
*on, on + 1,
i % 6 == 5 || i == NOPTS - 1 ? "\n" : "");
}
} else {
for (i = 0; i < NOPTS; i++)
if (equal(name, optlist[i].name)) {
len = strlen(name);
for (i = 0, on = optname; i < NOPTS; i++, on += *on + 1)
if (*on == len && memcmp(on + 1, name, len) == 0) {
setoptionbyindex(i, val);
return;
}
@ -281,18 +284,18 @@ minus_o(char *name, int val)
static void
setoptionbyindex(int idx, int val)
{
if (optlist[idx].letter == 'p' && !val && privileged) {
if (optletter[idx] == 'p' && !val && privileged) {
if (setgid(getgid()) == -1)
error("setgid");
if (setuid(getuid()) == -1)
error("setuid");
}
optlist[idx].val = val;
optval[idx] = val;
if (val) {
/* #%$ hack for ksh semantics */
if (optlist[idx].letter == 'V')
if (optletter[idx] == 'V')
Eflag = 0;
else if (optlist[idx].letter == 'E')
else if (optletter[idx] == 'E')
Vflag = 0;
}
}
@ -303,7 +306,7 @@ setoption(int flag, int val)
int i;
for (i = 0; i < NSHORTOPTS; i++)
if (optlist[i].letter == flag) {
if (optletter[i] == flag) {
setoptionbyindex(i, val);
return;
}

95
bin/sh/options.h
View File

@ -45,60 +45,57 @@ struct shparam {
#define eflag optlist[0].val
#define fflag optlist[1].val
#define Iflag optlist[2].val
#define iflag optlist[3].val
#define mflag optlist[4].val
#define nflag optlist[5].val
#define sflag optlist[6].val
#define xflag optlist[7].val
#define vflag optlist[8].val
#define Vflag optlist[9].val
#define Eflag optlist[10].val
#define Cflag optlist[11].val
#define aflag optlist[12].val
#define bflag optlist[13].val
#define uflag optlist[14].val
#define privileged optlist[15].val
#define Tflag optlist[16].val
#define Pflag optlist[17].val
#define hflag optlist[18].val
#define nologflag optlist[19].val
#define eflag optval[0]
#define fflag optval[1]
#define Iflag optval[2]
#define iflag optval[3]
#define mflag optval[4]
#define nflag optval[5]
#define sflag optval[6]
#define xflag optval[7]
#define vflag optval[8]
#define Vflag optval[9]
#define Eflag optval[10]
#define Cflag optval[11]
#define aflag optval[12]
#define bflag optval[13]
#define uflag optval[14]
#define privileged optval[15]
#define Tflag optval[16]
#define Pflag optval[17]
#define hflag optval[18]
#define nologflag optval[19]
#define NSHORTOPTS 19
#define NOPTS 20
struct optent {
const char *name;
const char letter;
char val;
};
extern struct optent optlist[NOPTS];
extern char optval[NOPTS];
extern const char optletter[NSHORTOPTS];
#ifdef DEFINE_OPTIONS
struct optent optlist[NOPTS] = {
{ "errexit", 'e', 0 },
{ "noglob", 'f', 0 },
{ "ignoreeof", 'I', 0 },
{ "interactive",'i', 0 },
{ "monitor", 'm', 0 },
{ "noexec", 'n', 0 },
{ "stdin", 's', 0 },
{ "xtrace", 'x', 0 },
{ "verbose", 'v', 0 },
{ "vi", 'V', 0 },
{ "emacs", 'E', 0 },
{ "noclobber", 'C', 0 },
{ "allexport", 'a', 0 },
{ "notify", 'b', 0 },
{ "nounset", 'u', 0 },
{ "privileged", 'p', 0 },
{ "trapsasync", 'T', 0 },
{ "physical", 'P', 0 },
{ "trackall", 'h', 0 },
{ "nolog", '\0', 0 },
};
char optval[NOPTS];
const char optletter[NSHORTOPTS] = "efIimnsxvVECabupTPh";
static const unsigned char optname[] =
"\007errexit"
"\006noglob"
"\011ignoreeof"
"\013interactive"
"\007monitor"
"\006noexec"
"\005stdin"
"\006xtrace"
"\007verbose"
"\002vi"
"\005emacs"
"\011noclobber"
"\011allexport"
"\006notify"
"\007nounset"
"\012privileged"
"\012trapsasync"
"\010physical"
"\010trackall"
"\005nolog"
;
#endif

4
bin/sh/tests/builtins/Makefile
View File

@ -48,6 +48,7 @@ FILES+= cd5.0
FILES+= cd6.0
FILES+= cd7.0
FILES+= cd8.0
FILES+= cd9.0 cd9.0.stdout
FILES+= command1.0
FILES+= command2.0
FILES+= command3.0
@ -94,6 +95,8 @@ FILES+= getopts5.0
FILES+= getopts6.0
FILES+= getopts7.0
FILES+= getopts8.0 getopts8.0.stdout
FILES+= getopts9.0 getopts9.0.stdout
FILES+= getopts10.0
FILES+= hash1.0 hash1.0.stdout
FILES+= hash2.0 hash2.0.stdout
FILES+= hash3.0 hash3.0.stdout
@ -108,6 +111,7 @@ FILES+= local1.0
FILES+= local2.0
FILES+= local3.0
FILES+= local4.0
FILES+= local5.0
.if ${MK_NLS} != "no"
FILES+= locale1.0
.endif

8
bin/sh/tests/builtins/cd9.0 Normal file
View File

@ -0,0 +1,8 @@
# $FreeBSD$
cd /dev
cd /bin
cd - >/dev/null
pwd
cd - >/dev/null
pwd

2
bin/sh/tests/builtins/cd9.0.stdout Normal file
View File

@ -0,0 +1,2 @@
/dev
/bin

11
bin/sh/tests/builtins/getopts10.0 Normal file
View File

@ -0,0 +1,11 @@
# $FreeBSD$
set -- -x arg
opt=not
getopts x opt
r1=$? OPTIND1=$OPTIND opt1=$opt
: $(: $((OPTIND = 1)))
getopts x opt
r2=$? OPTIND2=$OPTIND
[ "$r1" = 0 ] && [ "$OPTIND1" = 2 ] && [ "$opt1" = x ] && [ "$r2" != 0 ] &&
[ "$OPTIND2" = 2 ]

15
bin/sh/tests/builtins/local5.0 Normal file
View File

@ -0,0 +1,15 @@
# $FreeBSD$
f() {
local PATH IFS elem
IFS=:
for elem in ''$PATH''; do
PATH=/var/empty/$elem:$PATH
done
ls -d / >/dev/null
}
p1=$(command -v ls)
f
p2=$(command -v ls)
[ "$p1" = "$p2" ]

17
bin/sh/var.c
View File

@ -754,8 +754,8 @@ mklocal(char *name)
INTOFF;
lvp = ckmalloc(sizeof (struct localvar));
if (name[0] == '-' && name[1] == '\0') {
lvp->text = ckmalloc(sizeof optlist);
memcpy(lvp->text, optlist, sizeof optlist);
lvp->text = ckmalloc(sizeof optval);
memcpy(lvp->text, optval, sizeof optval);
vp = NULL;
} else {
vp = find_var(name, &vpp, NULL);
@ -791,22 +791,33 @@ poplocalvars(void)
{
struct localvar *lvp;
struct var *vp;
int islocalevar;
INTOFF;
while ((lvp = localvars) != NULL) {
localvars = lvp->next;
vp = lvp->vp;
if (vp == NULL) { /* $- saved */
memcpy(optlist, lvp->text, sizeof optlist);
memcpy(optval, lvp->text, sizeof optval);
ckfree(lvp->text);
optschanged();
} else if ((lvp->flags & (VUNSET|VSTRFIXED)) == VUNSET) {
(void)unsetvar(vp->text);
} else {
islocalevar = (vp->flags | lvp->flags) & VEXPORT &&
localevar(lvp->text);
if ((vp->flags & VTEXTFIXED) == 0)
ckfree(vp->text);
vp->flags = lvp->flags;
vp->text = lvp->text;
if (vp->func)
(*vp->func)(vp->text + vp->name_len + 1);
if (islocalevar) {
change_env(vp->text, vp->flags & VEXPORT &&
(vp->flags & VUNSET) == 0);
setlocale(LC_ALL, "");
updatecharset();
}
}
ckfree(lvp);
}

2
contrib/hyperv/tools/hv_kvp_daemon.c
View File

@ -1437,7 +1437,7 @@ main(int argc, char *argv[])
for (;;) {
r = poll (hv_kvp_poll_fd, 1, 100);
r = poll (hv_kvp_poll_fd, 1, INFTIM);
KVP_LOG(LOG_DEBUG, "poll returned r = %d, revent = 0x%x\n",
r, hv_kvp_poll_fd[0].revents);

2
contrib/less/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

39
contrib/less/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
contrib/less/README
View File

@ -7,9 +7,9 @@
**************************************************************************
**************************************************************************
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
@ -53,8 +53,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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/command.c
View File

@ -1,6 +1,6 @@
/* $FreeBSD$ */
/*
* 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,6 +35,7 @@ extern int top_scroll;
extern int ignore_eoi;
extern int secure;
extern int hshift;
extern int bs_mode;
extern int show_attn;
extern int less_is_more;
extern POSITION highest_hilite;
@ -56,6 +57,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 "!!" */
@ -70,6 +72,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
@ -77,9 +80,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();
@ -160,6 +163,7 @@ mca_search()
cmd_putstr("/");
else
cmd_putstr("?");
forw_prompt = 0;
set_mlist(ml_search, 0);
}
@ -194,6 +198,7 @@ mca_opt_toggle()
cmd_putstr("!");
break;
}
forw_prompt = 0;
set_mlist(NULL, 0);
}
@ -212,7 +217,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:
@ -688,7 +693,7 @@ prompt()
{
register constant char *p;
if (ungot != NULL)
if (ungot != NULL && !ungot->ug_end_command)
{
/*
* No prompt necessary if commands are from
@ -778,40 +783,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)
{
/*
@ -826,9 +797,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);
}
}
@ -843,10 +841,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;
}
/*
@ -869,9 +867,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;
@ -946,7 +945,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)
@ -974,7 +973,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;
@ -1019,7 +1018,6 @@ commands()
IFILE old_ifile;
IFILE new_ifile;
char *tagfile;
int until_hilite = 0;
search_type = SRCH_FORW;
wscroll = (sc_height + 1) / 2;
@ -1247,6 +1245,8 @@ commands()
/*
* Forward forever, ignoring EOF.
*/
if (show_attn)
set_attnpos(bottompos);
newaction = forw_loop(0);
break;
@ -1332,6 +1332,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.
@ -1374,6 +1385,7 @@ commands()
* previous file.
*/
hshift = save_hshift;
bs_mode = save_bs_mode;
if (edit_prev(1) == 0)
break;
}
@ -1389,7 +1401,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:
@ -1477,6 +1489,8 @@ commands()
cmd_exec();
save_hshift = hshift;
hshift = 0;
save_bs_mode = bs_mode;
bs_mode = BS_SPECIAL;
(void) edit(FAKE_HELPFILE);
break;

261
contrib/less/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 */

8
contrib/less/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
contrib/less/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,

13
contrib/less/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
contrib/less/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
contrib/less/forwback.c
View File

@ -1,6 +1,6 @@
/* $FreeBSD$ */
/*
* 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.
@ -21,6 +21,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;
@ -34,6 +35,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
@ -126,7 +132,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;
@ -145,6 +150,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())
@ -206,6 +218,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)
{
/*
@ -214,7 +229,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) &&
@ -276,7 +290,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();
@ -299,11 +313,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)
{
@ -327,7 +350,7 @@ back(n, pos, force, only_last)
}
}
if (nlines == 0)
if (nlines == 0 && same_pos_bell)
eof_bell();
else if (do_repaint)
repaint();

8
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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.

376
contrib/less/less.nro
View File

File diff suppressed because it is too large Load Diff

2
contrib/less/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.

2
contrib/less/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
contrib/less/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
contrib/less/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.

36
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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);

5
contrib/less/main.c
View File

@ -1,6 +1,6 @@
/* $FreeBSD$ */
/*
* 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.
@ -57,7 +57,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 no_init;
extern int pr_type;
@ -167,8 +166,6 @@ main(argc, argv)
if (less_is_more)
no_init = TRUE;
if (less_is_more && get_quit_at_eof())
quit_if_one_screen = TRUE;
#if EDITOR
editor = lgetenv("VISUAL");

10
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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.
@ -49,6 +49,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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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
contrib/less/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 */

7
contrib/llvm/projects/libunwind/src/AddressSpace.hpp
View File

@ -35,7 +35,12 @@ namespace libunwind {
#include "Registers.hpp"
#if _LIBUNWIND_ARM_EHABI
#ifdef __linux__
#if defined(__FreeBSD__)
#include <sys/link_elf.h>
typedef void *_Unwind_Ptr;
#elif defined(__linux__)
typedef long unsigned int *_Unwind_Ptr;
extern "C" _Unwind_Ptr __gnu_Unwind_Find_exidx(_Unwind_Ptr addr, int *len);

4
contrib/llvm/projects/libunwind/src/DwarfParser.hpp
View File

@ -380,7 +380,9 @@ bool CFI_Parser<A>::parseInstructions(A &addressSpace, pint_t instructions,
uint64_t length;
uint8_t opcode = addressSpace.get8(p);
uint8_t operand;
#if !defined(_LIBUNWIND_NO_HEAP)
PrologInfoStackEntry *entry;
#endif
++p;
switch (opcode) {
case DW_CFA_nop:
@ -492,6 +494,7 @@ bool CFI_Parser<A>::parseInstructions(A &addressSpace, pint_t instructions,
fprintf(stderr, "DW_CFA_register(reg=%" PRIu64 ", reg2=%" PRIu64 ")\n",
reg, reg2);
break;
#if !defined(_LIBUNWIND_NO_HEAP)
case DW_CFA_remember_state:
// avoid operator new, because that would be an upward dependency
entry = (PrologInfoStackEntry *)malloc(sizeof(PrologInfoStackEntry));
@ -517,6 +520,7 @@ bool CFI_Parser<A>::parseInstructions(A &addressSpace, pint_t instructions,
if (logDwarf)
fprintf(stderr, "DW_CFA_restore_state\n");
break;
#endif
case DW_CFA_def_cfa:
reg = addressSpace.getULEB128(p, instructionsEnd);
offset = (int64_t)addressSpace.getULEB128(p, instructionsEnd);

2
contrib/llvm/projects/libunwind/src/UnwindCursor.hpp
View File

@ -114,6 +114,7 @@ typename A::pint_t DwarfFDECache<A>::findFDE(pint_t mh, pint_t pc) {
template <typename A>
void DwarfFDECache<A>::add(pint_t mh, pint_t ip_start, pint_t ip_end,
pint_t fde) {
#if !defined(_LIBUNWIND_NO_HEAP)
_LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
if (_bufferUsed >= _bufferEnd) {
size_t oldSize = (size_t)(_bufferEnd - _buffer);
@ -139,6 +140,7 @@ void DwarfFDECache<A>::add(pint_t mh, pint_t ip_start, pint_t ip_end,
}
#endif
_LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
#endif
}
template <typename A>

9
contrib/llvm/projects/libunwind/src/UnwindRegistersSave.S
View File

@ -87,6 +87,15 @@ DEFINE_LIBUNWIND_FUNCTION(unw_getcontext)
xorl %eax, %eax # return UNW_ESUCCESS
ret
# elif defined(__mips__)
#
# extern int unw_getcontext(unw_context_t* thread_state)
#
# Just trap for the time being.
DEFINE_LIBUNWIND_FUNCTION(unw_getcontext)
teq $0, $0
#elif defined(__ppc__)
;

3
contrib/llvm/projects/libunwind/src/config.h
View File

@ -41,7 +41,8 @@
#define _LIBUNWIND_BUILD_ZERO_COST_APIS (defined(__i386__) || \
defined(__x86_64__) || \
defined(__arm64__))
defined(__arm64__) || \
defined(__mips__))
#define _LIBUNWIND_BUILD_SJLJ_APIS defined(__arm__)
#define _LIBUNWIND_SUPPORT_FRAME_APIS (defined(__i386__) || \
defined(__x86_64__))

2
contrib/llvm/projects/libunwind/src/libunwind.cpp
View File

@ -64,6 +64,8 @@ _LIBUNWIND_EXPORT int unw_init_local(unw_cursor_t *cursor,
#elif defined(__or1k__)
new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_or1k>(
context, LocalAddressSpace::sThisAddressSpace);
#elif defined(__mips__)
#warning The MIPS architecture is not supported.
#else
#error Architecture not supported
#endif

57
contrib/ntp/ChangeLog
View File

@ -1,4 +1,61 @@
---
(4.2.8p5) 2016/01/07 Released by Harlan Stenn <stenn@ntp.org>
* [Sec 2956] small-step/big-step. Close the panic gate earlier. HStenn.
* CID 1339955: Free allocated memory in caljulian test. HStenn.
* CID 1339962: Explicitly initialize variable in caljulian test. HStenn.
* CID 1341527: Quiet a CHECKED_RETURN in sntp/tests/t-log.c. HStenn.
* CID 1341533: Missing assertion in sntp/tests/t-log.c. HStenn.
* CID 1341534: Resource leak in tests/ntpd/t-ntp_signd.c. HStenn.
* CID 1341535: Resource leak in tests/ntpd/t-ntp_signd.c. HStenn.
* CID 1341536: Resource leak in tests/ntpd/t-ntp_signd.c. HStenn.
* CID 1341537: Resource leak in tests/ntpd/t-ntp_signd.c. HStenn.
* CID 1341538: Memory leak in tests/ntpd/ntp_prio_q.c:262. HStenn.
* CID 1341677: Nits in sntp/tests/keyFile.c. HStenn.
* CID 1341678: Nits in sntp/tests/keyFile.c. HStenn.
* CID 1341679: Nits in sntp/tests/keyFile.c. HStenn.
* CID 1341680: Nits in sntp/tests/keyFile.c. HStenn.
* CID 1341681: Nits in sntp/tests/keyFile.c. HStenn.
* CID 1341682: Nit in libntp/authreadkeys.c. HStenn.
* CID 1341684: Nit in tests/ntpd/t-ntp_signd.c. HStenn.
* [Bug 2829] Look at pipe_fds in ntpd.c (did so. perlinger@ntp.org)
* [Bug 2887] stratum -1 config results as showing value 99
- fudge stratum should only accept values [0..16]. perlinger@ntp.org
* [Bug 2932] Update leapsecond file info in miscopt.html. CWoodbury, HStenn.
* [Bug 2934] tests/ntpd/t-ntp_scanner.c has a magic constant wired in. HMurray
* [Bug 2944] errno is not preserved properly in ntpdate after sendto call.
- applied patch by Christos Zoulas. perlinger@ntp.org
* [Bug 2952] Symmetric active/passive mode is broken. HStenn.
* [Bug 2954] Version 4.2.8p4 crashes on startup with sig fault
- fixed data race conditions in threaded DNS worker. perlinger@ntp.org
- limit threading warm-up to linux; FreeBSD bombs on it. perlinger@ntp.org
* [Bug 2957] 'unsigned int' vs 'size_t' format clash. perlinger@ntp.org
- accept key file only if there are no parsing errors
- fixed size_t/u_int format clash
- fixed wrong use of 'strlcpy'
* [Bug 2958] ntpq: fatal error messages need a final newline. Craig Leres.
* [Bug 2962] truncation of size_t/ptrdiff_t on 64bit targets. perlinger@ntp.org
- fixed several other warnings (cast-alignment, missing const, missing prototypes)
- promote use of 'size_t' for values that express a size
- use ptr-to-const for read-only arguments
- make sure SOCKET values are not truncated (win32-specific)
- format string fixes
* [Bug 2965] Local clock didn't work since 4.2.8p4. Martin Burnicki.
* [Bug 2967] ntpdate command suffers an assertion failure
- fixed ntp_rfc2553.c to return proper address length. perlinger@ntp.org
* [Bug 2969] Seg fault from ntpq/mrulist when looking at server with
lots of clients. perlinger@ntp.org
* [Bug 2971] ntpq bails on ^C: select fails: Interrupted system call
- changed stacked/nested handling of CTRL-C. perlinger@ntp.org
* Unity cleanup for FreeBSD-6.4. Harlan Stenn.
* Unity test cleanup. Harlan Stenn.
* Libevent autoconf pthread fixes for FreeBSD-10. Harlan Stenn.
* Header cleanup in tests/sandbox/uglydate.c. Harlan Stenn.
* Header cleanup in tests/libntp/sfptostr.c. Harlan Stenn.
* Quiet a warning from clang. Harlan Stenn.
* Update the NEWS file. Harlan Stenn.
* Update scripts/calc_tickadj/Makefile.am. Harlan Stenn.
---
(4.2.8p4) 2015/10/21 Released by Harlan Stenn <stenn@ntp.org>
(4.2.8p4-RC1) 2015/10/06 Released by Harlan Stenn <stenn@ntp.org>

1477
contrib/ntp/CommitLog
View File

File diff suppressed because it is too large Load Diff

107
contrib/ntp/NEWS
View File

@ -1,7 +1,108 @@
---
NTP 4.2.8p5
Focus: Security, Bug fixes, enhancements.
Severity: MEDIUM
In addition to bug fixes and enhancements, this release fixes the
following medium-severity vulnerability:
* Small-step/big-step. Close the panic gate earlier.
References: Sec 2956, CVE-2015-5300
Affects: All ntp-4 releases up to, but not including 4.2.8p5, and
4.3.0 up to, but not including 4.3.78
CVSS3: (AV:N/AC:H/PR:H/UI:R/S:C/C:L/I:N/A:L) Base Score: 4.0, MEDIUM
Summary: If ntpd is always started with the -g option, which is
common and against long-standing recommendation, and if at the
moment ntpd is restarted an attacker can immediately respond to
enough requests from enough sources trusted by the target, which
is difficult and not common, there is a window of opportunity
where the attacker can cause ntpd to set the time to an
arbitrary value. Similarly, if an attacker is able to respond
to enough requests from enough sources trusted by the target,
the attacker can cause ntpd to abort and restart, at which
point it can tell the target to set the time to an arbitrary
value if and only if ntpd was re-started against long-standing
recommendation with the -g flag, or if ntpd was not given the
-g flag, the attacker can move the target system's time by at
most 900 seconds' time per attack.
Mitigation:
Configure ntpd to get time from multiple sources.
Upgrade to 4.2.8p5, or later, from the NTP Project Download
Page or the NTP Public Services Project Download Page
As we've long documented, only use the -g option to ntpd in
cold-start situations.
Monitor your ntpd instances.
Credit: This weakness was discovered by Aanchal Malhotra,
Isaac E. Cohen, and Sharon Goldberg at Boston University.
NOTE WELL: The -g flag disables the limit check on the panic_gate
in ntpd, which is 900 seconds by default. The bug identified by
the researchers at Boston University is that the panic_gate
check was only re-enabled after the first change to the system
clock that was greater than 128 milliseconds, by default. The
correct behavior is that the panic_gate check should be
re-enabled after any initial time correction.
If an attacker is able to inject consistent but erroneous time
responses to your systems via the network or "over the air",
perhaps by spoofing radio, cellphone, or navigation satellite
transmissions, they are in a great position to affect your
system's clock. There comes a point where your very best
defenses include:
Configure ntpd to get time from multiple sources.
Monitor your ntpd instances.
Other fixes:
* Coverity submission process updated from Coverity 5 to Coverity 7.
The NTP codebase has been undergoing regular Coverity scans on an
ongoing basis since 2006. As part of our recent upgrade from
Coverity 5 to Coverity 7, Coverity identified 16 nits in some of
the newly-written Unity test programs. These were fixed.
* [Bug 2829] Clean up pipe_fds in ntpd.c perlinger@ntp.org
* [Bug 2887] stratum -1 config results as showing value 99
- fudge stratum should only accept values [0..16]. perlinger@ntp.org
* [Bug 2932] Update leapsecond file info in miscopt.html. CWoodbury, HStenn.
* [Bug 2934] tests/ntpd/t-ntp_scanner.c has a magic constant wired in. HMurray
* [Bug 2944] errno is not preserved properly in ntpdate after sendto call.
- applied patch by Christos Zoulas. perlinger@ntp.org
* [Bug 2952] Peer associations broken by fix for Bug 2901/CVE-2015-7704.
* [Bug 2954] Version 4.2.8p4 crashes on startup on some OSes.
- fixed data race conditions in threaded DNS worker. perlinger@ntp.org
- limit threading warm-up to linux; FreeBSD bombs on it. perlinger@ntp.org
* [Bug 2957] 'unsigned int' vs 'size_t' format clash. perlinger@ntp.org
- accept key file only if there are no parsing errors
- fixed size_t/u_int format clash
- fixed wrong use of 'strlcpy'
* [Bug 2958] ntpq: fatal error messages need a final newline. Craig Leres.
* [Bug 2962] truncation of size_t/ptrdiff_t on 64bit targets. perlinger@ntp.org
- fixed several other warnings (cast-alignment, missing const, missing prototypes)
- promote use of 'size_t' for values that express a size
- use ptr-to-const for read-only arguments
- make sure SOCKET values are not truncated (win32-specific)
- format string fixes
* [Bug 2965] Local clock didn't work since 4.2.8p4. Martin Burnicki.
* [Bug 2967] ntpdate command suffers an assertion failure
- fixed ntp_rfc2553.c to return proper address length. perlinger@ntp.org
* [Bug 2969] Seg fault from ntpq/mrulist when looking at server with
lots of clients. perlinger@ntp.org
* [Bug 2971] ntpq bails on ^C: select fails: Interrupted system call
- changed stacked/nested handling of CTRL-C. perlinger@ntp.org
* Unity cleanup for FreeBSD-6.4. Harlan Stenn.
* Unity test cleanup. Harlan Stenn.
* Libevent autoconf pthread fixes for FreeBSD-10. Harlan Stenn.
* Header cleanup in tests/sandbox/uglydate.c. Harlan Stenn.
* Header cleanup in tests/libntp/sfptostr.c. Harlan Stenn.
* Quiet a warning from clang. Harlan Stenn.
---
NTP 4.2.8p4
Focus: Security, Bug fies, enhancements.
Focus: Security, Bug fixes, enhancements.
Severity: MEDIUM
@ -339,8 +440,8 @@ Credit: This weakness was discovered by Aleksandar Nikolic of Cisco Talos.
Backward-Incompatible changes:
* [Bug 2817] Default on Linux is now "rlimit memlock -1".
While the general default of 32M is still the case, under Linux
the default value has been changed to -1 (do not lock ntpd into
While the general default of 32M is still the case, under Linux
the default value has been changed to -1 (do not lock ntpd into
memory). A value of 0 means "lock ntpd into memory with whatever
memory it needs." If your ntp.conf file has an explicit "rlimit memlock"
value in it, that value will continue to be used.

28
contrib/ntp/configure vendored
View File

@ -1,6 +1,6 @@
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.69 for ntp 4.2.8p4.
# Generated by GNU Autoconf 2.69 for ntp 4.2.8p5.
#
# Report bugs to <http://bugs.ntp.org./>.
#
@ -590,8 +590,8 @@ MAKEFLAGS=
# Identity of this package.
PACKAGE_NAME='ntp'
PACKAGE_TARNAME='ntp'
PACKAGE_VERSION='4.2.8p4'
PACKAGE_STRING='ntp 4.2.8p4'
PACKAGE_VERSION='4.2.8p5'
PACKAGE_STRING='ntp 4.2.8p5'
PACKAGE_BUGREPORT='http://bugs.ntp.org./'
PACKAGE_URL='http://www.ntp.org./'
@ -1616,7 +1616,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures ntp 4.2.8p4 to adapt to many kinds of systems.
\`configure' configures ntp 4.2.8p5 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@ -1686,7 +1686,7 @@ fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of ntp 4.2.8p4:";;
short | recursive ) echo "Configuration of ntp 4.2.8p5:";;
esac
cat <<\_ACEOF
@ -1919,7 +1919,7 @@ fi
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
ntp configure 4.2.8p4
ntp configure 4.2.8p5
generated by GNU Autoconf 2.69
Copyright (C) 2012 Free Software Foundation, Inc.
@ -2749,7 +2749,7 @@ cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by ntp $as_me 4.2.8p4, which was
It was created by ntp $as_me 4.2.8p5, which was
generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
@ -3750,7 +3750,7 @@ fi
# Define the identity of the package.
PACKAGE='ntp'
VERSION='4.2.8p4'
VERSION='4.2.8p5'
cat >>confdefs.h <<_ACEOF
@ -20018,9 +20018,10 @@ $as_echo "$as_me: Using the installed libevent" >&6;}
# LDADD_LIBEVENT=`$PKG_CONFIG --libs libevent | sed 's:-levent::'`
# So now we dance...
LDADD_LIBEVENT=
for i in `$PKG_CONFIG --libs libevent`
for i in `$PKG_CONFIG --libs libevent` `$PKG_CONFIG --cflags-only-other libevent_pthreads`
do
case "$i" in
-D*) ;;
-levent*) ;;
*) case "$LDADD_LIBEVENT" in
'') LDADD_LIBEVENT="$i" ;;
@ -37035,8 +37036,9 @@ $as_echo "$ntp_ept" >&6; }
$as_echo_n "checking if we can run test-ntp_restrict... " >&6; }
ntp_test_ntp_restrict="no"
case "$ntp_ept:$cross:$host" in
no:0:*-*-freebsd6.4) ;;
no:0:*-*-hpux11.23*) ;;
no:0:*-*-solaris*) ;;
no:0:*-*-hpux-11.23*) ;;
*) ntp_test_ntp_restrict="yes" ;;
esac
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ntp_test_ntp_restrict" >&5
@ -37054,6 +37056,7 @@ fi
$as_echo_n "checking if we can run test-ntp_scanner... " >&6; }
ntp_test_ntp_scanner="no"
case "$ntp_ept:$cross:$host" in
no:0:*-*-freebsd6.4) ;;
no:0:*-*-solaris*) ;;
*) ntp_test_ntp_scanner="yes" ;;
esac
@ -37072,6 +37075,7 @@ fi
$as_echo_n "checking if we can run test-ntp_signd... " >&6; }
ntp_test_ntp_signd="no"
case "$ntp_ept:$cross:$host" in
no:0:*-*-freebsd6.4) ;;
no:0:*-*-solaris*) ;;
*) ntp_test_ntp_signd="yes" ;;
esac
@ -37836,7 +37840,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by ntp $as_me 4.2.8p4, which was
This file was extended by ntp $as_me 4.2.8p5, which was
generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
@ -37903,7 +37907,7 @@ _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
ntp config.status 4.2.8p4
ntp config.status 4.2.8p5
configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"

6
contrib/ntp/html/miscopt.html
View File

@ -3,7 +3,7 @@
<head>
<meta http-equiv="content-type" content="text/html;charset=iso-8859-1">
<title>Miscellaneous Commands and Options</title>
<!-- Changed by: Harlan Stenn, 29-Jun-2015 -->
<!-- Changed by: Harlan Stenn, 17-Nov-2015 -->
<link href="scripts/style.css" type="text/css" rel="stylesheet">
</head>
<body>
@ -11,7 +11,7 @@
<img src="pic/boom3.gif" alt="gif" align="left"><a href="http://www.eecis.udel.edu/~mills/pictures.html">from <i>Pogo</i>, Walt Kelly</a>
<p>We have three, now looking for more.</p>
<p>Last update:
<!-- #BeginDate format:En2m -->23-Sep-2015 10:20<!-- #EndDate -->
<!-- #BeginDate format:En2m -->17-Nov-2015 11:06<!-- #EndDate -->
UTC</p>
<br clear="left">
<h4>Related Links</h4>
@ -57,7 +57,7 @@
<dt id="interface"><tt>interface [listen | ignore | drop] [all | ipv4 | ipv6 | wildcard | <i>name</i> | <i>address</i>[/<i>prefixlen</i>]]</tt></dt>
<dd>This command controls which network addresses <tt>ntpd</tt> opens, and whether input is dropped without processing. The first parameter determines the action for addresses which match the second parameter. That parameter specifies a class of addresses, or a specific interface name, or an address. In the address case, <tt><i>prefixlen</i></tt> determines how many bits must match for this rule to apply. <tt>ignore</tt> prevents opening matching addresses, <tt>drop</tt> causes <tt>ntpd</tt> to open the address and drop all received packets without examination. Multiple <tt>interface</tt> commands can be used. The last rule which matches a particular address determines the action for it. <tt>interface</tt> commands are disabled if any <a href="ntpd.html#--interface"><tt>-I</tt></a>, <a href="ntpd.html#--interface"><tt>--interface</tt></a>, <a href="ntpd.html#--novirtualips"><tt>-L</tt></a>, or <a href="ntpd.html#--novirtualips"><tt>--novirtualips</tt></a> command-line options are used. If none of those options are used and no <tt>interface</tt> actions are specified in the configuration file, all available network addresses are opened. The <tt>nic</tt> command is an alias for <tt>interface</tt>.</dd>
<dt id="leapfile"><tt>leapfile <i>leapfile</i></tt></dt>
<dd>This command loads the NIST leapseconds file and initializes the leapsecond values for the next leapsecond time, expiration time and TAI offset. The file can be obtained directly from NIST national time servers using <tt>ftp</tt> as the ASCII file <tt>pub/leap-seconds</tt>.</dd>
<dd>This command loads the IERS leapseconds file and initializes the leapsecond values for the next leapsecond time, expiration time and TAI offset. The file can be obtained directly from the IERS at <a href="https://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list">https://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list</a> or <a href="ftp://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list">ftp://hpiers.obspm.fr/iers/bul/bulc/ntp/leap-seconds.list</a>.</dd>
<dd>The <i>leapfile</i> is scanned when <tt>ntpd</tt> processes the <tt>leapfile</tt> directive or when <tt>ntpd</tt> detects that <i>leapfile</i> has changed. <tt>ntpd</tt> checks once a day to see if the <i>leapfile</i> has changed.</dd>
<dd>While not strictly a security function, the Autokey protocol provides means to securely retrieve the current or updated leapsecond values from a server.</dd>
<dt id="leapsmearinterval"><tt>leapsmearinterval <i>seconds</i></tt></dt>

1
contrib/ntp/include/Makefile.am
View File

@ -66,6 +66,7 @@ noinst_HEADERS = \
recvbuff.h \
refclock_atom.h \
refidsmear.h \
safecast.h \
ssl_applink.c \
timepps-SCO.h \
timepps-Solaris.h \

1
contrib/ntp/include/Makefile.in
View File

@ -551,6 +551,7 @@ noinst_HEADERS = \
recvbuff.h \
refclock_atom.h \
refidsmear.h \
safecast.h \
ssl_applink.c \
timepps-SCO.h \
timepps-Solaris.h \

2
contrib/ntp/include/ntp_refclock.h
View File

@ -220,7 +220,7 @@ extern void refclock_buginfo(sockaddr_u *,
extern void refclock_control(sockaddr_u *,
const struct refclockstat *,
struct refclockstat *);
extern int refclock_open (char *, u_int, u_int);
extern int refclock_open (const char *, u_int, u_int);
extern int refclock_setup (int, u_int, u_int);
extern void refclock_timer (struct peer *);
extern void refclock_transmit(struct peer *);

8
contrib/ntp/include/ntp_stdlib.h
View File

@ -65,8 +65,8 @@ typedef void (*ctrl_c_fn)(void);
/* authkeys.c */
extern void auth_delkeys (void);
extern int auth_havekey (keyid_t);
extern int authdecrypt (keyid_t, u_int32 *, int, int);
extern int authencrypt (keyid_t, u_int32 *, int);
extern int authdecrypt (keyid_t, u_int32 *, size_t, size_t);
extern size_t authencrypt (keyid_t, u_int32 *, size_t);
extern int authhavekey (keyid_t);
extern int authistrusted (keyid_t);
extern int authreadkeys (const char *);
@ -95,8 +95,8 @@ extern void auth_prealloc_symkeys(int);
extern int ymd2yd (int, int, int);
/* a_md5encrypt.c */
extern int MD5authdecrypt (int, u_char *, u_int32 *, int, int);
extern int MD5authencrypt (int, u_char *, u_int32 *, int);
extern int MD5authdecrypt (int, const u_char *, u_int32 *, size_t, size_t);
extern size_t MD5authencrypt (int, const u_char *, u_int32 *, size_t);
extern void MD5auth_setkey (keyid_t, int, const u_char *, size_t);
extern u_int32 addr2refid (sockaddr_u *);

66
contrib/ntp/include/ntp_worker.h
View File

@ -43,19 +43,22 @@ typedef struct blocking_pipe_header_tag {
} blocking_pipe_header;
# ifdef WORK_THREAD
# ifdef WORK_PIPE
typedef pthread_t * thr_ref;
typedef sem_t * sem_ref;
# ifdef SYS_WINNT
typedef struct { HANDLE thnd; } thread_type;
typedef struct { HANDLE shnd; } sema_type;
# else
typedef HANDLE thr_ref;
typedef HANDLE sem_ref;
typedef pthread_t thread_type;
typedef sem_t sema_type;
# endif
typedef thread_type *thr_ref;
typedef sema_type *sem_ref;
# endif
/*
*
*/
#ifdef WORK_FORK
#if defined(WORK_FORK)
typedef struct blocking_child_tag {
int reusable;
int pid;
@ -66,38 +69,59 @@ typedef struct blocking_child_tag {
int resp_write_pipe;
int ispipe;
} blocking_child;
#elif defined(WORK_THREAD)
typedef struct blocking_child_tag {
/*
* blocking workitems and blocking_responses are dynamically-sized
* one-dimensional arrays of pointers to blocking worker requests and
* responses.
*
* IMPORTANT: This structure is shared between threads, and all access
* that is not atomic (especially queue operations) must hold the
* 'accesslock' semaphore to avoid data races.
*
* The resource management (thread/semaphore creation/destruction)
* functions and functions just testing a handle are safe because these
* are only changed by the main thread when no worker is running on the
* same data structure.
*/
int reusable;
thr_ref thread_ref;
u_int thread_id;
blocking_pipe_header * volatile * volatile
sem_ref accesslock; /* shared access lock */
thr_ref thread_ref; /* thread 'handle' */
/* the reuest queue */
blocking_pipe_header ** volatile
workitems;
volatile size_t workitems_alloc;
size_t next_workitem; /* parent */
size_t next_workeritem; /* child */
blocking_pipe_header * volatile * volatile
size_t head_workitem; /* parent */
size_t tail_workitem; /* child */
sem_ref workitems_pending; /* signalling */
/* the response queue */
blocking_pipe_header ** volatile
responses;
volatile size_t responses_alloc;
size_t next_response; /* child */
size_t next_workresp; /* parent */
size_t head_response; /* child */
size_t tail_response; /* parent */
/* event handles / sem_t pointers */
/* sem_ref child_is_blocking; */
sem_ref blocking_req_ready;
sem_ref wake_scheduled_sleep;
/* some systems use a pipe for notification, others a semaphore.
* Both employ the queue above for the actual data transfer.
*/
#ifdef WORK_PIPE
int resp_read_pipe; /* parent */
int resp_write_pipe;/* child */
int resp_read_pipe; /* parent */
int resp_write_pipe; /* child */
int ispipe;
void * resp_read_ctx; /* child */
void * resp_read_ctx; /* child */
#else
sem_ref blocking_response_ready;
sem_ref responses_pending; /* signalling */
#endif
sema_type sem_table[4];
thread_type thr_table[1];
} blocking_child;
#endif /* WORK_THREAD */
@ -111,7 +135,7 @@ extern u_int available_blocking_child_slot(void);
extern int queue_blocking_request(blocking_work_req, void *,
size_t, blocking_work_callback,
void *);
extern int queue_blocking_response(blocking_child *,
extern int queue_blocking_response(blocking_child *,
blocking_pipe_header *, size_t,
const blocking_pipe_header *);
extern void process_blocking_resp(blocking_child *);

3
contrib/ntp/include/ntpd.h
View File

@ -156,7 +156,7 @@ extern u_int sys_tai;
extern int freq_cnt;
/* ntp_monitor.c */
#define MON_HASH_SIZE (1U << mon_hash_bits)
#define MON_HASH_SIZE ((size_t)1U << mon_hash_bits)
#define MON_HASH_MASK (MON_HASH_SIZE - 1)
#define MON_HASH(addr) (sock_hash(addr) & MON_HASH_MASK)
extern void init_mon (void);
@ -408,6 +408,7 @@ extern int hardpps_enable; /* kernel PPS discipline enabled */
extern int ext_enable; /* external clock enabled */
extern int cal_enable; /* refclock calibrate enable */
extern int allow_panic; /* allow panic correction (-g) */
extern int enable_panic_check; /* Can we check allow_panic's state? */
extern int force_step_once; /* always step time once at startup (-G) */
extern int mode_ntpdate; /* exit on first clock set (-q) */
extern int peer_ntpdate; /* count of ntpdate peers */

34
contrib/ntp/include/safecast.h Normal file
View File

@ -0,0 +1,34 @@
#ifndef SAFECAST_H
#define SAFECAST_H
#include <limits.h>
static inline int size2int_chk(size_t v)
{
if (v > INT_MAX)
abort();
return (int)(v);
}
static inline int size2int_sat(size_t v)
{
return (v > INT_MAX) ? INT_MAX : (int)v;
}
/* Compilers can emit warning about increased alignment requirements
* when casting pointers. The impact is tricky: on machines where
* alignment is just a performance issue (x86,x64,...) this might just
* cause a performance penalty. On others, an address error can occur
* and the process dies...
*
* Still, there are many cases where the pointer arithmetic and the
* buffer alignment make sure this does not happen. OTOH, the compiler
* doesn't know this and still emits warnings.
*
* The following cast macros are going through void pointers to tell
* the compiler that there is no alignment requirement to watch.
*/
#define UA_PTR(ptype,pval) ((ptype *)(void*)(pval))
#define UAC_PTR(ptype,pval) ((const ptype *)(const void*)(pval))
#define UAV_PTR(ptype,pval) ((volatile ptype *)(volatile void*)(pval))
#endif

2
contrib/ntp/lib/isc/backtrace.c
View File

@ -278,7 +278,7 @@ isc_backtrace_getsymbol(const void *addr, const char **symbolp,
result = ISC_R_NOTFOUND;
else {
*symbolp = found->symbol;
*offsetp = (const char *)addr - (char *)found->addr;
*offsetp = (u_long)((const char *)addr - (char *)found->addr);
}
return (result);

4
contrib/ntp/lib/isc/buffer.c
View File

@ -406,7 +406,7 @@ isc__buffer_putmem(isc_buffer_t *b, const unsigned char *base,
void
isc__buffer_putstr(isc_buffer_t *b, const char *source) {
unsigned int l;
size_t l;
unsigned char *cp;
REQUIRE(ISC_BUFFER_VALID(b));
@ -421,7 +421,7 @@ isc__buffer_putstr(isc_buffer_t *b, const char *source) {
cp = isc_buffer_used(b);
memcpy(cp, source, l);
b->used += l;
b->used += (u_int)l; /* checked above - no overflow here */
}
isc_result_t

5
contrib/ntp/lib/isc/inet_aton.c
View File

@ -92,7 +92,7 @@ static char rcsid[] = "$Id: inet_aton.c,v 1.23 2008/12/01 23:47:45 tbox Exp $";
int
isc_net_aton(const char *cp, struct in_addr *addr) {
unsigned long val;
int base, n;
int base;
unsigned char c;
isc_uint8_t parts[4];
isc_uint8_t *pp = parts;
@ -166,8 +166,7 @@ isc_net_aton(const char *cp, struct in_addr *addr) {
* Concoct the address according to
* the number of parts specified.
*/
n = pp - parts + 1;
switch (n) {
switch (pp - parts + 1) {
case 1: /* a -- 32 bits */
break;

6
contrib/ntp/lib/isc/inet_pton.c
View File

@ -92,7 +92,7 @@ inet_pton4(const char *src, unsigned char *dst) {
const char *pch;
if ((pch = strchr(digits, ch)) != NULL) {
unsigned int newv = *tp * 10 + (pch - digits);
size_t newv = *tp * 10 + (pch - digits);
if (saw_digit && *tp == 0)
return (0);
@ -197,12 +197,12 @@ inet_pton6(const char *src, unsigned char *dst) {
* Since some memmove()'s erroneously fail to handle
* overlapping regions, we'll do the shift by hand.
*/
const int n = tp - colonp;
const size_t n = tp - colonp;
int i;
if (tp == endp)
return (0);
for (i = 1; i <= n; i++) {
for (i = 1; (size_t)i <= n; i++) {
endp[- i] = colonp[n - i];
colonp[n - i] = 0;
}

2
contrib/ntp/lib/isc/log.c
View File

@ -1146,7 +1146,7 @@ greatest_version(isc_logchannel_t *channel, int *greatestp) {
char *basenam, *digit_end;
const char *dirname;
int version, greatest = -1;
unsigned int basenamelen;
size_t basenamelen;
isc_dir_t dir;
isc_result_t result;
char sep = '/';

2
contrib/ntp/lib/isc/netaddr.c
View File

@ -159,7 +159,7 @@ isc_netaddr_totext(const isc_netaddr_t *netaddr, isc_buffer_t *target) {
if (r == NULL)
return (ISC_R_FAILURE);
alen = strlen(abuf);
alen = (unsigned int)strlen(abuf); /* no overflow possible */
INSIST(alen < sizeof(abuf));
zlen = 0;

4
contrib/ntp/lib/isc/sockaddr.c
View File

@ -134,7 +134,7 @@ isc_sockaddr_totext(const isc_sockaddr_t *sockaddr, isc_buffer_t *target) {
break;
#ifdef ISC_PLAFORM_HAVESYSUNH
case AF_UNIX:
plen = strlen(sockaddr->type.sunix.sun_path);
plen = (unsigned int)strlen(sockaddr->type.sunix.sun_path);
if (plen >= isc_buffer_availablelength(target))
return (ISC_R_NOSPACE);
@ -153,7 +153,7 @@ isc_sockaddr_totext(const isc_sockaddr_t *sockaddr, isc_buffer_t *target) {
return (ISC_R_FAILURE);
}
plen = strlen(pbuf);
plen = (unsigned int)strlen(pbuf);
INSIST(plen < sizeof(pbuf));
isc_netaddr_fromsockaddr(&netaddr, sockaddr);

Some files were not shown because too many files have changed in this diff Show More