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

Merge ^/head r293175 through r293279.

Browse Source
This commit is contained in:
dim 2016-01-06 21:31:07 +00:00
commit 90a2cc030c
130 changed files with 3950 additions and 1303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Makefile.inc1
View File

@ -1284,27 +1284,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
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' \
@${DESTDIR}/${DISTDIR}/kernel.meta | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.if ${BUILDKERNELS:[#]} > 1
.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
cd ${DESTDIR}/${DISTDIR}/kernel; \
tar cvf - --include '*/*/*.debug' $$(eval find .) | \
${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
.if ${BUILDKERNELS:[#]} > 1
.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

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

2
etc/mtree/BSD.tests.dist
View File

@ -622,6 +622,8 @@
..
pw
..
rpcbind
..
sa
..
..

10
etc/rc
View File

@ -130,11 +130,17 @@ for _rc_elem in ${files}; do
done
# Remove the firstboot sentinel, and reboot if it was requested.
# Be a bit paranoid about removing it to handle the common failure
# modes since the consequence of failure can be big.
# Note: this assumes firstboot_sentinel is on / when we have
# a read-only /, or that it is on media that's writable.
if [ -e ${firstboot_sentinel} ]; then
[ ${root_rw_mount} = "yes" ] || mount -uw /
/bin/rm ${firstboot_sentinel}
chflags -R 0 ${firstboot_sentinel}
rm -rf ${firstboot_sentinel}
if [ -e ${firstboot_sentinel}-reboot ]; then
/bin/rm ${firstboot_sentinel}-reboot
chflags -R 0 ${firstboot_sentinel}-reboot
rm -rf ${firstboot_sentinel}-reboot
[ ${root_rw_mount} = "yes" ] || mount -ur /
kill -INT 1
fi

4
include/paths.h
View File

@ -36,7 +36,7 @@
#include <sys/cdefs.h>
/* Default search path. */
#define _PATH_DEFPATH "/usr/bin:/bin"
#define _PATH_DEFPATH "/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin"
/* All standard utilities path. */
#define _PATH_STDPATH "/usr/bin:/bin:/usr/sbin:/sbin"
/* Locate system binaries. */
@ -108,7 +108,7 @@ __END_DECLS
#ifdef RESCUE
#undef _PATH_DEFPATH
#define _PATH_DEFPATH "/rescue:/usr/bin:/bin"
#define _PATH_DEFPATH "/rescue:/sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin"
#undef _PATH_STDPATH
#define _PATH_STDPATH "/rescue:/usr/bin:/bin:/usr/sbin:/sbin"
#undef _PATH_SYSPATH

4
lib/libc/gen/exec.3
View File

@ -28,7 +28,7 @@
.\" @(#)exec.3 8.3 (Berkeley) 1/24/94
.\" $FreeBSD$
.\"
.Dd December 12, 2015
.Dd January 5, 2016
.Dt EXEC 3
.Os
.Sh NAME
@ -161,7 +161,7 @@ the default path is set according to the
definition in
.In paths.h ,
which is set to
.Dq Ev /usr/bin:/bin .
.Dq Ev /sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin .
For
.Fn execvP ,
the search path is specified as an argument to the function.

4
lib/libc/gen/posix_spawn.3
View File

@ -34,7 +34,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd June 17, 2011
.Dd January 5, 2016
.Dt POSIX_SPAWN 3
.Os
.Sh NAME
@ -126,7 +126,7 @@ the default path is set according to the
definition in
.In paths.h ,
which is set to
.Dq Ev /usr/bin:/bin .
.Dq Ev /sbin:/bin:/usr/sbin:/usr/bin:/usr/local/sbin:/usr/local/bin .
.Pp
If
.Fa file_actions

5
lib/libstand/Makefile
View File

@ -38,8 +38,9 @@ SRCS+= ntoh.c
# string functions from libc
.PATH: ${LIBC_SRC}/string
SRCS+= bcmp.c bcopy.c bzero.c ffs.c memccpy.c memchr.c memcmp.c memcpy.c \
memmove.c memset.c qdivrem.c strcat.c strchr.c strcmp.c strcpy.c \
SRCS+= bcmp.c bcopy.c bzero.c ffs.c fls.c \
memccpy.c memchr.c memcmp.c memcpy.c memmove.c memset.c \
qdivrem.c strcat.c strchr.c strcmp.c strcpy.c \
strcspn.c strlcat.c strlcpy.c strlen.c strncat.c strncmp.c strncpy.c \
strpbrk.c strrchr.c strsep.c strspn.c strstr.c strtok.c swab.c
.if ${MACHINE_CPUARCH} == "arm"

4
libexec/rtld-elf/amd64/reloc.c
View File

@ -228,8 +228,8 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int flags,
/*
* These are deferred until all other relocations have
* been done. All we do here is make sure that the COPY
* relocation is not in a shared library. They are allowed
* only in executable files.
* relocation is not in a shared library. They are
* allowed only in executable files.
*/
if (!obj->mainprog) {
_rtld_error("%s: Unexpected R_X86_64_COPY "

8
libexec/rtld-elf/rtld.c
View File

@ -435,7 +435,7 @@ _rtld(Elf_Addr *sp, func_ptr_type *exit_proc, Obj_Entry **objp)
trust = !issetugid();
md_abi_variant_hook(aux_info);
/* md_abi_variant_hook(aux_info); */
ld_bind_now = getenv(_LD("BIND_NOW"));
/*
@ -1144,13 +1144,13 @@ digest_dynamic1(Obj_Entry *obj, int early, const Elf_Dyn **dyn_rpath,
* is mapped read-only. DT_MIPS_RLD_MAP is used instead.
*/
#ifndef __mips__
case DT_DEBUG:
if (!obj->writable_dynamic)
break;
if (!early)
dbg("Filling in DT_DEBUG entry");
((Elf_Dyn*)dynp)->d_un.d_ptr = (Elf_Addr) &r_debug;
break;
#endif
case DT_FLAGS:
if (dynp->d_un.d_val & DF_ORIGIN)
@ -1331,6 +1331,8 @@ digest_phdr(const Elf_Phdr *phdr, int phnum, caddr_t entry, const char *path)
break;
case PT_DYNAMIC:
if (ph->p_flags & PROT_WRITE)
obj->writable_dynamic = true;
obj->dynamic = (const Elf_Dyn *)(ph->p_vaddr + obj->relocbase);
break;

1
libexec/rtld-elf/rtld.h
View File

@ -264,6 +264,7 @@ typedef struct Struct_Obj_Entry {
bool valid_hash_sysv : 1; /* A valid System V hash hash tag is available */
bool valid_hash_gnu : 1; /* A valid GNU hash tag is available */
bool dlopened : 1; /* dlopen()-ed (vs. load statically) */
bool writable_dynamic : 1; /* PT_DYNAMIC is writable */
struct link_map linkmap; /* For GDB and dlinfo() */
Objlist dldags; /* Object belongs to these dlopened DAGs (%) */

10
release/Makefile
View File

@ -176,7 +176,7 @@ disc1: packagesystem
MK_DEBUG_FILES=no
# Copy distfiles
mkdir -p ${.TARGET}/usr/freebsd-dist
for dist in MANIFEST $$(ls *.txz | grep -v -- '-dbg'); \
for dist in MANIFEST $$(ls *.txz | grep -vE -- '(base|lib32)-dbg'); \
do cp $${dist} ${.TARGET}/usr/freebsd-dist; \
done
# Copy documentation, if generated
@ -225,7 +225,7 @@ dvd: packagesystem
MK_TESTS=no MK_DEBUG_FILES=no
# Copy distfiles
mkdir -p ${.TARGET}/usr/freebsd-dist
for dist in MANIFEST $$(ls *.txz | grep -v -- '-dbg'); \
for dist in MANIFEST $$(ls *.txz | grep -v -- '(base|lib32)-dbg'); \
do cp $${dist} ${.TARGET}/usr/freebsd-dist; \
done
# Copy documentation, if generated
@ -281,7 +281,11 @@ ftp: packagesystem
cp *.txz MANIFEST ftp
release: real-release vm-release cloudware-release
touch ${.OBJDIR}/${.TARGET}
${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} release-done
true
release-done:
touch release
real-release:
${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} obj

2
release/amd64/make-memstick.sh
View File

@ -29,12 +29,14 @@ if [ -e ${2} ]; then
fi
echo '/dev/ufs/FreeBSD_Install / ufs ro,noatime 1 1' > ${1}/etc/fstab
echo 'root_rw_mount="NO"' > ${1}/etc/rc.conf.local
makefs -B little -o label=FreeBSD_Install ${2}.part ${1}
if [ $? -ne 0 ]; then
echo "makefs failed"
exit 1
fi
rm ${1}/etc/fstab
rm ${1}/etc/rc.conf.local
mkimg -s gpt -b ${1}/boot/pmbr -p efi:=${1}/boot/boot1.efifat -p freebsd-boot:=${1}/boot/gptboot -p freebsd-ufs:=${2}.part -p freebsd-swap::1M -o ${2}
rm ${2}.part

2
release/amd64/mkisoimages.sh
View File

@ -56,5 +56,5 @@ NAME="$1"; shift
publisher="The FreeBSD Project. http://www.FreeBSD.org/"
echo "/dev/iso9660/$LABEL / cd9660 ro 0 0" > "$1/etc/fstab"
makefs -t cd9660 $bootable -o rockridge -o label="$LABEL" -o publisher="$publisher" "$NAME" "$@"
rm "$1/etc/fstab"
rm -f "$1/etc/fstab"
rm -f efiboot.img

2
release/arm64/make-memstick.sh
View File

@ -29,12 +29,14 @@ if [ -e ${2} ]; then
fi
echo '/dev/ufs/FreeBSD_Install / ufs ro,noatime 1 1' > ${1}/etc/fstab
echo 'root_rw_mount="NO"' > ${1}/etc/rc.conf.local
makefs -B little -o label=FreeBSD_Install ${2}.part ${1}
if [ $? -ne 0 ]; then
echo "makefs failed"
exit 1
fi
rm ${1}/etc/fstab
rm ${1}/etc/rc.conf.local
mkimg -s mbr -p efi:=${1}/boot/boot1.efifat -p freebsd:=${2}.part -o ${2}
rm ${2}.part

2
release/i386/make-memstick.sh
View File

@ -29,12 +29,14 @@ if [ -e ${2} ]; then
fi
echo '/dev/ufs/FreeBSD_Install / ufs ro,noatime 1 1' > ${1}/etc/fstab
echo 'root_rw_mount="NO"' > ${1}/etc/rc.conf.local
makefs -B little -o label=FreeBSD_Install ${2}.part ${1}
if [ $? -ne 0 ]; then
echo "makefs failed"
exit 1
fi
rm ${1}/etc/fstab
rm ${1}/etc/rc.conf.local
mkimg -s gpt -b ${1}/boot/pmbr -p freebsd-boot:=${1}/boot/gptboot -p freebsd-ufs:=${2}.part -p freebsd-swap::1M -o ${2}
rm ${2}.part

2
release/i386/mkisoimages.sh
View File

@ -42,4 +42,4 @@ NAME="$1"; shift
publisher="The FreeBSD Project. http://www.FreeBSD.org/"
echo "/dev/iso9660/$LABEL / cd9660 ro 0 0" > "$1/etc/fstab"
makefs -t cd9660 $bootable -o rockridge -o label="$LABEL" -o publisher="$publisher" "$NAME" "$@"
rm "$1/etc/fstab"
rm -f "$1/etc/fstab"

2
release/pc98/mkisoimages.sh
View File

@ -42,4 +42,4 @@ NAME="$1"; shift
publisher="The FreeBSD Project. http://www.FreeBSD.org/"
echo "/dev/iso9660/$LABEL / cd9660 ro 0 0" > "$1/etc/fstab"
makefs -t cd9660 $bootable -o rockridge -o label="$LABEL" -o publisher="$publisher" "$NAME" "$@"
rm "$1/etc/fstab"
rm -f "$1/etc/fstab"

2
release/powerpc/make-memstick.sh
View File

@ -33,6 +33,7 @@ if [ -e ${2} ]; then
fi
echo '/dev/da0s3 / ufs ro,noatime 1 1' > ${1}/etc/fstab
echo 'root_rw_mount="NO"' > ${1}/etc/rc.conf.local
rm -f ${tempfile}
makefs -B big ${tempfile} ${1}
if [ $? -ne 0 ]; then
@ -40,6 +41,7 @@ if [ $? -ne 0 ]; then
exit 1
fi
rm ${1}/etc/fstab
rm ${1}/etc/rc.conf.local
mkimg -s apm -p freebsd-boot:=${1}/boot/boot1.hfs -p freebsd-ufs/FreeBSD_Install:=${tempfile} -o ${2}

4
release/powerpc/mkisoimages.sh
View File

@ -64,6 +64,6 @@ NAME="$1"; shift
publisher="The FreeBSD Project. http://www.FreeBSD.org/"
echo "/dev/iso9660/$LABEL / cd9660 ro 0 0" > "$1/etc/fstab"
makefs -t cd9660 $bootable -o rockridge -o label="$LABEL" -o publisher="$publisher" "$NAME" "$@"
rm "$1/etc/fstab"
rm /tmp/hfs-boot-block
rm -f "$1/etc/fstab"
rm -f /tmp/hfs-boot-block
rm -rf "$1/ppc"

70
release/scripts/make-manifest.sh
View File

@ -9,18 +9,64 @@
#
# $FreeBSD$
desc_base="Base system (MANDATORY)"
desc_kernel="Kernel (MANDATORY)"
desc_doc="Additional documentation"
doc_default=off
desc_lib32="32-bit compatibility libraries"
desc_ports="Ports tree"
desc_src="System source code"
desc_tests="Test suite"
src_default=off
tests_default=off
base="Base system"
doc="Additional Documentation"
kernel="Kernel"
ports="Ports tree"
src="System source tree"
lib32="32-bit compatibility libraries"
tests="Test suite"
for i in $*; do
echo "`basename $i` `sha256 -q $i` `tar tvf $i | wc -l | tr -d ' '` `basename $i .txz` \"`eval echo \\\$desc_$(basename $i .txz)`\" `eval echo \\\${$(basename $i .txz)_default:-on}`"
desc_base="${base} (MANDATORY)"
desc_base_dbg="${base} (Debugging)"
desc_doc="${doc}"
desc_kernel="${kernel} (MANDATORY)"
desc_kernel_dbg="${kernel} (Debugging)"
desc_kernel_alt="Alternate ${kernel}"
desc_kernel_alt_dbg="Alternate ${kernel} (Debugging)"
desc_lib32="${lib32}"
desc_lib32_dbg="${lib32} (Debugging)"
desc_ports="${ports}"
desc_src="${src}"
desc_tests="${tests}"
default_doc=off
default_src=off
default_tests=off
default_base_dbg=off
default_lib32_dbg=off
default_kernel_alt=off
default_kernel_dbg=on
default_kernel_alt_dbg=off
for i in ${*}; do
dist="${i}"
distname="${i%%.txz}"
distname="$(echo ${distname} | tr '-' '_')"
distname="$(echo ${distname} | tr 'kernel.' 'kernel_')"
hash="$(sha256 -q ${i})"
nfiles="$(tar tvf ${i} | wc -l | tr -d ' ')"
default="$(eval echo \${default_${distname}:-on})"
desc="$(eval echo \"\${desc_${distname}}\")"
case ${i} in
kernel-dbg.txz)
desc="${desc_kernel_dbg}"
;;
kernel.*-dbg.txz)
desc="$(eval echo \"${desc_kernel_alt_dbg}\")"
desc="${desc}: $(eval echo ${i%%-dbg.txz} | cut -f 2 -d '.')"
default="$(eval echo \"${default_kernel_alt_dbg}\")"
;;
kernel.*.txz)
desc="$(eval echo \"${desc_kernel_alt}\")"
desc="${desc}: $(eval echo ${i%%.txz} | cut -f 2 -d '.')"
default="$(eval echo \"${default_kernel_alt}\")"
;;
*)
;;
esac
printf "${dist}\t${hash}\t${nfiles}\t${distname}\t\"${desc}\"\t${default}\n"
done

2
release/sparc64/mkisoimages.sh
View File

@ -38,7 +38,7 @@ BASEBITSDIR="$1"
publisher="The FreeBSD Project. http://www.FreeBSD.org/"
echo "/dev/iso9660/$LABEL / cd9660 ro 0 0" > "$BASEBITSDIR/etc/fstab"
makefs -t cd9660 -o rockridge -o label="$LABEL" -o publisher="$publisher" "$NAME.tmp" "$@"
rm "$BASEBITSDIR/etc/fstab"
rm -f "$BASEBITSDIR/etc/fstab"
if [ "x$BOPT" != "x-b" ]; then
mv "$NAME.tmp" "$NAME"

4
share/man/man4/ioat.4
View File

@ -24,7 +24,7 @@
.\"
.\" $FreeBSD$
.\"
.Dd December 17, 2015
.Dd January 5, 2016
.Dt IOAT 4
.Os
.Sh NAME
@ -65,6 +65,8 @@ In
.Fn ioat_put_dmaengine "bus_dmaengine_t dmaengine"
.Ft int
.Fn ioat_get_hwversion "bus_dmaengine_t dmaengine"
.Ft size_t
.Fn ioat_get_max_io_size "bus_dmaengine_t dmaengine"
.Ft int
.Fn ioat_set_interrupt_coalesce "bus_dmaengine_t dmaengine" "uint16_t delay"
.Ft uint16_t

9
sys/boot/efi/boot1/boot1.c
View File

@ -132,8 +132,7 @@ EFI_STATUS efi_main(EFI_HANDLE Ximage, EFI_SYSTEM_TABLE* Xsystab)
conout->Reset(conout, TRUE);
max_dim = best_mode = 0;
for (i = 0; ; i++) {
status = conout->QueryMode(conout, i,
&cols, &rows);
status = conout->QueryMode(conout, i, &cols, &rows);
if (EFI_ERROR(status))
break;
if (cols * rows > max_dim) {
@ -331,20 +330,20 @@ load(const char *fname)
buffer, bufsize, &loaderhandle);
if (EFI_ERROR(status))
printf("LoadImage failed with error %lu\n",
status & ~EFI_ERROR_MASK);
EFI_ERROR_CODE(status));
status = systab->BootServices->HandleProtocol(loaderhandle,
&LoadedImageGUID, (VOID**)&loaded_image);
if (EFI_ERROR(status))
printf("HandleProtocol failed with error %lu\n",
status & ~EFI_ERROR_MASK);
EFI_ERROR_CODE(status));
loaded_image->DeviceHandle = bootdevhandle;
status = systab->BootServices->StartImage(loaderhandle, NULL, NULL);
if (EFI_ERROR(status))
printf("StartImage failed with error %lu\n",
status & ~EFI_ERROR_MASK);
EFI_ERROR_CODE(status));
}
static void

