Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

integrated updated 'tr' from ftp.uu.net:bsd-sources

Browse Source
This commit is contained in:
glass 1993-04-27 04:52:26 +00:00
parent 3a1c5d4c02
commit 9acecc037c
5 changed files with 820 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
usr.bin/tr/Makefile
View File

@ -1,5 +1,6 @@
# @(#)Makefile 5.2 (Berkeley) 5/11/90
# @(#)Makefile 5.3 (Berkeley) 10/27/91
PROG= tr
SRCS= str.c tr.c
.include <bsd.prog.mk>

51
usr.bin/tr/extern.h Normal file
View File

@ -0,0 +1,51 @@
/*-
* Copyright (c) 1991 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.
*
* @(#)extern.h 5.2 (Berkeley) 10/27/91
*/
typedef struct {
enum { STRING1, STRING2 } which;
enum { EOS, INFINITE, NORMAL, RANGE, SEQUENCE, SET } state;
int cnt; /* character count */
int lastch; /* last character */
int equiv[2]; /* equivalence set */
int *set; /* set of characters */
char *str; /* user's string */
} STR;
#include <limits.h>
#define NCHARS (UCHAR_MAX + 1) /* Number of possible characters. */
#define OOBCH (UCHAR_MAX + 1) /* Out of band character value. */
void err __P((const char *fmt, ...));
int next __P((STR *));

351
usr.bin/tr/str.c Normal file
View File

