X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=coreutils%2Ftr.c;h=e67948a36c88a148f22cd6a5af97e75159cfefa1;hb=d5ac9c88a7f620f6b775e404b145017827a10480;hp=32f6f5966e17c76ae5a48e3c44f5821bcc328c35;hpb=ab58d5cf8a0a59d6c3beafb519b1747b15fd9099;p=oweals%2Fbusybox.git

diff --git a/coreutils/tr.c b/coreutils/tr.c
index 32f6f5966..e67948a36 100644
--- a/coreutils/tr.c
+++ b/coreutils/tr.c
@@ -13,241 +13,334 @@
  * This version of tr is adapted from Minix tr and was modified
  * by Erik Andersen <andersen@codepoet.org> to be used in busybox.
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+ */
+/* http://www.opengroup.org/onlinepubs/009695399/utilities/tr.html
+ * TODO: graph, print
  */
 
-#include "busybox.h"
+//kbuild:lib-$(CONFIG_TR) += tr.o
 
-// Even with -funsigned-char, gcc still complains about char as an array index.
+//config:config TR
+//config:	bool "tr"
+//config:	default y
+//config:	help
+//config:	  tr is used to squeeze, and/or delete characters from standard
+//config:	  input, writing to standard output.
+//config:
+//config:config FEATURE_TR_CLASSES
+//config:	bool "Enable character classes (such as [:upper:])"
+//config:	default y
+//config:	depends on TR
+//config:	help
+//config:	  Enable character classes, enabling commands such as:
+//config:	  tr [:upper:] [:lower:] to convert input into lowercase.
+//config:
+//config:config FEATURE_TR_EQUIV
+//config:	bool "Enable equivalence classes"
+//config:	default y
+//config:	depends on TR
+//config:	help
+//config:	  Enable equivalence classes, which essentially add the enclosed
+//config:	  character to the current set. For instance, tr [=a=] xyz would
+//config:	  replace all instances of 'a' with 'xyz'. This option is mainly
+//config:	  useful for cases when no other way of expressing a character
+//config:	  is possible.
 
-#define GCC4_IS_STUPID int
+//usage:#define tr_trivial_usage
+//usage:       "[-cds] STRING1 [STRING2]"
+//usage:#define tr_full_usage "\n\n"
+//usage:       "Translate, squeeze, or delete characters from stdin, writing to stdout\n"
+//usage:     "\n	-c	Take complement of STRING1"
+//usage:     "\n	-d	Delete input characters coded STRING1"
+//usage:     "\n	-s	Squeeze multiple output characters of STRING2 into one character"
+//usage:
+//usage:#define tr_example_usage
+//usage:       "$ echo \"gdkkn vnqkc\" | tr [a-y] [b-z]\n"
+//usage:       "hello world\n"
 
-#define ASCII 0377
+#include "libbb.h"
 
-/* some "globals" shared across this file */
-static char com_fl, del_fl, sq_fl;
-/* these last are pointers to static buffers declared in tr_main */
-static char *poutput, *pvector, *pinvec, *poutvec;
+enum {
+	ASCII = 256,
+	/* string buffer needs to be at least as big as the whole "alphabet".
+	 * BUFSIZ == ASCII is ok, but we will realloc in expand
+	 * even for smallest patterns, let's avoid that by using *2:
+	 */
+	TR_BUFSIZ = (BUFSIZ > ASCII*2) ? BUFSIZ : ASCII*2,
+};
 