6
sys/boot/efi/include/amd64/efibind.h
View File

@ -39,7 +39,7 @@ Revision History
// No ANSI C 1999/2000 stdint.h integer width declarations
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
// Use Microsoft C compiler integer width declarations
@ -164,7 +164,7 @@ typedef uint64_t UINTN;
#endif
#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
#define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler
#else
#define EFIAPI // Substitute expresion to force C calling convention
@ -265,7 +265,7 @@ typedef uint64_t UINTN;
#endif
#endif /* __FreeBSD__ */
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
#pragma warning ( disable : 4731 ) // Suppress warnings about modification of EBP
#endif

4
sys/boot/efi/include/arm64/efibind.h
View File

@ -39,7 +39,7 @@ Revision History
// No ANSI C 1999/2000 stdint.h integer width declarations
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
// Use Microsoft C compiler integer width declarations
@ -159,7 +159,7 @@ typedef uint64_t UINTN;
//
#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
#define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler
#else
#define EFIAPI // Substitute expresion to force C calling convention

3
sys/boot/efi/include/efierr.h
View File

@ -30,7 +30,8 @@ Revision History
#define EFIWARN(a) (a)
#define EFI_ERROR(a) (((INTN) a) < 0)
#define EFI_ERROR(a) (((INTN) a) < 0)
#define EFI_ERROR_CODE(a) (a & ~EFI_ERROR_MASK)
#define EFI_SUCCESS 0