@ -0,0 +1,351 @@
/*-
* Copyright (c) 1991 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.
*/
#ifndef lint
static char sccsid[] = "@(#)str.c 5.9 (Berkeley) 3/4/93";
#endif /* not lint */
#include <sys/cdefs.h>
#include <sys/types.h>
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "extern.h"
static int backslash __P((STR *));
static int bracket __P((STR *));
static int c_class __P((const void *, const void *));
static void genclass __P((STR *));
static void genequiv __P((STR *));
static int genrange __P((STR *));
static void genseq __P((STR *));
int
next(s)
register STR *s;
{
register int ch;
switch (s->state) {
case EOS:
return (0);
case INFINITE:
return (1);
case NORMAL:
switch (ch = *s->str) {
case '\0':
s->state = EOS;
return (0);
case '\\':
s->lastch = backslash(s);
break;
case '[':
if (bracket(s))
return (next(s));
/* FALLTHROUGH */
default:
++s->str;
s->lastch = ch;
break;
}
/* We can start a range at any time. */
if (s->str[0] == '-' && genrange(s))
return (next(s));
return (1);
case RANGE:
if (s->cnt-- == 0) {
s->state = NORMAL;
return (next(s));
}
++s->lastch;
return (1);
case SEQUENCE:
if (s->cnt-- == 0) {
s->state = NORMAL;
return (next(s));
}
return (1);
case SET:
if ((s->lastch = s->set[s->cnt++]) == OOBCH) {
s->state = NORMAL;
return (next(s));
}
return (1);
}
/* NOTREACHED */
}
static int
bracket(s)
register STR *s;
{
register char *p;
switch (s->str[1]) {
case ':': /* "[:class:]" */
if ((p = strstr(s->str + 2, ":]")) == NULL)
return (0);
*p = '\0';
s->str += 2;
genclass(s);
s->str = p + 2;
return (1);
case '=': /* "[=equiv=]" */
if ((p = strstr(s->str + 2, "=]")) == NULL)
return (0);
s->str += 2;
genequiv(s);
return (1);
default: /* "[\###*n]" or "[#*n]" */
if ((p = strpbrk(s->str + 2, "*]")) == NULL)
return (0);
if (p[0] != '*' || index(p, ']') == NULL)
return (0);
s->str += 1;
genseq(s);
return (1);
}
/* NOTREACHED */
}
int isalnum __P((int)),
isalpha __P((int)),
isblank __P((int)),
isspace __P((int)),
iscntrl __P((int)),
isdigit __P((int)),
isgraph __P((int)),
islower __P((int)),
isprint __P((int)),
ispunct __P((int)),
isupper __P((int)),
isxdigit __P((int));
static int isblank(x) /* until 4.4 */
int x;
{
if ((x == ' ') || (x== '\t')) return 1;
return 0;
}
typedef struct {
char *name;
int (*func) __P((int));
int *set;
} CLASS;
static CLASS classes[] = {
{ "alnum", isalnum, },
{ "alpha", isalpha, },
{ "blank", isblank, },
{ "cntrl", iscntrl, },
{ "digit", isdigit, },
{ "graph", isgraph, },
{ "lower", islower, },
{ "print", isupper, },
{ "punct", ispunct, },
{ "space", isspace, },
{ "upper", isupper, },
{ "xdigit", isxdigit, },
};
static void
genclass(s)
STR *s;
{
register int cnt, (*func) __P((int));
CLASS *cp, tmp;
int *p;
tmp.name = s->str;
if ((cp = (CLASS *)bsearch(&tmp, classes, sizeof(classes) /
sizeof(CLASS), sizeof(CLASS), c_class)) == NULL)
err("unknown class %s", s->str);
if ((cp->set = p = malloc((NCHARS + 1) * sizeof(int))) == NULL)
err("%s", strerror(errno));
bzero(p, (NCHARS + 1) * sizeof(int));
for (cnt = 0, func = cp->func; cnt < NCHARS; ++cnt)
if ((func)(cnt))
*p++ = cnt;
*p = OOBCH;
s->cnt = 0;
s->state = SET;
s->set = cp->set;
}
static int
c_class(a, b)
const void *a, *b;
{
return (strcmp(((CLASS *)a)->name, ((CLASS *)b)->name));
}
/*
* English doesn't have any equivalence classes, so for now
* we just syntax check and grab the character.
*/
static void
genequiv(s)
STR *s;
{
if (*s->str == '\\') {
s->equiv[0] = backslash(s);
if (*s->str != '=')
err("misplaced equivalence equals sign");
} else {
s->equiv[0] = s->str[0];
if (s->str[1] != '=')
err("misplaced equivalence equals sign");
}
s->str += 2;
s->cnt = 0;
s->state = SET;
s->set = s->equiv;
}
static int
genrange(s)
STR *s;
{
int stopval;
char *savestart;
savestart = s->str;
stopval = *++s->str == '\\' ? backslash(s) : *s->str;
if (stopval < s->lastch) {
s->str = savestart;
return (0);
}
s->cnt = stopval - s->lastch + 1;
s->state = RANGE;
--s->lastch;
return (1);
}
static void
genseq(s)
STR *s;
{
char *ep;
if (s->which == STRING1)
err("sequences only valid in string2");
if (*s->str == '\\')
s->lastch = backslash(s);
else
s->lastch = *s->str++;
if (*s->str != '*')
err("misplaced sequence asterisk");
switch (*++s->str) {
case '\\':
s->cnt = backslash(s);
break;
case ']':
s->cnt = 0;
++s->str;
break;
default:
if (isdigit(*s->str)) {
s->cnt = strtol(s->str, &ep, 0);
if (*ep == ']') {
s->str = ep + 1;
break;
}
}
err("illegal sequence count");
/* NOTREACHED */
}
s->state = s->cnt ? SEQUENCE : INFINITE;
}
/* Use the #defines isXXX() here, DON'T use them above. */
#include <ctype.h>
/*
* Translate \??? into a character. Up to 3 octal digits, if no digits either
* an escape code or a literal character.
*/
static int
backslash(s)
register STR *s;
{
register int ch, cnt, val;
for (cnt = val = 0;;) {
ch = *++s->str;
if (!isascii(ch) || !isdigit(ch))
break;
val = val * 8 + ch - '0';
if (++cnt == 3) {
++s->str;
break;
}
}
if (cnt)
return (val);
if (ch != '\0')
++s->str;
switch (ch) {
case 'a': /* escape characters */
return ('\7');
case 'b':
return ('\b');
case 'f':
return ('\f');
case 'n':
return ('\n');
case 'r':
return ('\r');
case 't':
return ('\t');
case 'v':
return ('\13');
case '\0': /* \" -> \ */
s->state = EOS;
return ('\\');
default: /* \x" -> x */
return (ch);
}
}

