Ignore:
Timestamp:
Nov 6, 2007, 11:01:53 AM (13 years ago)
Author:
Bruno Cornec
Message:
  • Better output for mindi-busybox revision
  • Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
  • strace useful for debug
  • fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
  • fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
  • fix typo in label-partitions-as-necessary which doesn't seem to work
  • Update to busybox 1.7.2
  • perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

  • next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
  • small optimization in mindi on keyboard handling (one single find instead of multiple)
  • better interaction for USB device when launching mindi manually
  • attempt to automatically guess block disk size for ramdisk
  • fix typos in bkphw
  • Fix the remaining problem with UUID support for swap partitions
  • Updates mondoarchive man page for USB support
  • Adds preliminary Hardware support to mindi (Proliant SSSTK)
  • Tries to add udev support also for rhel4
  • Fix UUID support which was still broken.
  • Be conservative in test for the start-nfs script
  • Update config file for mindi-busybox for 1.7.2 migration
  • Try to run around a busybox bug (1.2.2 pb on inexistant links)
  • Add build content for mindi-busybox in pb
  • Remove distributions content for mindi-busybox
  • Fix a warning on inexistant raidtab
  • Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
  • Create MONDO_CACHE and use it everywhere + creation at start
  • Really never try to eject a USB device
  • Fix a issue with &> usage (replaced with 1> and 2>)
  • Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
  • tty modes correct to avoid sh error messages
  • Use ext3 normally and not ext2 instead
  • USB device should be corrected after reading (take 1st part)
  • Adds a mount_USB_here function derived from mount_CDROM_here
  • usb detection place before /dev detection in device name at restore time
  • Fix when restoring from USB: media is asked in interactive mode
  • Adds USB support for mondorestore
  • mount_cdrom => mount_media
  • elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
  • untar-and-softlink => untar (+ interface change)
  • suppress useless softlinks creation/removal in boot process
  • avoids udevd messages on groups
  • Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
  • skip existing big file creation
  • seems to work correctly for USB mindi boot
  • Adds group and tty link to udev conf
  • Always load usb-torage (even 2.6) to initiate USB bus discovery
  • Better printing of messages
  • Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
  • Links were not correctly done as non relative for modules in mindi
  • exclusion of modules denied now works
  • Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
  • Fix bugs for DENY_MODS handling
  • Add device /dev/console for udev
  • ide-generic should now really be excluded
  • Fix a bug in major number for tty
  • If udev then adds modprobe/insmod to rootfs
  • tty0 is also cretaed with udev
  • ide-generic put rather in DENY_MODS
  • udevd remove from deplist s handled in mindi directly
  • better default for mindi when using --usb
  • Handles dynamically linked busybox (in case we want to use it soon ;-)
  • Adds fixed devices to create for udev
  • ide-generic should not be part of the initrd when using libata v2
  • support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
  • Improvement in udev support (do not use cl options not available in busybox)
  • Udev in mindi
    • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
    • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
    • add support for 64 bits udev
  • Try to render MyInsmod? silent at boot time
  • Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
  • We also need vaft format support for USB boot
  • Adds libusual support (Ubuntu 7.10 needs it for USB)
  • Improve Ubuntu/Debian? keyboard detection and support
  • pbinit adapted to new pb (0.8.10). Filtering of docs done in it
  • Suppress some mondo warnings and errors on USB again
  • Tries to fix lack of files in deb mindi package
  • Verify should now work for USB devices
  • More log/mesages improvement for USB support
  • - Supress g_erase_tmpdir_and_scratchdir
  • Improve some log messages for USB support
  • Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
  • Improve mindi-busybox build
  • In conformity with pb 0.8.9
  • Add support for Ubuntu 7.10 in build process
  • Add USB Key button to Menu UI (CD streamer removed)
  • Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
  • Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René? Ribaud).
  • Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
  • Put mondorescue in conformity with new pb filtering rules
  • Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
  • Unmounting USB device before removal of temporary scratchdir
  • Stil refining USB copy back to mondo (one command was not executed)
  • No need to have the image subdor in the csratchdir when USB.
  • umount the USB partition before attempting to use it
  • Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/stable/mindi-busybox/coreutils/cut.c

    r821 r1770  
    1 /* vi: set sw=8 ts=8: */
     1/* vi: set sw=4 ts=4: */
    22/*
    33 * cut.c - minimalist version of cut
     
    55 * Copyright (C) 1999,2000,2001 by Lineo, inc.
    66 * Written by Mark Whitley <markw@codepoet.org>
     7 * debloated by Bernhard Fischer
    78 *
    8  * This program is free software; you can redistribute it and/or modify
    9  * it under the terms of the GNU General Public License as published by
    10  * the Free Software Foundation; either version 2 of the License, or
    11  * (at your option) any later version.
    12  *
    13  * This program is distributed in the hope that it will be useful,
    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    16  * General Public License for more details.
    17  *
    18  * You should have received a copy of the GNU General Public License
    19  * along with this program; if not, write to the Free Software
    20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    21  *
     9 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
    2210 */
    2311
    24 #include <stdio.h>
    25 #include <stdlib.h>
    26 #include <unistd.h>
    27 #include <string.h>
    28 #include <limits.h>
    29 #include "busybox.h"
     12#include "libbb.h"
     13
     14/* This is a NOEXEC applet. Be very careful! */
    3015
    3116
    3217/* option vars */
    33 static const char optstring[] = "b:c:f:d:sn";
    34 #define OPT_BYTE_FLGS    1
    35 #define OPT_CHAR_FLGS    2
    36 #define OPT_FIELDS_FLGS  4
    37 #define OPT_DELIM_FLGS   8
    38 #define OPT_SUPRESS_FLGS 16
    39 static char part; /* (b)yte, (c)har, (f)ields */
    40 static unsigned int supress_non_delimited_lines;
    41 static char delim = '\t'; /* delimiter, default is tab */
     18static const char optstring[] ALIGN1 = "b:c:f:d:sn";
     19#define CUT_OPT_BYTE_FLGS   (1<<0)
     20#define CUT_OPT_CHAR_FLGS   (1<<1)
     21#define CUT_OPT_FIELDS_FLGS (1<<2)
     22#define CUT_OPT_DELIM_FLGS  (1<<3)
     23#define CUT_OPT_SUPPRESS_FLGS (1<<4)
     24
     25static char delim = '\t';   /* delimiter, default is tab */
    4226
    4327struct cut_list {
     
    5236};
    5337
    54 static struct cut_list *cut_lists = NULL; /* growable array holding a series of lists */
    55 static unsigned int nlists = 0; /* number of elements in above list */
     38/* growable array holding a series of lists */
     39static struct cut_list *cut_lists;
     40static unsigned int nlists; /* number of elements in above list */
    5641
    5742
    5843static int cmpfunc(const void *a, const void *b)
    5944{
    60     struct cut_list *la = (struct cut_list *)a;
    61     struct cut_list *lb = (struct cut_list *)b;
    62 
    63     if (la->startpos > lb->startpos)
    64         return 1;
    65     if (la->startpos < lb->startpos)
    66         return -1;
    67     return 0;
     45    return (((struct cut_list *) a)->startpos -
     46            ((struct cut_list *) b)->startpos);
     47
    6848}
    6949
    70 
    71 /*
    72  * parse_lists() - parses a list and puts values into startpos and endpos.
    73  * valid list formats: N, N-, N-M, -M
    74  * more than one list can be separated by commas
    75  */
    76 static void parse_lists(char *lists)
    77 {
    78     char *ltok = NULL;
    79     char *ntok = NULL;
    80     char *junk;
    81     int s = 0, e = 0;
    82 
    83     /* take apart the lists, one by one (they are separated with commas */
    84     while ((ltok = strsep(&lists, ",")) != NULL) {
    85 
    86         /* it's actually legal to pass an empty list */
    87         if (strlen(ltok) == 0)
    88             continue;
    89 
    90         /* get the start pos */
    91         ntok = strsep(&ltok, "-");
    92         if (ntok == NULL) {
    93             fprintf(stderr, "Help ntok is null for starting position! What do I do?\n");
    94         } else if (strlen(ntok) == 0) {
    95             s = BOL;
    96         } else {
    97             s = strtoul(ntok, &junk, 10);
    98             if(*junk != '\0' || s < 0)
    99                 bb_error_msg_and_die("invalid byte or field list");
    100 
    101             /* account for the fact that arrays are zero based, while the user
    102              * expects the first char on the line to be char # 1 */
    103             if (s != 0)
    104                 s--;
    105         }
    106 
    107         /* get the end pos */
    108         ntok = strsep(&ltok, "-");
    109         if (ntok == NULL) {
    110             e = NON_RANGE;
    111         } else if (strlen(ntok) == 0) {
    112             e = EOL;
    113         } else {
    114             e = strtoul(ntok, &junk, 10);
    115             if(*junk != '\0' || e < 0)
    116                 bb_error_msg_and_die("invalid byte or field list");
    117             /* if the user specified and end position of 0, that means "til the
    118              * end of the line */
    119             if (e == 0)
    120                 e = INT_MAX;
    121             e--; /* again, arrays are zero based, lines are 1 based */
    122             if (e == s)
    123                 e = NON_RANGE;
    124         }
    125 
    126         /* if there's something left to tokenize, the user past an invalid list */
    127         if (ltok)
    128             bb_error_msg_and_die("invalid byte or field list");
    129 
    130         /* add the new list */
    131         cut_lists = xrealloc(cut_lists, sizeof(struct cut_list) * (++nlists));
    132         cut_lists[nlists-1].startpos = s;
    133         cut_lists[nlists-1].endpos = e;
    134     }
    135 
    136     /* make sure we got some cut positions out of all that */
    137     if (nlists == 0)
    138         bb_error_msg_and_die("missing list of positions");
    139 
    140     /* now that the lists are parsed, we need to sort them to make life easier
    141      * on us when it comes time to print the chars / fields / lines */
    142     qsort(cut_lists, nlists, sizeof(struct cut_list), cmpfunc);
    143 
    144 }
    145 
    146 
    147 static void cut_line_by_chars(const char *line)
    148 {
    149     int c, l;
    150     /* set up a list so we can keep track of what's been printed */
    151     char *printed = xcalloc(strlen(line), sizeof(char));
    152 
    153     /* print the chars specified in each cut list */
    154     for (c = 0; c < nlists; c++) {
    155         l = cut_lists[c].startpos;
    156         while (l < strlen(line)) {
    157             if (!printed[l]) {
    158                 putchar(line[l]);
    159                 printed[l] = 'X';
    160             }
    161             l++;
    162             if (cut_lists[c].endpos == NON_RANGE || l > cut_lists[c].endpos)
    163                 break;
    164         }
    165     }
    166     putchar('\n'); /* cuz we were handed a chomped line */
    167     free(printed);
    168 }
    169 
    170 
    171 static void cut_line_by_fields(char *line)
    172 {
    173     int c, f;
    174     int ndelim = -1; /* zero-based / one-based problem */
    175     int nfields_printed = 0;
    176     char *field = NULL;
    177     char d[2] = { delim, 0 };
    178     char *printed;
    179 
    180     /* test the easy case first: does this line contain any delimiters? */
    181     if (strchr(line, delim) == NULL) {
    182         if (!supress_non_delimited_lines)
    183             puts(line);
    184         return;
    185     }
    186 
    187     /* set up a list so we can keep track of what's been printed */
    188     printed = xcalloc(strlen(line), sizeof(char));
    189 
    190     /* process each list on this line, for as long as we've got a line to process */
    191     for (c = 0; c < nlists && line; c++) {
    192         f = cut_lists[c].startpos;
    193         do {
    194 
    195             /* find the field we're looking for */
    196             while (line && ndelim < f) {
    197                 field = strsep(&line, d);
    198                 ndelim++;
    199             }
    200 
    201             /* we found it, and it hasn't been printed yet */
    202             if (field && ndelim == f && !printed[ndelim]) {
    203                 /* if this isn't our first time through, we need to print the
    204                  * delimiter after the last field that was printed */
    205                 if (nfields_printed > 0)
    206                     putchar(delim);
    207                 fputs(field, stdout);
    208                 printed[ndelim] = 'X';
    209                 nfields_printed++;
    210             }
    211 
    212             f++;
    213 
    214             /* keep going as long as we have a line to work with, this is a
    215              * list, and we're not at the end of that list */
    216         } while (line && cut_lists[c].endpos != NON_RANGE && f <= cut_lists[c].endpos);
    217     }
    218 
    219     /* if we printed anything at all, we need to finish it with a newline cuz
    220      * we were handed a chomped line */
    221     putchar('\n');
    222 
    223     free(printed);
    224 }
    225 
    226 
    227 static void cut_file_by_lines(const char *line, unsigned int linenum)
    228 {
    229     static int c = 0;
    230     static int l = -1;
    231 
    232     /* I can't initialize this above cuz the "initializer isn't
    233      * constant" *sigh* */
    234     if (l == -1)
    235         l = cut_lists[c].startpos;
    236 
    237     /* get out if we have no more lists to process or if the lines are lower
    238      * than what we're interested in */
    239     if (c >= nlists || linenum < l)
    240         return;
    241 
    242     /* if the line we're looking for is lower than the one we were passed, it
    243      * means we displayed it already, so move on */
    244     while (l < linenum) {
    245         l++;
    246         /* move on to the next list if we're at the end of this one */
    247         if (cut_lists[c].endpos == NON_RANGE || l > cut_lists[c].endpos) {
    248             c++;
    249             /* get out if there's no more lists to process */
    250             if (c >= nlists)
    251                 return;
    252             l = cut_lists[c].startpos;
    253             /* get out if the current line is lower than the one we just became
    254              * interested in */
    255             if (linenum < l)
    256                 return;
    257         }
    258     }
    259 
    260     /* If we made it here, it means we've found the line we're looking for, so print it */
    261     puts(line);
    262 }
    263 
    264 
    265 /*
    266  * snippy-snip
    267  */
    268 static void cut_file(FILE *file)
     50static void cut_file(FILE * file)
    26951{
    27052    char *line = NULL;
    271     unsigned int linenum = 0; /* keep these zero-based to be consistent */
     53    unsigned int linenum = 0;   /* keep these zero-based to be consistent */
    27254
    27355    /* go through every line in the file */
    274     while ((line = bb_get_chomped_line_from_file(file)) != NULL) {
     56    while ((line = xmalloc_getline(file)) != NULL) {
     57
     58        /* set up a list so we can keep track of what's been printed */
     59        char * printed = xzalloc(strlen(line) * sizeof(char));
     60        char * orig_line = line;
     61        unsigned int cl_pos = 0;
     62        int spos;
    27563
    27664        /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
    277         if ((part & (OPT_CHAR_FLGS | OPT_BYTE_FLGS)))
    278             cut_line_by_chars(line);
    279 
    280         /* cut based on fields */
    281         else {
    282             if (delim == '\n')
    283                 cut_file_by_lines(line, linenum);
    284             else
    285                 cut_line_by_fields(line);
    286         }
    287 
     65        if (option_mask32 & (CUT_OPT_CHAR_FLGS | CUT_OPT_BYTE_FLGS)) {
     66            /* print the chars specified in each cut list */
     67            for (; cl_pos < nlists; cl_pos++) {
     68                spos = cut_lists[cl_pos].startpos;
     69                while (spos < strlen(line)) {
     70                    if (!printed[spos]) {
     71                        printed[spos] = 'X';
     72                        putchar(line[spos]);
     73                    }
     74                    spos++;
     75                    if (spos > cut_lists[cl_pos].endpos
     76                        || cut_lists[cl_pos].endpos == NON_RANGE)
     77                        break;
     78                }
     79            }
     80        } else if (delim == '\n') { /* cut by lines */
     81            spos = cut_lists[cl_pos].startpos;
     82
     83            /* get out if we have no more lists to process or if the lines
     84             * are lower than what we're interested in */
     85            if (linenum < spos || cl_pos >= nlists)
     86                goto next_line;
     87
     88            /* if the line we're looking for is lower than the one we were
     89             * passed, it means we displayed it already, so move on */
     90            while (spos < linenum) {
     91                spos++;
     92                /* go to the next list if we're at the end of this one */
     93                if (spos > cut_lists[cl_pos].endpos
     94                    || cut_lists[cl_pos].endpos == NON_RANGE) {
     95                    cl_pos++;
     96                    /* get out if there's no more lists to process */
     97                    if (cl_pos >= nlists)
     98                        goto next_line;
     99                    spos = cut_lists[cl_pos].startpos;
     100                    /* get out if the current line is lower than the one
     101                     * we just became interested in */
     102                    if (linenum < spos)
     103                        goto next_line;
     104                }
     105            }
     106
     107            /* If we made it here, it means we've found the line we're
     108             * looking for, so print it */
     109            puts(line);
     110            goto next_line;
     111        } else {        /* cut by fields */
     112            int ndelim = -1;    /* zero-based / one-based problem */
     113            int nfields_printed = 0;
     114            char *field = NULL;
     115            const char delimiter[2] = { delim, 0 };
     116
     117            /* does this line contain any delimiters? */
     118            if (strchr(line, delim) == NULL) {
     119                if (!(option_mask32 & CUT_OPT_SUPPRESS_FLGS))
     120                    puts(line);
     121                goto next_line;
     122            }
     123
     124            /* process each list on this line, for as long as we've got
     125             * a line to process */
     126            for (; cl_pos < nlists && line; cl_pos++) {
     127                spos = cut_lists[cl_pos].startpos;
     128                do {
     129                    /* find the field we're looking for */
     130                    while (line && ndelim < spos) {
     131                        field = strsep(&line, delimiter);
     132                        ndelim++;
     133                    }
     134
     135                    /* we found it, and it hasn't been printed yet */
     136                    if (field && ndelim == spos && !printed[ndelim]) {
     137                        /* if this isn't our first time through, we need to
     138                         * print the delimiter after the last field that was
     139                         * printed */
     140                        if (nfields_printed > 0)
     141                            putchar(delim);
     142                        fputs(field, stdout);
     143                        printed[ndelim] = 'X';
     144                        nfields_printed++;  /* shouldn't overflow.. */
     145                    }
     146
     147                    spos++;
     148
     149                    /* keep going as long as we have a line to work with,
     150                     * this is a list, and we're not at the end of that
     151                     * list */
     152                } while (spos <= cut_lists[cl_pos].endpos && line
     153                         && cut_lists[cl_pos].endpos != NON_RANGE);
     154            }
     155        }
     156        /* if we printed anything at all, we need to finish it with a
     157         * newline cuz we were handed a chomped line */
     158        putchar('\n');
     159 next_line:
    288160        linenum++;
    289         free(line);
     161        free(printed);
     162        free(orig_line);
    290163    }
    291164}
    292165
    293 
     166static const char _op_on_field[] ALIGN1 = " only when operating on fields";
     167
     168int cut_main(int argc, char **argv);
    294169int cut_main(int argc, char **argv)
    295170{
    296     unsigned long opt;
    297     char *sopt, *sdopt;
    298 
    299     bb_opt_complementally = "b--bcf:c--bcf:f--bcf";
    300     opt = bb_getopt_ulflags(argc, argv, optstring, &sopt, &sopt, &sopt, &sdopt);
    301     part = opt & (OPT_BYTE_FLGS|OPT_CHAR_FLGS|OPT_FIELDS_FLGS);
    302     if(part == 0)
    303         bb_error_msg_and_die("you must specify a list of bytes, characters, or fields");
    304     if(opt & BB_GETOPT_ERROR)
    305         bb_error_msg_and_die("only one type of list may be specified");
    306     parse_lists(sopt);
    307     if((opt & (OPT_DELIM_FLGS))) {
    308         if (strlen(sdopt) > 1) {
     171    char *sopt, *ltok;
     172
     173    opt_complementary = "b--bcf:c--bcf:f--bcf";
     174    getopt32(argv, optstring, &sopt, &sopt, &sopt, &ltok);
     175//  argc -= optind;
     176    argv += optind;
     177    if (!(option_mask32 & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS)))
     178        bb_error_msg_and_die("expected a list of bytes, characters, or fields");
     179
     180    if (option_mask32 & CUT_OPT_DELIM_FLGS) {
     181        if (strlen(ltok) > 1) {
    309182            bb_error_msg_and_die("the delimiter must be a single character");
    310183        }
    311         delim = sdopt[0];
    312     }
    313     supress_non_delimited_lines = opt & OPT_SUPRESS_FLGS;
     184        delim = ltok[0];
     185    }
    314186
    315187    /*  non-field (char or byte) cutting has some special handling */
    316     if (part != OPT_FIELDS_FLGS) {
    317         if (supress_non_delimited_lines) {
    318             bb_error_msg_and_die("suppressing non-delimited lines makes sense"
    319                     " only when operating on fields");
     188    if (!(option_mask32 & CUT_OPT_FIELDS_FLGS)) {
     189        if (option_mask32 & CUT_OPT_SUPPRESS_FLGS) {
     190            bb_error_msg_and_die
     191                ("suppressing non-delimited lines makes sense%s",
     192                 _op_on_field);
    320193        }
    321194        if (delim != '\t') {
    322             bb_error_msg_and_die("a delimiter may be specified only when operating on fields");
    323         }
    324     }
    325 
    326     /* argv[(optind)..(argc-1)] should be names of file to process. If no
     195            bb_error_msg_and_die
     196                ("a delimiter may be specified%s", _op_on_field);
     197        }
     198    }
     199
     200    /*
     201     * parse list and put values into startpos and endpos.
     202     * valid list formats: N, N-, N-M, -M
     203     * more than one list can be separated by commas
     204     */
     205    {
     206        char *ntok;
     207        int s = 0, e = 0;
     208
     209        /* take apart the lists, one by one (they are separated with commas */
     210        while ((ltok = strsep(&sopt, ",")) != NULL) {
     211
     212            /* it's actually legal to pass an empty list */
     213            if (strlen(ltok) == 0)
     214                continue;
     215
     216            /* get the start pos */
     217            ntok = strsep(&ltok, "-");
     218            if (ntok == NULL) {
     219                bb_error_msg
     220                    ("internal error: ntok is null for start pos!?\n");
     221            } else if (strlen(ntok) == 0) {
     222                s = BOL;
     223            } else {
     224                s = xatoi_u(ntok);
     225                /* account for the fact that arrays are zero based, while
     226                 * the user expects the first char on the line to be char #1 */
     227                if (s != 0)
     228                    s--;
     229            }
     230
     231            /* get the end pos */
     232            ntok = strsep(&ltok, "-");
     233            if (ntok == NULL) {
     234                e = NON_RANGE;
     235            } else if (strlen(ntok) == 0) {
     236                e = EOL;
     237            } else {
     238                e = xatoi_u(ntok);
     239                /* if the user specified and end position of 0, that means "til the
     240                 * end of the line */
     241                if (e == 0)
     242                    e = EOL;
     243                e--;    /* again, arrays are zero based, lines are 1 based */
     244                if (e == s)
     245                    e = NON_RANGE;
     246            }
     247
     248            /* if there's something left to tokenize, the user passed
     249             * an invalid list */
     250            if (ltok)
     251                bb_error_msg_and_die("invalid byte or field list");
     252
     253            /* add the new list */
     254            cut_lists = xrealloc(cut_lists, sizeof(struct cut_list) * (++nlists));
     255            cut_lists[nlists-1].startpos = s;
     256            cut_lists[nlists-1].endpos = e;
     257        }
     258
     259        /* make sure we got some cut positions out of all that */
     260        if (nlists == 0)
     261            bb_error_msg_and_die("missing list of positions");
     262
     263        /* now that the lists are parsed, we need to sort them to make life
     264         * easier on us when it comes time to print the chars / fields / lines
     265         */
     266        qsort(cut_lists, nlists, sizeof(struct cut_list), cmpfunc);
     267    }
     268
     269    /* argv[0..argc-1] should be names of file to process. If no
    327270     * files were specified or '-' was specified, take input from stdin.
    328271     * Otherwise, we process all the files specified. */
    329     if (argv[optind] == NULL || (strcmp(argv[optind], "-") == 0)) {
     272    if (argv[0] == NULL || LONE_DASH(argv[0])) {
    330273        cut_file(stdin);
    331     }
    332     else {
    333         int i;
     274    } else {
    334275        FILE *file;
    335         for (i = optind; i < argc; i++) {
    336             file = bb_wfopen(argv[i], "r");
    337             if(file) {
     276
     277        do {
     278            file = fopen_or_warn(argv[0], "r");
     279            if (file) {
    338280                cut_file(file);
    339281                fclose(file);
    340282            }
    341         }
    342     }
    343 
     283        } while (*++argv);
     284    }
     285    if (ENABLE_FEATURE_CLEAN_UP)
     286        free(cut_lists);
    344287    return EXIT_SUCCESS;
    345288}
Note: See TracChangeset for help on using the changeset viewer.