6
sys/boot/efi/include/i386/efibind.h
View File

@ -39,7 +39,7 @@ Revision History
// No ANSI C 1999/2000 stdint.h integer width declarations
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
// Use Microsoft C compiler integer width declarations
@ -160,7 +160,7 @@ typedef uint32_t UINTN;
//
#ifndef EFIAPI // Forces EFI calling conventions reguardless of compiler options
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
#define EFIAPI __cdecl // Force C calling convention for Microsoft C compiler
#else
#define EFIAPI // Substitute expresion to force C calling convention
@ -261,7 +261,7 @@ typedef uint32_t UINTN;
#endif
#endif /* __FreeBSD__ */
#if _MSC_EXTENSIONS
#ifdef _MSC_EXTENSIONS
#pragma warning ( disable : 4731 ) // Suppress warnings about modification of EBP
#endif

1
sys/boot/efi/libefi/Makefile
View File

@ -21,5 +21,6 @@ CFLAGS+= -I${.CURDIR}/../../common
# Handle FreeBSD specific %b and %D printf format specifiers
CFLAGS+= ${FORMAT_EXTENSIONS}
CFLAGS+= -DTERM_EMU
.include <bsd.lib.mk>

424
sys/boot/efi/libefi/efi_console.c
View File

@ -35,6 +35,69 @@ __FBSDID("$FreeBSD$");
static SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
static SIMPLE_INPUT_INTERFACE *conin;
#ifdef TERM_EMU
#define DEFAULT_FGCOLOR EFI_LIGHTGRAY
#define DEFAULT_BGCOLOR EFI_BLACK
#define MAXARGS 8
static int args[MAXARGS], argc;
static int fg_c, bg_c, curx, cury;
static int esc;
void get_pos(int *x, int *y);
void curs_move(int *_x, int *_y, int x, int y);
static void CL(int);
#endif
static void efi_cons_probe(struct console *);
static int efi_cons_init(int);
void efi_cons_putchar(int);
int efi_cons_getchar(void);
void efi_cons_efiputchar(int);
int efi_cons_poll(void);
struct console efi_console = {
"efi",
"EFI console",
0,
efi_cons_probe,
efi_cons_init,
efi_cons_putchar,
efi_cons_getchar,
efi_cons_poll
};
#ifdef TERM_EMU
/* Get cursor position. */
void
get_pos(int *x, int *y)
{
*x = conout->Mode->CursorColumn;
*y = conout->Mode->CursorRow;
}
/* Move cursor to x rows and y cols (0-based). */
void
curs_move(int *_x, int *_y, int x, int y)
{
conout->SetCursorPosition(conout, x, y);
if (_x != NULL)
*_x = conout->Mode->CursorColumn;
if (_y != NULL)
*_y = conout->Mode->CursorRow;
}
/* Clear internal state of the terminal emulation code. */
void
end_term(void)
{
esc = 0;
argc = -1;
}
#endif
static void
efi_cons_probe(struct console *cp)
{
@ -46,22 +109,314 @@ efi_cons_probe(struct console *cp)
static int
efi_cons_init(int arg)
{
conout->SetAttribute(conout, EFI_TEXT_ATTR(EFI_LIGHTGRAY, EFI_BLACK));
conout->SetAttribute(conout, EFI_TEXT_ATTR(DEFAULT_FGCOLOR,
DEFAULT_BGCOLOR));
#ifdef TERM_EMU
end_term();
get_pos(&curx, &cury);
curs_move(&curx, &cury, curx, cury);
fg_c = DEFAULT_FGCOLOR;
bg_c = DEFAULT_BGCOLOR;
#endif
conout->EnableCursor(conout, TRUE);
return 0;
}
static void
efi_cons_rawputchar(int c)
{
int i;
UINTN x, y;
conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
if (c == '\t')
/* XXX lame tab expansion */
for (i = 0; i < 8; i++)
efi_cons_rawputchar(' ');
else {
#ifndef TERM_EMU
if (c == '\n')
efi_cons_efiputchar('\r');
else
efi_cons_efiputchar(c);
#else
switch (c) {
case '\r':
curx = 0;
curs_move(&curx, &cury, curx, cury);
return;
case '\n':
cury++;
if (cury >= y) {
efi_cons_efiputchar('\n');
cury--;
} else
curs_move(&curx, &cury, curx, cury);
return;
case '\b':
if (curx > 0) {
curx--;
curs_move(&curx, &cury, curx, cury);
}
return;
default:
efi_cons_efiputchar(c);
curx++;
if (curx > x-1) {
curx = 0;
cury++;
}
if (cury > y-1) {
curx = 0;
cury--;
}
}
curs_move(&curx, &cury, curx, cury);
#endif
}
}
/* Gracefully exit ESC-sequence processing in case of misunderstanding. */
static void
bail_out(int c)
{
char buf[16], *ch;
int i;
if (esc) {
efi_cons_rawputchar('\033');
if (esc != '\033')
efi_cons_rawputchar(esc);
for (i = 0; i <= argc; ++i) {
sprintf(buf, "%d", args[i]);
ch = buf;
while (*ch)
efi_cons_rawputchar(*ch++);
}
}
efi_cons_rawputchar(c);
end_term();
}
/* Clear display from current position to end of screen. */
static void
CD(void) {
int i;
UINTN x, y;
get_pos(&curx, &cury);
if (curx == 0 && cury == 0) {
conout->ClearScreen(conout);
end_term();
return;
}
conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
CL(0); /* clear current line from cursor to end */
for (i = cury + 1; i < y-1; i++) {
curs_move(NULL, NULL, 0, i);
CL(0);
}
curs_move(NULL, NULL, curx, cury);
end_term();
}
/*
* Absolute cursor move to args[0] rows and args[1] columns
* (the coordinates are 1-based).
*/
static void
CM(void)
{
if (args[0] > 0)
args[0]--;
if (args[1] > 0)
args[1]--;
curs_move(&curx, &cury, args[1], args[0]);
end_term();
}
/* Home cursor (left top corner), also called from mode command. */
void
HO(void)
{
argc = 1;
args[0] = args[1] = 1;
CM();
}
/* Clear line from current position to end of line */
static void
CL(int direction)
{
int i, len;
UINTN x, y;
CHAR16 *line;
conout->QueryMode(conout, conout->Mode->Mode, &x, &y);
switch (direction) {
case 0: /* from cursor to end */
len = x - curx + 1;
break;
case 1: /* from beginning to cursor */
len = curx;
break;
case 2: /* entire line */
len = x;
break;
}
if (cury == y - 1)
len--;
line = malloc(len * sizeof (CHAR16));
if (line == NULL) {
printf("out of memory\n");
return;
}
for (i = 0; i < len; i++)
line[i] = ' ';
line[len-1] = 0;
if (direction != 0)
curs_move(NULL, NULL, 0, cury);
conout->OutputString(conout, line);
/* restore cursor position */
curs_move(NULL, NULL, curx, cury);
free(line);
end_term();
}
static void
get_arg(int c)
{
if (argc < 0)
argc = 0;
args[argc] *= 10;
args[argc] += c - '0';
}
/* Emulate basic capabilities of cons25 terminal */
static void
efi_term_emu(int c)
{
static int ansi_col[] = {
0, 4, 2, 6, 1, 5, 3, 7
};
int t, i;
switch (esc) {
case 0:
switch (c) {
case '\033':
esc = c;
break;
default:
efi_cons_rawputchar(c);
break;
}
break;
case '\033':
switch (c) {
case '[':
esc = c;
args[0] = 0;
argc = -1;
break;
default:
bail_out(c);
break;
}
break;
case '[':
switch (c) {
case ';':
if (argc < 0)
argc = 0;
else if (argc + 1 >= MAXARGS)
bail_out(c);
else
args[++argc] = 0;
break;
case 'H': /* ho = \E[H */
if (argc < 0)
HO();
else if (argc == 1)
CM();
else
bail_out(c);
break;
case 'J': /* cd = \E[J */
if (argc < 0)
CD();
else
bail_out(c);
break;
case 'm':
if (argc < 0) {
fg_c = DEFAULT_FGCOLOR;
bg_c = DEFAULT_BGCOLOR;
}
for (i = 0; i <= argc; ++i) {
switch (args[i]) {
case 0: /* back to normal */
fg_c = DEFAULT_FGCOLOR;
bg_c = DEFAULT_BGCOLOR;
break;
case 1: /* bold */
fg_c |= 0x8;
break;
case 4: /* underline */
case 5: /* blink */
bg_c |= 0x8;
break;
case 7: /* reverse */
t = fg_c;
fg_c = bg_c;
bg_c = t;
break;
case 30: case 31: case 32: case 33:
case 34: case 35: case 36: case 37:
fg_c = ansi_col[args[i] - 30];
break;
case 39: /* normal */
fg_c = DEFAULT_FGCOLOR;
break;
case 40: case 41: case 42: case 43:
case 44: case 45: case 46: case 47:
bg_c = ansi_col[args[i] - 40];
break;
case 49: /* normal */
bg_c = DEFAULT_BGCOLOR;
break;
}
}
conout->SetAttribute(conout, EFI_TEXT_ATTR(fg_c, bg_c));
end_term();
break;
default:
if (isdigit(c))
get_arg(c);
else
bail_out(c);
break;
}
break;
default:
bail_out(c);
break;
}
}
void
efi_cons_putchar(int c)
{
CHAR16 buf[2];
if (c == '\n')
efi_cons_putchar('\r');
buf[0] = c;
buf[1] = 0;
conout->OutputString(conout, buf);
#ifdef TERM_EMU
efi_term_emu(c);
#else
efi_cons_rawputchar(c);
#endif
}
int
@ -77,6 +432,12 @@ efi_cons_getchar()
BS->WaitForEvent(1, &conin->WaitForKey, &junk);
status = conin->ReadKeyStroke(conin, &key);
}
switch (key.ScanCode) {
case 0x17: /* ESC */
return (0x1b); /* esc */
}
/* this can return */
return (key.UnicodeChar);
}
@ -87,13 +448,36 @@ efi_cons_poll()
return (BS->CheckEvent(conin->WaitForKey) == EFI_SUCCESS);
}
struct console efi_console = {
"efi",
"EFI console",
0,
efi_cons_probe,
efi_cons_init,
efi_cons_putchar,
efi_cons_getchar,
efi_cons_poll
};
/* Plain direct access to EFI OutputString(). */
void
efi_cons_efiputchar(int c)
{
CHAR16 buf[2];
/*
* translate box chars to unicode
*/
switch (c) {
/* single frame */
case 0xb3: buf[0] = BOXDRAW_VERTICAL; break;
case 0xbf: buf[0] = BOXDRAW_DOWN_LEFT; break;
case 0xc0: buf[0] = BOXDRAW_UP_RIGHT; break;
case 0xc4: buf[0] = BOXDRAW_HORIZONTAL; break;
case 0xda: buf[0] = BOXDRAW_DOWN_RIGHT; break;
case 0xd9: buf[0] = BOXDRAW_UP_LEFT; break;
/* double frame */
case 0xba: buf[0] = BOXDRAW_DOUBLE_VERTICAL; break;
case 0xbb: buf[0] = BOXDRAW_DOUBLE_DOWN_LEFT; break;
case 0xbc: buf[0] = BOXDRAW_DOUBLE_UP_LEFT; break;
case 0xc8: buf[0] = BOXDRAW_DOUBLE_UP_RIGHT; break;
case 0xc9: buf[0] = BOXDRAW_DOUBLE_DOWN_RIGHT; break;
case 0xcd: buf[0] = BOXDRAW_DOUBLE_HORIZONTAL; break;
default:
buf[0] = c;
}
buf[1] = 0; /* terminate string */
conout->OutputString(conout, buf);
}