363
usr.bin/tr/tr.1
View File

@ -32,9 +32,9 @@
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\" @(#)tr.1 6.6 (Berkeley) 7/30/91
.\" @(#)tr.1 6.9 (Berkeley) 10/27/91
.\"
.Dd July 30, 1991
.Dd October 27, 1991
.Dt TR 1
.Os
.Sh NAME
@ -42,180 +42,251 @@
.Nd Translate Characters.
.Sh SYNOPSIS
.Nm tr
.Op Fl cs
.Ar string1 string2
.Nm tr
.Op Fl c
.Op Fl d | Fl s
.Fl d
.Ar string1
.Nm tr
.Op Fl c
.Fl s
.Ar string1
.Nm tr
.Op Fl c
.Fl ds
.Ar string1 string2
.Sh DESCRIPTION
The tr utility copies the standard input to the standard
output with substitution or deletion of selected characters.
The options specified and the
.Ar string1
and
.Ar string2
operands
control translations that occur while copying characters.
The
.Nm tr
utility copies the standard input to the standard output with substitution
or deletion of selected characters.
.Pp
The following options are available:
.Bl -tag -width Ds
.It Fl c
Complements the set of characters in string1 with
respect to the universe of characters whose
.Tn ISO
646
[4] codes are 00 through 0377 octal.
Complements the set of characters in
.Ar string1 ,
that is ``-c ab'' includes every character except for ``a'' and ``b''.
.It Fl d
Deletes all input characters in
.Ar string1 .
.It Fl s
Squeezes all output strings of one or more
instances of a single character in
.Ar string2
to a
single instance of that character.
Input characters found
in
.Ar string1
are mapped into the corresponding characters
of
.Ar string2 .
When
.Ar string2
is shorter than
.Ar string1 , string2
is extended to the length of
.Ar string1
by duplicating the last character of
.Ar string2 .
If
.Ar string2
is explicitly a string of zero
length,
.Ar string2
is padded with
.Tn NUL
characters.
.El
.Pp
The following operands are available:
.Bl -tag -width stringx
.It Ar string1
.It Ar string2
Translation character strings.
.El
.Pp
.Pp
If
the
.Fl c
option is given in conjunction with the
The
.Fl d
option, then only those characters found in
option causes characters to be deleted from the input.
.It Fl s
The
.Fl s
option squeezes multiple occurrences of the characters listed in the last
operand (either
.Ar string1
is copied to the standard output.
or
.Ar string2 )
in the input into a single instance of the character.
This occurs after all deletion and translation is completed.
.El
.Pp
In the first synopsis form, the characters in
.Ar string1
are translated into the characters in
.Ar string2
where the first character in
.Ar string1
is translated into the first character in
.Ar string2
and so on.
If
.Ar string1
is longer than
.Ar string2 ,
the last character found in
.Ar string2
is duplicated until
.Ar string1
is exhausted.
.Pp
In the second synopsis form, the characters in
.Ar string1
are deleted from the input.
.Pp
In the third synopsis form, the characters in
.Ar string1
are compressed as described for the
.Fl s
option.
.Pp
In the fourth synopsis form, the characters in
.Ar string1
are deleted from the input, and the characters in
.Ar string2
are compressed as described for the
.Fl s
option.
.Pp
The following conventions can be used in
.Ar string1
or
and
.Ar string2
or both to specify characters, character ranges, character
classes, or collating elements:
.Bl -tag -width [[:equiv:]]
to specify sets of characters:
.Bl -tag -width [:equiv:]
.It character
Represents that character.
Any character not described by one of the following conventions
represents itself.
.It \eoctal
A backslash followed by 1, 2, or 3 octal
digits represents a character with that
encoded value.
If a \eoctal sequence is
followed by digits, the backslash and up to
three digits are interpreted to prepare a
character; subsequent digits are interpreted
as individual characters.
A backslash followed by 1, 2 or 3 octal digits represents a character
with that encoded value.
To follow an octal sequence with a digit as a character, left zero-pad
the octal sequence to the full 3 octal digits.
.It \echaracter
A backslash followed by any character except
an octal digit represents that character.
.It [c-c]
Represents the range of ordered elements
between the range endpoints, inclusive.
.\" ; as
.\" defined by the current setting of the
.\" setlocale() category
.\" .Em LC_COLLATE .
.\" The collating
.\" elements are ordered in ascending collating
.\" sequence, and the first endpoint shall precede
.\" the second in the collating sequence.
.It [[:class:]]
Represents all characters belonging to the
defined character class.
.\" as defined by the
.\" current setting of the setlocale() category
.\" .Ev LC_CTYPE .
Allowable names for class are:
.Bl -column alpha upper lower digit xdigit -offset indent
alpha upper lower digit xdigit alnum
space punct print graph cntrl
A backslash followed by certain special characters maps to special
values.
.sp
.Bl -column
.It \ea <alert character>
.It \eb <backspace>
.It \ef <form-feed>
.It \en <newline>
.It \er <carriage return>
.It \et <tab>
.It \ev <vertical tab>
.El
.sp
A backslash followed by any other character maps to that character.
.It c-c
Represents the range of characters between the range endpoints, inclusively.
.It [:class:]
Represents all characters belonging to the defined character class.
Class names are:
.sp
.Bl -column
.It alnum <alphanumeric characters>
.It alpha <alphabetic characters>
.It cntrl <control characters>
.It digit <numeric characters>
.It graph <graphic characters>
.It lower <lower-case alphabetic characters>
.It print <printable characters>
.It punct <punctuation characters>
.It space <space characters>
.It upper <upper-case characters>
.It xdigit <hexadecimal characters>
.El
.Pp
The characters placed in ascending order.
.\" .Em LC_COLLATE .
.\" (Characters not defined in the
.\" current collating sequence are ordered
.\" according to the collation sequence's rules
.\" for ordering of undefined characters.)
.It [[=equiv=]]
Represents all characters or collating (sorting)
elements belonging to the same equivalence class
as equiv.
.\"
.\"
.\" .Em LC_COLLATE .
\." All classes may be used in
\." .Ar string1 ,
\." and in
\." .Ar string2
\." when both the
\." .Fl d
\." and
\." .Fl s
\." options are specified.
\." Otherwise, only the classes ``upper'' and ``lower'' may be used in
\." .Ar string2
\." and then only when the corresponding class (``upper'' for ``lower''
\." and vice-versa) is specified in the same relative position in
\." .Ar string1 .
\." .Pp
With the exception of the ``upper'' and ``lower'' classes, characters
in the classes are in unspecified order.
In the ``upper'' and ``lower'' classes, characters are entered in
ascending order.
.Pp
For specific information as to which ASCII characters are included
in these classes, see
.Xr ctype 3
and related manual pages.
.It [=equiv=]
Represents all characters or collating (sorting) elements belonging to
the same equivalence class as
.Ar equiv .
If
there is a secondary ordering within the
equivalence class, the characters are ordered
in ascending sequence.
Otherwise, they are
ordered after their encoded values.
.It [[.cs.]]
Represents a collating symbol.
Multicharacter
collating symbols shall be represented as
collating symbols to distinguish them from a
string of the same characters.
.It [x*n]
Represents n repeated occurrences of the
character or collating symbol x.
there is a secondary ordering within the equivalence class, the characters
are ordered in ascending sequence.
Otherwise, they are ordered after their encoded values.
An example of an equivalence class might be ``c'' and ``ch'' in Spanish;
English has no equivalence classes.
.It [#*n]
Represents
.Ar n
repeated occurrences of the character represented by
.Ar # .
This
expression is only valid when it occurs in
.Ar string2 .
If n is omitted or is zero, it is
be interpreted as large enough to extend the
.Ar string2 Ns -based
sequence to the length of the
.Ar string1 Ns -based
sequence.
If n has a leading
zero, it shall be interpreted as an octal
value.
Otherwise, it shall be interpreted as
a decimal value.
If
.Ar n
is omitted or is zero, it is be interpreted as large enough to extend
.Ar string2
sequence to the length of
.Ar string1 .
If
.Ar n
has a leading zero, it is interpreted as an octal value, otherwise,
it's interpreted as a decimal value.
.El
.Pp
Characters belonging to an equivalence class occupy the same
position in the sequence, ordered after secondary ordering.
.Pp
The
.Nm tr
utility exits with one of the following values:
.Bl -tag -width Ds
.It 0
All input was processed successfully.
.It 1
An error occurred.
.El
utility exits 0 on success, and >0 if an error occurs.
.Sh EXAMPLES
The following examples are shown as given to the shell:
.sp
Create a list of the words in file1, one per line, where a word is taken to
be a maximal string of letters.
.sp
.D1 Li "tr -cs \*q[:alpha:]\*q \*q\en\*q < file1"
.sp
Translate the contents of file1 to upper-case.
.sp
.D1 Li "tr \*q[:lower:]\*q \*q[:upper:]\*q < file1"
.sp
Strip out non-printable characters from file1.
.sp
.D1 Li "tr -cd \*q[:print:]\*q < file1"
.Sh COMPATIBILITY
System V has historically implemented character ranges using the syntax
``[c-c]'' instead of the ``c-c'' used by historic BSD implementations and
standardized by POSIX.
System V shell scripts should work under this implementation as long as
the range is intended to map in another range, i.e. the command
``tr [a-z] [A-Z]'' will work as it will map the ``['' character in
.Ar string1
to the ``['' character in
.Ar string2.
However, if the shell script is deleting or squeezing characters as in
the command ``tr -d [a-z]'', the characters ``['' and ``]'' will be
included in the deletion or compression list which would not have happened
under an historic System V implementation.
Additionally, any scripts that depended on the sequence ``a-z'' to
represent the three characters ``a'', ``-'' and ``z'' will have to be
rewritten as ``a\e-z''.
.Pp
The
.Nm tr
utility has historically not permitted the manipulation of NUL bytes in
its input and, additionally, stripped NUL's from its input stream.
This implementation has removed this behavior as a bug.
.Pp
The
.Nm tr
utility has historically been extremely forgiving of syntax errors,
for example, the
.Fl c
and
.Fl s
options were ignored unless two strings were specified.
This implementation will not permit illegal syntax.
.Sh STANDARDS
The
.Nm tr
utility is expected to be
.St -p1003.2
compatible.
It should be noted that the feature wherein the last character of
.Ar string2
is duplicated if
.Ar string2
has less characters than
.Ar string1
is permitted by POSIX but is not required.
Shell scripts attempting to be portable to other POSIX systems should use
the ``[#*]'' convention instead of relying on this behavior.

339
usr.bin/tr/tr.c
View File

@ -38,31 +38,63 @@ char copyright[] =
#endif /* not lint */
#ifndef lint
static char sccsid[] = "@(#)tr.c 4.7 (Berkeley) 7/23/90";
static char sccsid[] = "@(#)tr.c 5.4 (Berkeley) 3/3/93";
#endif /* not lint */
#include <sys/types.h>
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "extern.h"
#define NCHARS 256 /* size of u_char */
#define OOBCH 257 /* out of band value */
static int string1[NCHARS] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /* ASCII */
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
}, string2[NCHARS];
typedef struct {
char *str;
int lastch, endrange;
enum { NORM, INRANGE, EOS } state;
} STR;
STR s1 = { STRING1, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
STR s2 = { STRING2, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
static void setup __P((int *, char *, STR *, int));
static void usage __P((void));
int
main(argc, argv)
int argc;
char **argv;
{
extern int optind;
STR s1, s2;
register int ch, indx, lastch;
int cflag, dflag, sflag;
u_char *tp, tab[NCHARS], squeeze[NCHARS];
register int ch, cnt, lastch, *p;
int cflag, dflag, sflag, isstring2;
cflag = dflag = sflag = 0;
while ((ch = getopt(argc, argv, "cds")) != EOF)
@ -78,151 +110,178 @@ main(argc, argv)
break;
case '?':
default:
fprintf(stderr,
"usage: tr [-cds] [string1 [string2]]\n");
exit(1);
usage();
}
argc -= optind;
argv += optind;
switch(argc) {
case 0:
default:
usage();
/* NOTREACHED */
case 1:
isstring2 = 0;
break;
case 2:
isstring2 = 1;
break;
}
/*
* the original tr was amazingly tolerant of the command line.
* Neither -c or -s have any effect unless there are two strings.
* Extra arguments are silently ignored. Bag this noise, they
* should all be errors.
* tr -ds [-c] string1 string2
* Delete all characters (or complemented characters) in string1.
* Squeeze all characters in string2.
*/
if (argc < 2 && !dflag) {
while ((ch = getchar()) != EOF)
putchar(ch);
if (dflag && sflag) {
if (!isstring2)
usage();
setup(string1, argv[0], &s1, cflag);
setup(string2, argv[1], &s2, 0);
for (lastch = OOBCH; (ch = getchar()) != EOF;)
if (!string1[ch] && (!string2[ch] || lastch != ch)) {
lastch = ch;
(void)putchar(ch);
}
exit(0);
}
bzero(tab, NCHARS);
if (sflag) {
s1.str = argv[1];
s1.state = NORM;
s1.lastch = OOBCH;
while (next(&s1))
squeeze[s1.lastch] = 1;
}
/*
* tr -d [-c] string1
* Delete all characters (or complemented characters) in string1.
*/
if (dflag) {
s1.str = argv[0];
s1.state = NORM;
s1.lastch = OOBCH;
while (next(&s1))
tab[s1.lastch] = 1;
if (cflag)
for (tp = tab, indx = 0; indx < NCHARS; ++tp, ++indx)
*tp = !*tp;
if (sflag)
for (lastch = OOBCH; (ch = getchar()) != EOF;) {
if (tab[ch] || (squeeze[ch] && lastch == ch))
continue;
if (isstring2)
usage();
setup(string1, argv[0], &s1, cflag);
while ((ch = getchar()) != EOF)
if (!string1[ch])
(void)putchar(ch);
exit(0);
}
/*
* tr -s [-c] string1
* Squeeze all characters (or complemented characters) in string1.
*/
if (sflag && !isstring2) {
setup(string1, argv[0], &s1, cflag);
for (lastch = OOBCH; (ch = getchar()) != EOF;)
if (!string1[ch] || lastch != ch) {
lastch = ch;
putchar(ch);
(void)putchar(ch);
}
else
while ((ch = getchar()) != EOF)
if (!tab[ch])
putchar(ch);
} else {
s1.str = argv[0];
s2.str = argv[1];
s1.state = s2.state = NORM;
s1.lastch = s2.lastch = OOBCH;
if (cflag) {
/*
* if cflag is set, tr just pretends it only got one
* character in string2. As reasonable as anything
* else. Should really be an error.
*/
while (next(&s2));
lastch = s2.lastch;
for (tp = tab, indx = 0; indx < NCHARS; ++tp, ++indx)
*tp = lastch;
while (next(&s1))
tab[s1.lastch] = s1.lastch;
} else {
for (tp = tab, indx = 0; indx < NCHARS; ++tp, ++indx)
*tp = indx;
while (next(&s1)) {
(void)next(&s2);
tab[s1.lastch] = s2.lastch;
exit(0);
}
/*
* tr [-cs] string1 string2
* Replace all characters (or complemented characters) in string1 with
* the character in the same position in string2. If the -s option is
* specified, squeeze all the characters in string2.
*/
if (!isstring2)
usage();
s1.str = argv[0];
s2.str = argv[1];
if (cflag)
for (cnt = NCHARS, p = string1; cnt--;)
*p++ = OOBCH;
if (!next(&s2))
err("empty string2");
/* If string2 runs out of characters, use the last one specified. */
if (sflag)
while (next(&s1)) {
string1[s1.lastch] = ch = s2.lastch;
string2[ch] = 1;
(void)next(&s2);
}
else
while (next(&s1)) {
string1[s1.lastch] = ch = s2.lastch;
(void)next(&s2);
}
if (cflag)
for (cnt = 0, p = string1; cnt < NCHARS; ++p, ++cnt)
*p = *p == OOBCH ? ch : cnt;
if (sflag)
for (lastch = OOBCH; (ch = getchar()) != EOF;) {
ch = string1[ch];
if (!string2[ch] || lastch != ch) {
lastch = ch;
(void)putchar(ch);
}
}
if (sflag)
for (lastch = OOBCH; (ch = getchar()) != EOF;) {
ch = tab[ch];
if (squeeze[ch] && lastch == ch)
continue;
lastch = ch;
putchar(ch);
}
else
while ((ch = getchar()) != EOF)
putchar((int)tab[ch]);
}
exit(0);
else
while ((ch = getchar()) != EOF)
(void)putchar(string1[ch]);
exit (0);
}
next(s)
register STR *s;
static void
setup(string, arg, str, cflag)
int *string;
char *arg;
STR *str;
int cflag;
{
register int ch;
register int cnt, *p;
if (s->state == EOS)
return(0);
if (s->state == INRANGE) {
if (++s->lastch == s->endrange)
s->state = NORM;
return(1);
}
if (!(ch = *s->str++)) {
s->state = EOS;
return(0);
}
if (ch == '\\') { /* \### */
s->lastch = tran(s);
return(1);
}
if (ch == '-') { /* ranges */
if (s->lastch == OOBCH) /* "-a" */
goto fail2;
if (!(ch = *s->str++)) /* "a-" */
goto fail1;
if (ch == '\\') /* \### */
ch = tran(s);
if (s->lastch > ch) { /* "z-a" */
fail1: --s->str;
fail2: s->lastch = '-';
return(1);
}
if (s->lastch == ch) /* "a-a" */
return(next(s));
s->state = INRANGE; /* "a-z" */
s->endrange = ch;
return(1);
}
s->lastch = ch;
return(1);
str->str = arg;
bzero(string, NCHARS * sizeof(int));
while (next(str))
string[str->lastch] = 1;
if (cflag)
for (p = string, cnt = NCHARS; cnt--; ++p)
*p = !*p;
}
/*
* Translate \-escapes. Up to 3 octal digits => char; no digits => literal.
* Unadorned backslash "\" is like \000.
*/
tran(s)
register STR *s;
static void
usage()
{
register int ch, cnt = 0, val = 0;
for (;;) {
ch = *s->str++;
if (!isascii(ch) || !isdigit(ch) || ++cnt > 3)
break;
val = val * 8 + ch - '0';
}
if (cnt || ch == 0)
s->str--;
return (cnt ? val : ch);
(void)fprintf(stderr, "usage: tr [-cs] string1 string2\n");
(void)fprintf(stderr, " tr [-c] -d string1\n");
(void)fprintf(stderr, " tr [-c] -s string1\n");
(void)fprintf(stderr, " tr [-c] -ds string1 string2\n");
exit(1);
}
#if __STDC__
#include <stdarg.h>
#else
#include <varargs.h>
#endif
void
#if __STDC__
err(const char *fmt, ...)
#else
err(fmt, va_alist)
char *fmt;
va_dcl
#endif
{
va_list ap;
#if __STDC__
va_start(ap, fmt);
#else
va_start(ap);
#endif
(void)fprintf(stderr, "tr: ");
(void)vfprintf(stderr, fmt, ap);
va_end(ap);
(void)fprintf(stderr, "\n");
exit(1);
/* NOTREACHED */
}