--- trunk/mkinitrd-magellan/busybox/coreutils/tr.c 2010/04/29 20:38:48 983 +++ trunk/mkinitrd-magellan/busybox/coreutils/tr.c 2010/05/30 11:32:42 984 @@ -16,235 +16,284 @@ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. */ /* http://www.opengroup.org/onlinepubs/009695399/utilities/tr.html - * TODO: xdigit, graph, print + * TODO: graph, print */ #include "libbb.h" -#define ASCII 0377 +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 map(char *pvector, - unsigned char *string1, unsigned int string1_len, - unsigned char *string2, unsigned int string2_len) + 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[string1[i]] = last; + pvector[(unsigned char)(string1[i])] = last; else - pvector[string1[i]] = last = string2[j++]; + pvector[(unsigned char)(string1[i])] = last = string2[j++]; } } /* supported constructs: * Ranges, e.g., 0-9 ==> 0123456789 - * 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; + 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); + buffer[pos++] = bb_process_escape_sequence(&arg); continue; } if (arg[1] == '-') { /* "0-9..." */ ac = arg[2]; if (ac == '\0') { /* "0-": copy verbatim */ - *buffer++ = *arg++; /* copy '0' */ + buffer[pos++] = *arg++; /* copy '0' */ continue; /* next iter will copy '-' and stop */ } - i = *arg; + i = (unsigned char) *arg; while (i <= ac) /* ok: i is unsigned _int_ */ - *buffer++ = i++; + buffer[pos++] = i++; arg += 3; /* skip 0-9 */ continue; } - if (*arg == '[') { /* "[xyz..." */ + if ((ENABLE_FEATURE_TR_CLASSES || ENABLE_FEATURE_TR_EQUIV) + && *arg == '[' + ) { arg++; - i = *arg++; - /* "[xyz...", i=x, arg points to y */ - if (ENABLE_FEATURE_TR_CLASSES && i == ':') { + 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; -#define CLASS_invalid 0 /* we increment the retval */ -#define CLASS_alpha 1 -#define CLASS_alnum 2 -#define CLASS_digit 3 -#define CLASS_lower 4 -#define CLASS_upper 5 -#define CLASS_space 6 -#define CLASS_blank 7 -#define CLASS_punct 8 -#define CLASS_cntrl 9 -//#define CLASS_xdigit 10 -//#define CLASS_graph 11 -//#define CLASS_print 12 + "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; - { /* not really pretty.. */ - char *tmp = xstrndup(arg, 7); // warning: xdigit would need 8, not 7 - j = index_in_strings(classes, tmp) + 1; - free(tmp); - } - if (j == CLASS_alnum || j == CLASS_digit) { + 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; + buffer[pos++] = i; } if (j == CLASS_alpha || j == CLASS_alnum || j == CLASS_upper) { for (i = 'A'; i <= 'Z'; i++) - *buffer++ = i; + buffer[pos++] = i; } if (j == CLASS_alpha || j == CLASS_alnum || j == CLASS_lower) { for (i = 'a'; i <= 'z'; i++) - *buffer++ = i; + buffer[pos++] = i; } if (j == CLASS_space || j == CLASS_blank) { - *buffer++ = '\t'; + buffer[pos++] = '\t'; if (j == CLASS_space) { - *buffer++ = '\n'; - *buffer++ = '\v'; - *buffer++ = '\f'; - *buffer++ = '\r'; + buffer[pos++] = '\n'; + buffer[pos++] = '\v'; + buffer[pos++] = '\f'; + buffer[pos++] = '\r'; } - *buffer++ = ' '; + buffer[pos++] = ' '; } if (j == CLASS_punct || j == CLASS_cntrl) { - for (i = '\0'; i <= ASCII; i++) - if ((j == CLASS_punct && isprint(i) && !isalnum(i) && !isspace(i)) - || (j == CLASS_cntrl && iscntrl(i))) - *buffer++ = i; - } - if (j == CLASS_invalid) { - *buffer++ = '['; - *buffer++ = ':'; - continue; + 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; + } + } } - break; + if (j == CLASS_xdigit) { + for (i = 'A'; i <= 'F'; i++) { + buffer[pos + 6] = i | 0x20; + buffer[pos++] = i; + } + pos += 6; + } + continue; } /* "[xyz...", i=x, arg points to y */ if (ENABLE_FEATURE_TR_EQUIV && i == '=') { /* [=CHAR=] */ - *buffer++ = *arg; /* copy CHAR */ - if (!*arg || arg[1] != '=' || arg[2] != ']') + buffer[pos++] = *arg; /* copy CHAR */ + if (!arg[0] || arg[1] != '=' || arg[2] != ']') bb_show_usage(); arg += 3; /* skip CHAR=] */ continue; } - if (i == '\0' || *arg != '-') { /* not [x-...] - copy verbatim */ - *buffer++ = '['; - arg--; /* points to x */ - continue; /* copy all, including eventual ']' */ - } - /* [x-z] */ - arg++; /* skip - */ - if (arg[0] == '\0' || arg[1] != ']') - bb_show_usage(); - ac = *arg++; - while (i <= ac) - *buffer++ = i++; - arg++; /* skip ] */ - continue; + /* 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++ = *arg++; + 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) { - int i, j, ix; - char conv[ASCII + 2]; - - 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; + int len; + char conv[ASCII]; + unsigned char ch; + + 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) MAIN_EXTERNALLY_VISIBLE; int tr_main(int argc UNUSED_PARAM, char **argv) { - int output_length = 0, input_length; int i; - smalluint flags; - ssize_t read_chars = 0; - size_t in_index = 0, out_index = 0; + 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; - unsigned char *output = xmalloc(BUFSIZ); - char *vector = xzalloc((ASCII+1) * 3); - char *invec = vector + (ASCII+1); - char *outvec = vector + (ASCII+1) * 2; - -#define TR_OPT_complement (1 << 0) -#define TR_OPT_delete (1 << 1) -#define TR_OPT_squeeze_reps (1 << 2) - - flags = getopt32(argv, "+cds"); /* '+': stop at first non-option */ - argv += optind; + 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++) { + for (i = 0; i < ASCII; i++) { vector[i] = i; /*invec[i] = outvec[i] = FALSE; - done by xzalloc */ } -#define tr_buf bb_common_bufsiz1 - if (*argv != NULL) { - input_length = expand(*argv++, tr_buf); - if (flags & TR_OPT_complement) - input_length = complement(tr_buf, input_length); - if (*argv) { - if (argv[0][0] == '\0') - bb_error_msg_and_die("STRING2 cannot be empty"); - output_length = expand(*argv, (char *)output); - map(vector, (unsigned char *)tr_buf, input_length, output, output_length); - } - for (i = 0; i < input_length; i++) - invec[(unsigned char)tr_buf[i]] = TRUE; - for (i = 0; i < output_length; i++) - outvec[output[i]] = TRUE; + /* -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, (char *)output, out_index); + xwrite(STDOUT_FILENO, str2, out_index); + start_from: out_index = 0; } - read_chars = safe_read(STDIN_FILENO, tr_buf, BUFSIZ); + 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); - exit(EXIT_SUCCESS); + break; } in_index = 0; } - c = tr_buf[in_index++]; - coded = vector[c]; - if ((flags & TR_OPT_delete) && invec[c]) + c = str1[in_index++]; + if ((opts & TR_OPT_delete) && invec[c]) continue; - if ((flags & TR_OPT_squeeze_reps) && last == coded - && (invec[c] || outvec[coded])) + coded = vector[c]; + if ((opts & TR_OPT_squeeze_reps) && last == coded + && (invec[c] || outvec[coded]) + ) { continue; - output[out_index++] = last = coded; + } + str2[out_index++] = last = coded; } - /* NOTREACHED */ + return EXIT_SUCCESS; }