8
sys/boot/efi/loader/arch/amd64/framebuffer.c
View File

@ -178,7 +178,7 @@ efifb_uga_find_pixel(EFI_UGA_DRAW_PROTOCOL *uga, u_int line,
printf("No change detected in frame buffer");
fail:
printf(" -- error %lu\n", status & ~EFI_ERROR_MASK);
printf(" -- error %lu\n", EFI_ERROR_CODE(status));
free(data1);
return (-1);
}
@ -473,7 +473,7 @@ command_gop(int argc, char *argv[])
status = BS->LocateProtocol(&gop_guid, NULL, (VOID **)&gop);
if (EFI_ERROR(status)) {
sprintf(command_errbuf, "%s: Graphics Output Protocol not "
"present (error=%lu)", argv[0], status & ~EFI_ERROR_MASK);
"present (error=%lu)", argv[0], EFI_ERROR_CODE(status));
return (CMD_ERROR);
}
@ -494,7 +494,7 @@ command_gop(int argc, char *argv[])
if (EFI_ERROR(status)) {
sprintf(command_errbuf, "%s: Unable to set mode to "
"%u (error=%lu)", argv[0], mode,
status & ~EFI_ERROR_MASK);
EFI_ERROR_CODE(status));
return (CMD_ERROR);
}
} else if (!strcmp(argv[1], "get")) {
@ -541,7 +541,7 @@ command_uga(int argc, char *argv[])
status = BS->LocateProtocol(&uga_guid, NULL, (VOID **)&uga);
if (EFI_ERROR(status)) {
sprintf(command_errbuf, "%s: UGA Protocol not present "
"(error=%lu)", argv[0], status & ~EFI_ERROR_MASK);
"(error=%lu)", argv[0], EFI_ERROR_CODE(status));
return (CMD_ERROR);
}