-static void convert(void)
-{
-	int read_chars = 0, in_index = 0, out_index = 0, c, coded, last = -1;
-
-	for (;;) {
-		// If we're out of input, flush output and read more input.
-
-		if (in_index == read_chars) {
-			if (out_index) {
-				if (write(1, (char *) poutput, out_index) != out_index)
-					bb_error_msg_and_die(bb_msg_write_error);
-				out_index = 0;
-			}
-
-			if ((read_chars = read(0, bb_common_bufsiz1, BUFSIZ)) <= 0) {
-				if (write(1, (char *) poutput, out_index) != out_index)
-					bb_error_msg(bb_msg_write_error);
-				exit(0);
-			}
-			in_index = 0;
-		}
-		c = bb_common_bufsiz1[in_index++];
-		coded = pvector[c];
-		if (del_fl && pinvec[c])
-			continue;
-		if (sq_fl && last == coded && (pinvec[c] || poutvec[coded]))
-			continue;
-		poutput[out_index++] = last = coded;
-	}
-
-	/* NOTREACHED */
-}
-
-static void map(char *string1, unsigned int string1_len,
-		char *string2, unsigned int string2_len)
+static void map(char *pvector,
+		char *string1, unsigned string1_len,
+		char *string2, unsigned string2_len)
 {
 	char last = '0';
-	unsigned int i, j;
+	unsigned i, j;
 
 	for (j = 0, i = 0; i < string1_len; i++) {
 		if (string2_len <= j)
-			pvector[(GCC4_IS_STUPID)string1[i]] = last;
+			pvector[(unsigned char)(string1[i])] = last;
 		else
-			pvector[(GCC4_IS_STUPID)string1[i]] = last = string2[j++];
+			pvector[(unsigned char)(string1[i])] = last = string2[j++];
 	}
 }
 
 /* supported constructs:
- *   Ranges,  e.g.,  [0-9]  ==>  0123456789
- *   Escapes, e.g.,  \a     ==>  Control-G
- *	 Character classes, e.g. [:upper:] ==> A ... Z
+ *   Ranges,  e.g.,  0-9   ==>  0123456789
+ *   Escapes, e.g.,  \a    ==>  Control-G
+ *   Character classes, e.g. [:upper:] ==> A...Z
+ *   Equiv classess, e.g. [=A=] ==> A   (hmmmmmmm?)
+ * not supported:
+ *   \ooo-\ooo - octal ranges
+ *   [x*N] - repeat char x N times
+ *   [x*] - repeat char x until it fills STRING2:
+ * # echo qwe123 | /usr/bin/tr 123456789 '[d]'
+ * qwe[d]
+ * # echo qwe123 | /usr/bin/tr 123456789 '[d*]'
+ * qweddd
  */
