Remove duplicate sed
This commit is contained in:
Thomas Veerman
parent
ff555cdea6
commit
2ed11343a6
|
|
@ -24,7 +24,7 @@ SUBDIR= add_route arp ash at \
|
|||
profile progressbar pr_routes ps pwd pwdauth \
|
||||
ramdisk rarpd rawspeed rcp rdate readall readclock \
|
||||
reboot remsync rev rget rlogin \
|
||||
rotate rsh rshd sed service setup shar acksize \
|
||||
rotate rsh rshd service setup shar acksize \
|
||||
sleep slip sort spell split srccrc \
|
||||
stty sum svclog svrctl swifi sync synctree sysenv \
|
||||
syslogd tail tar tcpd tcpdp tcpstat tee telnet \
|
||||
|
|
|
|||
|
|
@ -1,11 +0,0 @@
|
|||
# $NetBSD: Makefile,v 1.13 2006/06/02 19:44:48 mrg Exp $
|
||||
# from: @(#)Makefile 8.1 (Berkeley) 6/6/93
|
||||
|
||||
.include <bsd.own.mk>
|
||||
|
||||
PROG= sed
|
||||
SRCS= compile.c main.c misc.c process.c
|
||||
|
||||
BINDIR=/bin
|
||||
|
||||
.include <bsd.prog.mk>
|
||||
|
|
@ -1,199 +0,0 @@
|
|||
# $NetBSD: POSIX,v 1.4 1997/01/09 20:21:25 tls Exp $
|
||||
# from: @(#)POSIX 8.1 (Berkeley) 6/6/93
|
||||
|
||||
Comments on the IEEE P1003.2 Draft 12
|
||||
Part 2: Shell and Utilities
|
||||
Section 4.55: sed - Stream editor
|
||||
|
||||
Diomidis Spinellis <dds@doc.ic.ac.uk>
|
||||
Keith Bostic <bostic@cs.berkeley.edu>
|
||||
|
||||
In the following paragraphs, "wrong" usually means "inconsistent with
|
||||
historic practice", as most of the following comments refer to
|
||||
undocumented inconsistencies between the historical versions of sed and
|
||||
the POSIX 1003.2 standard. All the comments are notes taken while
|
||||
implementing a POSIX-compatible version of sed, and should not be
|
||||
interpreted as official opinions or criticism towards the POSIX committee.
|
||||
All uses of "POSIX" refer to section 4.55, Draft 12 of POSIX 1003.2.
|
||||
|
||||
1. 32V and BSD derived implementations of sed strip the text
|
||||
arguments of the a, c and i commands of their initial blanks,
|
||||
i.e.
|
||||
|
||||
#!/bin/sed -f
|
||||
a\
|
||||
foo\
|
||||
\ indent\
|
||||
bar
|
||||
|
||||
produces:
|
||||
|
||||
foo
|
||||
indent
|
||||
bar
|
||||
|
||||
POSIX does not specify this behavior as the System V versions of
|
||||
sed do not do this stripping. The argument against stripping is
|
||||
that it is difficult to write sed scripts that have leading blanks
|
||||
if they are stripped. The argument for stripping is that it is
|
||||
difficult to write readable sed scripts unless indentation is allowed
|
||||
and ignored, and leading whitespace is obtainable by entering a
|
||||
backslash in front of it. This implementation follows the BSD
|
||||
historic practice.
|
||||
|
||||
2. Historical versions of sed required that the w flag be the last
|
||||
flag to an s command as it takes an additional argument. This
|
||||
is obvious, but not specified in POSIX.
|
||||
|
||||
3. Historical versions of sed required that whitespace follow a w
|
||||
flag to an s command. This is not specified in POSIX. This
|
||||
implementation permits whitespace but does not require it.
|
||||
|
||||
4. Historical versions of sed permitted any number of whitespace
|
||||
characters to follow the w command. This is not specified in
|
||||
POSIX. This implementation permits whitespace but does not
|
||||
require it.
|
||||
|
||||
5. The rule for the l command differs from historic practice. Table
|
||||
2-15 includes the various ANSI C escape sequences, including \\
|
||||
for backslash. Some historical versions of sed displayed two
|
||||
digit octal numbers, too, not three as specified by POSIX. POSIX
|
||||
is a cleanup, and is followed by this implementation.
|
||||
|
||||
6. The POSIX specification for ! does not specify that for a single
|
||||
command the command must not contain an address specification
|
||||
whereas the command list can contain address specifications. The
|
||||
specification for ! implies that "3!/hello/p" works, and it never
|
||||
has, historically. Note,
|
||||
|
||||
3!{
|
||||
/hello/p
|
||||
}
|
||||
|
||||
does work.
|
||||
|
||||
7. POSIX does not specify what happens with consecutive ! commands
|
||||
(e.g. /foo/!!!p). Historic implementations allow any number of
|
||||
!'s without changing the behaviour. (It seems logical that each
|
||||
one might reverse the behaviour.) This implementation follows
|
||||
historic practice.
|
||||
|
||||
8. Historic versions of sed permitted commands to be separated
|
||||
by semi-colons, e.g. 'sed -ne '1p;2p;3q' printed the first
|
||||
three lines of a file. This is not specified by POSIX.
|
||||
Note, the ; command separator is not allowed for the commands
|
||||
a, c, i, w, r, :, b, t, # and at the end of a w flag in the s
|
||||
command. This implementation follows historic practice and
|
||||
implements the ; separator.
|
||||
|
||||
9. Historic versions of sed terminated the script if EOF was reached
|
||||
during the execution of the 'n' command, i.e.:
|
||||
|
||||
sed -e '
|
||||
n
|
||||
i\
|
||||
hello
|
||||
' </dev/null
|
||||
|
||||
did not produce any output. POSIX does not specify this behavior.
|
||||
This implementation follows historic practice.
|
||||
|
||||
10. Deleted.
|
||||
|
||||
11. Historical implementations do not output the change text of a c
|
||||
command in the case of an address range whose first line number
|
||||
is greater than the second (e.g. 3,1). POSIX requires that the
|
||||
text be output. Since the historic behavior doesn't seem to have
|
||||
any particular purpose, this implementation follows the POSIX
|
||||
behavior.
|
||||
|
||||
12. POSIX does not specify whether address ranges are checked and
|
||||
reset if a command is not executed due to a jump. The following
|
||||
program will behave in different ways depending on whether the
|
||||
'c' command is triggered at the third line, i.e. will the text
|
||||
be output even though line 3 of the input will never logically
|
||||
encounter that command.
|
||||
|
||||
2,4b
|
||||
1,3c\
|
||||
text
|
||||
|
||||
Historic implementations, and this implementation, do not output
|
||||
the text in the above example. The general rule, therefore,
|
||||
is that a range whose second address is never matched extends to
|
||||
the end of the input.
|
||||
|
||||
13. Historical implementations allow an output suppressing #n at the
|
||||
beginning of -e arguments as well as in a script file. POSIX
|
||||
does not specify this. This implementation follows historical
|
||||
practice.
|
||||
|
||||
14. POSIX does not explicitly specify how sed behaves if no script is
|
||||
specified. Since the sed Synopsis permits this form of the command,
|
||||
and the language in the Description section states that the input
|
||||
is output, it seems reasonable that it behave like the cat(1)
|
||||
command. Historic sed implementations behave differently for "ls |
|
||||
sed", where they produce no output, and "ls | sed -e#", where they
|
||||
behave like cat. This implementation behaves like cat in both cases.
|
||||
|
||||
15. The POSIX requirement to open all w files at the beginning makes
|
||||
sed behave nonintuitively when the w commands are preceded by
|
||||
addresses or are within conditional blocks. This implementation
|
||||
follows historic practice and POSIX, by default, and provides the
|
||||
-a option which opens the files only when they are needed.
|
||||
|
||||
16. POSIX does not specify how escape sequences other than \n and \D
|
||||
(where D is the delimiter character) are to be treated. This is
|
||||
reasonable, however, it also doesn't state that the backslash is
|
||||
to be discarded from the output regardless. A strict reading of
|
||||
POSIX would be that "echo xyz | sed s/./\a" would display "\ayz".
|
||||
As historic sed implementations always discarded the backslash,
|
||||
this implementation does as well.
|
||||
|
||||
17. POSIX specifies that an address can be "empty". This implies
|
||||
that constructs like ",d" or "1,d" and ",5d" are allowed. This
|
||||
is not true for historic implementations or this implementation
|
||||
of sed.
|
||||
|
||||
18. The b t and : commands are documented in POSIX to ignore leading
|
||||
white space, but no mention is made of trailing white space.
|
||||
Historic implementations of sed assigned different locations to
|
||||
the labels "x" and "x ". This is not useful, and leads to subtle
|
||||
programming errors, but it is historic practice and changing it
|
||||
could theoretically break working scripts. This implementation
|
||||
follows historic practice.
|
||||
|
||||
19. Although POSIX specifies that reading from files that do not exist
|
||||
from within the script must not terminate the script, it does not
|
||||
specify what happens if a write command fails. Historic practice
|
||||
is to fail immediately if the file cannot be opened or written.
|
||||
This implementation follows historic practice.
|
||||
|
||||
20. Historic practice is that the \n construct can be used for either
|
||||
string1 or string2 of the y command. This is not specified by
|
||||
POSIX. This implementation follows historic practice.
|
||||
|
||||
21. Deleted.
|
||||
|
||||
22. Historic implementations of sed ignore the RE delimiter characters
|
||||
within character classes. This is not specified in POSIX. This
|
||||
implementation follows historic practice.
|
||||
|
||||
23. Historic implementations handle empty RE's in a special way: the
|
||||
empty RE is interpreted as if it were the last RE encountered,
|
||||
whether in an address or elsewhere. POSIX does not document this
|
||||
behavior. For example the command:
|
||||
|
||||
sed -e /abc/s//XXX/
|
||||
|
||||
substitutes XXX for the pattern abc. The semantics of "the last
|
||||
RE" can be defined in two different ways:
|
||||
|
||||
1. The last RE encountered when compiling (lexical/static scope).
|
||||
2. The last RE encountered while running (dynamic scope).
|
||||
|
||||
While many historical implementations fail on programs depending
|
||||
on scope differences, the SunOS version exhibited dynamic scope
|
||||
behaviour. This implementation does dynamic scoping, as this seems
|
||||
the most useful and in order to remain consistent with historical
|
||||
practice.
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
/hanoi.sed/1.3/Thu Jan 9 20:21:35 1997//Tnetbsd-5-0
|
||||
/math.sed/1.3/Thu Jan 9 20:21:36 1997//Tnetbsd-5-0
|
||||
/sed.test/1.4/Mon Oct 27 20:09:49 2003//Tnetbsd-5-0
|
||||
D
|
||||
|
|
@ -1 +0,0 @@
|
|||
src/usr.bin/sed/TEST
|
||||
|
|
@ -1 +0,0 @@
|
|||
anoncvs@anoncvs.NetBSD.org:/cvsroot
|
||||
|
|
@ -1 +0,0 @@
|
|||
Tnetbsd-5-0
|
||||
|
|
@ -1,103 +0,0 @@
|
|||
# Towers of Hanoi in sed.
|
||||
#
|
||||
# from: @(#)hanoi.sed 8.1 (Berkeley) 6/6/93
|
||||
# $NetBSD: hanoi.sed,v 1.3 1997/01/09 20:21:35 tls Exp $
|
||||
#
|
||||
#
|
||||
# Ex:
|
||||
# Run "sed -f hanoi.sed", and enter:
|
||||
#
|
||||
# :abcd: : :<CR><CR>
|
||||
#
|
||||
# note -- TWO carriage returns, a peculiarity of sed), this will output the
|
||||
# sequence of states involved in moving 4 rings, the largest called "a" and
|
||||
# the smallest called "d", from the first to the second of three towers, so
|
||||
# that the rings on any tower at any time are in descending order of size.
|
||||
# You can start with a different arrangement and a different number of rings,
|
||||
# say :ce:b:ax: and it will give the shortest procedure for moving them all
|
||||
# to the middle tower. The rules are: the names of the rings must all be
|
||||
# lower-case letters, they must be input within 3 fields (representing the
|
||||
# towers) and delimited by 4 colons, such that the letters within each field
|
||||
# are in alphabetical order (i.e. rings are in descending order of size).
|
||||
#
|
||||
# For the benefit of anyone who wants to figure out the script, an "internal"
|
||||
# line of the form
|
||||
# b:0abx:1a2b3 :2 :3x2
|
||||
# has the following meaning: the material after the three markers :1, :2,
|
||||
# and :3 represents the three towers; in this case the current set-up is
|
||||
# ":ab : :x :". The numbers after a, b and x in these fields indicate
|
||||
# that the next time it gets a chance, it will move a to tower 2, move b
|
||||
# to tower 3, and move x to tower 2. The string after :0 just keeps track
|
||||
# of the alphabetical order of the names of the rings. The b at the
|
||||
# beginning means that it is now dealing with ring b (either about to move
|
||||
# it, or re-evaluating where it should next be moved to).
|
||||
#
|
||||
# Although this version is "limited" to 26 rings because of the size of the
|
||||
# alphabet, one could write a script using the same idea in which the rings
|
||||
# were represented by arbitrary [strings][within][brackets], and in place of
|
||||
# the built-in line of the script giving the order of the letters of the
|
||||
# alphabet, it would accept from the user a line giving the ordering to be
|
||||
# assumed, e.g. [ucbvax][decvax][hplabs][foo][bar].
|
||||
#
|
||||
# George Bergman
|
||||
# Math, UC Berkeley 94720 USA
|
||||
|
||||
# cleaning, diagnostics
|
||||
s/ *//g
|
||||
/^$/d
|
||||
/[^a-z:]/{a\
|
||||
Illegal characters: use only a-z and ":". Try again.
|
||||
d
|
||||
}
|
||||
/^:[a-z]*:[a-z]*:[a-z]*:$/!{a\
|
||||
Incorrect format: use\
|
||||
\ : string1 : string2 : string3 :<CR><CR>\
|
||||
Try again.
|
||||
d
|
||||
}
|
||||
/\([a-z]\).*\1/{a\
|
||||
Repeated letters not allowed. Try again.
|
||||
d
|
||||
}
|
||||
# initial formatting
|
||||
h
|
||||
s/[a-z]/ /g
|
||||
G
|
||||
s/^:\( *\):\( *\):\( *\):\n:\([a-z]*\):\([a-z]*\):\([a-z]*\):$/:1\4\2\3:2\5\1\3:3\6\1\2:0/
|
||||
s/[a-z]/&2/g
|
||||
s/^/abcdefghijklmnopqrstuvwxyz/
|
||||
:a
|
||||
s/^\(.\).*\1.*/&\1/
|
||||
s/.//
|
||||
/^[^:]/ba
|
||||
s/\([^0]*\)\(:0.*\)/\2\1:/
|
||||
s/^[^0]*0\(.\)/\1&/
|
||||
:b
|
||||
# outputting current state without markers
|
||||
h
|
||||
s/.*:1/:/
|
||||
s/[123]//gp
|
||||
g
|
||||
:c
|
||||
# establishing destinations
|
||||
/^\(.\).*\1:1/td
|
||||
/^\(.\).*:1[^:]*\11/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\31/
|
||||
/^\(.\).*:1[^:]*\12/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\33/
|
||||
/^\(.\).*:1[^:]*\13/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\32/
|
||||
/^\(.\).*:2[^:]*\11/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\33/
|
||||
/^\(.\).*:2[^:]*\12/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\32/
|
||||
/^\(.\).*:2[^:]*\13/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\31/
|
||||
/^\(.\).*:3[^:]*\11/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\32/
|
||||
/^\(.\).*:3[^:]*\12/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\31/
|
||||
/^\(.\).*:3[^:]*\13/s/^\(.\)\(.*\1\([a-z]\).*\)\3./\3\2\33/
|
||||
bc
|
||||
# iterate back to find smallest out-of-place ring
|
||||
:d
|
||||
s/^\(.\)\(:0[^:]*\([^:]\)\1.*:\([123]\)[^:]*\1\)\4/\3\2\4/
|
||||
td
|
||||
# move said ring (right, resp. left)
|
||||
s/^\(.\)\(.*\)\1\([23]\)\(.*:\3[^ ]*\) /\1\2 \4\1\3/
|
||||
s/^\(.\)\(.*:\([12]\)[^ ]*\) \(.*\)\1\3/\1\2\1\3\4 /
|
||||
tb
|
||||
s/.*/Done! Try another, or end with ^D./p
|
||||
d
|
||||
|
|
@ -1,164 +0,0 @@
|
|||
#
|
||||
# from: @(#)math.sed 8.1 (Berkeley) 6/6/93
|
||||
# $NetBSD: math.sed,v 1.3 1997/01/09 20:21:36 tls Exp $
|
||||
#
|
||||
# Addition and multiplication in sed.
|
||||
# ++ for a limited time only do (expr) too!!!
|
||||
#
|
||||
# Kevin S Braunsdorf, PUCC UNIX Group, ksb@cc.purdue.edu.
|
||||
#
|
||||
# Ex:
|
||||
# echo "4+7*3" | sed -f %f
|
||||
|
||||
# make sure the expression is well formed
|
||||
s/[ ]//g
|
||||
/[+*\/-]$/{
|
||||
a\
|
||||
poorly formed expression, operator on the end
|
||||
q
|
||||
}
|
||||
/^[+*\/]/{
|
||||
a\
|
||||
poorly formed expression, leading operator
|
||||
q
|
||||
}
|
||||
|
||||
# fill hold space with done token
|
||||
x
|
||||
s/^.*/done/
|
||||
x
|
||||
|
||||
# main loop, process operators (*, + and () )
|
||||
: loop
|
||||
/^\+/{
|
||||
s///
|
||||
b loop
|
||||
}
|
||||
/^\(.*\)(\([^)]*\))\(.*\)$/{
|
||||
H
|
||||
s//\2/
|
||||
x
|
||||
s/^\(.*\)\n\(.*\)(\([^()]*\))\(.*\)$/()\2@\4@\1/
|
||||
x
|
||||
b loop
|
||||
}
|
||||
/^[0-9]*\*/b mul
|
||||
/^\([0-9]*\)\+\([0-9+*]*\*[0-9]*\)$/{
|
||||
s//\2+\1/
|
||||
b loop
|
||||
}
|
||||
/^[0-9]*\+/{
|
||||
s/$/=/
|
||||
b add
|
||||
}
|
||||
x
|
||||
/^done$/{
|
||||
x
|
||||
p
|
||||
d
|
||||
}
|
||||
/^()/{
|
||||
s///
|
||||
x
|
||||
G
|
||||
s/\(.*\)\n\([^@]*\)@\([^@]*\)@\(.*\)/\2\1\3/
|
||||
x
|
||||
s/[^@]*@[^@]*@\(.*\)/\1/
|
||||
x
|
||||
b loop
|
||||
}
|
||||
i\
|
||||
help, stack problem
|
||||
p
|
||||
x
|
||||
p
|
||||
q
|
||||
|
||||
# turn mul into add until 1*x -> x
|
||||
: mul
|
||||
/^0*1\*/{
|
||||
s///
|
||||
b loop
|
||||
}
|
||||
/^\([0-9]*\)0\*/{
|
||||
s/^\([0-9]*\)0\*\([0-9]*\)/\1*\20/
|
||||
b mul
|
||||
}
|
||||
s/^\([0-9]*\)1\*/\10*/
|
||||
s/^\([0-9]*\)2\*/\11*/
|
||||
s/^\([0-9]*\)3\*/\12*/
|
||||
s/^\([0-9]*\)4\*/\13*/
|
||||
s/^\([0-9]*\)5\*/\14*/
|
||||
s/^\([0-9]*\)6\*/\15*/
|
||||
s/^\([0-9]*\)7\*/\16*/
|
||||
s/^\([0-9]*\)8\*/\17*/
|
||||
s/^\([0-9]*\)9\*/\18*/
|
||||
s/\*\([0-9*]*\)/*\1+\1/
|
||||
b mul
|
||||
|
||||
# get rid of a plus term until 0+x -> x
|
||||
: add
|
||||
/^\+\([0-9+*]*\)=/{
|
||||
s//\1/
|
||||
b loop
|
||||
}
|
||||
/^\([0-9*]*\)\+=/{
|
||||
s//\1/
|
||||
b loop
|
||||
}
|
||||
/^\([0-9]*\)\+\([0-9*+]*\)\+=/{
|
||||
s//\2+\1/
|
||||
b loop
|
||||
}
|
||||
/^\([0-9]*\)0\+\([0-9]*\)\([0-9]\)=/{
|
||||
s//\1+\2=\3/
|
||||
b add
|
||||
}
|
||||
/^\([0-9]*\)\([0-9]\)\+\([0-9]*\)0=/{
|
||||
s//\1+\3=\2/
|
||||
b add
|
||||
}
|
||||
/^\([0-9]*\)0\+\([0-9*+]*\)\+\([0-9]*\)\([0-9]\)=/{
|
||||
s//\1+\2+\3=\4/
|
||||
b add
|
||||
}
|
||||
/^\([0-9]*\)\([0-9]\)\+\([0-9*+]*\)\+\([0-9]*\)0=/{
|
||||
s//\1+\3+\4=\2/
|
||||
b add
|
||||
}
|
||||
s/^\([0-9]*\)1\+/\10+/
|
||||
s/^\([0-9]*\)2\+/\11+/
|
||||
s/^\([0-9]*\)3\+/\12+/
|
||||
s/^\([0-9]*\)4\+/\13+/
|
||||
s/^\([0-9]*\)5\+/\14+/
|
||||
s/^\([0-9]*\)6\+/\15+/
|
||||
s/^\([0-9]*\)7\+/\16+/
|
||||
s/^\([0-9]*\)8\+/\17+/
|
||||
s/^\([0-9]*\)9\+/\18+/
|
||||
|
||||
s/9=\([0-9]*\)$/_=\1/
|
||||
s/8=\([0-9]*\)$/9=\1/
|
||||
s/7=\([0-9]*\)$/8=\1/
|
||||
s/6=\([0-9]*\)$/7=\1/
|
||||
s/5=\([0-9]*\)$/6=\1/
|
||||
s/4=\([0-9]*\)$/5=\1/
|
||||
s/3=\([0-9]*\)$/4=\1/
|
||||
s/2=\([0-9]*\)$/3=\1/
|
||||
s/1=\([0-9]*\)$/2=\1/
|
||||
/_/{
|
||||
s//_0/
|
||||
: inc
|
||||
s/9_/_0/
|
||||
s/8_/9/
|
||||
s/7_/8/
|
||||
s/6_/7/
|
||||
s/5_/6/
|
||||
s/4_/5/
|
||||
s/3_/4/
|
||||
s/2_/3/
|
||||
s/1_/2/
|
||||
s/0_/1/
|
||||
s/\+_/+1/
|
||||
/_/b inc
|
||||
}
|
||||
b add
|
||||
|
|
@ -1,554 +0,0 @@
|
|||
#!/bin/sh -
|
||||
# $NetBSD: sed.test,v 1.4 2003/10/27 20:09:49 uwe Exp $
|
||||
#
|
||||
# Copyright (c) 1992 Diomidis Spinellis.
|
||||
# Copyright (c) 1992, 1993
|
||||
# The Regents of the University of California. 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.
|
||||
# 3. All advertising materials mentioning features or use of this software
|
||||
# must display the following acknowledgement:
|
||||
# This product includes software developed by the University of
|
||||
# California, Berkeley and its contributors.
|
||||
# 4. Neither the name of the University nor the names of its contributors
|
||||
# may be used to endorse or promote products derived from this software
|
||||
# without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
#
|
||||
# from: @(#)sed.test 8.1 (Berkeley) 6/6/93
|
||||
# $NetBSD: sed.test,v 1.4 2003/10/27 20:09:49 uwe Exp $
|
||||
#
|
||||
|
||||
# sed Regression Tests
|
||||
#
|
||||
# The following files are created:
|
||||
# lines[1-4], script1, script2
|
||||
# Two directories *.out contain the test results
|
||||
|
||||
main()
|
||||
{
|
||||
BASE=/usr/old/bin/sed
|
||||
BASELOG=sed.out
|
||||
TEST=../obj/sed
|
||||
TESTLOG=nsed.out
|
||||
DICT=/usr/share/dict/words
|
||||
|
||||
test_error | more
|
||||
|
||||
awk 'END { for (i = 1; i < 15; i++) print "l1_" i}' </dev/null >lines1
|
||||
awk 'END { for (i = 1; i < 10; i++) print "l2_" i}' </dev/null >lines2
|
||||
|
||||
exec 4>&1 5>&2
|
||||
|
||||
# Set these flags to get messages about known problems
|
||||
BSD=1
|
||||
GNU=0
|
||||
SUN=0
|
||||
tests $BASE $BASELOG
|
||||
|
||||
BSD=0
|
||||
GNU=0
|
||||
SUN=0
|
||||
tests $TEST $TESTLOG
|
||||
exec 1>&4 2>&5
|
||||
diff -c $BASELOG $TESTLOG | more
|
||||
}
|
||||
|
||||
tests()
|
||||
{
|
||||
SED=$1
|
||||
DIR=$2
|
||||
rm -rf $DIR
|
||||
mkdir $DIR
|
||||
MARK=100
|
||||
|
||||
test_args
|
||||
test_addr
|
||||
echo Testing commands
|
||||
test_group
|
||||
test_acid
|
||||
test_branch
|
||||
test_pattern
|
||||
test_print
|
||||
test_subst
|
||||
}
|
||||
|
||||
mark()
|
||||
{
|
||||
MARK=`expr $MARK + 1`
|
||||
exec 1>&4 2>&5
|
||||
exec >"$DIR/${MARK}_$1"
|
||||
echo "Test $1:$MARK"
|
||||
# Uncomment this line to match tests with sed error messages
|
||||
echo "Test $1:$MARK" >&5
|
||||
}
|
||||
|
||||
test_args()
|
||||
{
|
||||
mark '1.1'
|
||||
echo Testing argument parsing
|
||||
echo First type
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED 's/^/e1_/p' lines1
|
||||
fi
|
||||
mark '1.2' ; $SED -n 's/^/e1_/p' lines1
|
||||
mark '1.3'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED 's/^/e1_/p' <lines1
|
||||
fi
|
||||
mark '1.4' ; $SED -n 's/^/e1_/p' <lines1
|
||||
echo Second type
|
||||
mark '1.4.1'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed fails this
|
||||
fi
|
||||
$SED -e '' <lines1
|
||||
echo 's/^/s1_/p' >script1
|
||||
echo 's/^/s2_/p' >script2
|
||||
mark '1.5'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -f script1 lines1
|
||||
fi
|
||||
mark '1.6'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -f script1 <lines1
|
||||
fi
|
||||
mark '1.7'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -e 's/^/e1_/p' lines1
|
||||
fi
|
||||
mark '1.8'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -e 's/^/e1_/p' <lines1
|
||||
fi
|
||||
mark '1.9' ; $SED -n -f script1 lines1
|
||||
mark '1.10' ; $SED -n -f script1 <lines1
|
||||
mark '1.11' ; $SED -n -e 's/^/e1_/p' lines1
|
||||
mark '1.12'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -n -e 's/^/e1_/p' <lines1
|
||||
fi
|
||||
mark '1.13'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -e 's/^/e1_/p' -e 's/^/e2_/p' lines1
|
||||
fi
|
||||
mark '1.14'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -f script1 -f script2 lines1
|
||||
fi
|
||||
mark '1.15'
|
||||
if [ $GNU -eq 1 -o $SUN -eq 1 ] ; then
|
||||
echo GNU and SunOS sed fail this following older POSIX draft
|
||||
else
|
||||
$SED -e 's/^/e1_/p' -f script1 lines1
|
||||
fi
|
||||
mark '1.16'
|
||||
if [ $SUN -eq 1 ] ; then
|
||||
echo SunOS sed prints only with -n
|
||||
else
|
||||
$SED -e 's/^/e1_/p' lines1 lines1
|
||||
fi
|
||||
# POSIX D11.2:11251
|
||||
mark '1.17' ; $SED p <lines1 lines1
|
||||
cat >script1 <<EOF
|
||||
#n
|
||||
# A comment
|
||||
|
||||
p
|
||||
EOF
|
||||
mark '1.18' ; $SED -f script1 <lines1 lines1
|
||||
}
|
||||
|
||||
test_addr()
|
||||
{
|
||||
echo Testing address ranges
|
||||
mark '2.1' ; $SED -n -e '4p' lines1
|
||||
mark '2.2' ; $SED -n -e '20p' lines1 lines2
|
||||
mark '2.3' ; $SED -n -e '$p' lines1
|
||||
mark '2.4' ; $SED -n -e '$p' lines1 lines2
|
||||
mark '2.5' ; $SED -n -e '$a\
|
||||
hello' /dev/null
|
||||
mark '2.6' ; $SED -n -e '$p' lines1 /dev/null lines2
|
||||
# Should not print anything
|
||||
mark '2.7' ; $SED -n -e '20p' lines1
|
||||
mark '2.8' ; $SED -n -e '0p' lines1
|
||||
mark '2.9' ; $SED -n '/l1_7/p' lines1
|
||||
mark '2.10' ; $SED -n ' /l1_7/ p' lines1
|
||||
mark '2.11'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo BSD sed fails this test
|
||||
fi
|
||||
if [ $GNU -eq 1 ] ; then
|
||||
echo GNU sed fails this
|
||||
fi
|
||||
$SED -n '\_l1\_7_p' lines1
|
||||
mark '2.12' ; $SED -n '1,4p' lines1
|
||||
mark '2.13' ; $SED -n '1,$p' lines1 lines2
|
||||
mark '2.14' ; $SED -n '1,/l2_9/p' lines1 lines2
|
||||
mark '2.15' ; $SED -n '/4/,$p' lines1 lines2
|
||||
mark '2.16' ; $SED -n '/4/,20p' lines1 lines2
|
||||
mark '2.17' ; $SED -n '/4/,/10/p' lines1 lines2
|
||||
mark '2.18' ; $SED -n '/l2_3/,/l1_8/p' lines1 lines2
|
||||
mark '2.19'
|
||||
if [ $GNU -eq 1 ] ; then
|
||||
echo GNU sed fails this
|
||||
fi
|
||||
$SED -n '12,3p' lines1 lines2
|
||||
mark '2.20'
|
||||
if [ $GNU -eq 1 ] ; then
|
||||
echo GNU sed fails this
|
||||
fi
|
||||
$SED -n '/l1_7/,3p' lines1 lines2
|
||||
}
|
||||
|
||||
test_group()
|
||||
{
|
||||
echo Brace and other grouping
|
||||
mark '3.1' ; $SED -e '
|
||||
4,12 {
|
||||
s/^/^/
|
||||
s/$/$/
|
||||
s/_/T/
|
||||
}' lines1
|
||||
mark '3.2' ; $SED -e '
|
||||
4,12 {
|
||||
s/^/^/
|
||||
/6/,/10/ {
|
||||
s/$/$/
|
||||
/8/ s/_/T/
|
||||
}
|
||||
}' lines1
|
||||
mark '3.3' ; $SED -e '
|
||||
4,12 !{
|
||||
s/^/^/
|
||||
/6/,/10/ !{
|
||||
s/$/$/
|
||||
/8/ !s/_/T/
|
||||
}
|
||||
}' lines1
|
||||
mark '3.4' ; $SED -e '4,12!s/^/^/' lines1
|
||||
}
|
||||
|
||||
test_acid()
|
||||
{
|
||||
echo Testing a c d and i commands
|
||||
mark '4.1' ; $SED -n -e '
|
||||
s/^/before_i/p
|
||||
20i\
|
||||
inserted
|
||||
s/^/after_i/p
|
||||
' lines1 lines2
|
||||
mark '4.2' ; $SED -n -e '
|
||||
5,12s/^/5-12/
|
||||
s/^/before_a/p
|
||||
/5-12/a\
|
||||
appended
|
||||
s/^/after_a/p
|
||||
' lines1 lines2
|
||||
mark '4.3'
|
||||
if [ $GNU -eq 1 ] ; then
|
||||
echo GNU sed fails this
|
||||
fi
|
||||
$SED -n -e '
|
||||
s/^/^/p
|
||||
/l1_/a\
|
||||
appended
|
||||
8,10N
|
||||
s/$/$/p
|
||||
' lines1 lines2
|
||||
mark '4.4' ; $SED -n -e '
|
||||
c\
|
||||
hello
|
||||
' lines1
|
||||
mark '4.5' ; $SED -n -e '
|
||||
8c\
|
||||
hello
|
||||
' lines1
|
||||
mark '4.6' ; $SED -n -e '
|
||||
3,14c\
|
||||
hello
|
||||
' lines1
|
||||
# SunOS and GNU sed behave differently. We follow POSIX
|
||||
# mark '4.7' ; $SED -n -e '
|
||||
#8,3c\
|
||||
#hello
|
||||
#' lines1
|
||||
mark '4.8' ; $SED d <lines1
|
||||
}
|
||||
|
||||
test_branch()
|
||||
{
|
||||
echo Testing labels and branching
|
||||
mark '5.1' ; $SED -n -e '
|
||||
b label4
|
||||
:label3
|
||||
s/^/label3_/p
|
||||
b end
|
||||
:label4
|
||||
2,12b label1
|
||||
b label2
|
||||
:label1
|
||||
s/^/label1_/p
|
||||
b
|
||||
:label2
|
||||
s/^/label2_/p
|
||||
b label3
|
||||
:end
|
||||
' lines1
|
||||
mark '5.2'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo BSD sed fails this test
|
||||
fi
|
||||
$SED -n -e '
|
||||
s/l1_/l2_/
|
||||
t ok
|
||||
b
|
||||
:ok
|
||||
s/^/tested /p
|
||||
' lines1 lines2
|
||||
# SunOS sed behaves differently here. Clarification needed.
|
||||
# mark '5.3' ; $SED -n -e '
|
||||
#5,8b inside
|
||||
#1,5 {
|
||||
# s/^/^/p
|
||||
# :inside
|
||||
# s/$/$/p
|
||||
#}
|
||||
#' lines1
|
||||
# Check that t clears the substitution done flag
|
||||
mark '5.4' ; $SED -n -e '
|
||||
1,8s/^/^/
|
||||
t l1
|
||||
:l1
|
||||
t l2
|
||||
s/$/$/p
|
||||
b
|
||||
:l2
|
||||
s/^/ERROR/
|
||||
' lines1
|
||||
# Check that reading a line clears the substitution done flag
|
||||
mark '5.5'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo BSD sed fails this test
|
||||
fi
|
||||
$SED -n -e '
|
||||
t l2
|
||||
1,8s/^/^/p
|
||||
2,7N
|
||||
b
|
||||
:l2
|
||||
s/^/ERROR/p
|
||||
' lines1
|
||||
mark '5.6' ; $SED 5q lines1
|
||||
mark '5.7' ; $SED -e '
|
||||
5i\
|
||||
hello
|
||||
5q' lines1
|
||||
# Branch across block boundary
|
||||
mark '5.8' ; $SED -e '
|
||||
{
|
||||
:b
|
||||
}
|
||||
s/l/m/
|
||||
tb' lines1
|
||||
}
|
||||
|
||||
test_pattern()
|
||||
{
|
||||
echo Pattern space commands
|
||||
# Check that the pattern space is deleted
|
||||
mark '6.1' ; $SED -n -e '
|
||||
c\
|
||||
changed
|
||||
p
|
||||
' lines1
|
||||
mark '6.2' ; $SED -n -e '
|
||||
4d
|
||||
p
|
||||
' lines1
|
||||
# SunOS sed refused to print here
|
||||
# mark '6.3' ; $SED -e '
|
||||
#N
|
||||
#N
|
||||
#N
|
||||
#D
|
||||
#P
|
||||
#4p
|
||||
#' lines1
|
||||
mark '6.4' ; $SED -e '
|
||||
2h
|
||||
3H
|
||||
4g
|
||||
5G
|
||||
6x
|
||||
6p
|
||||
6x
|
||||
6p
|
||||
' lines1
|
||||
mark '6.5' ; $SED -e '4n' lines1
|
||||
mark '6.6' ; $SED -n -e '4n' lines1
|
||||
}
|
||||
|
||||
test_print()
|
||||
{
|
||||
echo Testing print and file routines
|
||||
awk 'END {for (i = 1; i < 256; i++) printf("%c", i);print "\n"}' \
|
||||
</dev/null >lines3
|
||||
# GNU and SunOS sed behave differently here
|
||||
mark '7.1'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo 'BSD sed drops core on this one; TEST SKIPPED'
|
||||
else
|
||||
$SED -n l lines3
|
||||
fi
|
||||
mark '7.2' ; $SED -e '/l2_/=' lines1 lines2
|
||||
rm -f lines4
|
||||
mark '7.3' ; $SED -e '3,12w lines4' lines1
|
||||
echo w results
|
||||
cat lines4
|
||||
mark '7.4' ; $SED -e '4r lines2' lines1
|
||||
mark '7.5' ; $SED -e '5r /dev/dds' lines1
|
||||
mark '7.6' ; $SED -e '6r /dev/null' lines1
|
||||
mark '7.7'
|
||||
if [ $BSD -eq 1 -o $GNU -eq 1 -o $SUN -eq 1 ] ; then
|
||||
echo BSD, GNU and SunOS cannot pass this one
|
||||
else
|
||||
sed '200q' $DICT | sed 's$.*$s/^/&/w tmpdir/&$' >script1
|
||||
rm -rf tmpdir
|
||||
mkdir tmpdir
|
||||
$SED -f script1 lines1
|
||||
cat tmpdir/*
|
||||
rm -rf tmpdir
|
||||
fi
|
||||
mark '7.8'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo BSD sed cannot pass 7.7
|
||||
else
|
||||
echo line1 > lines3
|
||||
echo "" >> lines3
|
||||
$SED -n -e '$p' lines3 /dev/null
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
test_subst()
|
||||
{
|
||||
echo Testing substitution commands
|
||||
mark '8.1' ; $SED -e 's/./X/g' lines1
|
||||
mark '8.2' ; $SED -e 's,.,X,g' lines1
|
||||
# GNU and SunOS sed thinks we are escaping . as wildcard, not as separator
|
||||
# mark '8.3' ; $SED -e 's.\..X.g' lines1
|
||||
# POSIX does not say that this should work
|
||||
# mark '8.4' ; $SED -e 's/[/]/Q/' lines1
|
||||
mark '8.4' ; $SED -e 's/[\/]/Q/' lines1
|
||||
mark '8.5' ; $SED -e 's_\__X_' lines1
|
||||
mark '8.6' ; $SED -e 's/./(&)/g' lines1
|
||||
mark '8.7' ; $SED -e 's/./(\&)/g' lines1
|
||||
mark '8.8' ; $SED -e 's/\(.\)\(.\)\(.\)/x\3x\2x\1/g' lines1
|
||||
mark '8.9' ; $SED -e 's/_/u0\
|
||||
u1\
|
||||
u2/g' lines1
|
||||
mark '8.10'
|
||||
if [ $BSD -eq 1 -o $GNU -eq 1 ] ; then
|
||||
echo 'BSD/GNU sed do not understand digit flags on s commands'
|
||||
fi
|
||||
$SED -e 's/./X/4' lines1
|
||||
rm -f lines4
|
||||
mark '8.11' ; $SED -e 's/1/X/w lines4' lines1
|
||||
echo s wfile results
|
||||
cat lines4
|
||||
mark '8.12' ; $SED -e 's/[123]/X/g' lines1
|
||||
mark '8.13' ; $SED -e 'y/0123456789/9876543210/' lines1
|
||||
mark '8.14' ;
|
||||
if [ $BSD -eq 1 -o $GNU -eq 1 -o $SUN -eq 1 ] ; then
|
||||
echo BSD/GNU/SUN sed fail this test
|
||||
else
|
||||
$SED -e 'y10\123456789198765432\101' lines1
|
||||
fi
|
||||
mark '8.15' ; $SED -e '1N;2y/\n/X/' lines1
|
||||
mark '8.16'
|
||||
if [ $BSD -eq 1 ] ; then
|
||||
echo 'BSD sed does not handle branch defined REs'
|
||||
else
|
||||
echo 'eeefff' | $SED -e 'p' -e 's/e/X/p' -e ':x' \
|
||||
-e 's//Y/p' -e '/f/bx'
|
||||
fi
|
||||
}
|
||||
|
||||
test_error()
|
||||
{
|
||||
exec 3<&0 4>&1 5>&2
|
||||
exec 0</dev/null
|
||||
exec 2>&1
|
||||
set -x
|
||||
$TEST -x && exit 1
|
||||
$TEST -f && exit 1
|
||||
$TEST -e && exit 1
|
||||
$TEST -f /dev/dds && exit 1
|
||||
$TEST p /dev/dds && exit 1
|
||||
$TEST -f /bin/sh && exit 1
|
||||
$TEST '{' && exit 1
|
||||
$TEST '{' && exit 1
|
||||
$TEST '/hello/' && exit 1
|
||||
$TEST '1,/hello/' && exit 1
|
||||
$TEST -e '-5p' && exit 1
|
||||
$TEST '/jj' && exit 1
|
||||
$TEST 'a hello' && exit 1
|
||||
$TEST 'a \ hello' && exit 1
|
||||
$TEST 'b foo' && exit 1
|
||||
$TEST 'd hello' && exit 1
|
||||
$TEST 's/aa' && exit 1
|
||||
$TEST 's/aa/' && exit 1
|
||||
$TEST 's/a/b' && exit 1
|
||||
$TEST 's/a/b/c/d' && exit 1
|
||||
$TEST 's/a/b/ 1 2' && exit 1
|
||||
$TEST 's/a/b/ 1 g' && exit 1
|
||||
$TEST 's/a/b/w' && exit 1
|
||||
$TEST 'y/aa' && exit 1
|
||||
$TEST 'y/aa/b/' && exit 1
|
||||
$TEST 'y/aa/' && exit 1
|
||||
$TEST 'y/a/b' && exit 1
|
||||
$TEST 'y/a/b/c/d' && exit 1
|
||||
$TEST '!' && exit 1
|
||||
$TEST supercalifrangolisticexprialidociussupercalifrangolisticexcius
|
||||
set +x
|
||||
exec 0<&3 1>&4 2>&5
|
||||
}
|
||||
|
||||
main
|
||||
|
|
@ -1,859 +0,0 @@
|
|||
/* $NetBSD: compile.c,v 1.35 2007/04/17 20:30:29 christos Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
#if HAVE_NBTOOL_CONFIG_H
|
||||
#include "nbtool_config.h"
|
||||
#endif
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <limits.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "defs.h"
|
||||
#include "extern.h"
|
||||
|
||||
#ifndef _POSIX2_LINE_MAX
|
||||
#define _POSIX2_LINE_MAX (2 * BUFSIZ)
|
||||
#endif
|
||||
|
||||
#define LHSZ 128
|
||||
#define LHMASK (LHSZ - 1)
|
||||
static struct labhash {
|
||||
struct labhash *lh_next;
|
||||
u_int lh_hash;
|
||||
struct s_command *lh_cmd;
|
||||
int lh_ref;
|
||||
} *labels[LHSZ];
|
||||
|
||||
static char *compile_addr(char *, struct s_addr *);
|
||||
static char *compile_ccl(char **, char *);
|
||||
static char *compile_delimited(char *, char *);
|
||||
static char *compile_flags(char *, struct s_subst *);
|
||||
static char *compile_re(char *, regex_t **);
|
||||
static char *compile_subst(char *, struct s_subst *);
|
||||
static char *compile_text(void);
|
||||
static char *compile_tr(char *, char **);
|
||||
static struct s_command
|
||||
**compile_stream(struct s_command **);
|
||||
static char *duptoeol(char *, char *);
|
||||
static void enterlabel(struct s_command *);
|
||||
static struct s_command
|
||||
*findlabel(char *);
|
||||
static void fixuplabel(struct s_command *, struct s_command *);
|
||||
static void uselabel(void);
|
||||
|
||||
/*
|
||||
* Command specification. This is used to drive the command parser.
|
||||
*/
|
||||
struct s_format {
|
||||
char code; /* Command code */
|
||||
int naddr; /* Number of address args */
|
||||
enum e_args args; /* Argument type */
|
||||
};
|
||||
|
||||
static struct s_format cmd_fmts[] = {
|
||||
{'{', 2, GROUP},
|
||||
{'}', 0, ENDGROUP},
|
||||
{'a', 1, TEXT},
|
||||
{'b', 2, BRANCH},
|
||||
{'c', 2, TEXT},
|
||||
{'d', 2, EMPTY},
|
||||
{'D', 2, EMPTY},
|
||||
{'g', 2, EMPTY},
|
||||
{'G', 2, EMPTY},
|
||||
{'h', 2, EMPTY},
|
||||
{'H', 2, EMPTY},
|
||||
{'i', 1, TEXT},
|
||||
{'l', 2, EMPTY},
|
||||
{'n', 2, EMPTY},
|
||||
{'N', 2, EMPTY},
|
||||
{'p', 2, EMPTY},
|
||||
{'P', 2, EMPTY},
|
||||
{'q', 1, EMPTY},
|
||||
{'r', 1, RFILE},
|
||||
{'s', 2, SUBST},
|
||||
{'t', 2, BRANCH},
|
||||
{'w', 2, WFILE},
|
||||
{'x', 2, EMPTY},
|
||||
{'y', 2, TR},
|
||||
{'!', 2, NONSEL},
|
||||
{':', 0, LABEL},
|
||||
{'#', 0, COMMENT},
|
||||
{'=', 1, EMPTY},
|
||||
{'\0', 0, COMMENT},
|
||||
};
|
||||
|
||||
/* The compiled program. */
|
||||
struct s_command *prog;
|
||||
|
||||
/*
|
||||
* Compile the program into prog.
|
||||
* Initialise appends.
|
||||
*/
|
||||
void
|
||||
compile(void)
|
||||
{
|
||||
*compile_stream(&prog) = NULL;
|
||||
fixuplabel(prog, NULL);
|
||||
uselabel();
|
||||
if (appendnum > 0)
|
||||
appends = xmalloc(sizeof(struct s_appends) * appendnum);
|
||||
match = xmalloc((maxnsub + 1) * sizeof(regmatch_t));
|
||||
}
|
||||
|
||||
#define EATSPACE() \
|
||||
while (*p && isascii((unsigned char)*p) && \
|
||||
isspace((unsigned char)*p)) \
|
||||
p++ \
|
||||
|
||||
static struct s_command **
|
||||
compile_stream(struct s_command **link)
|
||||
{
|
||||
char *p;
|
||||
static char lbuf[_POSIX2_LINE_MAX + 1]; /* To save stack */
|
||||
struct s_command *cmd, *cmd2, *stack;
|
||||
struct s_format *fp;
|
||||
int naddr; /* Number of addresses */
|
||||
|
||||
stack = 0;
|
||||
for (;;) {
|
||||
if ((p = cu_fgets(lbuf, sizeof(lbuf))) == NULL) {
|
||||
if (stack != 0)
|
||||
err(COMPILE, "unexpected EOF (pending }'s)");
|
||||
return (link);
|
||||
}
|
||||
|
||||
semicolon: EATSPACE();
|
||||
if (*p == '#' || *p == '\0')
|
||||
continue;
|
||||
else if (*p == ';') {
|
||||
p++;
|
||||
goto semicolon;
|
||||
}
|
||||
*link = cmd = xmalloc(sizeof(struct s_command));
|
||||
link = &cmd->next;
|
||||
cmd->nonsel = cmd->inrange = 0;
|
||||
/* First parse the addresses */
|
||||
naddr = 0;
|
||||
|
||||
/* Valid characters to start an address */
|
||||
#define addrchar(c) (strchr("0123456789/\\$", (c)))
|
||||
if (addrchar(*p)) {
|
||||
naddr++;
|
||||
cmd->a1 = xmalloc(sizeof(struct s_addr));
|
||||
p = compile_addr(p, cmd->a1);
|
||||
EATSPACE(); /* EXTENSION */
|
||||
if (*p == ',') {
|
||||
p++;
|
||||
EATSPACE(); /* EXTENSION */
|
||||
naddr++;
|
||||
cmd->a2 = xmalloc(sizeof(struct s_addr));
|
||||
p = compile_addr(p, cmd->a2);
|
||||
EATSPACE();
|
||||
} else
|
||||
cmd->a2 = 0;
|
||||
} else
|
||||
cmd->a1 = cmd->a2 = 0;
|
||||
|
||||
nonsel: /* Now parse the command */
|
||||
if (!*p)
|
||||
err(COMPILE, "command expected");
|
||||
cmd->code = *p;
|
||||
for (fp = cmd_fmts; fp->code; fp++)
|
||||
if (fp->code == *p)
|
||||
break;
|
||||
if (!fp->code)
|
||||
err(COMPILE, "invalid command code %c", *p);
|
||||
if (naddr > fp->naddr)
|
||||
err(COMPILE,
|
||||
"command %c expects up to %d address(es), found %d", *p, fp->naddr, naddr);
|
||||
switch (fp->args) {
|
||||
case NONSEL: /* ! */
|
||||
p++;
|
||||
EATSPACE();
|
||||
cmd->nonsel = ! cmd->nonsel;
|
||||
goto nonsel;
|
||||
case GROUP: /* { */
|
||||
p++;
|
||||
EATSPACE();
|
||||
cmd->next = stack;
|
||||
stack = cmd;
|
||||
link = &cmd->u.c;
|
||||
if (*p)
|
||||
goto semicolon;
|
||||
break;
|
||||
case ENDGROUP:
|
||||
/*
|
||||
* Short-circuit command processing, since end of
|
||||
* group is really just a noop.
|
||||
*/
|
||||
cmd->nonsel = 1;
|
||||
if (stack == 0)
|
||||
err(COMPILE, "unexpected }");
|
||||
cmd2 = stack;
|
||||
stack = cmd2->next;
|
||||
cmd2->next = cmd;
|
||||
/*FALLTHROUGH*/
|
||||
case EMPTY: /* d D g G h H l n N p P q x = \0 */
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p == ';') {
|
||||
p++;
|
||||
link = &cmd->next;
|
||||
goto semicolon;
|
||||
}
|
||||
if (*p)
|
||||
err(COMPILE,
|
||||
"extra characters at the end of %c command", cmd->code);
|
||||
break;
|
||||
case TEXT: /* a c i */
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p != '\\')
|
||||
err(COMPILE,
|
||||
"command %c expects \\ followed by text", cmd->code);
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p)
|
||||
err(COMPILE,
|
||||
"extra characters after \\ at the end of %c command", cmd->code);
|
||||
cmd->t = compile_text();
|
||||
break;
|
||||
case COMMENT: /* \0 # */
|
||||
break;
|
||||
case WFILE: /* w */
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p == '\0')
|
||||
err(COMPILE, "filename expected");
|
||||
cmd->t = duptoeol(p, "w command");
|
||||
if (aflag)
|
||||
cmd->u.fd = -1;
|
||||
else if ((cmd->u.fd = open(p,
|
||||
O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
|
||||
DEFFILEMODE)) == -1)
|
||||
err(FATAL, "%s: %s", p, strerror(errno));
|
||||
break;
|
||||
case RFILE: /* r */
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p == '\0')
|
||||
err(COMPILE, "filename expected");
|
||||
else
|
||||
cmd->t = duptoeol(p, "read command");
|
||||
break;
|
||||
case BRANCH: /* b t */
|
||||
p++;
|
||||
EATSPACE();
|
||||
if (*p == '\0')
|
||||
cmd->t = NULL;
|
||||
else
|
||||
cmd->t = duptoeol(p, "branch");
|
||||
break;
|
||||
case LABEL: /* : */
|
||||
p++;
|
||||
EATSPACE();
|
||||
cmd->t = duptoeol(p, "label");
|
||||
if (strlen(p) == 0)
|
||||
err(COMPILE, "empty label");
|
||||
enterlabel(cmd);
|
||||
break;
|
||||
case SUBST: /* s */
|
||||
p++;
|
||||
if (*p == '\0' || *p == '\\')
|
||||
err(COMPILE,
|
||||
"substitute pattern can not be delimited by newline or backslash");
|
||||
cmd->u.s = xmalloc(sizeof(struct s_subst));
|
||||
p = compile_re(p, &cmd->u.s->re);
|
||||
if (p == NULL)
|
||||
err(COMPILE, "unterminated substitute pattern");
|
||||
--p;
|
||||
p = compile_subst(p, cmd->u.s);
|
||||
p = compile_flags(p, cmd->u.s);
|
||||
EATSPACE();
|
||||
if (*p == ';') {
|
||||
p++;
|
||||
link = &cmd->next;
|
||||
goto semicolon;
|
||||
}
|
||||
break;
|
||||
case TR: /* y */
|
||||
p++;
|
||||
p = compile_tr(p, (char **)(void *)&cmd->u.y);
|
||||
EATSPACE();
|
||||
if (*p == ';') {
|
||||
p++;
|
||||
link = &cmd->next;
|
||||
goto semicolon;
|
||||
}
|
||||
if (*p)
|
||||
err(COMPILE,
|
||||
"extra text at the end of a transform command");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Get a delimited string. P points to the delimiter of the string; d points
|
||||
* to a buffer area. Newline and delimiter escapes are processed; other
|
||||
* escapes are ignored.
|
||||
*
|
||||
* Returns a pointer to the first character after the final delimiter or NULL
|
||||
* in the case of a non-terminated string. The character array d is filled
|
||||
* with the processed string.
|
||||
*/
|
||||
static char *
|
||||
compile_delimited(char *p, char *d)
|
||||
{
|
||||
char c;
|
||||
|
||||
c = *p++;
|
||||
if (c == '\0')
|
||||
return (NULL);
|
||||
else if (c == '\\')
|
||||
err(COMPILE, "\\ can not be used as a string delimiter");
|
||||
else if (c == '\n')
|
||||
err(COMPILE, "newline can not be used as a string delimiter");
|
||||
while (*p) {
|
||||
if (*p == '[') {
|
||||
if ((d = compile_ccl(&p, d)) == NULL)
|
||||
err(COMPILE, "unbalanced brackets ([])");
|
||||
continue;
|
||||
} else if (*p == '\\' && p[1] == '[') {
|
||||
*d++ = *p++;
|
||||
} else if (*p == '\\' && p[1] == c)
|
||||
p++;
|
||||
else if (*p == '\\' && p[1] == 'n') {
|
||||
*d++ = '\n';
|
||||
p += 2;
|
||||
continue;
|
||||
} else if (*p == '\\' && p[1] == 't') {
|
||||
*d++ = '\t';
|
||||
p += 2;
|
||||
continue;
|
||||
} else if (*p == '\\' && p[1] == '\\')
|
||||
*d++ = *p++;
|
||||
else if (*p == c) {
|
||||
*d = '\0';
|
||||
return (p + 1);
|
||||
}
|
||||
*d++ = *p++;
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
|
||||
/* compile_ccl: expand a POSIX character class */
|
||||
static char *
|
||||
compile_ccl(char **sp, char *t)
|
||||
{
|
||||
int c, d;
|
||||
char *s = *sp;
|
||||
|
||||
*t++ = *s++;
|
||||
if (*s == '^')
|
||||
*t++ = *s++;
|
||||
if (*s == ']')
|
||||
*t++ = *s++;
|
||||
for (; *s && (*t = *s) != ']'; s++, t++)
|
||||
if (*s == '[' && ((d = *(s+1)) == '.' || d == ':' || d == '=')) {
|
||||
*++t = *++s, t++, s++;
|
||||
for (c = *s; (*t = *s) != ']' || c != d; s++, t++)
|
||||
if ((c = *s) == '\0')
|
||||
return NULL;
|
||||
} else if (*s == '\\' && s[1] == 'n')
|
||||
*t = '\n', s++;
|
||||
return (*s == ']') ? *sp = ++s, ++t : NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Get a regular expression. P points to the delimiter of the regular
|
||||
* expression; repp points to the address of a regexp pointer. Newline
|
||||
* and delimiter escapes are processed; other escapes are ignored.
|
||||
* Returns a pointer to the first character after the final delimiter
|
||||
* or NULL in the case of a non terminated regular expression. The regexp
|
||||
* pointer is set to the compiled regular expression.
|
||||
* Cflags are passed to regcomp.
|
||||
*/
|
||||
static char *
|
||||
compile_re(char *p, regex_t **repp)
|
||||
{
|
||||
int eval;
|
||||
char re[_POSIX2_LINE_MAX + 1];
|
||||
|
||||
p = compile_delimited(p, re);
|
||||
if (p && strlen(re) == 0) {
|
||||
*repp = NULL;
|
||||
return (p);
|
||||
}
|
||||
*repp = xmalloc(sizeof(regex_t));
|
||||
if (p && (eval = regcomp(*repp, re, ere)) != 0)
|
||||
err(COMPILE, "RE error: %s", strregerror(eval, *repp));
|
||||
if (maxnsub < (*repp)->re_nsub)
|
||||
maxnsub = (*repp)->re_nsub;
|
||||
return (p);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compile the substitution string of a regular expression and set res to
|
||||
* point to a saved copy of it. Nsub is the number of parenthesized regular
|
||||
* expressions.
|
||||
*/
|
||||
static char *
|
||||
compile_subst(char *p, struct s_subst *s)
|
||||
{
|
||||
static char lbuf[_POSIX2_LINE_MAX + 1];
|
||||
int asize, ref, size;
|
||||
char c, *text, *op, *sp;
|
||||
int sawesc = 0;
|
||||
|
||||
c = *p++; /* Terminator character */
|
||||
if (c == '\0')
|
||||
return (NULL);
|
||||
|
||||
s->maxbref = 0;
|
||||
s->linenum = linenum;
|
||||
asize = 2 * _POSIX2_LINE_MAX + 1;
|
||||
text = xmalloc(asize);
|
||||
size = 0;
|
||||
do {
|
||||
op = sp = text + size;
|
||||
for (; *p; p++) {
|
||||
if (*p == '\\' || sawesc) {
|
||||
/*
|
||||
* If this is a continuation from the last
|
||||
* buffer, we won't have a character to
|
||||
* skip over.
|
||||
*/
|
||||
if (sawesc)
|
||||
sawesc = 0;
|
||||
else
|
||||
p++;
|
||||
|
||||
if (*p == '\0') {
|
||||
/*
|
||||
* This escaped character is continued
|
||||
* in the next part of the line. Note
|
||||
* this fact, then cause the loop to
|
||||
* exit w/ normal EOL case and reenter
|
||||
* above with the new buffer.
|
||||
*/
|
||||
sawesc = 1;
|
||||
p--;
|
||||
continue;
|
||||
} else if (strchr("123456789", *p) != NULL) {
|
||||
*sp++ = '\\';
|
||||
ref = *p - '0';
|
||||
if (s->re != NULL &&
|
||||
ref > s->re->re_nsub)
|
||||
err(COMPILE,
|
||||
"\\%c not defined in the RE", *p);
|
||||
if (s->maxbref < ref)
|
||||
s->maxbref = ref;
|
||||
} else if (*p == '&' || *p == '\\')
|
||||
*sp++ = '\\';
|
||||
} else if (*p == c) {
|
||||
p++;
|
||||
*sp++ = '\0';
|
||||
size += sp - op;
|
||||
s->new = xrealloc(text, size);
|
||||
return (p);
|
||||
} else if (*p == '\n') {
|
||||
err(COMPILE,
|
||||
"unescaped newline inside substitute pattern");
|
||||
/* NOTREACHED */
|
||||
}
|
||||
*sp++ = *p;
|
||||
}
|
||||
size += sp - op;
|
||||
if (asize - size < _POSIX2_LINE_MAX + 1) {
|
||||
asize *= 2;
|
||||
text = xrealloc(text, asize);
|
||||
}
|
||||
} while (cu_fgets(p = lbuf, sizeof(lbuf)));
|
||||
err(COMPILE, "unterminated substitute in regular expression");
|
||||
/* NOTREACHED */
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compile the flags of the s command
|
||||
*/
|
||||
static char *
|
||||
compile_flags(char *p, struct s_subst *s)
|
||||
{
|
||||
int gn; /* True if we have seen g or n */
|
||||
char wfile[_POSIX2_LINE_MAX + 1], *q;
|
||||
|
||||
s->n = 1; /* Default */
|
||||
s->p = 0;
|
||||
s->wfile = NULL;
|
||||
s->wfd = -1;
|
||||
for (gn = 0;;) {
|
||||
EATSPACE(); /* EXTENSION */
|
||||
switch (*p) {
|
||||
case 'g':
|
||||
if (gn)
|
||||
err(COMPILE,
|
||||
"more than one number or 'g' in substitute flags");
|
||||
gn = 1;
|
||||
s->n = 0;
|
||||
break;
|
||||
case '\0':
|
||||
case '\n':
|
||||
case ';':
|
||||
return (p);
|
||||
case 'p':
|
||||
s->p = 1;
|
||||
break;
|
||||
case '1': case '2': case '3':
|
||||
case '4': case '5': case '6':
|
||||
case '7': case '8': case '9':
|
||||
if (gn)
|
||||
err(COMPILE,
|
||||
"more than one number or 'g' in substitute flags");
|
||||
gn = 1;
|
||||
/* XXX Check for overflow */
|
||||
s->n = (int)strtol(p, &p, 10);
|
||||
p--;
|
||||
break;
|
||||
case 'w':
|
||||
p++;
|
||||
#ifdef HISTORIC_PRACTICE
|
||||
if (*p != ' ') {
|
||||
err(WARNING, "space missing before w wfile");
|
||||
return (p);
|
||||
}
|
||||
#endif
|
||||
EATSPACE();
|
||||
q = wfile;
|
||||
while (*p) {
|
||||
if (*p == '\n')
|
||||
break;
|
||||
*q++ = *p++;
|
||||
}
|
||||
*q = '\0';
|
||||
if (q == wfile)
|
||||
err(COMPILE, "no wfile specified");
|
||||
s->wfile = strdup(wfile);
|
||||
if (!aflag && (s->wfd = open(wfile,
|
||||
O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
|
||||
DEFFILEMODE)) == -1)
|
||||
err(FATAL, "%s: %s", wfile, strerror(errno));
|
||||
return (p);
|
||||
default:
|
||||
err(COMPILE,
|
||||
"bad flag in substitute command: '%c'", *p);
|
||||
break;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Compile a translation set of strings into a lookup table.
|
||||
*/
|
||||
static char *
|
||||
compile_tr(char *p, char **transtab)
|
||||
{
|
||||
int i;
|
||||
char *lt, *op, *np;
|
||||
char old[_POSIX2_LINE_MAX + 1];
|
||||
char new[_POSIX2_LINE_MAX + 1];
|
||||
|
||||
if (*p == '\0' || *p == '\\')
|
||||
err(COMPILE,
|
||||
"transform pattern can not be delimited by newline or backslash");
|
||||
p = compile_delimited(p, old);
|
||||
if (p == NULL) {
|
||||
err(COMPILE, "unterminated transform source string");
|
||||
return (NULL);
|
||||
}
|
||||
p = compile_delimited(--p, new);
|
||||
if (p == NULL) {
|
||||
err(COMPILE, "unterminated transform target string");
|
||||
return (NULL);
|
||||
}
|
||||
EATSPACE();
|
||||
if (strlen(new) != strlen(old)) {
|
||||
err(COMPILE, "transform strings are not the same length");
|
||||
return (NULL);
|
||||
}
|
||||
/* We assume characters are 8 bits */
|
||||
lt = xmalloc(UCHAR_MAX+1);
|
||||
for (i = 0; i <= UCHAR_MAX; i++)
|
||||
lt[i] = (char)i;
|
||||
for (op = old, np = new; *op; op++, np++)
|
||||
lt[(u_char)*op] = *np;
|
||||
*transtab = lt;
|
||||
return (p);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compile the text following an a, c, or i command.
|
||||
*/
|
||||
static char *
|
||||
compile_text(void)
|
||||
{
|
||||
int asize, size;
|
||||
char *text, *p, *op, *s;
|
||||
char lbuf[_POSIX2_LINE_MAX + 1];
|
||||
|
||||
asize = 2 * _POSIX2_LINE_MAX + 1;
|
||||
text = xmalloc(asize);
|
||||
size = 0;
|
||||
while (cu_fgets(lbuf, sizeof(lbuf))) {
|
||||
op = s = text + size;
|
||||
p = lbuf;
|
||||
for (; *p; p++) {
|
||||
if (*p == '\\')
|
||||
p++;
|
||||
*s++ = *p;
|
||||
}
|
||||
size += s - op;
|
||||
if (p[-2] != '\\') {
|
||||
*s = '\0';
|
||||
break;
|
||||
}
|
||||
if (asize - size < _POSIX2_LINE_MAX + 1) {
|
||||
asize *= 2;
|
||||
text = xrealloc(text, asize);
|
||||
}
|
||||
}
|
||||
return (xrealloc(text, size + 1));
|
||||
}
|
||||
|
||||
/*
|
||||
* Get an address and return a pointer to the first character after
|
||||
* it. Fill the structure pointed to according to the address.
|
||||
*/
|
||||
static char *
|
||||
compile_addr(char *p, struct s_addr *a)
|
||||
{
|
||||
char *end;
|
||||
|
||||
switch (*p) {
|
||||
case '\\': /* Context address */
|
||||
++p;
|
||||
/* FALLTHROUGH */
|
||||
case '/': /* Context address */
|
||||
p = compile_re(p, &a->u.r);
|
||||
if (p == NULL)
|
||||
err(COMPILE, "unterminated regular expression");
|
||||
a->type = AT_RE;
|
||||
return (p);
|
||||
|
||||
case '$': /* Last line */
|
||||
a->type = AT_LAST;
|
||||
return (p + 1);
|
||||
/* Line number */
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
a->type = AT_LINE;
|
||||
a->u.l = strtol(p, &end, 10);
|
||||
return (end);
|
||||
default:
|
||||
err(COMPILE, "expected context address");
|
||||
return (NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* duptoeol --
|
||||
* Return a copy of all the characters up to \n or \0.
|
||||
*/
|
||||
static char *
|
||||
duptoeol(char *s, char *ctype)
|
||||
{
|
||||
size_t len;
|
||||
int ws;
|
||||
char *start;
|
||||
|
||||
ws = 0;
|
||||
for (start = s; *s != '\0' && *s != '\n'; ++s)
|
||||
ws = isspace((unsigned char)*s);
|
||||
*s = '\0';
|
||||
if (ws)
|
||||
err(WARNING, "whitespace after %s", ctype);
|
||||
len = s - start + 1;
|
||||
return (memmove(xmalloc(len), start, len));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert goto label names to addresses, and count a and r commands, in
|
||||
* the given subset of the script. Free the memory used by labels in b
|
||||
* and t commands (but not by :).
|
||||
*
|
||||
* TODO: Remove } nodes
|
||||
*/
|
||||
static void
|
||||
fixuplabel(struct s_command *cp, struct s_command *end)
|
||||
{
|
||||
|
||||
for (; cp != end; cp = cp->next)
|
||||
switch (cp->code) {
|
||||
case 'a':
|
||||
case 'r':
|
||||
appendnum++;
|
||||
break;
|
||||
case 'b':
|
||||
case 't':
|
||||
/* Resolve branch target. */
|
||||
if (cp->t == NULL) {
|
||||
cp->u.c = NULL;
|
||||
break;
|
||||
}
|
||||
if ((cp->u.c = findlabel(cp->t)) == NULL)
|
||||
err(COMPILE2, "undefined label '%s'", cp->t);
|
||||
free(cp->t);
|
||||
break;
|
||||
case '{':
|
||||
/* Do interior commands. */
|
||||
fixuplabel(cp->u.c, cp->next);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Associate the given command label for later lookup.
|
||||
*/
|
||||
static void
|
||||
enterlabel(struct s_command *cp)
|
||||
{
|
||||
struct labhash **lhp, *lh;
|
||||
u_char *p;
|
||||
u_int h, c;
|
||||
|
||||
for (h = 0, p = (u_char *)cp->t; (c = *p) != 0; p++)
|
||||
h = (h << 5) + h + c;
|
||||
lhp = &labels[h & LHMASK];
|
||||
for (lh = *lhp; lh != NULL; lh = lh->lh_next)
|
||||
if (lh->lh_hash == h && strcmp(cp->t, lh->lh_cmd->t) == 0)
|
||||
err(COMPILE2, "duplicate label '%s'", cp->t);
|
||||
lh = xmalloc(sizeof *lh);
|
||||
lh->lh_next = *lhp;
|
||||
lh->lh_hash = h;
|
||||
lh->lh_cmd = cp;
|
||||
lh->lh_ref = 0;
|
||||
*lhp = lh;
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the label contained in the command l in the command linked
|
||||
* list cp. L is excluded from the search. Return NULL if not found.
|
||||
*/
|
||||
static struct s_command *
|
||||
findlabel(char *name)
|
||||
{
|
||||
struct labhash *lh;
|
||||
u_char *p;
|
||||
u_int h, c;
|
||||
|
||||
for (h = 0, p = (u_char *)name; (c = *p) != 0; p++)
|
||||
h = (h << 5) + h + c;
|
||||
for (lh = labels[h & LHMASK]; lh != NULL; lh = lh->lh_next) {
|
||||
if (lh->lh_hash == h && strcmp(name, lh->lh_cmd->t) == 0) {
|
||||
lh->lh_ref = 1;
|
||||
return (lh->lh_cmd);
|
||||
}
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Warn about any unused labels. As a side effect, release the label hash
|
||||
* table space.
|
||||
*/
|
||||
static void
|
||||
uselabel(void)
|
||||
{
|
||||
struct labhash *lh, *next;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < LHSZ; i++) {
|
||||
for (lh = labels[i]; lh != NULL; lh = next) {
|
||||
next = lh->lh_next;
|
||||
if (!lh->lh_ref)
|
||||
err(WARNING, "unused label '%s'",
|
||||
lh->lh_cmd->t);
|
||||
free(lh);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,181 +0,0 @@
|
|||
/* $NetBSD: defs.h,v 1.9 2004/11/20 06:40:42 grant Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*
|
||||
* from: @(#)defs.h 8.1 (Berkeley) 6/6/93
|
||||
* $NetBSD: defs.h,v 1.9 2004/11/20 06:40:42 grant Exp $
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*
|
||||
* from: @(#)defs.h 8.1 (Berkeley) 6/6/93
|
||||
* $NetBSD: defs.h,v 1.9 2004/11/20 06:40:42 grant Exp $
|
||||
*/
|
||||
|
||||
/*
|
||||
* Types of address specifications
|
||||
*/
|
||||
enum e_atype {
|
||||
AT_RE, /* Line that match RE */
|
||||
AT_LINE, /* Specific line */
|
||||
AT_LAST /* Last line */
|
||||
};
|
||||
|
||||
/*
|
||||
* Format of an address
|
||||
*/
|
||||
struct s_addr {
|
||||
enum e_atype type; /* Address type */
|
||||
union {
|
||||
u_long l; /* Line number */
|
||||
regex_t *r; /* Regular expression */
|
||||
} u;
|
||||
};
|
||||
|
||||
/*
|
||||
* Substitution command
|
||||
*/
|
||||
struct s_subst {
|
||||
int n; /* Occurrence to subst. */
|
||||
int p; /* True if p flag */
|
||||
char *wfile; /* NULL if no wfile */
|
||||
int wfd; /* Cached file descriptor */
|
||||
regex_t *re; /* Regular expression */
|
||||
int maxbref; /* Largest backreference. */
|
||||
u_long linenum; /* Line number. */
|
||||
char *new; /* Replacement text */
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* An internally compiled command.
|
||||
* Initialy, label references are stored in t, on a second pass they
|
||||
* are updated to pointers.
|
||||
*/
|
||||
struct s_command {
|
||||
struct s_command *next; /* Pointer to next command */
|
||||
struct s_addr *a1, *a2; /* Start and end address */
|
||||
char *t; /* Text for : a c i r w */
|
||||
union {
|
||||
struct s_command *c; /* Command(s) for b t { */
|
||||
struct s_subst *s; /* Substitute command */
|
||||
u_char *y; /* Replace command array */
|
||||
int fd; /* File descriptor for w */
|
||||
} u;
|
||||
char code; /* Command code */
|
||||
u_int nonsel:1; /* True if ! */
|
||||
u_int inrange:1; /* True if in range */
|
||||
};
|
||||
|
||||
/*
|
||||
* Types of command arguments recognised by the parser
|
||||
*/
|
||||
enum e_args {
|
||||
EMPTY, /* d D g G h H l n N p P q x = \0 */
|
||||
TEXT, /* a c i */
|
||||
NONSEL, /* ! */
|
||||
GROUP, /* { */
|
||||
ENDGROUP, /* } */
|
||||
COMMENT, /* # */
|
||||
BRANCH, /* b t */
|
||||
LABEL, /* : */
|
||||
RFILE, /* r */
|
||||
WFILE, /* w */
|
||||
SUBST, /* s */
|
||||
TR /* y */
|
||||
};
|
||||
|
||||
/*
|
||||
* Structure containing things to append before a line is read
|
||||
*/
|
||||
struct s_appends {
|
||||
enum {AP_STRING, AP_FILE} type;
|
||||
char *s;
|
||||
size_t len;
|
||||
};
|
||||
|
||||
enum e_spflag {
|
||||
APPEND, /* Append to the contents. */
|
||||
REPLACE /* Replace the contents. */
|
||||
};
|
||||
|
||||
/*
|
||||
* Structure for a space (process, hold, otherwise).
|
||||
*/
|
||||
typedef struct {
|
||||
char *space; /* Current space pointer. */
|
||||
size_t len; /* Current length. */
|
||||
int deleted; /* If deleted. */
|
||||
char *back; /* Backing memory. */
|
||||
size_t blen; /* Backing memory length. */
|
||||
} SPACE;
|
||||
|
||||
/*
|
||||
* Error severity codes:
|
||||
*/
|
||||
#define FATAL 0 /* Exit immediately with 1 */
|
||||
#define ERROR 1 /* Continue, but change exit value */
|
||||
#define WARNING 2 /* Just print the warning */
|
||||
#define COMPILE 3 /* Print error, count and finish script */
|
||||
#define COMPILE2 3 /* Print error, count and finish script */
|
||||
|
|
@ -1,97 +0,0 @@
|
|||
/* $NetBSD: extern.h,v 1.9 2003/08/07 11:15:49 agc Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*
|
||||
* from: @(#)extern.h 8.1 (Berkeley) 6/6/93
|
||||
* $NetBSD: extern.h,v 1.9 2003/08/07 11:15:49 agc Exp $
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*
|
||||
* from: @(#)extern.h 8.1 (Berkeley) 6/6/93
|
||||
* $NetBSD: extern.h,v 1.9 2003/08/07 11:15:49 agc Exp $
|
||||
*/
|
||||
|
||||
extern struct s_command *prog;
|
||||
extern struct s_appends *appends;
|
||||
extern regmatch_t *match;
|
||||
extern size_t maxnsub;
|
||||
extern u_long linenum;
|
||||
extern int appendnum;
|
||||
extern int lastline;
|
||||
extern int aflag, eflag, nflag;
|
||||
extern int ere;
|
||||
extern char *fname;
|
||||
|
||||
void cfclose(struct s_command *, struct s_command *);
|
||||
void compile(void);
|
||||
void cspace(SPACE *, char *, size_t, enum e_spflag);
|
||||
char *cu_fgets(char *, int);
|
||||
void err(int, const char *, ...)
|
||||
__attribute__((__format__(__printf__, 2, 3)));
|
||||
int mf_fgets(SPACE *, enum e_spflag);
|
||||
void process(void);
|
||||
char *strregerror(int, regex_t *);
|
||||
void *xmalloc(u_int);
|
||||
void *xrealloc(void *, u_int);
|
||||
|
|
@ -1,379 +0,0 @@
|
|||
/* $NetBSD: main.c,v 1.19 2008/09/16 13:32:04 perry Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
#if HAVE_NBTOOL_CONFIG_H
|
||||
#include "nbtool_config.h"
|
||||
#endif
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <regex.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "defs.h"
|
||||
#include "extern.h"
|
||||
|
||||
/*
|
||||
* Linked list of units (strings and files) to be compiled
|
||||
*/
|
||||
struct s_compunit {
|
||||
struct s_compunit *next;
|
||||
enum e_cut {CU_FILE, CU_STRING} type;
|
||||
char *s; /* Pointer to string or fname */
|
||||
};
|
||||
|
||||
/*
|
||||
* Linked list pointer to compilation units and pointer to current
|
||||
* next pointer.
|
||||
*/
|
||||
static struct s_compunit *script, **cu_nextp = &script;
|
||||
|
||||
/*
|
||||
* Linked list of files to be processed
|
||||
*/
|
||||
struct s_flist {
|
||||
char *fname;
|
||||
struct s_flist *next;
|
||||
};
|
||||
|
||||
/*
|
||||
* Linked list pointer to files and pointer to current
|
||||
* next pointer.
|
||||
*/
|
||||
static struct s_flist *files, **fl_nextp = &files;
|
||||
|
||||
int aflag, eflag, nflag, ere;
|
||||
|
||||
/*
|
||||
* Current file and line number; line numbers restart across compilation
|
||||
* units, but span across input files.
|
||||
*/
|
||||
char *fname; /* File name. */
|
||||
u_long linenum;
|
||||
int lastline; /* TRUE on the last line of the last file */
|
||||
|
||||
static void add_compunit(enum e_cut, char *);
|
||||
static void add_file(char *);
|
||||
int main(int, char **);
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
int c, fflag;
|
||||
|
||||
fflag = 0;
|
||||
while ((c = getopt(argc, argv, "ae:f:nrE")) != -1)
|
||||
switch (c) {
|
||||
case 'a':
|
||||
aflag = 1;
|
||||
break;
|
||||
case 'e':
|
||||
eflag = 1;
|
||||
add_compunit(CU_STRING, optarg);
|
||||
break;
|
||||
case 'f':
|
||||
fflag = 1;
|
||||
add_compunit(CU_FILE, optarg);
|
||||
break;
|
||||
case 'n':
|
||||
nflag = 1;
|
||||
break;
|
||||
case 'r':
|
||||
case 'E':
|
||||
ere = REG_EXTENDED;
|
||||
break;
|
||||
default:
|
||||
case '?':
|
||||
(void)fprintf(stderr,
|
||||
"usage:\t%s [-aEnr] script [file ...]\n\t%s [-aEnr] [-e script] ... [-f script_file] ... [file ...]\n",
|
||||
getprogname(), getprogname());
|
||||
exit(1);
|
||||
}
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
|
||||
/* First usage case; script is the first arg */
|
||||
if (!eflag && !fflag && *argv) {
|
||||
add_compunit(CU_STRING, *argv);
|
||||
argv++;
|
||||
}
|
||||
|
||||
compile();
|
||||
|
||||
/* Continue with first and start second usage */
|
||||
if (*argv)
|
||||
for (; *argv; argv++)
|
||||
add_file(*argv);
|
||||
else
|
||||
add_file(NULL);
|
||||
process();
|
||||
cfclose(prog, NULL);
|
||||
if (fclose(stdout))
|
||||
err(FATAL, "stdout: %s", strerror(errno));
|
||||
exit (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Like fgets, but go through the chain of compilation units chaining them
|
||||
* together. Empty strings and files are ignored.
|
||||
*/
|
||||
char *
|
||||
cu_fgets(char *buf, int n)
|
||||
{
|
||||
static enum {ST_EOF, ST_FILE, ST_STRING} state = ST_EOF;
|
||||
static FILE *f; /* Current open file */
|
||||
static char *s; /* Current pointer inside string */
|
||||
static char string_ident[30];
|
||||
char *p;
|
||||
|
||||
again:
|
||||
switch (state) {
|
||||
case ST_EOF:
|
||||
if (script == NULL)
|
||||
return (NULL);
|
||||
linenum = 0;
|
||||
switch (script->type) {
|
||||
case CU_FILE:
|
||||
if ((f = fopen(script->s, "r")) == NULL)
|
||||
err(FATAL,
|
||||
"%s: %s", script->s, strerror(errno));
|
||||
fname = script->s;
|
||||
state = ST_FILE;
|
||||
goto again;
|
||||
case CU_STRING:
|
||||
if ((snprintf(string_ident,
|
||||
sizeof(string_ident), "\"%s\"", script->s)) >=
|
||||
sizeof(string_ident) - 1)
|
||||
(void)strcpy(string_ident +
|
||||
sizeof(string_ident) - 6, " ...\"");
|
||||
fname = string_ident;
|
||||
s = script->s;
|
||||
state = ST_STRING;
|
||||
goto again;
|
||||
}
|
||||
case ST_FILE:
|
||||
if ((p = fgets(buf, n, f)) != NULL) {
|
||||
linenum++;
|
||||
if (linenum == 1 && buf[0] == '#' && buf[1] == 'n')
|
||||
nflag = 1;
|
||||
return (p);
|
||||
}
|
||||
script = script->next;
|
||||
(void)fclose(f);
|
||||
state = ST_EOF;
|
||||
goto again;
|
||||
case ST_STRING:
|
||||
if (linenum == 0 && s[0] == '#' && s[1] == 'n')
|
||||
nflag = 1;
|
||||
p = buf;
|
||||
for (;;) {
|
||||
if (n-- <= 1) {
|
||||
*p = '\0';
|
||||
linenum++;
|
||||
return (buf);
|
||||
}
|
||||
switch (*s) {
|
||||
case '\0':
|
||||
state = ST_EOF;
|
||||
if (s == script->s) {
|
||||
script = script->next;
|
||||
goto again;
|
||||
} else {
|
||||
script = script->next;
|
||||
*p = '\0';
|
||||
linenum++;
|
||||
return (buf);
|
||||
}
|
||||
case '\n':
|
||||
*p++ = '\n';
|
||||
*p = '\0';
|
||||
s++;
|
||||
linenum++;
|
||||
return (buf);
|
||||
default:
|
||||
*p++ = *s++;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* NOTREACHED */
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Like fgets, but go through the list of files chaining them together.
|
||||
* Set len to the length of the line.
|
||||
*/
|
||||
int
|
||||
mf_fgets(SPACE *sp, enum e_spflag spflag)
|
||||
{
|
||||
static FILE *f; /* Current open file */
|
||||
size_t len;
|
||||
char *p;
|
||||
int c;
|
||||
|
||||
if (f == NULL)
|
||||
/* Advance to first non-empty file */
|
||||
for (;;) {
|
||||
if (files == NULL) {
|
||||
lastline = 1;
|
||||
return (0);
|
||||
}
|
||||
if (files->fname == NULL) {
|
||||
f = stdin;
|
||||
fname = "stdin";
|
||||
} else {
|
||||
fname = files->fname;
|
||||
if ((f = fopen(fname, "r")) == NULL)
|
||||
err(FATAL, "%s: %s",
|
||||
fname, strerror(errno));
|
||||
}
|
||||
if ((c = getc(f)) != EOF) {
|
||||
(void)ungetc(c, f);
|
||||
break;
|
||||
}
|
||||
(void)fclose(f);
|
||||
files = files->next;
|
||||
}
|
||||
|
||||
if (lastline) {
|
||||
sp->len = 0;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Use fgetln so that we can handle essentially infinite input data.
|
||||
* Can't use the pointer into the stdio buffer as the process space
|
||||
* because the ungetc() can cause it to move.
|
||||
*/
|
||||
p = fgetln(f, &len);
|
||||
if (ferror(f))
|
||||
err(FATAL, "%s: %s", fname, strerror(errno ? errno : EIO));
|
||||
cspace(sp, p, len, spflag);
|
||||
|
||||
linenum++;
|
||||
/* Advance to next non-empty file */
|
||||
while ((c = getc(f)) == EOF) {
|
||||
(void)fclose(f);
|
||||
files = files->next;
|
||||
if (files == NULL) {
|
||||
lastline = 1;
|
||||
return (1);
|
||||
}
|
||||
if (files->fname == NULL) {
|
||||
f = stdin;
|
||||
fname = "stdin";
|
||||
} else {
|
||||
fname = files->fname;
|
||||
if ((f = fopen(fname, "r")) == NULL)
|
||||
err(FATAL, "%s: %s", fname, strerror(errno));
|
||||
}
|
||||
}
|
||||
(void)ungetc(c, f);
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Add a compilation unit to the linked list
|
||||
*/
|
||||
static void
|
||||
add_compunit(enum e_cut type, char *s)
|
||||
{
|
||||
struct s_compunit *cu;
|
||||
|
||||
cu = xmalloc(sizeof(struct s_compunit));
|
||||
cu->type = type;
|
||||
cu->s = s;
|
||||
cu->next = NULL;
|
||||
*cu_nextp = cu;
|
||||
cu_nextp = &cu->next;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add a file to the linked list
|
||||
*/
|
||||
static void
|
||||
add_file(char *s)
|
||||
{
|
||||
struct s_flist *fp;
|
||||
|
||||
fp = xmalloc(sizeof(struct s_flist));
|
||||
fp->next = NULL;
|
||||
*fl_nextp = fp;
|
||||
fp->fname = s;
|
||||
fl_nextp = &fp->next;
|
||||
}
|
||||
|
|
@ -1,156 +0,0 @@
|
|||
/* $NetBSD: misc.c,v 1.9 2006/06/18 05:16:41 gdamore Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
#if HAVE_NBTOOL_CONFIG_H
|
||||
#include "nbtool_config.h"
|
||||
#endif
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <regex.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "defs.h"
|
||||
#include "extern.h"
|
||||
|
||||
/*
|
||||
* malloc with result test
|
||||
*/
|
||||
void *
|
||||
xmalloc(u_int size)
|
||||
{
|
||||
void *p;
|
||||
|
||||
if ((p = malloc(size)) == NULL)
|
||||
err(FATAL, "%s", strerror(errno));
|
||||
return (p);
|
||||
}
|
||||
|
||||
/*
|
||||
* realloc with result test
|
||||
*/
|
||||
void *
|
||||
xrealloc(void *p, u_int size)
|
||||
{
|
||||
if (p == NULL) /* Compatibility hack. */
|
||||
return (xmalloc(size));
|
||||
|
||||
if ((p = realloc(p, size)) == NULL)
|
||||
err(FATAL, "%s", strerror(errno));
|
||||
return (p);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return a string for a regular expression error passed. This is a overkill,
|
||||
* because of the silly semantics of regerror (we can never know the size of
|
||||
* the buffer).
|
||||
*/
|
||||
char *
|
||||
strregerror(int errcode, regex_t *preg)
|
||||
{
|
||||
static char *oe;
|
||||
size_t s;
|
||||
|
||||
if (oe != NULL)
|
||||
free(oe);
|
||||
s = regerror(errcode, preg, "", 0);
|
||||
oe = xmalloc(s);
|
||||
(void)regerror(errcode, preg, oe, s);
|
||||
return (oe);
|
||||
}
|
||||
|
||||
/*
|
||||
* Error reporting function
|
||||
*/
|
||||
void
|
||||
err(int severity, const char *fmt, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
(void)fprintf(stderr, "sed: ");
|
||||
switch (severity) {
|
||||
case WARNING:
|
||||
case COMPILE:
|
||||
(void)fprintf(stderr, "%lu: %s: ", linenum, fname);
|
||||
}
|
||||
(void)vfprintf(stderr, fmt, ap);
|
||||
va_end(ap);
|
||||
(void)fprintf(stderr, "\n");
|
||||
if (severity == WARNING)
|
||||
return;
|
||||
exit(1);
|
||||
/* NOTREACHED */
|
||||
}
|
||||
|
|
@ -1,683 +0,0 @@
|
|||
/* $NetBSD: process.c,v 1.37 2006/06/18 05:16:41 gdamore Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992, 1993, 1994
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1992 Diomidis Spinellis.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis of Imperial College, University of London.
|
||||
*
|
||||
* 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.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* This product includes software developed by the University of
|
||||
* California, Berkeley and its contributors.
|
||||
* 4. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
*/
|
||||
|
||||
#if HAVE_NBTOOL_CONFIG_H
|
||||
#include "nbtool_config.h"
|
||||
#endif
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/uio.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <limits.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <termios.h>
|
||||
|
||||
#include "defs.h"
|
||||
#include "extern.h"
|
||||
|
||||
static SPACE HS, PS, SS;
|
||||
#define pd PS.deleted
|
||||
#define ps PS.space
|
||||
#define psl PS.len
|
||||
#define hs HS.space
|
||||
#define hsl HS.len
|
||||
|
||||
static __inline int applies(struct s_command *);
|
||||
static void flush_appends(void);
|
||||
static void lputs(char *);
|
||||
static __inline int regexec_e(regex_t *, const char *, int, int, size_t);
|
||||
static void regsub(SPACE *, char *, char *);
|
||||
static int substitute(struct s_command *);
|
||||
|
||||
struct s_appends *appends; /* Array of pointers to strings to append. */
|
||||
static int appendx; /* Index into appends array. */
|
||||
int appendnum; /* Size of appends array. */
|
||||
|
||||
static int lastaddr; /* Set by applies if last address of a range. */
|
||||
static int sdone; /* If any substitutes since last line input. */
|
||||
/* Iov structure for 'w' commands. */
|
||||
static regex_t *defpreg;
|
||||
size_t maxnsub;
|
||||
regmatch_t *match;
|
||||
|
||||
#define OUT(s) { fwrite(s, sizeof(u_char), psl, stdout); }
|
||||
|
||||
void
|
||||
process(void)
|
||||
{
|
||||
struct s_command *cp;
|
||||
SPACE tspace;
|
||||
size_t len, oldpsl;
|
||||
char *p;
|
||||
|
||||
oldpsl = 0;
|
||||
for (linenum = 0; mf_fgets(&PS, REPLACE);) {
|
||||
pd = 0;
|
||||
top:
|
||||
cp = prog;
|
||||
redirect:
|
||||
while (cp != NULL) {
|
||||
if (!applies(cp)) {
|
||||
cp = cp->next;
|
||||
continue;
|
||||
}
|
||||
switch (cp->code) {
|
||||
case '{':
|
||||
cp = cp->u.c;
|
||||
goto redirect;
|
||||
case 'a':
|
||||
if (appendx >= appendnum) {
|
||||
appends = xrealloc(appends,
|
||||
sizeof(struct s_appends) *
|
||||
(appendnum * 2));
|
||||
appendnum *= 2;
|
||||
}
|
||||
appends[appendx].type = AP_STRING;
|
||||
appends[appendx].s = cp->t;
|
||||
appends[appendx].len = strlen(cp->t);
|
||||
appendx++;
|
||||
break;
|
||||
case 'b':
|
||||
cp = cp->u.c;
|
||||
goto redirect;
|
||||
case 'c':
|
||||
pd = 1;
|
||||
psl = 0;
|
||||
if (cp->a2 == NULL || lastaddr)
|
||||
(void)printf("%s", cp->t);
|
||||
break;
|
||||
case 'd':
|
||||
pd = 1;
|
||||
goto new;
|
||||
case 'D':
|
||||
if (psl == 0)
|
||||
pd = 1;
|
||||
if (pd)
|
||||
goto new;
|
||||
if ((p = memchr(ps, '\n', psl - 1)) == NULL) {
|
||||
pd = 1;
|
||||
goto new;
|
||||
} else {
|
||||
psl -= (p + 1) - ps;
|
||||
memmove(ps, p + 1, psl);
|
||||
goto top;
|
||||
}
|
||||
case 'g':
|
||||
cspace(&PS, hs, hsl, REPLACE);
|
||||
break;
|
||||
case 'G':
|
||||
if (hs == NULL)
|
||||
cspace(&HS, "\n", 1, REPLACE);
|
||||
cspace(&PS, hs, hsl, 0);
|
||||
break;
|
||||
case 'h':
|
||||
cspace(&HS, ps, psl, REPLACE);
|
||||
break;
|
||||
case 'H':
|
||||
cspace(&HS, ps, psl, 0);
|
||||
break;
|
||||
case 'i':
|
||||
(void)printf("%s", cp->t);
|
||||
break;
|
||||
case 'l':
|
||||
lputs(ps);
|
||||
break;
|
||||
case 'n':
|
||||
if (!nflag && !pd)
|
||||
OUT(ps)
|
||||
flush_appends();
|
||||
if (!mf_fgets(&PS, REPLACE))
|
||||
exit(0);
|
||||
pd = 0;
|
||||
break;
|
||||
case 'N':
|
||||
flush_appends();
|
||||
if (!mf_fgets(&PS, 0)) {
|
||||
if (!nflag && !pd)
|
||||
OUT(ps)
|
||||
exit(0);
|
||||
}
|
||||
break;
|
||||
case 'p':
|
||||
if (pd)
|
||||
break;
|
||||
OUT(ps)
|
||||
break;
|
||||
case 'P':
|
||||
if (pd)
|
||||
break;
|
||||
if ((p = memchr(ps, '\n', psl - 1)) != NULL) {
|
||||
oldpsl = psl;
|
||||
psl = (p + 1) - ps;
|
||||
}
|
||||
OUT(ps)
|
||||
if (p != NULL)
|
||||
psl = oldpsl;
|
||||
break;
|
||||
case 'q':
|
||||
if (!nflag && !pd)
|
||||
OUT(ps)
|
||||
flush_appends();
|
||||
exit(0);
|
||||
case 'r':
|
||||
if (appendx >= appendnum) {
|
||||
appends = xrealloc(appends,
|
||||
sizeof(struct s_appends) *
|
||||
(appendnum * 2));
|
||||
appendnum *= 2;
|
||||
}
|
||||
appends[appendx].type = AP_FILE;
|
||||
appends[appendx].s = cp->t;
|
||||
appends[appendx].len = strlen(cp->t);
|
||||
appendx++;
|
||||
break;
|
||||
case 's':
|
||||
sdone |= substitute(cp);
|
||||
break;
|
||||
case 't':
|
||||
if (sdone) {
|
||||
sdone = 0;
|
||||
cp = cp->u.c;
|
||||
goto redirect;
|
||||
}
|
||||
break;
|
||||
case 'w':
|
||||
if (pd)
|
||||
break;
|
||||
if (cp->u.fd == -1 && (cp->u.fd = open(cp->t,
|
||||
O_WRONLY|O_APPEND|O_CREAT|O_TRUNC,
|
||||
DEFFILEMODE)) == -1)
|
||||
err(FATAL, "%s: %s",
|
||||
cp->t, strerror(errno));
|
||||
if (write(cp->u.fd, ps, psl) != psl)
|
||||
err(FATAL, "%s: %s",
|
||||
cp->t, strerror(errno));
|
||||
break;
|
||||
case 'x':
|
||||
if (hs == NULL)
|
||||
cspace(&HS, "\n", 1, REPLACE);
|
||||
tspace = PS;
|
||||
PS = HS;
|
||||
HS = tspace;
|
||||
break;
|
||||
case 'y':
|
||||
if (pd)
|
||||
break;
|
||||
for (p = ps, len = psl; --len; ++p)
|
||||
*p = cp->u.y[(int)*p];
|
||||
break;
|
||||
case ':':
|
||||
case '}':
|
||||
break;
|
||||
case '=':
|
||||
(void)printf("%lu\n", linenum);
|
||||
}
|
||||
cp = cp->next;
|
||||
} /* for all cp */
|
||||
|
||||
new: if (!nflag && !pd)
|
||||
OUT(ps)
|
||||
flush_appends();
|
||||
} /* for all lines */
|
||||
}
|
||||
|
||||
/*
|
||||
* TRUE if the address passed matches the current program state
|
||||
* (lastline, linenumber, ps).
|
||||
*/
|
||||
#define MATCH(a) \
|
||||
(a)->type == AT_RE ? regexec_e((a)->u.r, ps, 0, 1, psl) : \
|
||||
(a)->type == AT_LINE ? linenum == (a)->u.l : lastline
|
||||
|
||||
/*
|
||||
* Return TRUE if the command applies to the current line. Sets the inrange
|
||||
* flag to process ranges. Interprets the non-select (``!'') flag.
|
||||
*/
|
||||
static __inline int
|
||||
applies(struct s_command *cp)
|
||||
{
|
||||
int r;
|
||||
|
||||
lastaddr = 0;
|
||||
if (cp->a1 == NULL && cp->a2 == NULL)
|
||||
r = 1;
|
||||
else if (cp->a2) {
|
||||
if (cp->inrange) {
|
||||
if (MATCH(cp->a2)) {
|
||||
cp->inrange = 0;
|
||||
lastaddr = 1;
|
||||
}
|
||||
r = 1;
|
||||
} else if (cp->a1 && MATCH(cp->a1)) {
|
||||
/*
|
||||
* If the second address is a number less than or
|
||||
* equal to the line number first selected, only
|
||||
* one line shall be selected.
|
||||
* -- POSIX 1003.2
|
||||
*/
|
||||
if (cp->a2->type == AT_LINE &&
|
||||
linenum >= cp->a2->u.l)
|
||||
lastaddr = 1;
|
||||
else
|
||||
cp->inrange = 1;
|
||||
r = 1;
|
||||
} else
|
||||
r = 0;
|
||||
} else
|
||||
r = MATCH(cp->a1);
|
||||
return (cp->nonsel ? ! r : r);
|
||||
}
|
||||
|
||||
/*
|
||||
* substitute --
|
||||
* Do substitutions in the pattern space. Currently, we build a
|
||||
* copy of the new pattern space in the substitute space structure
|
||||
* and then swap them.
|
||||
*/
|
||||
static int
|
||||
substitute(struct s_command *cp)
|
||||
{
|
||||
SPACE tspace;
|
||||
regex_t *re;
|
||||
size_t re_off, slen;
|
||||
int lastempty, n;
|
||||
char *s;
|
||||
|
||||
s = ps;
|
||||
re = cp->u.s->re;
|
||||
if (re == NULL) {
|
||||
if (defpreg != NULL && cp->u.s->maxbref > defpreg->re_nsub) {
|
||||
linenum = cp->u.s->linenum;
|
||||
err(COMPILE, "\\%d not defined in the RE",
|
||||
cp->u.s->maxbref);
|
||||
}
|
||||
}
|
||||
if (!regexec_e(re, s, 0, 0, psl))
|
||||
return (0);
|
||||
|
||||
SS.len = 0; /* Clean substitute space. */
|
||||
slen = psl;
|
||||
n = cp->u.s->n;
|
||||
lastempty = 1;
|
||||
|
||||
switch (n) {
|
||||
case 0: /* Global */
|
||||
do {
|
||||
if (lastempty || match[0].rm_so != match[0].rm_eo) {
|
||||
/* Locate start of replaced string. */
|
||||
re_off = match[0].rm_so;
|
||||
/* Copy leading retained string. */
|
||||
cspace(&SS, s, re_off, APPEND);
|
||||
/* Add in regular expression. */
|
||||
regsub(&SS, s, cp->u.s->new);
|
||||
}
|
||||
|
||||
/* Move past this match. */
|
||||
if (match[0].rm_so != match[0].rm_eo) {
|
||||
s += match[0].rm_eo;
|
||||
slen -= match[0].rm_eo;
|
||||
lastempty = 0;
|
||||
} else {
|
||||
if (match[0].rm_so == 0)
|
||||
cspace(&SS,
|
||||
s, match[0].rm_so + 1, APPEND);
|
||||
else
|
||||
cspace(&SS,
|
||||
s + match[0].rm_so, 1, APPEND);
|
||||
s += match[0].rm_so + 1;
|
||||
slen -= match[0].rm_so + 1;
|
||||
lastempty = 1;
|
||||
}
|
||||
} while (slen > 0 && regexec_e(re, s, REG_NOTBOL, 0, slen));
|
||||
/* Copy trailing retained string. */
|
||||
if (slen > 0)
|
||||
cspace(&SS, s, slen, APPEND);
|
||||
break;
|
||||
default: /* Nth occurrence */
|
||||
while (--n) {
|
||||
s += match[0].rm_eo;
|
||||
slen -= match[0].rm_eo;
|
||||
if (!regexec_e(re, s, REG_NOTBOL, 0, slen))
|
||||
return (0);
|
||||
}
|
||||
/* FALLTHROUGH */
|
||||
case 1: /* 1st occurrence */
|
||||
/* Locate start of replaced string. */
|
||||
re_off = match[0].rm_so + (s - ps);
|
||||
/* Copy leading retained string. */
|
||||
cspace(&SS, ps, re_off, APPEND);
|
||||
/* Add in regular expression. */
|
||||
regsub(&SS, s, cp->u.s->new);
|
||||
/* Copy trailing retained string. */
|
||||
s += match[0].rm_eo;
|
||||
slen -= match[0].rm_eo;
|
||||
cspace(&SS, s, slen, APPEND);
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Swap the substitute space and the pattern space, and make sure
|
||||
* that any leftover pointers into stdio memory get lost.
|
||||
*/
|
||||
tspace = PS;
|
||||
PS = SS;
|
||||
SS = tspace;
|
||||
SS.space = SS.back;
|
||||
|
||||
/* Handle the 'p' flag. */
|
||||
if (cp->u.s->p)
|
||||
OUT(ps)
|
||||
|
||||
/* Handle the 'w' flag. */
|
||||
if (cp->u.s->wfile && !pd) {
|
||||
if (cp->u.s->wfd == -1 && (cp->u.s->wfd = open(cp->u.s->wfile,
|
||||
O_WRONLY|O_APPEND|O_CREAT|O_TRUNC, DEFFILEMODE)) == -1)
|
||||
err(FATAL, "%s: %s", cp->u.s->wfile, strerror(errno));
|
||||
if (write(cp->u.s->wfd, ps, psl) != psl)
|
||||
err(FATAL, "%s: %s", cp->u.s->wfile, strerror(errno));
|
||||
}
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Flush append requests. Always called before reading a line,
|
||||
* therefore it also resets the substitution done (sdone) flag.
|
||||
*/
|
||||
static void
|
||||
flush_appends(void)
|
||||
{
|
||||
FILE *f;
|
||||
int count, i;
|
||||
char buf[8 * 1024];
|
||||
|
||||
for (i = 0; i < appendx; i++)
|
||||
switch (appends[i].type) {
|
||||
case AP_STRING:
|
||||
fwrite(appends[i].s, sizeof(char), appends[i].len,
|
||||
stdout);
|
||||
break;
|
||||
case AP_FILE:
|
||||
/*
|
||||
* Read files probably shouldn't be cached. Since
|
||||
* it's not an error to read a non-existent file,
|
||||
* it's possible that another program is interacting
|
||||
* with the sed script through the file system. It
|
||||
* would be truly bizarre, but possible. It's probably
|
||||
* not that big a performance win, anyhow.
|
||||
*/
|
||||
if ((f = fopen(appends[i].s, "r")) == NULL)
|
||||
break;
|
||||
while ((count =
|
||||
fread(buf, sizeof(char), sizeof(buf), f)) > 0)
|
||||
(void)fwrite(buf, sizeof(char), count, stdout);
|
||||
(void)fclose(f);
|
||||
break;
|
||||
}
|
||||
if (ferror(stdout))
|
||||
err(FATAL, "stdout: %s", strerror(errno ? errno : EIO));
|
||||
appendx = sdone = 0;
|
||||
}
|
||||
|
||||
static void
|
||||
lputs(char *s)
|
||||
{
|
||||
int count;
|
||||
char *escapes, *p;
|
||||
#ifndef HAVE_NBTOOL_CONFIG_H
|
||||
struct winsize win;
|
||||
#endif
|
||||
static int termwidth = -1;
|
||||
|
||||
if (termwidth == -1) {
|
||||
if ((p = getenv("COLUMNS")) != NULL)
|
||||
termwidth = atoi(p);
|
||||
#ifndef HAVE_NBTOOL_CONFIG_H
|
||||
else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
|
||||
win.ws_col > 0)
|
||||
termwidth = win.ws_col;
|
||||
#endif
|
||||
else
|
||||
termwidth = 60;
|
||||
}
|
||||
for (count = 0; *s; ++s) {
|
||||
if (count >= termwidth) {
|
||||
(void)printf("\\\n");
|
||||
count = 0;
|
||||
}
|
||||
if (isascii((unsigned char)*s) && isprint((unsigned char)*s) &&
|
||||
*s != '\\') {
|
||||
(void)putchar(*s);
|
||||
count++;
|
||||
} else {
|
||||
escapes = "\\\a\b\f\n\r\t\v";
|
||||
(void)putchar('\\');
|
||||
if ((p = strchr(escapes, *s)) != NULL) {
|
||||
(void)putchar("\\abfnrtv"[p - escapes]);
|
||||
count += 2;
|
||||
} else {
|
||||
(void)printf("%03o", *(u_char *)s);
|
||||
count += 4;
|
||||
}
|
||||
}
|
||||
}
|
||||
(void)putchar('$');
|
||||
(void)putchar('\n');
|
||||
if (ferror(stdout))
|
||||
err(FATAL, "stdout: %s", strerror(errno ? errno : EIO));
|
||||
}
|
||||
|
||||
static __inline int
|
||||
regexec_e(regex_t *preg, const char *string, int eflags, int nomatch, size_t slen)
|
||||
{
|
||||
int eval;
|
||||
#ifndef REG_STARTEND
|
||||
char *buf;
|
||||
#endif
|
||||
|
||||
if (preg == NULL) {
|
||||
if (defpreg == NULL)
|
||||
err(FATAL, "first RE may not be empty");
|
||||
} else
|
||||
defpreg = preg;
|
||||
|
||||
/* Set anchors, discounting trailing newline (if any). */
|
||||
if (slen > 0 && string[slen - 1] == '\n')
|
||||
slen--;
|
||||
|
||||
#ifndef REG_STARTEND
|
||||
if ((buf = malloc(slen + 1)) == NULL)
|
||||
err(1, NULL);
|
||||
(void)memcpy(buf, string, slen);
|
||||
buf[slen] = '\0';
|
||||
eval = regexec(defpreg, buf,
|
||||
nomatch ? 0 : maxnsub + 1, match, eflags);
|
||||
free(buf);
|
||||
#else
|
||||
match[0].rm_so = 0;
|
||||
match[0].rm_eo = slen;
|
||||
eval = regexec(defpreg, string,
|
||||
nomatch ? 0 : maxnsub + 1, match, eflags | REG_STARTEND);
|
||||
#endif
|
||||
switch(eval) {
|
||||
case 0:
|
||||
return (1);
|
||||
case REG_NOMATCH:
|
||||
return (0);
|
||||
}
|
||||
err(FATAL, "RE error: %s", strregerror(eval, defpreg));
|
||||
/* NOTREACHED */
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* regsub - perform substitutions after a regexp match
|
||||
* Based on a routine by Henry Spencer
|
||||
*/
|
||||
static void
|
||||
regsub(SPACE *sp, char *string, char *src)
|
||||
{
|
||||
int len, no;
|
||||
char c, *dst;
|
||||
|
||||
#define NEEDSP(reqlen) \
|
||||
if (sp->len + (reqlen) + 1 >= sp->blen) { \
|
||||
size_t newlen = sp->blen + (reqlen) + 1024; \
|
||||
sp->space = sp->back = xrealloc(sp->back, newlen); \
|
||||
sp->blen = newlen; \
|
||||
dst = sp->space + sp->len; \
|
||||
}
|
||||
|
||||
dst = sp->space + sp->len;
|
||||
while ((c = *src++) != '\0') {
|
||||
if (c == '&')
|
||||
no = 0;
|
||||
else if (c == '\\' && isdigit((unsigned char)*src))
|
||||
no = *src++ - '0';
|
||||
else
|
||||
no = -1;
|
||||
if (no < 0) { /* Ordinary character. */
|
||||
if (c == '\\' && (*src == '\\' || *src == '&'))
|
||||
c = *src++;
|
||||
NEEDSP(1);
|
||||
*dst++ = c;
|
||||
++sp->len;
|
||||
} else if (match[no].rm_so != -1 && match[no].rm_eo != -1) {
|
||||
len = match[no].rm_eo - match[no].rm_so;
|
||||
NEEDSP(len);
|
||||
memmove(dst, string + match[no].rm_so, len);
|
||||
dst += len;
|
||||
sp->len += len;
|
||||
}
|
||||
}
|
||||
NEEDSP(1);
|
||||
*dst = '\0';
|
||||
}
|
||||
|
||||
/*
|
||||
* aspace --
|
||||
* Append the source space to the destination space, allocating new
|
||||
* space as necessary.
|
||||
*/
|
||||
void
|
||||
cspace(SPACE *sp, char *p, size_t len, enum e_spflag spflag)
|
||||
{
|
||||
size_t tlen;
|
||||
|
||||
/* Make sure SPACE has enough memory and ramp up quickly. */
|
||||
tlen = sp->len + len + 1;
|
||||
if (tlen > sp->blen) {
|
||||
size_t newlen = tlen + 1024;
|
||||
sp->space = sp->back = xrealloc(sp->back, newlen);
|
||||
sp->blen = newlen;
|
||||
}
|
||||
|
||||
if (spflag == REPLACE)
|
||||
sp->len = 0;
|
||||
|
||||
memmove(sp->space + sp->len, p, len);
|
||||
|
||||
sp->space[sp->len += len] = '\0';
|
||||
}
|
||||
|
||||
/*
|
||||
* Close all cached opened files and report any errors
|
||||
*/
|
||||
void
|
||||
cfclose(struct s_command *cp, struct s_command *end)
|
||||
{
|
||||
|
||||
for (; cp != end; cp = cp->next)
|
||||
switch(cp->code) {
|
||||
case 's':
|
||||
if (cp->u.s->wfd != -1 && close(cp->u.s->wfd))
|
||||
err(FATAL,
|
||||
"%s: %s", cp->u.s->wfile, strerror(errno));
|
||||
cp->u.s->wfd = -1;
|
||||
break;
|
||||
case 'w':
|
||||
if (cp->u.fd != -1 && close(cp->u.fd))
|
||||
err(FATAL, "%s: %s", cp->t, strerror(errno));
|
||||
cp->u.fd = -1;
|
||||
break;
|
||||
case '{':
|
||||
cfclose(cp->u.c, cp->next);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1,518 +0,0 @@
|
|||
.\" $NetBSD: sed.1,v 1.27 2008/09/21 16:46:01 wiz Exp $
|
||||
.\"
|
||||
.\" Copyright (c) 1992, 1993
|
||||
.\" The Regents of the University of California. All rights reserved.
|
||||
.\"
|
||||
.\" This code is derived from software contributed to Berkeley by
|
||||
.\" the Institute of Electrical and Electronics Engineers, Inc.
|
||||
.\"
|
||||
.\" 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.
|
||||
.\" 3. Neither the name of the University nor the names of its contributors
|
||||
.\" may be used to endorse or promote products derived from this software
|
||||
.\" without specific prior written permission.
|
||||
.\"
|
||||
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
|
||||
.\"
|
||||
.\" @(#)sed.1 8.2 (Berkeley) 12/30/93
|
||||
.\"
|
||||
.Dd September 21, 2008
|
||||
.Dt SED 1
|
||||
.Os
|
||||
.Sh NAME
|
||||
.Nm sed
|
||||
.Nd stream editor
|
||||
.Sh SYNOPSIS
|
||||
.Nm
|
||||
.Op Fl aEnr
|
||||
.Ar command
|
||||
.Op Ar file ...
|
||||
.Nm
|
||||
.Op Fl aEnr
|
||||
.Op Fl e Ar command
|
||||
.Op Fl f Ar command_file
|
||||
.Op Ar file ...
|
||||
.Sh DESCRIPTION
|
||||
The
|
||||
.Nm
|
||||
utility reads the specified files, or the standard input if no files
|
||||
are specified, modifying the input as specified by a list of commands.
|
||||
The input is then written to the standard output.
|
||||
.Pp
|
||||
A single command may be specified as the first argument to
|
||||
.Nm .
|
||||
Multiple commands may be specified by using the
|
||||
.Fl e
|
||||
or
|
||||
.Fl f
|
||||
options.
|
||||
All commands are applied to the input in the order they are specified
|
||||
regardless of their origin.
|
||||
.Pp
|
||||
The following options are available:
|
||||
.Bl -tag -width indent
|
||||
.It Fl a
|
||||
The files listed as parameters for the
|
||||
.Dq w
|
||||
functions are created (or truncated) before any processing begins,
|
||||
by default.
|
||||
The
|
||||
.Fl a
|
||||
option causes
|
||||
.Nm
|
||||
to delay opening each file until a command containing the related
|
||||
.Dq w
|
||||
function is applied to a line of input.
|
||||
.It Fl E
|
||||
Enables the use of extended regular expressions instead of the
|
||||
usual basic regular expression syntax.
|
||||
.It Fl e Ar command
|
||||
Append the editing commands specified by the
|
||||
.Ar command
|
||||
argument
|
||||
to the list of commands.
|
||||
.It Fl f Ar command_file
|
||||
Append the editing commands found in the file
|
||||
.Ar command_file
|
||||
to the list of commands.
|
||||
The editing commands should each be listed on a separate line.
|
||||
.It Fl n
|
||||
By default, each line of input is echoed to the standard output after
|
||||
all of the commands have been applied to it.
|
||||
The
|
||||
.Fl n
|
||||
option suppresses this behavior.
|
||||
.It Fl r
|
||||
Identical to
|
||||
.Fl E ,
|
||||
present for compatibility with GNU sed.
|
||||
.El
|
||||
.Pp
|
||||
The form of a
|
||||
.Nm
|
||||
command is as follows:
|
||||
.sp
|
||||
.Dl [address[,address]]function[arguments]
|
||||
.sp
|
||||
Whitespace may be inserted before the first address and the function
|
||||
portions of the command.
|
||||
.Pp
|
||||
Normally,
|
||||
.Nm
|
||||
cyclically copies a line of input, not including its terminating newline
|
||||
character, into a
|
||||
.Em "pattern space" ,
|
||||
(unless there is something left after a
|
||||
.Dq D
|
||||
function),
|
||||
applies all of the commands with addresses that select that pattern space,
|
||||
copies the pattern space to the standard output, appending a newline, and
|
||||
deletes the pattern space.
|
||||
.Pp
|
||||
Some of the functions use a
|
||||
.Em "hold space"
|
||||
to save all or part of the pattern space for subsequent retrieval.
|
||||
.Sh SED ADDRESSES
|
||||
An address is not required, but if specified must be a number (that counts
|
||||
input lines
|
||||
cumulatively across input files), a dollar
|
||||
.Po
|
||||
.Dq $
|
||||
.Pc
|
||||
character that addresses the last line of input, or a context address
|
||||
(which consists of a regular expression preceded and followed by a
|
||||
delimiter).
|
||||
.Pp
|
||||
A command line with no addresses selects every pattern space.
|
||||
.Pp
|
||||
A command line with one address selects all of the pattern spaces
|
||||
that match the address.
|
||||
.Pp
|
||||
A command line with two addresses selects the inclusive range from
|
||||
the first pattern space that matches the first address through the next
|
||||
pattern space that matches the second.
|
||||
(If the second address is a number less than or equal to the line number
|
||||
first selected, only that line is selected.)
|
||||
Starting at the first line following the selected range,
|
||||
.Nm
|
||||
starts looking again for the first address.
|
||||
.Pp
|
||||
Editing commands can be applied to non-selected pattern spaces by use
|
||||
of the exclamation character
|
||||
.Pq Dq \&!
|
||||
function.
|
||||
.Sh SED REGULAR EXPRESSIONS
|
||||
The
|
||||
.Nm
|
||||
regular expressions are basic regular expressions (BRE's, see
|
||||
.Xr re_format 7
|
||||
for more information).
|
||||
In addition,
|
||||
.Nm
|
||||
has the following two additions to BRE's:
|
||||
.sp
|
||||
.Bl -enum -compact
|
||||
.It
|
||||
In a context address, any character other than a backslash
|
||||
.Po
|
||||
.Dq \e
|
||||
.Pc
|
||||
or newline character may be used to delimit the regular expression
|
||||
by prefixing the first use of that delimiter with a backslash.
|
||||
Also, putting a backslash character before the delimiting character
|
||||
causes the character to be treated literally.
|
||||
For example, in the context address \exabc\exdefx, the RE delimiter
|
||||
is an
|
||||
.Dq x
|
||||
and the second
|
||||
.Dq x
|
||||
stands for itself, so that the regular expression is
|
||||
.Dq abcxdef .
|
||||
.sp
|
||||
.It
|
||||
The escape sequence \en matches a newline character embedded in the
|
||||
pattern space.
|
||||
You can't, however, use a literal newline character in an address or
|
||||
in the substitute command.
|
||||
.El
|
||||
.Pp
|
||||
One special feature of
|
||||
.Nm
|
||||
regular expressions is that they can default to the last regular
|
||||
expression used.
|
||||
If a regular expression is empty, i.e. just the delimiter characters
|
||||
are specified, the last regular expression encountered is used instead.
|
||||
The last regular expression is defined as the last regular expression
|
||||
used as part of an address or substitute command, and at run-time, not
|
||||
compile-time.
|
||||
For example, the command
|
||||
.Dq /abc/s//XXX/
|
||||
will substitute
|
||||
.Dq XXX
|
||||
for the pattern
|
||||
.Dq abc .
|
||||
.Sh SED FUNCTIONS
|
||||
In the following list of commands, the maximum number of permissible
|
||||
addresses for each command is indicated by [0addr], [1addr], or [2addr],
|
||||
representing zero, one, or two addresses.
|
||||
.Pp
|
||||
The argument
|
||||
.Em text
|
||||
consists of one or more lines.
|
||||
To embed a newline in the text, precede it with a backslash.
|
||||
Other backslashes in text are deleted and the following character
|
||||
taken literally.
|
||||
.Pp
|
||||
The
|
||||
.Dq r
|
||||
and
|
||||
.Dq w
|
||||
functions take an optional file parameter, which should be separated
|
||||
from the function letter by white space.
|
||||
Each file given as an argument to
|
||||
.Nm
|
||||
is created (or its contents truncated) before any input processing begins.
|
||||
.Pp
|
||||
The
|
||||
.Dq b ,
|
||||
.Dq r ,
|
||||
.Dq s ,
|
||||
.Dq t ,
|
||||
.Dq w ,
|
||||
.Dq y ,
|
||||
.Dq \&! ,
|
||||
and
|
||||
.Dq \&:
|
||||
functions all accept additional arguments.
|
||||
The following synopses indicate which arguments have to be separated from
|
||||
the function letters by white space characters.
|
||||
.Pp
|
||||
Two of the functions take a function-list.
|
||||
This is a list of
|
||||
.Nm
|
||||
functions separated by newlines, as follows:
|
||||
.Bd -literal -offset indent
|
||||
{ function
|
||||
function
|
||||
...
|
||||
function
|
||||
}
|
||||
.Ed
|
||||
.Pp
|
||||
The
|
||||
.Dq {
|
||||
can be preceded by white space and can be followed by white space.
|
||||
The function can be preceded by white space.
|
||||
The terminating
|
||||
.Dq }
|
||||
must be preceded by a newline (and optionally white space).
|
||||
.sp
|
||||
.Bl -tag -width "XXXXXX" -compact
|
||||
.It [2addr] function-list
|
||||
Execute function-list only when the pattern space is selected.
|
||||
.sp
|
||||
.It [1addr]a\e
|
||||
.It text
|
||||
.br
|
||||
Write
|
||||
.Em text
|
||||
to standard output immediately before each attempt to read a line of input,
|
||||
whether by executing the
|
||||
.Dq N
|
||||
function or by beginning a new cycle.
|
||||
.sp
|
||||
.It [2addr]b[label]
|
||||
Branch to the
|
||||
.Dq \&:
|
||||
function with the specified label.
|
||||
If the label is not specified, branch to the end of the script.
|
||||
.sp
|
||||
.It [2addr]c\e
|
||||
.It text
|
||||
.br
|
||||
Delete the pattern space.
|
||||
With 0 or 1 address or at the end of a 2-address range,
|
||||
.Em text
|
||||
is written to the standard output.
|
||||
.sp
|
||||
.It [2addr]d
|
||||
Delete the pattern space and start the next cycle.
|
||||
.sp
|
||||
.It [2addr]D
|
||||
Delete the initial segment of the pattern space through the first
|
||||
newline character and start the next cycle.
|
||||
.sp
|
||||
.It [2addr]g
|
||||
Replace the contents of the pattern space with the contents of the
|
||||
hold space.
|
||||
.sp
|
||||
.It [2addr]G
|
||||
Append a newline character followed by the contents of the hold space
|
||||
to the pattern space.
|
||||
.sp
|
||||
.It [2addr]h
|
||||
Replace the contents of the hold space with the contents of the
|
||||
pattern space.
|
||||
.sp
|
||||
.It [2addr]H
|
||||
Append a newline character followed by the contents of the pattern space
|
||||
to the hold space.
|
||||
.sp
|
||||
.It [1addr]i\e
|
||||
.It text
|
||||
.br
|
||||
Write
|
||||
.Em text
|
||||
to the standard output.
|
||||
.sp
|
||||
.It [2addr]l
|
||||
(The letter ell.)
|
||||
Write the pattern space to the standard output in a visually unambiguous
|
||||
form.
|
||||
This form is as follows:
|
||||
.sp
|
||||
.Bl -tag -width "carriage-returnXX" -offset indent -compact
|
||||
.It backslash
|
||||
\e\e
|
||||
.It alert
|
||||
\ea
|
||||
.It form-feed
|
||||
\ef
|
||||
.It newline
|
||||
\en
|
||||
.It carriage-return
|
||||
\er
|
||||
.It tab
|
||||
\et
|
||||
.It vertical tab
|
||||
\ev
|
||||
.El
|
||||
.Pp
|
||||
Nonprintable characters are written as three-digit octal numbers (with a
|
||||
preceding backslash) for each byte in the character (most significant byte
|
||||
first).
|
||||
Long lines are folded, with the point of folding indicated by displaying
|
||||
a backslash followed by a newline.
|
||||
The end of each line is marked with a
|
||||
.Dq $ .
|
||||
.sp
|
||||
.It [2addr]n
|
||||
Write the pattern space to the standard output if the default output has
|
||||
not been suppressed, and replace the pattern space with the next line of
|
||||
input. (Does not begin a new cycle.)
|
||||
.sp
|
||||
.It [2addr]N
|
||||
Append the next line of input to the pattern space, using an embedded
|
||||
newline character to separate the appended material from the original
|
||||
contents.
|
||||
Note that the current line number changes.
|
||||
.sp
|
||||
.It [2addr]p
|
||||
Write the pattern space to standard output.
|
||||
.sp
|
||||
.It [2addr]P
|
||||
Write the pattern space, up to the first newline character to the
|
||||
standard output.
|
||||
.sp
|
||||
.It [1addr]q
|
||||
Branch to the end of the script and quit without starting a new cycle.
|
||||
.sp
|
||||
.It [1addr]r file
|
||||
Copy the contents of
|
||||
.Em file
|
||||
to the standard output immediately before the next attempt to read a
|
||||
line of input.
|
||||
If
|
||||
.Em file
|
||||
cannot be read for any reason, it is silently ignored and no error
|
||||
condition is set.
|
||||
.sp
|
||||
.It [2addr]s/regular expression/replacement/flags
|
||||
Substitute the replacement string for the first instance of the regular
|
||||
expression in the pattern space.
|
||||
Any character other than backslash or newline can be used instead of
|
||||
a slash to delimit the RE and the replacement.
|
||||
Within the RE and the replacement, the RE delimiter itself can be used as
|
||||
a literal character if it is preceded by a backslash.
|
||||
.Pp
|
||||
An ampersand
|
||||
.Po
|
||||
.Dq \*[Am]
|
||||
.Pc
|
||||
appearing in the replacement is replaced by the string matching the RE.
|
||||
The special meaning of
|
||||
.Dq \*[Am]
|
||||
in this context can be suppressed by preceding it by a backslash.
|
||||
The string
|
||||
.Dq \e# ,
|
||||
where
|
||||
.Dq #
|
||||
is a digit, is replaced by the text matched
|
||||
by the corresponding backreference expression (see
|
||||
.Xr re_format 7 ) .
|
||||
.Pp
|
||||
A line can be split by substituting a newline character into it.
|
||||
To specify a newline character in the replacement string, precede it with
|
||||
a backslash.
|
||||
.Pp
|
||||
The value of
|
||||
.Em flags
|
||||
in the substitute function is zero or more of the following:
|
||||
.Bl -tag -width "XXXXXX" -offset indent
|
||||
.It "0 ... 9"
|
||||
Make the substitution only for the N'th occurrence of the regular
|
||||
expression in the pattern space.
|
||||
.It g
|
||||
Make the substitution for all non-overlapping matches of the
|
||||
regular expression, not just the first one.
|
||||
.It p
|
||||
Write the pattern space to standard output if a replacement was made.
|
||||
If the replacement string is identical to that which it replaces, it
|
||||
is still considered to have been a replacement.
|
||||
.It w Em file
|
||||
Append the pattern space to
|
||||
.Em file
|
||||
if a replacement was made.
|
||||
If the replacement string is identical to that which it replaces, it
|
||||
is still considered to have been a replacement.
|
||||
.El
|
||||
.sp
|
||||
.It [2addr]t [label]
|
||||
Branch to the
|
||||
.Dq \&:
|
||||
function bearing the label if any substitutions have been made since the
|
||||
most recent reading of an input line or execution of a
|
||||
.Dq t
|
||||
function.
|
||||
If no label is specified, branch to the end of the script.
|
||||
.sp
|
||||
.It [2addr]w Em file
|
||||
Append the pattern space to the
|
||||
.Em file .
|
||||
.sp
|
||||
.It [2addr]x
|
||||
Swap the contents of the pattern and hold spaces.
|
||||
.sp
|
||||
.It [2addr]y/string1/string2/
|
||||
Replace all occurrences of characters in
|
||||
.Em string1
|
||||
in the pattern space with the corresponding characters from
|
||||
.Em string2 .
|
||||
Any character other than a backslash or newline can be used instead of
|
||||
a slash to delimit the strings.
|
||||
Within
|
||||
.Em string1
|
||||
and
|
||||
.Em string2 ,
|
||||
a backslash followed by any character other than a newline is that literal
|
||||
character, and a backslash followed by an ``n'' is replaced by a newline
|
||||
character.
|
||||
.sp
|
||||
.It [2addr]!function
|
||||
.It [2addr]!function-list
|
||||
Apply the function or function-list only to the lines that are
|
||||
.Em not
|
||||
selected by the address(es).
|
||||
.sp
|
||||
.It [0addr]:label
|
||||
This function does nothing; it bears a label to which the
|
||||
.Dq b
|
||||
and
|
||||
.Dq t
|
||||
commands may branch.
|
||||
.sp
|
||||
.It [1addr]=
|
||||
Write the line number to the standard output followed by a newline
|
||||
character.
|
||||
.sp
|
||||
.It [0addr]
|
||||
Empty lines are ignored.
|
||||
.sp
|
||||
.It [0addr]#
|
||||
The
|
||||
.Dq #
|
||||
and the remainder of the line are ignored (treated as a comment), with
|
||||
the single exception that if the first two characters in the file are
|
||||
.Dq #n ,
|
||||
the default output is suppressed.
|
||||
This is the same as specifying the
|
||||
.Fl n
|
||||
option on the command line.
|
||||
.El
|
||||
.Pp
|
||||
The
|
||||
.Nm
|
||||
utility exits 0 on success and \*[Gt]0 if an error occurs.
|
||||
.Sh SEE ALSO
|
||||
.Xr awk 1 ,
|
||||
.Xr ed 1 ,
|
||||
.Xr grep 1 ,
|
||||
.Xr regex 3 ,
|
||||
.Xr re_format 7
|
||||
.Sh STANDARDS
|
||||
The
|
||||
.Nm
|
||||
function is expected to be a superset of the
|
||||
.St -p1003.2
|
||||
specification.
|
||||
.Sh HISTORY
|
||||
A
|
||||
.Nm
|
||||
command appeared in
|
||||
.At v7 .
|
||||
Loading…
Reference in a new issue