7
sys/boot/efi/loader/bootinfo.c
View File

@ -290,7 +290,7 @@ bi_load_efi_data(struct preloaded_file *kfp)
pages, &addr);
if (EFI_ERROR(status)) {
printf("%s: AllocatePages error %lu\n", __func__,
(unsigned long)(status & ~EFI_ERROR_MASK));
EFI_ERROR_CODE(status));
return (ENOMEM);
}
@ -306,7 +306,7 @@ bi_load_efi_data(struct preloaded_file *kfp)
status = BS->GetMemoryMap(&sz, mm, &efi_mapkey, &mmsz, &mmver);
if (EFI_ERROR(status)) {
printf("%s: GetMemoryMap error %lu\n", __func__,
(unsigned long)(status & ~EFI_ERROR_MASK));
EFI_ERROR_CODE(status));
return (EINVAL);
}
status = BS->ExitBootServices(IH, efi_mapkey);
@ -320,8 +320,7 @@ bi_load_efi_data(struct preloaded_file *kfp)
}
BS->FreePages(addr, pages);
}
printf("ExitBootServices error %lu\n",
(unsigned long)(status & ~EFI_ERROR_MASK));
printf("ExitBootServices error %lu\n", EFI_ERROR_CODE(status));
return (EINVAL);
}