-static unsigned int expand(const char *arg, char *buffer)
+static unsigned expand(const char *arg, char **buffer_p)
 {
-	char *buffer_start = buffer;
-	int i, ac;
+	char *buffer = *buffer_p;
+	unsigned pos = 0;
+	unsigned size = TR_BUFSIZ;
+	unsigned i; /* can't be unsigned char: must be able to hold 256 */
+	unsigned char ac;
 
 	while (*arg) {
+		if (pos + ASCII > size) {
+			size += ASCII;
+			*buffer_p = buffer = xrealloc(buffer, size);
+		}
 		if (*arg == '\\') {
 			arg++;
-			*buffer++ = bb_process_escape_sequence(&arg);
-		} else if (*(arg+1) == '-') {
-			ac = *(arg+2);
-			if(ac == 0) {
-				*buffer++ = *arg++;
-				continue;
+			buffer[pos++] = bb_process_escape_sequence(&arg);
+			continue;
+		}
+		if (arg[1] == '-') { /* "0-9..." */
+			ac = arg[2];
+			if (ac == '\0') { /* "0-": copy verbatim */
+				buffer[pos++] = *arg++; /* copy '0' */
+				continue; /* next iter will copy '-' and stop */
 			}
-			i = *arg;
-			while (i <= ac)
-				*buffer++ = i++;
-			arg += 3; /* Skip the assumed a-z */
-		} else if (*arg == '[') {
+			i = (unsigned char) *arg;
+			while (i <= ac) /* ok: i is unsigned _int_ */
+				buffer[pos++] = i++;
+			arg += 3; /* skip 0-9 */
+			continue;
+		}
+		if ((ENABLE_FEATURE_TR_CLASSES || ENABLE_FEATURE_TR_EQUIV)
+		 && *arg == '['
+		) {
 			arg++;
-			i = *arg++;
-			if (ENABLE_FEATURE_TR_CLASSES && i == ':') {
-				if (strncmp(arg, "alpha", 5) == 0) {
-					for (i = 'A'; i <= 'Z'; i++)
-						*buffer++ = i;
-					for (i = 'a'; i <= 'z'; i++)
-						*buffer++ = i;
-				}
-				else if (strncmp(arg, "alnum", 5) == 0) {
+			i = (unsigned char) *arg++;
+			/* "[xyz...". i=x, arg points to y */
+			if (ENABLE_FEATURE_TR_CLASSES && i == ':') { /* [:class:] */
+#define CLO ":]\0"
+				static const char classes[] ALIGN1 =
+					"alpha"CLO "alnum"CLO "digit"CLO
+					"lower"CLO "upper"CLO "space"CLO
+					"blank"CLO "punct"CLO "cntrl"CLO
+					"xdigit"CLO;
+				enum {
+					CLASS_invalid = 0, /* we increment the retval */
+					CLASS_alpha = 1,
+					CLASS_alnum = 2,
+					CLASS_digit = 3,
+					CLASS_lower = 4,
+					CLASS_upper = 5,
+					CLASS_space = 6,
+					CLASS_blank = 7,
+					CLASS_punct = 8,
+					CLASS_cntrl = 9,
+					CLASS_xdigit = 10,
+					//CLASS_graph = 11,
+					//CLASS_print = 12,
+				};
+				smalluint j;
+				char *tmp;
+
+				/* xdigit needs 8, not 7 */
+				i = 7 + (arg[0] == 'x');
+				tmp = xstrndup(arg, i);
+				j = index_in_strings(classes, tmp) + 1;
+				free(tmp);
+
+				if (j == CLASS_invalid)
+					goto skip_bracket;
+
+				arg += i;
+				if (j == CLASS_alnum || j == CLASS_digit || j == CLASS_xdigit) {
 					for (i = '0'; i <= '9'; i++)
-						*buffer++ = i;
-					for (i = 'A'; i <= 'Z'; i++)
-						*buffer++ = i;
-					for (i = 'a'; i <= 'z'; i++)
-						*buffer++ = i;
+						buffer[pos++] = i;
 				}
-				else if (strncmp(arg, "digit", 5) == 0)
-					for (i = '0'; i <= '9'; i++)
-						*buffer++ = i;
-				else if (strncmp(arg, "lower", 5) == 0)
-					for (i = 'a'; i <= 'z'; i++)
-						*buffer++ = i;
-				else if (strncmp(arg, "upper", 5) == 0)
+				if (j == CLASS_alpha || j == CLASS_alnum || j == CLASS_upper) {
 					for (i = 'A'; i <= 'Z'; i++)
-						*buffer++ = i;
-				else if (strncmp(arg, "space", 5) == 0) {
-				    const char s[] = "\t\n\v\f\r ";
-					strcat((char*)buffer, s);
-					buffer += sizeof(s) - 1;
+						buffer[pos++] = i;
 				}
-				else if (strncmp(arg, "blank", 5) == 0) {
-					*buffer++ = '\t';
-					*buffer++ = ' ';
+				if (j == CLASS_alpha || j == CLASS_alnum || j == CLASS_lower) {
+					for (i = 'a'; i <= 'z'; i++)
+						buffer[pos++] = i;
 				}
-				/* gcc gives a warning if braces aren't used here */
-				else if (strncmp(arg, "punct", 5) == 0) {
-					for (i = 0; i <= ASCII; i++)
-						if (isprint(i) && (!isalnum(i)) && (!isspace(i)))
-							*buffer++ = i;
+				if (j == CLASS_space || j == CLASS_blank) {
+					buffer[pos++] = '\t';
+					if (j == CLASS_space) {
+						buffer[pos++] = '\n';
+						buffer[pos++] = '\v';
+						buffer[pos++] = '\f';
+						buffer[pos++] = '\r';
+					}
+					buffer[pos++] = ' ';
 				}
-				else if (strncmp(arg, "cntrl", 5) == 0) {
-					for (i = 0; i <= ASCII; i++)
-						if (iscntrl(i))
-							*buffer++ = i;
+				if (j == CLASS_punct || j == CLASS_cntrl) {
+					for (i = '\0'; i < ASCII; i++) {
+						if ((j == CLASS_punct && isprint_asciionly(i) && !isalnum(i) && !isspace(i))
+						 || (j == CLASS_cntrl && iscntrl(i))
+						) {
+							buffer[pos++] = i;
+						}
+					}
 				}
-				else {
-					*buffer++ = '[';
-					*buffer++ = ':';
-					continue;
+				if (j == CLASS_xdigit) {
+					for (i = 'A'; i <= 'F'; i++) {
+						buffer[pos + 6] = i | 0x20;
+						buffer[pos++] = i;
+					}
+					pos += 6;
 				}
-				break;
-			}
-			if (ENABLE_FEATURE_TR_EQUIV && i == '=') {
-				*buffer++ = *arg;
-				/* skip the closing =] */
-				arg += 3;
 				continue;
 			}
-			if (*arg++ != '-') {
-				*buffer++ = '[';
-				arg -= 2;
+			/* "[xyz...", i=x, arg points to y */
+			if (ENABLE_FEATURE_TR_EQUIV && i == '=') { /* [=CHAR=] */
+				buffer[pos++] = *arg; /* copy CHAR */
+				if (!arg[0] || arg[1] != '=' || arg[2] != ']')
+					bb_show_usage();
+				arg += 3;  /* skip CHAR=] */
 				continue;
 			}
-			ac = *arg++;
-			while (i <= ac)
-				*buffer++ = i++;
-			arg++;				/* Skip the assumed ']' */
-		} else
-			*buffer++ = *arg++;
+			/* The rest of "[xyz..." cases is treated as normal
+			 * string, "[" has no special meaning here:
+			 * tr "[a-z]" "[A-Z]" can be written as tr "a-z" "A-Z",
+			 * also try tr "[a-z]" "_A-Z+" and you'll see that
+			 * [] is not special here.
+			 */
+ skip_bracket:
+			arg -= 2; /* points to "[" in "[xyz..." */
+		}
+		buffer[pos++] = *arg++;
 	}
-
-	return (buffer - buffer_start);
+	return pos;
 }
 
+/* NB: buffer is guaranteed to be at least TR_BUFSIZE
+ * (which is >= ASCII) big.
+ */
 static int complement(char *buffer, int buffer_len)
 {
-	register short i, j, ix;
-	char conv[ASCII + 2];
+	int len;
+	char conv[ASCII];
+	unsigned char ch;
 
-	ix = 0;
-	for (i = 0; i <= ASCII; i++) {
-		for (j = 0; j < buffer_len; j++)
-			if (buffer[j] == i)
-				break;
-		if (j == buffer_len)
-			conv[ix++] = i & ASCII;
+	len = 0;
+	ch = '\0';
+	while (1) {
+		if (memchr(buffer, ch, buffer_len) == NULL)
+			conv[len++] = ch;
+		if (++ch == '\0')
+			break;
 	}
-	memcpy(buffer, conv, ix);
-	return ix;
+	memcpy(buffer, conv, len);
+	return len;
 }
 
-int tr_main(int argc, char **argv)
+int tr_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int tr_main(int argc UNUSED_PARAM, char **argv)
 {
-	register unsigned char *ptr;
-	int output_length=0, input_length;
-	int idx = 1;
 	int i;
-	RESERVE_CONFIG_BUFFER(output, BUFSIZ);
-	RESERVE_CONFIG_BUFFER(vector, ASCII+1);
-	RESERVE_CONFIG_BUFFER(invec,  ASCII+1);
-	RESERVE_CONFIG_BUFFER(outvec, ASCII+1);
-
-	/* ... but make them available globally */
-	poutput = output;
-	pvector = vector;
-	pinvec  = invec;
-	poutvec = outvec;
-
-	if (argc > 1 && argv[idx][0] == '-') {
-		for (ptr = (unsigned char *) &argv[idx][1]; *ptr; ptr++) {
-			switch (*ptr) {
-			case 'c':
-				com_fl = TRUE;
-				break;
-			case 'd':
-				del_fl = TRUE;
-				break;
-			case 's':
-				sq_fl = TRUE;
+	smalluint opts;
+	ssize_t read_chars;
+	size_t in_index, out_index;
+	unsigned last = UCHAR_MAX + 1; /* not equal to any char */
+	unsigned char coded, c;
+	char *str1 = xmalloc(TR_BUFSIZ);
+	char *str2 = xmalloc(TR_BUFSIZ);
+	int str2_length;
+	int str1_length;
+	char *vector = xzalloc(ASCII * 3);
+	char *invec  = vector + ASCII;
+	char *outvec = vector + ASCII * 2;
+
+#define TR_OPT_complement   (3 << 0)
+#define TR_OPT_delete       (1 << 2)
+#define TR_OPT_squeeze_reps (1 << 3)
+
+	for (i = 0; i < ASCII; i++) {
+		vector[i] = i;
+		/*invec[i] = outvec[i] = FALSE; - done by xzalloc */
+	}
+
+	/* -C/-c difference is that -C complements "characters",
+	 * and -c complements "values" (binary bytes I guess).
+	 * In POSIX locale, these are the same.
+	 */
+
+	opt_complementary = "-1";
+	opts = getopt32(argv, "+Ccds"); /* '+': stop at first non-option */
+	argv += optind;
+
+	str1_length = expand(*argv++, &str1);
+	str2_length = 0;
+	if (opts & TR_OPT_complement)
+		str1_length = complement(str1, str1_length);
+	if (*argv) {
+		if (argv[0][0] == '\0')
+			bb_error_msg_and_die("STRING2 cannot be empty");
+		str2_length = expand(*argv, &str2);
+		map(vector, str1, str1_length,
+				str2, str2_length);
+	}
+	for (i = 0; i < str1_length; i++)
+		invec[(unsigned char)(str1[i])] = TRUE;
+	for (i = 0; i < str2_length; i++)
+		outvec[(unsigned char)(str2[i])] = TRUE;
+
+	goto start_from;
+
+	/* In this loop, str1 space is reused as input buffer,
+	 * str2 - as output one. */
+	for (;;) {
+		/* If we're out of input, flush output and read more input. */
+		if ((ssize_t)in_index == read_chars) {
+			if (out_index) {
+				xwrite(STDOUT_FILENO, str2, out_index);
+ start_from:
+				out_index = 0;
+			}
+			read_chars = safe_read(STDIN_FILENO, str1, TR_BUFSIZ);
+			if (read_chars <= 0) {
+				if (read_chars < 0)
+					bb_perror_msg_and_die(bb_msg_read_error);
 				break;
-			default:
-				bb_show_usage();
 			}
+			in_index = 0;
 		}
-		idx++;
-	}
-	for (i = 0; i <= ASCII; i++) {
-		vector[i] = i;
-		invec[i] = outvec[i] = FALSE;
+		c = str1[in_index++];
+		if ((opts & TR_OPT_delete) && invec[c])
+			continue;
+		coded = vector[c];
+		if ((opts & TR_OPT_squeeze_reps) && last == coded
+		 && (invec[c] || outvec[coded])
+		) {
+			continue;
+		}
+		str2[out_index++] = last = coded;
 	}
 
-	if (argv[idx] != NULL) {
-		input_length = expand(argv[idx++], bb_common_bufsiz1);
-		if (com_fl)
-			input_length = complement(bb_common_bufsiz1, input_length);
-		if (argv[idx] != NULL) {
-			if (*argv[idx] == '\0')
-				bb_error_msg_and_die("STRING2 cannot be empty");
-			output_length = expand(argv[idx], output);
-			map(bb_common_bufsiz1, input_length, output, output_length);
-		}
-		for (i = 0; i < input_length; i++)
-			invec[(GCC4_IS_STUPID)bb_common_bufsiz1[i]] = TRUE;
-		for (i = 0; i < output_length; i++)
-			outvec[(GCC4_IS_STUPID)output[i]] = TRUE;
+	if (ENABLE_FEATURE_CLEAN_UP) {
+		free(vector);
+		free(str2);
+		free(str1);
 	}
-	convert();
-	return (0);
+
+	return EXIT_SUCCESS;
 }