Index: stable/9/tools/build/make_check/Makefile =================================================================== --- stable/9/tools/build/make_check/Makefile (revision 278061) +++ stable/9/tools/build/make_check/Makefile (revision 278062) @@ -1,297 +1,297 @@ # $FreeBSD$ .MAKE.MODE= normal # Test for broken LHS expansion. # This *must* cause make(1) to detect a recursive variable, and fail as such. .if make(lhs_expn) FOO= ${BAR} BAR${NIL}= ${FOO} FOO${BAR}= ${FOO} .endif DATA1= helllo DATA2:= ${DATA1} DATA3= ${DATA2:S/ll/rr/g} DATA4:= ${DATA2:S/ll/rr/g} DATA2?= allo DATA5:= ${DATA2:S/ll/ii/g} ${DATA1:S/ll/rr/g} DATA2= yello DATA1:= ${DATA5:S/l/r/g} NIL= SMAKE= MAKEFLAGS= ${MAKE} -C ${.CURDIR} all: @echo '1..17' - @${SMAKE} C_check || { cd ${.CURDIR} ; ${MAKE} failure ; } + @${SMAKE} C_check || { ${MAKE} -C ${.CURDIR} failure ; } @echo "ok 1 - C_check # Test of -C flag existence detected no regression." @echo 1:${DATA1} 2:${DATA2} 3:${DATA3} 4:${DATA4} 5:${DATA5} | \ diff -u ${.CURDIR}/regress.variables.out - || \ ${SMAKE} failure @echo "ok 2 - test_variables # Test variables detected no regression, output matches." @${SMAKE} double 2>/dev/null || ${SMAKE} failure @echo "ok 3 - test_targets # Test targets detected no regression." @${SMAKE} sysvmatch || ${SMAKE} failure @echo "ok 4 - sysvmatch # Test sysvmatch detected no regression." @! ${SMAKE} lhs_expn && true || ${SMAKE} failure @echo "ok 5 lhs_expn # Test lhs_expn detected no regression." @${SMAKE} notdef || ${SMAKE} failure @echo "ok 6 - notdef # Test notdef detected no regression." @${SMAKE} modifiers || ${SMAKE} failure @echo "ok 7 - modifiers # Test modifiers detected no regression." @${SMAKE} funny_targets || ${SMAKE} failure @echo "ok 8 funny_targets # Test funny_targets detected no regression." @${SMAKE} arith_expr || ${SMAKE} failure @echo "ok 9 arith_expr # Test arith_expr detected no regression." @${SMAKE} PATH_exists || ${SMAKE} failure @echo "ok 10 PATH_exists # Test PATH_exists detected no regression." @${SMAKE} double_quotes || ${SMAKE} failure @echo "ok 11 double_quotes # Test double_quotes detected no regression." @! ${SMAKE} double_quotes2 >/dev/null 2>&1 && true || ${SMAKE} failure @echo "ok 12 double_quotes2 # Test double_quotes2 detected no regression." @${SMAKE} pass_cmd_vars || ${SMAKE} failure @echo "ok 13 pass_cmd_vars # Test pass_cmd_vars detected no regression." @${SMAKE} plus_flag || ${SMAKE} failure @echo "ok 14 plus_flag # Test plus_flag detected no regression." @! ${SMAKE} shell >/dev/null 2>&1 && true || ${SMAKE} failure @echo "ok 15 shell # Test shell detected no regression." @${SMAKE} shell_1 || ${SMAKE} failure @echo "ok 16 shell_1 # Test shell_1 detected no regression." @${SMAKE} shell_2 || ${SMAKE} failure @echo "ok 17 shell_2 # Test shell_2 detected no regression." .if make(C_check) C_check: .endif .if make(double) # Doubly-defined targets. make(1) will warn, but use the "right" one. If it # switches to using the "non-right" one, it breaks things worse than a little # regression test. double: @true double: @false .endif .if make(sysvmatch) # Some versions of FreeBSD make(1) do not handle a nil LHS in sysvsubst. sysvmatch: @echo EMPTY ${NIL:=foo} LHS | \ diff -u ${.CURDIR}/regress.sysvmatch.out - || false .endif # A bogus target for the lhs_expn test; If this is reached, then the make(1) # program has not errored out because of the recursion caused by not expanding # the left-hand-side's embedded variables above. lhs_expn: @true .if make(notdef) # make(1) claims to only evaluate a conditional as far as is necessary # to determine its value; that was not always the case. .undef notdef notdef: .if defined(notdef) && ${notdef:U} .endif .endif .if make(modifiers) # See if make(1) supports the C modifier. modifiers: @if ${SMAKE} -V .CURDIR:C/.// 2>&1 >/dev/null | \ grep -q "Unknown modifier 'C'"; then \ false; \ fi .endif .if make(funny_targets) funny_targets: colons::target exclamation!target colons::target: exclamation!target: .endif .if make(arith_expr) arith_expr: # See if arithmetic expression parsing is broken. # The different spacing below is intentional. VALUE= 0 .if (${VALUE} < 0)||(${VALUE}>0) .endif .endif .if make(PATH_exists) PATH_exists: .PATH: ${.CURDIR} .if !exists(${.CURDIR}/) || !exists(${.CURDIR}/.) || !exists(${.CURDIR}/..) .error exists() failed .endif .endif .if make(double_quotes) VALUE= foo "" double_quotes: .if ${VALUE:S/$//} != ${VALUE} .error "" reduced to " .endif .endif .if make(double_quotes2) double_quotes2: @cat /dev/null "" .endif # # Check passing of variable via MAKEFLAGS # .if make(pass_cmd_vars) pass_cmd_vars: @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_1 @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_2 @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_3 @${SMAKE} CMD1=cmd1 CMD2=cmd2 pass_cmd_vars_4 .endif # # Check that the variable definition arrived from the calling make # .if make(pass_cmd_vars_1) # These values should get overridden by the commandline CMD1=oops1 CMD2=oops2 pass_cmd_vars_1: @: .if ${CMD1} != cmd1 || ${CMD2} != cmd2 .error variables not passed through MAKEFLAGS .endif .endif .if make(pass_cmd_vars_2) # Check that we cannot override the passed variables CMD1=foo1 CMD2=foo2 .if ${CMD1} != cmd1 || ${CMD2} != cmd2 .error MAKEFLAGS-passed variables overridden .endif pass_cmd_vars_2: @: .endif .if make(pass_cmd_vars_3) # Check that we can override the passed variables on the next sub-make's # command line pass_cmd_vars_3: @${SMAKE} CMD1=foo1 pass_cmd_vars_3_1 .endif .if make(pass_cmd_vars_3_1) .if ${CMD1} != foo1 || ${CMD2} != cmd2 .error MAKEFLAGS-passed variables not overridden on command line .endif pass_cmd_vars_3_1: @: .endif .if make(pass_cmd_vars_4) # Ensure that a variable assignment passed via MAKEFLAGS may be overwritten # by evaluating the .MAKEFLAGS target. .MAKEFLAGS: CMD1=baz1 pass_cmd_vars_4: @${SMAKE} pass_cmd_vars_4_1 .if ${CMD1} != baz1 || ${CMD2} != cmd2 .error MAKEFLAGS-passed variables not overridden via .MAKEFLAGS target .endif .endif .if make(pass_cmd_vars_4_1) .if ${CMD1} != baz1 || ${CMD2} != cmd2 .error MAKEFLAGS-passed variables not overridden via .MAKEFLAGS target (2) .endif pass_cmd_vars_4_1: @: .endif # # Test whether make supports the '+' flag (meaning: execute even with -n) # .if make(plus_flag) OUT != ${SMAKE} -n plus_flag_1 .if ${OUT:M/tmp} != "/tmp" .error make doesn't handle + flag .endif plus_flag: @: .endif .if make(plus_flag_1) plus_flag_1: +@cd /tmp; pwd .endif .if make(shell) # Test if make fully supports the .SHELL specification. .SHELL: path=/nonexistent A!= echo ok shell: .endif .if make(shell_1) # Test if setting the shell by name only works. Because we have no ksh # in the base system we test that we can set sh and csh. We try only exact # matching names and do not exercise the rather strange matching algorithm. shell_1: @${SMAKE} shell_1_csh @${SMAKE} shell_1_sh .endif .if make(shell_1_csh) .SHELL: name="csh" shell_1_csh: @ps -ax -opid,command | awk '$$1=="'$$$$'" { print $$2 }' | grep -E -q '^(/bin/)?csh$$' .endif .if make(shell_1_sh) .SHELL: name="sh" shell_1_sh: @ps -ax -opid,command | awk '$$1=="'$$$$'" { print $$2 }' | grep -E -q '^(/bin/)?sh$$' .endif .if make(shell_2) # Test if we can replace the shell specification. We do this by using # a shell scripts that prints us its arguments and standard input as the shell shell_2: shell_test @${SMAKE} -B shell_2B | \ diff -u ${.CURDIR}/regress.shell_2B.out - || false @${SMAKE} -j1 shell_2j | \ diff -u ${.CURDIR}/regress.shell_2j.out - || false .endif .if make(shell_2B) .SHELL: name="echo" path="${.OBJDIR}/shell_test" quiet="be quiet" echo="be verbose" filter="be verbose" echoFlag="x" errFlag="y" hasErrCtl=y check="check errors" ignore="ignore errors" shell_2B: -@funny $$ funnier $$ .endif .if make(shell_2j) .SHELL: name="echo" path="${.OBJDIR}/shell_test" quiet="be quiet" echo="be verbose" filter="be verbose" echoFlag="x" errFlag="y" hasErrCtl=y check="check errors" ignore="ignore errors" shell_2j: -@funny $$ funnier $$ .endif failure: @echo "not ok # Test failed: regression detected. See above." @false CLEANFILES= shell_test .include Index: stable/9/tools/build/options/WITHOUT_LZMA_SUPPORT =================================================================== --- stable/9/tools/build/options/WITHOUT_LZMA_SUPPORT (nonexistent) +++ stable/9/tools/build/options/WITHOUT_LZMA_SUPPORT (revision 278062) @@ -0,0 +1,2 @@ +.\" $FreeBSD$ +Set to build some programs without optional lzma compression support. Property changes on: stable/9/tools/build/options/WITHOUT_LZMA_SUPPORT ___________________________________________________________________ Added: svn:keywords ## -0,0 +1 ## +FreeBSD=%H \ No newline at end of property Index: stable/9/tools/build/options =================================================================== --- stable/9/tools/build/options (revision 278061) +++ stable/9/tools/build/options (revision 278062) Property changes on: stable/9/tools/build/options ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/tools/build/options:r245171 Index: stable/9/tools/build =================================================================== --- stable/9/tools/build (revision 278061) +++ stable/9/tools/build (revision 278062) Property changes on: stable/9/tools/build ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/tools/build:r245171 Index: stable/9/tools =================================================================== --- stable/9/tools (revision 278061) +++ stable/9/tools (revision 278062) Property changes on: stable/9/tools ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/tools:r245171 Index: stable/9/usr.bin/grep/Makefile =================================================================== --- stable/9/usr.bin/grep/Makefile (revision 278061) +++ stable/9/usr.bin/grep/Makefile (revision 278062) @@ -1,81 +1,89 @@ # $NetBSD: Makefile,v 1.4 2011/02/16 01:31:33 joerg Exp $ # $FreeBSD$ # $OpenBSD: Makefile,v 1.6 2003/06/25 15:00:04 millert Exp $ .include .if ${MK_BSD_GREP} == "yes" PROG= grep .else PROG= bsdgrep CLEANFILES+= bsdgrep.1 bsdgrep.1: grep.1 cp ${.ALLSRC} ${.TARGET} .endif SRCS= file.c grep.c queue.c util.c # Extra files ported backported form some regex improvements .PATH: ${.CURDIR}/regex SRCS+= fastmatch.c hashtable.c tre-compile.c tre-fastmatch.c xmalloc.c CFLAGS+=-I${.CURDIR}/regex .if ${MK_BSD_GREP} == "yes" LINKS= ${BINDIR}/grep ${BINDIR}/egrep \ ${BINDIR}/grep ${BINDIR}/fgrep \ ${BINDIR}/grep ${BINDIR}/zgrep \ ${BINDIR}/grep ${BINDIR}/zegrep \ ${BINDIR}/grep ${BINDIR}/zfgrep MLINKS= grep.1 egrep.1 \ grep.1 fgrep.1 \ grep.1 zgrep.1 \ grep.1 zegrep.1 \ - grep.1 zfgrep.1 \ - grep.1 xzgrep.1 \ - grep.1 xzegrep.1 \ - grep.1 xzfgrep.1 \ - grep.1 lzgrep.1 \ - grep.1 lzegrep.1 \ - grep.1 lzfgrep.1 + grep.1 zfgrep.1 .endif +LDADD= -lz +DPADD= ${LIBZ} + +.if !defined(WITHOUT_LZMA_SUPPORT) +LDADD+= -llzma +DPADD+= ${LIBLZMA} + LINKS+= ${BINDIR}/${PROG} ${BINDIR}/xzgrep \ ${BINDIR}/${PROG} ${BINDIR}/xzegrep \ ${BINDIR}/${PROG} ${BINDIR}/xzfgrep \ ${BINDIR}/${PROG} ${BINDIR}/lzgrep \ ${BINDIR}/${PROG} ${BINDIR}/lzegrep \ ${BINDIR}/${PROG} ${BINDIR}/lzfgrep -LDADD= -lz -llzma -DPADD= ${LIBZ} ${LIBLZMA} +MLINKS+= grep.1 xzgrep.1 \ + grep.1 xzegrep.1 \ + grep.1 xzfgrep.1 \ + grep.1 lzgrep.1 \ + grep.1 lzegrep.1 \ + grep.1 lzfgrep.1 +.else +CFLAGS+= -DWITHOUT_LZMA +.endif -.if !defined(WITHOUT_BZIP2) +.if !defined(WITHOUT_BZIP2_SUPPORT) LDADD+= -lbz2 DPADD+= ${LIBBZ2} .if ${MK_BSD_GREP} == "yes" LINKS+= ${BINDIR}/grep ${BINDIR}/bzgrep \ ${BINDIR}/grep ${BINDIR}/bzegrep \ ${BINDIR}/grep ${BINDIR}/bzfgrep MLINKS+= grep.1 bzgrep.1 \ grep.1 bzegrep.1 \ grep.1 bzfgrep.1 .endif .else CFLAGS+= -DWITHOUT_BZIP2 .endif .if !defined(WITHOUT_GNU_COMPAT) CFLAGS+= -I/usr/include/gnu LDADD+= -lgnuregex DPADD+= ${LIBGNUREGEX} .endif .if !defined(WITHOUT_NLS) .include "${.CURDIR}/nls/Makefile.inc" .else CFLAGS+= -DWITHOUT_NLS .endif .include Index: stable/9/usr.bin/grep/file.c =================================================================== --- stable/9/usr.bin/grep/file.c (revision 278061) +++ stable/9/usr.bin/grep/file.c (revision 278062) @@ -1,325 +1,332 @@ /* $NetBSD: file.c,v 1.5 2011/02/16 18:35:39 joerg Exp $ */ /* $FreeBSD$ */ /* $OpenBSD: file.c,v 1.11 2010/07/02 20:48:48 nicm Exp $ */ /*- * Copyright (c) 1999 James Howard and Dag-Erling Coïdan Smørgrav * Copyright (C) 2008-2010 Gabor Kovesdan * Copyright (C) 2010 Dimitry Andric * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include -#include #include #include #include #include #include #include #include +#ifndef WITHOUT_LZMA +#include +#endif + #ifndef WITHOUT_BZIP2 #include #endif #include "grep.h" #define MAXBUFSIZ (32 * 1024) #define LNBUFBUMP 80 static gzFile gzbufdesc; +#ifndef WITHOUT_LZMA static lzma_stream lstrm = LZMA_STREAM_INIT; +#endif #ifndef WITHOUT_BZIP2 static BZFILE* bzbufdesc; #endif static unsigned char *buffer; static unsigned char *bufpos; static size_t bufrem; static size_t fsiz; static unsigned char *lnbuf; static size_t lnbuflen; static inline int grep_refill(struct file *f) { ssize_t nr; if (filebehave == FILE_MMAP) return (0); bufpos = buffer; bufrem = 0; if (filebehave == FILE_GZIP) { nr = gzread(gzbufdesc, buffer, MAXBUFSIZ); #ifndef WITHOUT_BZIP2 } else if (filebehave == FILE_BZIP && bzbufdesc != NULL) { int bzerr; nr = BZ2_bzRead(&bzerr, bzbufdesc, buffer, MAXBUFSIZ); switch (bzerr) { case BZ_OK: case BZ_STREAM_END: /* No problem, nr will be okay */ break; case BZ_DATA_ERROR_MAGIC: /* * As opposed to gzread(), which simply returns the * plain file data, if it is not in the correct * compressed format, BZ2_bzRead() instead aborts. * * So, just restart at the beginning of the file again, * and use plain reads from now on. */ BZ2_bzReadClose(&bzerr, bzbufdesc); bzbufdesc = NULL; if (lseek(f->fd, 0, SEEK_SET) == -1) return (-1); nr = read(f->fd, buffer, MAXBUFSIZ); break; default: /* Make sure we exit with an error */ nr = -1; } #endif +#ifndef WITHOUT_LZMA } else if ((filebehave == FILE_XZ) || (filebehave == FILE_LZMA)) { lzma_action action = LZMA_RUN; uint8_t in_buf[MAXBUFSIZ]; lzma_ret ret; ret = (filebehave == FILE_XZ) ? lzma_stream_decoder(&lstrm, UINT64_MAX, LZMA_CONCATENATED) : lzma_alone_decoder(&lstrm, UINT64_MAX); if (ret != LZMA_OK) return (-1); lstrm.next_out = buffer; lstrm.avail_out = MAXBUFSIZ; lstrm.next_in = in_buf; nr = read(f->fd, in_buf, MAXBUFSIZ); if (nr < 0) return (-1); else if (nr == 0) action = LZMA_FINISH; lstrm.avail_in = nr; ret = lzma_code(&lstrm, action); if (ret != LZMA_OK && ret != LZMA_STREAM_END) return (-1); bufrem = MAXBUFSIZ - lstrm.avail_out; return (0); +#endif /* WIHTOUT_LZMA */ } else nr = read(f->fd, buffer, MAXBUFSIZ); if (nr < 0) return (-1); bufrem = nr; return (0); } static inline int grep_lnbufgrow(size_t newlen) { if (lnbuflen < newlen) { lnbuf = grep_realloc(lnbuf, newlen); lnbuflen = newlen; } return (0); } char * grep_fgetln(struct file *f, size_t *lenp) { unsigned char *p; char *ret; size_t len; size_t off; ptrdiff_t diff; /* Fill the buffer, if necessary */ if (bufrem == 0 && grep_refill(f) != 0) goto error; if (bufrem == 0) { /* Return zero length to indicate EOF */ *lenp = 0; return (bufpos); } /* Look for a newline in the remaining part of the buffer */ if ((p = memchr(bufpos, '\n', bufrem)) != NULL) { ++p; /* advance over newline */ ret = bufpos; len = p - bufpos; bufrem -= len; bufpos = p; *lenp = len; return (ret); } /* We have to copy the current buffered data to the line buffer */ for (len = bufrem, off = 0; ; len += bufrem) { /* Make sure there is room for more data */ if (grep_lnbufgrow(len + LNBUFBUMP)) goto error; memcpy(lnbuf + off, bufpos, len - off); off = len; if (grep_refill(f) != 0) goto error; if (bufrem == 0) /* EOF: return partial line */ break; if ((p = memchr(bufpos, '\n', bufrem)) == NULL) continue; /* got it: finish up the line (like code above) */ ++p; diff = p - bufpos; len += diff; if (grep_lnbufgrow(len)) goto error; memcpy(lnbuf + off, bufpos, diff); bufrem -= diff; bufpos = p; break; } *lenp = len; return (lnbuf); error: *lenp = 0; return (NULL); } /* * Opens a file for processing. */ struct file * grep_open(const char *path) { struct file *f; f = grep_malloc(sizeof *f); memset(f, 0, sizeof *f); if (path == NULL) { /* Processing stdin implies --line-buffered. */ lbflag = true; f->fd = STDIN_FILENO; } else if ((f->fd = open(path, O_RDONLY)) == -1) goto error1; if (filebehave == FILE_MMAP) { struct stat st; if ((fstat(f->fd, &st) == -1) || (st.st_size > OFF_MAX) || (!S_ISREG(st.st_mode))) filebehave = FILE_STDIO; else { int flags = MAP_PRIVATE | MAP_NOCORE | MAP_NOSYNC; #ifdef MAP_PREFAULT_READ flags |= MAP_PREFAULT_READ; #endif fsiz = st.st_size; buffer = mmap(NULL, fsiz, PROT_READ, flags, f->fd, (off_t)0); if (buffer == MAP_FAILED) filebehave = FILE_STDIO; else { bufrem = st.st_size; bufpos = buffer; madvise(buffer, st.st_size, MADV_SEQUENTIAL); } } } if ((buffer == NULL) || (buffer == MAP_FAILED)) buffer = grep_malloc(MAXBUFSIZ); if (filebehave == FILE_GZIP && (gzbufdesc = gzdopen(f->fd, "r")) == NULL) goto error2; #ifndef WITHOUT_BZIP2 if (filebehave == FILE_BZIP && (bzbufdesc = BZ2_bzdopen(f->fd, "r")) == NULL) goto error2; #endif /* Fill read buffer, also catches errors early */ if (bufrem == 0 && grep_refill(f) != 0) goto error2; /* Check for binary stuff, if necessary */ if (binbehave != BINFILE_TEXT && memchr(bufpos, '\0', bufrem) != NULL) f->binary = true; return (f); error2: close(f->fd); error1: free(f); return (NULL); } /* * Closes a file. */ void grep_close(struct file *f) { close(f->fd); /* Reset read buffer and line buffer */ if (filebehave == FILE_MMAP) { munmap(buffer, fsiz); buffer = NULL; } bufpos = buffer; bufrem = 0; free(lnbuf); lnbuf = NULL; lnbuflen = 0; } Index: stable/9/usr.bin/grep =================================================================== --- stable/9/usr.bin/grep (revision 278061) +++ stable/9/usr.bin/grep (revision 278062) Property changes on: stable/9/usr.bin/grep ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/usr.bin/grep:r245171,277939 Index: stable/9/usr.bin =================================================================== --- stable/9/usr.bin (revision 278061) +++ stable/9/usr.bin (revision 278062) Property changes on: stable/9/usr.bin ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head/usr.bin:r245171,277939 Index: stable/9 =================================================================== --- stable/9 (revision 278061) +++ stable/9 (revision 278062) Property changes on: stable/9 ___________________________________________________________________ Modified: svn:mergeinfo ## -0,0 +0,1 ## Merged /head:r228099,245171,277939