Home | History | Annotate | Line # | Download | only in split
split.c revision 1.6.6.1
      1  1.6.6.1  wrstuden /*	$NetBSD: split.c,v 1.6.6.1 1999/12/27 18:37:10 wrstuden Exp $	*/
      2      1.4       jtc 
      3      1.1       cgd /*
      4      1.4       jtc  * Copyright (c) 1987, 1993, 1994
      5      1.4       jtc  *	The Regents of the University of California.  All rights reserved.
      6      1.1       cgd  *
      7      1.1       cgd  * Redistribution and use in source and binary forms, with or without
      8      1.1       cgd  * modification, are permitted provided that the following conditions
      9      1.1       cgd  * are met:
     10      1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     11      1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     12      1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     13      1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     14      1.1       cgd  *    documentation and/or other materials provided with the distribution.
     15      1.1       cgd  * 3. All advertising materials mentioning features or use of this software
     16      1.1       cgd  *    must display the following acknowledgement:
     17      1.1       cgd  *	This product includes software developed by the University of
     18      1.1       cgd  *	California, Berkeley and its contributors.
     19      1.1       cgd  * 4. Neither the name of the University nor the names of its contributors
     20      1.1       cgd  *    may be used to endorse or promote products derived from this software
     21      1.1       cgd  *    without specific prior written permission.
     22      1.1       cgd  *
     23      1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24      1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25      1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26      1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27      1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28      1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29      1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30      1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31      1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32      1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33      1.1       cgd  * SUCH DAMAGE.
     34      1.1       cgd  */
     35      1.1       cgd 
     36      1.6     lukem #include <sys/cdefs.h>
     37      1.1       cgd #ifndef lint
     38      1.6     lukem __COPYRIGHT("@(#) Copyright (c) 1987, 1993, 1994\n\
     39      1.6     lukem 	The Regents of the University of California.  All rights reserved.\n");
     40      1.1       cgd #endif /* not lint */
     41      1.1       cgd 
     42      1.1       cgd #ifndef lint
     43      1.4       jtc #if 0
     44      1.5       jtc static char sccsid[] = "@(#)split.c	8.3 (Berkeley) 4/25/94";
     45      1.4       jtc #endif
     46  1.6.6.1  wrstuden __RCSID("$NetBSD: split.c,v 1.6.6.1 1999/12/27 18:37:10 wrstuden Exp $");
     47      1.1       cgd #endif /* not lint */
     48      1.1       cgd 
     49      1.1       cgd #include <sys/param.h>
     50      1.4       jtc 
     51      1.4       jtc #include <ctype.h>
     52      1.4       jtc #include <err.h>
     53      1.4       jtc #include <fcntl.h>
     54      1.1       cgd #include <stdio.h>
     55      1.4       jtc #include <stdlib.h>
     56      1.4       jtc #include <string.h>
     57      1.4       jtc #include <unistd.h>
     58      1.4       jtc 
     59      1.4       jtc #define DEFLINE	1000			/* Default num lines per file. */
     60      1.4       jtc 
     61      1.4       jtc long	 bytecnt;			/* Byte count to split on. */
     62      1.4       jtc long	 numlines;			/* Line count to split on. */
     63      1.4       jtc int	 file_open;			/* If a file open. */
     64      1.4       jtc int	 ifd = -1, ofd = -1;		/* Input/output file descriptors. */
     65      1.4       jtc char	 bfr[MAXBSIZE];			/* I/O buffer. */
     66      1.4       jtc char	 fname[MAXPATHLEN];		/* File name prefix. */
     67      1.4       jtc 
     68      1.6     lukem int  main __P((int, char **));
     69      1.4       jtc void newfile __P((void));
     70      1.4       jtc void split1 __P((void));
     71      1.4       jtc void split2 __P((void));
     72      1.4       jtc void usage __P((void));
     73      1.1       cgd 
     74      1.4       jtc int
     75      1.1       cgd main(argc, argv)
     76      1.1       cgd 	int argc;
     77      1.4       jtc 	char *argv[];
     78      1.1       cgd {
     79      1.4       jtc 	int ch;
     80      1.4       jtc 	char *ep, *p;
     81      1.4       jtc 
     82      1.6     lukem 	while ((ch = getopt(argc, argv, "-0123456789b:l:")) != -1)
     83      1.4       jtc 		switch (ch) {
     84      1.4       jtc 		case '0': case '1': case '2': case '3': case '4':
     85      1.4       jtc 		case '5': case '6': case '7': case '8': case '9':
     86      1.4       jtc 			/*
     87      1.4       jtc 			 * Undocumented kludge: split was originally designed
     88      1.4       jtc 			 * to take a number after a dash.
     89      1.4       jtc 			 */
     90      1.4       jtc 			if (numlines == 0) {
     91      1.4       jtc 				p = argv[optind - 1];
     92      1.4       jtc 				if (p[0] == '-' && p[1] == ch && !p[2])
     93      1.4       jtc 					numlines = strtol(++p, &ep, 10);
     94      1.4       jtc 				else
     95      1.4       jtc 					numlines =
     96      1.4       jtc 					    strtol(argv[optind] + 1, &ep, 10);
     97      1.4       jtc 				if (numlines <= 0 || *ep)
     98      1.4       jtc 					errx(1,
     99      1.4       jtc 					    "%s: illegal line count.", optarg);
    100      1.1       cgd 			}
    101      1.4       jtc 			break;
    102      1.4       jtc 		case '-':		/* Undocumented: historic stdin flag. */
    103      1.4       jtc 			if (ifd != -1)
    104      1.4       jtc 				usage();
    105      1.4       jtc 			ifd = 0;
    106      1.4       jtc 			break;
    107      1.4       jtc 		case 'b':		/* Byte count. */
    108      1.4       jtc 			if ((bytecnt = strtol(optarg, &ep, 10)) <= 0 ||
    109      1.6     lukem 			    (*ep != '\0' && *ep != 'k' && *ep != 'm'))
    110      1.4       jtc 				errx(1, "%s: illegal byte count.", optarg);
    111      1.4       jtc 			if (*ep == 'k')
    112      1.4       jtc 				bytecnt *= 1024;
    113      1.4       jtc 			else if (*ep == 'm')
    114      1.4       jtc 				bytecnt *= 1048576;
    115      1.4       jtc 			break;
    116      1.4       jtc 		case 'l':		/* Line count. */
    117      1.4       jtc 			if (numlines != 0)
    118      1.4       jtc 				usage();
    119      1.5       jtc 			if ((numlines = strtol(optarg, &ep, 10)) <= 0 || *ep)
    120      1.4       jtc 				errx(1, "%s: illegal line count.", optarg);
    121      1.4       jtc 			break;
    122      1.4       jtc 		default:
    123      1.4       jtc 			usage();
    124      1.4       jtc 		}
    125      1.4       jtc 	argv += optind;
    126      1.4       jtc 	argc -= optind;
    127      1.4       jtc 
    128      1.4       jtc 	if (*argv != NULL)
    129      1.4       jtc 		if (ifd == -1) {		/* Input file. */
    130      1.4       jtc 			if ((ifd = open(*argv, O_RDONLY, 0)) < 0)
    131      1.4       jtc 				err(1, "%s", *argv);
    132      1.4       jtc 			++argv;
    133      1.1       cgd 		}
    134      1.4       jtc 	if (*argv != NULL)			/* File name prefix. */
    135      1.4       jtc 		(void)strcpy(fname, *argv++);
    136      1.4       jtc 	if (*argv != NULL)
    137      1.4       jtc 		usage();
    138      1.4       jtc 
    139      1.4       jtc 	if (numlines == 0)
    140      1.4       jtc 		numlines = DEFLINE;
    141      1.4       jtc 	else if (bytecnt)
    142      1.4       jtc 		usage();
    143      1.4       jtc 
    144      1.4       jtc 	if (ifd == -1)				/* Stdin by default. */
    145      1.1       cgd 		ifd = 0;
    146      1.4       jtc 
    147      1.4       jtc 	if (bytecnt) {
    148      1.1       cgd 		split1();
    149      1.4       jtc 		exit (0);
    150      1.4       jtc 	}
    151      1.1       cgd 	split2();
    152      1.1       cgd 	exit(0);
    153      1.1       cgd }
    154      1.1       cgd 
    155      1.1       cgd /*
    156      1.1       cgd  * split1 --
    157      1.4       jtc  *	Split the input by bytes.
    158      1.1       cgd  */
    159      1.4       jtc void
    160      1.1       cgd split1()
    161      1.1       cgd {
    162      1.4       jtc 	long bcnt;
    163      1.4       jtc 	int dist, len;
    164      1.4       jtc 	char *C;
    165      1.1       cgd 
    166      1.1       cgd 	for (bcnt = 0;;)
    167      1.4       jtc 		switch (len = read(ifd, bfr, MAXBSIZE)) {
    168      1.1       cgd 		case 0:
    169      1.4       jtc 			exit(0);
    170      1.4       jtc 		case -1:
    171      1.4       jtc 			err(1, "read");
    172      1.4       jtc 			/* NOTREACHED */
    173      1.1       cgd 		default:
    174      1.1       cgd 			if (!file_open) {
    175      1.1       cgd 				newfile();
    176      1.4       jtc 				file_open = 1;
    177      1.1       cgd 			}
    178      1.1       cgd 			if (bcnt + len >= bytecnt) {
    179      1.1       cgd 				dist = bytecnt - bcnt;
    180      1.1       cgd 				if (write(ofd, bfr, dist) != dist)
    181      1.4       jtc 					err(1, "write");
    182      1.1       cgd 				len -= dist;
    183      1.4       jtc 				for (C = bfr + dist; len >= bytecnt;
    184      1.4       jtc 				    len -= bytecnt, C += bytecnt) {
    185      1.1       cgd 					newfile();
    186      1.4       jtc 					if (write(ofd,
    187      1.4       jtc 					    C, (int)bytecnt) != bytecnt)
    188      1.4       jtc 						err(1, "write");
    189      1.1       cgd 				}
    190      1.1       cgd 				if (len) {
    191      1.1       cgd 					newfile();
    192      1.1       cgd 					if (write(ofd, C, len) != len)
    193      1.4       jtc 						err(1, "write");
    194      1.4       jtc 				} else
    195      1.4       jtc 					file_open = 0;
    196      1.1       cgd 				bcnt = len;
    197      1.4       jtc 			} else {
    198      1.1       cgd 				bcnt += len;
    199      1.1       cgd 				if (write(ofd, bfr, len) != len)
    200      1.4       jtc 					err(1, "write");
    201      1.1       cgd 			}
    202      1.1       cgd 		}
    203      1.1       cgd }
    204      1.1       cgd 
    205      1.1       cgd /*
    206      1.1       cgd  * split2 --
    207      1.4       jtc  *	Split the input by lines.
    208      1.1       cgd  */
    209      1.4       jtc void
    210      1.1       cgd split2()
    211      1.1       cgd {
    212      1.4       jtc 	long lcnt;
    213      1.4       jtc 	int len, bcnt;
    214      1.4       jtc 	char *Ce, *Cs;
    215      1.1       cgd 
    216      1.1       cgd 	for (lcnt = 0;;)
    217      1.4       jtc 		switch (len = read(ifd, bfr, MAXBSIZE)) {
    218      1.1       cgd 		case 0:
    219      1.1       cgd 			exit(0);
    220      1.4       jtc 		case -1:
    221      1.4       jtc 			err(1, "read");
    222      1.4       jtc 			/* NOTREACHED */
    223      1.1       cgd 		default:
    224      1.1       cgd 			if (!file_open) {
    225      1.1       cgd 				newfile();
    226      1.4       jtc 				file_open = 1;
    227      1.1       cgd 			}
    228      1.1       cgd 			for (Cs = Ce = bfr; len--; Ce++)
    229      1.1       cgd 				if (*Ce == '\n' && ++lcnt == numlines) {
    230      1.1       cgd 					bcnt = Ce - Cs + 1;
    231      1.1       cgd 					if (write(ofd, Cs, bcnt) != bcnt)
    232      1.4       jtc 						err(1, "write");
    233      1.1       cgd 					lcnt = 0;
    234      1.1       cgd 					Cs = Ce + 1;
    235      1.1       cgd 					if (len)
    236      1.1       cgd 						newfile();
    237      1.1       cgd 					else
    238      1.4       jtc 						file_open = 0;
    239      1.1       cgd 				}
    240      1.1       cgd 			if (Cs < Ce) {
    241      1.1       cgd 				bcnt = Ce - Cs;
    242      1.1       cgd 				if (write(ofd, Cs, bcnt) != bcnt)
    243      1.4       jtc 					err(1, "write");
    244      1.1       cgd 			}
    245      1.1       cgd 		}
    246      1.1       cgd }
    247      1.1       cgd 
    248      1.1       cgd /*
    249      1.1       cgd  * newfile --
    250      1.4       jtc  *	Open a new output file.
    251      1.1       cgd  */
    252      1.4       jtc void
    253      1.1       cgd newfile()
    254      1.1       cgd {
    255      1.1       cgd 	static long fnum;
    256      1.4       jtc 	static int defname;
    257      1.1       cgd 	static char *fpnt;
    258      1.1       cgd 
    259      1.4       jtc 	if (ofd == -1) {
    260      1.4       jtc 		if (fname[0] == '\0') {
    261      1.1       cgd 			fname[0] = 'x';
    262      1.1       cgd 			fpnt = fname + 1;
    263      1.4       jtc 			defname = 1;
    264      1.4       jtc 		} else {
    265      1.4       jtc 			fpnt = fname + strlen(fname);
    266      1.4       jtc 			defname = 0;
    267      1.1       cgd 		}
    268      1.1       cgd 		ofd = fileno(stdout);
    269      1.1       cgd 	}
    270      1.1       cgd 	/*
    271      1.4       jtc 	 * Hack to increase max files; original code wandered through
    272      1.1       cgd 	 * magic characters.  Maximum files is 3 * 26 * 26 == 2028
    273      1.1       cgd 	 */
    274      1.1       cgd #define MAXFILES	676
    275      1.1       cgd 	if (fnum == MAXFILES) {
    276      1.4       jtc 		if (!defname || fname[0] == 'z')
    277      1.4       jtc 			errx(1, "too many files.");
    278      1.1       cgd 		++fname[0];
    279      1.1       cgd 		fnum = 0;
    280      1.1       cgd 	}
    281      1.1       cgd 	fpnt[0] = fnum / 26 + 'a';
    282      1.1       cgd 	fpnt[1] = fnum % 26 + 'a';
    283      1.1       cgd 	++fnum;
    284      1.4       jtc 	if (!freopen(fname, "w", stdout))
    285      1.4       jtc 		err(1, "%s", fname);
    286      1.1       cgd }
    287      1.1       cgd 
    288      1.4       jtc void
    289      1.1       cgd usage()
    290      1.1       cgd {
    291      1.4       jtc 	(void)fprintf(stderr,
    292      1.4       jtc "usage: split [-b byte_count] [-l line_count] [file [prefix]]\n");
    293      1.1       cgd 	exit(1);
    294      1.1       cgd }
    295