2
sys/boot/efi/loader/copy.c
View File

@ -56,7 +56,7 @@ efi_copy_init(void)
STAGE_PAGES, &staging);
if (EFI_ERROR(status)) {
printf("failed to allocate staging area: %lu\n",
(unsigned long)(status & EFI_ERROR_MASK));
EFI_ERROR_CODE(status));
return (status);
}
staging_end = staging + STAGE_PAGES * EFI_PAGE_SIZE;

4
sys/boot/efi/loader/devicename.c
View File

@ -147,7 +147,7 @@ efi_fmtdev(void *vdev)
break;
}
return(buf);
return (buf);
}
/*
@ -161,7 +161,7 @@ efi_setcurrdev(struct env_var *ev, int flags, const void *value)
rv = efi_parsedev(&ncurr, value, NULL);
if (rv != 0)
return(rv);
return (rv);
free(ncurr);
env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);

67
sys/boot/efi/loader/main.c
View File

@ -227,50 +227,47 @@ command_memmap(int argc, char *argv[])
status = BS->GetMemoryMap(&sz, 0, &key, &dsz, &dver);
if (status != EFI_BUFFER_TOO_SMALL) {
printf("Can't determine memory map size\n");
return CMD_ERROR;
return (CMD_ERROR);
}
map = malloc(sz);
status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);
if (EFI_ERROR(status)) {
printf("Can't read memory map\n");
return CMD_ERROR;
return (CMD_ERROR);
}
ndesc = sz / dsz;
printf("%23s %12s %12s %8s %4s\n",
"Type", "Physical", "Virtual", "#Pages", "Attr");
"Type", "Physical", "Virtual", "#Pages", "Attr");
for (i = 0, p = map; i < ndesc;
i++, p = NextMemoryDescriptor(p, dsz)) {
printf("%23s %012lx %012lx %08lx ",
types[p->Type],
p->PhysicalStart,
p->VirtualStart,
p->NumberOfPages);
if (p->Attribute & EFI_MEMORY_UC)
printf("UC ");
if (p->Attribute & EFI_MEMORY_WC)
printf("WC ");
if (p->Attribute & EFI_MEMORY_WT)
printf("WT ");
if (p->Attribute & EFI_MEMORY_WB)
printf("WB ");
if (p->Attribute & EFI_MEMORY_UCE)
printf("UCE ");
if (p->Attribute & EFI_MEMORY_WP)
printf("WP ");
if (p->Attribute & EFI_MEMORY_RP)
printf("RP ");
if (p->Attribute & EFI_MEMORY_XP)
printf("XP ");
printf("\n");
printf("%23s %012lx %012lx %08lx ", types[p->Type],
p->PhysicalStart, p->VirtualStart, p->NumberOfPages);
if (p->Attribute & EFI_MEMORY_UC)
printf("UC ");
if (p->Attribute & EFI_MEMORY_WC)
printf("WC ");
if (p->Attribute & EFI_MEMORY_WT)
printf("WT ");
if (p->Attribute & EFI_MEMORY_WB)
printf("WB ");
if (p->Attribute & EFI_MEMORY_UCE)
printf("UCE ");
if (p->Attribute & EFI_MEMORY_WP)
printf("WP ");
if (p->Attribute & EFI_MEMORY_RP)
printf("RP ");
if (p->Attribute & EFI_MEMORY_XP)
printf("XP ");
printf("\n");
}
return CMD_OK;
return (CMD_OK);
}
COMMAND_SET(configuration, "configuration",
"print configuration tables", command_configuration);
COMMAND_SET(configuration, "configuration", "print configuration tables",
command_configuration);
static const char *
guid_to_string(EFI_GUID *guid)
@ -318,7 +315,7 @@ command_configuration(int argc, char *argv[])
printf(" at %p\n", ST->ConfigurationTable[i].VendorTable);
}
return CMD_OK;
return (CMD_OK);
}
@ -334,6 +331,7 @@ command_mode(int argc, char *argv[])
char rowenv[8];
EFI_STATUS status;
SIMPLE_TEXT_OUTPUT_INTERFACE *conout;
extern void HO(void);
conout = ST->ConOut;
@ -355,7 +353,7 @@ command_mode(int argc, char *argv[])
}
sprintf(rowenv, "%u", (unsigned)rows);
setenv("LINES", rowenv, 1);
HO(); /* set cursor */
return (CMD_OK);
}
@ -394,20 +392,17 @@ command_nvram(int argc, char *argv[])
status = RS->GetNextVariableName(&varsz, NULL, NULL);
for (; status != EFI_NOT_FOUND; ) {
status = RS->GetNextVariableName(&varsz, var,
&varguid);
status = RS->GetNextVariableName(&varsz, var, &varguid);
//if (EFI_ERROR(status))
//break;
conout->OutputString(conout, var);
printf("=");
datasz = 0;
status = RS->GetVariable(var, &varguid, NULL, &datasz,
NULL);
status = RS->GetVariable(var, &varguid, NULL, &datasz, NULL);
/* XXX: check status */
data = malloc(datasz);
status = RS->GetVariable(var, &varguid, NULL, &datasz,
data);
status = RS->GetVariable(var, &varguid, NULL, &datasz, data);
if (EFI_ERROR(status))
printf("<error retrieving variable>");
else {

2
sys/boot/ficl/amd64/sysdep.c
View File

@ -55,7 +55,7 @@ void ficlTextOut(FICL_VM *pVM, char *msg, int fNewline)
IGNORE(pVM);
while(*msg != 0)
putchar(*(msg++));
putchar((unsigned char)*(msg++));
if (fNewline)
putchar('\n');

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