[unix-history] / usr / src / cmd / dd.c

#include <stdio.h>
#include <signal.h>

#define	BIG	2147483647
#define	LCASE	01
#define	UCASE	02
#define	SWAB	04
#define NERR	010
#define SYNC	020
int	cflag;
int	fflag;
int	skip;
int	seekn;
int	count;
int	files	= 1;
char	*string;
char	*ifile;
char	*ofile;
char	*ibuf;
char	*obuf;
char	*sbrk();
int	ibs	= 512;
int	obs	= 512;
int	bs;
int	cbs;
int	ibc;
int	obc;
int	cbc;
int	nifr;
int	nipr;
int	nofr;
int	nopr;
int	ntrunc;
int	ibf;
int	obf;
char	*op;
int	nspace;
char	etoa[] = {
	0000,0001,0002,0003,0234,0011,0206,0177,
	0227,0215,0216,0013,0014,0015,0016,0017,
	0020,0021,0022,0023,0235,0205,0010,0207,
	0030,0031,0222,0217,0034,0035,0036,0037,
	0200,0201,0202,0203,0204,0012,0027,0033,
	0210,0211,0212,0213,0214,0005,0006,0007,
	0220,0221,0026,0223,0224,0225,0226,0004,
	0230,0231,0232,0233,0024,0025,0236,0032,
	0040,0240,0241,0242,0243,0244,0245,0246,
	0247,0250,0133,0056,0074,0050,0053,0041,
	0046,0251,0252,0253,0254,0255,0256,0257,
	0260,0261,0135,0044,0052,0051,0073,0136,
	0055,0057,0262,0263,0264,0265,0266,0267,
	0270,0271,0174,0054,0045,0137,0076,0077,
	0272,0273,0274,0275,0276,0277,0300,0301,
	0302,0140,0072,0043,0100,0047,0075,0042,
	0303,0141,0142,0143,0144,0145,0146,0147,
	0150,0151,0304,0305,0306,0307,0310,0311,
	0312,0152,0153,0154,0155,0156,0157,0160,
	0161,0162,0313,0314,0315,0316,0317,0320,
	0321,0176,0163,0164,0165,0166,0167,0170,
	0171,0172,0322,0323,0324,0325,0326,0327,
	0330,0331,0332,0333,0334,0335,0336,0337,
	0340,0341,0342,0343,0344,0345,0346,0347,
	0173,0101,0102,0103,0104,0105,0106,0107,
	0110,0111,0350,0351,0352,0353,0354,0355,
	0175,0112,0113,0114,0115,0116,0117,0120,
	0121,0122,0356,0357,0360,0361,0362,0363,
	0134,0237,0123,0124,0125,0126,0127,0130,
	0131,0132,0364,0365,0366,0367,0370,0371,
	0060,0061,0062,0063,0064,0065,0066,0067,
	0070,0071,0372,0373,0374,0375,0376,0377,
};
char	atoe[] = {
	0000,0001,0002,0003,0067,0055,0056,0057,
	0026,0005,0045,0013,0014,0015,0016,0017,
	0020,0021,0022,0023,0074,0075,0062,0046,
	0030,0031,0077,0047,0034,0035,0036,0037,
	0100,0117,0177,0173,0133,0154,0120,0175,
	0115,0135,0134,0116,0153,0140,0113,0141,
	0360,0361,0362,0363,0364,0365,0366,0367,
	0370,0371,0172,0136,0114,0176,0156,0157,
	0174,0301,0302,0303,0304,0305,0306,0307,
	0310,0311,0321,0322,0323,0324,0325,0326,
	0327,0330,0331,0342,0343,0344,0345,0346,
	0347,0350,0351,0112,0340,0132,0137,0155,
	0171,0201,0202,0203,0204,0205,0206,0207,
	0210,0211,0221,0222,0223,0224,0225,0226,
	0227,0230,0231,0242,0243,0244,0245,0246,
	0247,0250,0251,0300,0152,0320,0241,0007,
	0040,0041,0042,0043,0044,0025,0006,0027,
	0050,0051,0052,0053,0054,0011,0012,0033,
	0060,0061,0032,0063,0064,0065,0066,0010,
	0070,0071,0072,0073,0004,0024,0076,0341,
	0101,0102,0103,0104,0105,0106,0107,0110,
	0111,0121,0122,0123,0124,0125,0126,0127,
	0130,0131,0142,0143,0144,0145,0146,0147,
	0150,0151,0160,0161,0162,0163,0164,0165,
	0166,0167,0170,0200,0212,0213,0214,0215,
	0216,0217,0220,0232,0233,0234,0235,0236,
	0237,0240,0252,0253,0254,0255,0256,0257,
	0260,0261,0262,0263,0264,0265,0266,0267,
	0270,0271,0272,0273,0274,0275,0276,0277,
	0312,0313,0314,0315,0316,0317,0332,0333,
	0334,0335,0336,0337,0352,0353,0354,0355,
	0356,0357,0372,0373,0374,0375,0376,0377,
};
char	atoibm[] =
{
	0000,0001,0002,0003,0067,0055,0056,0057,
	0026,0005,0045,0013,0014,0015,0016,0017,
	0020,0021,0022,0023,0074,0075,0062,0046,
	0030,0031,0077,0047,0034,0035,0036,0037,
	0100,0132,0177,0173,0133,0154,0120,0175,
	0115,0135,0134,0116,0153,0140,0113,0141,
	0360,0361,0362,0363,0364,0365,0366,0367,
	0370,0371,0172,0136,0114,0176,0156,0157,
	0174,0301,0302,0303,0304,0305,0306,0307,
	0310,0311,0321,0322,0323,0324,0325,0326,
	0327,0330,0331,0342,0343,0344,0345,0346,
	0347,0350,0351,0255,0340,0275,0137,0155,
	0171,0201,0202,0203,0204,0205,0206,0207,
	0210,0211,0221,0222,0223,0224,0225,0226,
	0227,0230,0231,0242,0243,0244,0245,0246,
	0247,0250,0251,0300,0117,0320,0241,0007,
	0040,0041,0042,0043,0044,0025,0006,0027,
	0050,0051,0052,0053,0054,0011,0012,0033,
	0060,0061,0032,0063,0064,0065,0066,0010,
	0070,0071,0072,0073,0004,0024,0076,0341,
	0101,0102,0103,0104,0105,0106,0107,0110,
	0111,0121,0122,0123,0124,0125,0126,0127,
	0130,0131,0142,0143,0144,0145,0146,0147,
	0150,0151,0160,0161,0162,0163,0164,0165,
	0166,0167,0170,0200,0212,0213,0214,0215,
	0216,0217,0220,0232,0233,0234,0235,0236,
	0237,0240,0252,0253,0254,0255,0256,0257,
	0260,0261,0262,0263,0264,0265,0266,0267,
	0270,0271,0272,0273,0274,0275,0276,0277,
	0312,0313,0314,0315,0316,0317,0332,0333,
	0334,0335,0336,0337,0352,0353,0354,0355,
	0356,0357,0372,0373,0374,0375,0376,0377,
};


main(argc, argv)
int	argc;
char	**argv;
{
	int (*conv)();
	register char *ip;
	register c;
	int ebcdic(), ibm(), ascii(), null(), cnull(), term();
	int a;

	conv = null;
	for(c=1; c<argc; c++) {
		string = argv[c];
		if(match("ibs=")) {
			ibs = number(BIG);
			continue;
		}
		if(match("obs=")) {
			obs = number(BIG);
			continue;
		}
		if(match("cbs=")) {
			cbs = number(BIG);
			continue;
		}
		if (match("bs=")) {
			bs = number(BIG);
			continue;
		}
		if(match("if=")) {
			ifile = string;
			continue;
		}
		if(match("of=")) {
			ofile = string;
			continue;
		}
		if(match("skip=")) {
			skip = number(BIG);
			continue;
		}
		if(match("seek=")) {
			seekn = number(BIG);
			continue;
		}
		if(match("count=")) {
			count = number(BIG);
			continue;
		}
		if(match("files=")) {
			files = number(BIG);
			continue;
		}
		if(match("conv=")) {
		cloop:
			if(match(","))
				goto cloop;
			if(*string == '\0')
				continue;
			if(match("ebcdic")) {
				conv = ebcdic;
				goto cloop;
			}
			if(match("ibm")) {
				conv = ibm;
				goto cloop;
			}
			if(match("ascii")) {
				conv = ascii;
				goto cloop;
			}
			if(match("lcase")) {
				cflag |= LCASE;
				goto cloop;
			}
			if(match("ucase")) {
				cflag |= UCASE;
				goto cloop;
			}
			if(match("swab")) {
				cflag |= SWAB;
				goto cloop;
			}
			if(match("noerror")) {
				cflag |= NERR;
				goto cloop;
			}
			if(match("sync")) {
				cflag |= SYNC;
				goto cloop;
			}
		}
		fprintf(stderr,"bad arg: %s\n", string);
		exit(0);
	}
	if(conv == null && cflag&(LCASE|UCASE))
		conv = cnull;
	if (ifile)
		ibf = open(ifile, 0);
	else
		ibf = dup(0);
	if(ibf < 0) {
		fprintf(stderr,"cannot open: %s\n", ifile);
		exit(0);
	}
	if (ofile)
		obf = creat(ofile, 0666);
	else
		obf = dup(1);
	if(obf < 0) {
		fprintf(stderr,"cannot create: %s\n", ofile);
		exit(0);
	}
	if (bs) {
		ibs = obs = bs;
		if (conv == null)
			fflag++;
	}
	if(ibs == 0 || obs == 0) {
		fprintf(stderr,"counts: cannot be zero\n");
		exit(0);
	}
	ibuf = sbrk(ibs);
	if (fflag)
		obuf = ibuf;
	else
		obuf = sbrk(obs);
	sbrk(64);	/* For good measure */
	if(ibuf == (char *)-1 || obuf == (char *)-1) {
		fprintf(stderr, "not enough memory\n");
		exit(0);
	}
	ibc = 0;
	obc = 0;
	cbc = 0;
	op = obuf;

	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
		signal(SIGINT, term);
	while(skip) {
		read(ibf, ibuf, ibs);
		skip--;
	}
	while(seekn) {
		lseek(obf, (long)obs, 1);
		seekn--;
	}

loop:
	if(ibc-- == 0) {
		ibc = 0;
		if(count==0 || nifr+nipr!=count) {
			if(cflag&(NERR|SYNC))
			for(ip=ibuf+ibs; ip>ibuf;)
				*--ip = 0;
			ibc = read(ibf, ibuf, ibs);
		}
		if(ibc == -1) {
			perror("read");
			if((cflag&NERR) == 0) {
				flsh();
				term();
			}
			ibc = 0;
			for(c=0; c<ibs; c++)
				if(ibuf[c] != 0)
					ibc = c;
			stats();
		}
		if(ibc == 0 && --files<=0) {
			flsh();
			term();
		}
		if(ibc != ibs) {
			nipr++;
			if(cflag&SYNC)
				ibc = ibs;
		} else
			nifr++;
		ip = ibuf;
		c = (ibc>>1) & ~1;
		if(cflag&SWAB && c)
		do {
			a = *ip++;
			ip[-1] = *ip;
			*ip++ = a;
		} while(--c);
		ip = ibuf;
		if (fflag) {
			obc = ibc;
			flsh();
			ibc = 0;
		}
		goto loop;
	}
	c = 0;
	c |= *ip++;
	c &= 0377;
	(*conv)(c);
	goto loop;
}

flsh()
{
	register c;

	if(obc) {
		if(obc == obs)
			nofr++; else
			nopr++;
		c = write(obf, obuf, obc);
		if(c != obc) {
			perror("write");
			term();
		}
		obc = 0;
	}
}

match(s)
char *s;
{
	register char *cs;

	cs = string;
	while(*cs++ == *s)
		if(*s++ == '\0')
			goto true;
	if(*s != '\0')
		return(0);

true:
	cs--;
	string = cs;
	return(1);
}

number(big)
{
	register char *cs;
	long n;

	cs = string;
	n = 0;
	while(*cs >= '0' && *cs <= '9')
		n = n*10 + *cs++ - '0';
	for(;;)
	switch(*cs++) {

	case 'k':
		n *= 1024;
		continue;

	case 'w':
		n *= sizeof(int);
		continue;

	case 'b':
		n *= 512;
		continue;

	case '*':
	case 'x':
		string = cs;
		n *= number(BIG);

	case '\0':
		if (n>=big || n<0) {
			fprintf(stderr, "dd: argument %D out of range\n", n);
			exit(1);
		}
		return(n);
	}
	/* never gets here */
}

cnull(cc)
{
	register c;

	c = cc;
	if(cflag&UCASE && c>='a' && c<='z')
		c += 'A'-'a';
	if(cflag&LCASE && c>='A' && c<='Z')
		c += 'a'-'A';
	null(c);
}

null(c)
{

	*op = c;
	op++;
	if(++obc >= obs) {
		flsh();
		op = obuf;
	}
}

ascii(cc)
{
	register c;

	c = etoa[cc] & 0377;
	if(cbs == 0) {
		cnull(c);
		return;
	}
	if(c == ' ') {
		nspace++;
		goto out;
	}
	while(nspace > 0) {
		null(' ');
		nspace--;
	}
	cnull(c);

out:
	if(++cbc >= cbs) {
		null('\n');
		cbc = 0;
		nspace = 0;
	}
}

ebcdic(cc)
{
	register c;

	c = cc;
	if(cflag&UCASE && c>='a' && c<='z')
		c += 'A'-'a';
	if(cflag&LCASE && c>='A' && c<='Z')
		c += 'a'-'A';
	c = atoe[c] & 0377;
	if(cbs == 0) {
		null(c);
		return;
	}
	if(cc == '\n') {
		while(cbc < cbs) {
			null(atoe[' ']);
			cbc++;
		}
		cbc = 0;
		return;
	}
	if(cbc == cbs)
		ntrunc++;
	cbc++;
	if(cbc <= cbs)
		null(c);
}

ibm(cc)
{
	register c;

	c = cc;
	if(cflag&UCASE && c>='a' && c<='z')
		c += 'A'-'a';
	if(cflag&LCASE && c>='A' && c<='Z')
		c += 'a'-'A';
	c = atoibm[c] & 0377;
	if(cbs == 0) {
		null(c);
		return;
	}
	if(cc == '\n') {
		while(cbc < cbs) {
			null(atoibm[' ']);
			cbc++;
		}
		cbc = 0;
		return;
	}
	if(cbc == cbs)
		ntrunc++;
	cbc++;
	if(cbc <= cbs)
		null(c);
}

term()
{

	stats();
	exit(0);
}

stats()
{

	fprintf(stderr,"%u+%u records in\n", nifr, nipr);
	fprintf(stderr,"%u+%u records out\n", nofr, nopr);
	if(ntrunc)
		fprintf(stderr,"%u truncated records\n", ntrunc);
}
Commit	Line	Data
179a654b TL	1	#include <stdio.h>
	2	#include <signal.h>
	3
	4	#define BIG 2147483647
	5	#define LCASE 01
	6	#define UCASE 02
	7	#define SWAB 04
	8	#define NERR 010
	9	#define SYNC 020
	10	int cflag;
	11	int fflag;
	12	int skip;
	13	int seekn;
	14	int count;
	15	int files = 1;
	16	char *string;
	17	char *ifile;
	18	char *ofile;
	19	char *ibuf;
	20	char *obuf;
	21	char *sbrk();
	22	int ibs = 512;
	23	int obs = 512;
	24	int bs;
	25	int cbs;
	26	int ibc;
	27	int obc;
	28	int cbc;
	29	int nifr;
	30	int nipr;
	31	int nofr;
	32	int nopr;
	33	int ntrunc;
	34	int ibf;
	35	int obf;
	36	char *op;
	37	int nspace;
	38	char etoa[] = {
	39	0000,0001,0002,0003,0234,0011,0206,0177,
	40	0227,0215,0216,0013,0014,0015,0016,0017,
	41	0020,0021,0022,0023,0235,0205,0010,0207,
	42	0030,0031,0222,0217,0034,0035,0036,0037,
	43	0200,0201,0202,0203,0204,0012,0027,0033,
	44	0210,0211,0212,0213,0214,0005,0006,0007,
	45	0220,0221,0026,0223,0224,0225,0226,0004,
	46	0230,0231,0232,0233,0024,0025,0236,0032,
	47	0040,0240,0241,0242,0243,0244,0245,0246,
	48	0247,0250,0133,0056,0074,0050,0053,0041,
	49	0046,0251,0252,0253,0254,0255,0256,0257,
	50	0260,0261,0135,0044,0052,0051,0073,0136,
	51	0055,0057,0262,0263,0264,0265,0266,0267,
	52	0270,0271,0174,0054,0045,0137,0076,0077,
	53	0272,0273,0274,0275,0276,0277,0300,0301,
	54	0302,0140,0072,0043,0100,0047,0075,0042,
	55	0303,0141,0142,0143,0144,0145,0146,0147,
	56	0150,0151,0304,0305,0306,0307,0310,0311,
	57	0312,0152,0153,0154,0155,0156,0157,0160,
	58	0161,0162,0313,0314,0315,0316,0317,0320,
	59	0321,0176,0163,0164,0165,0166,0167,0170,
	60	0171,0172,0322,0323,0324,0325,0326,0327,
	61	0330,0331,0332,0333,0334,0335,0336,0337,
	62	0340,0341,0342,0343,0344,0345,0346,0347,
	63	0173,0101,0102,0103,0104,0105,0106,0107,
	64	0110,0111,0350,0351,0352,0353,0354,0355,
65	0175,0112,0113,0114,0115,0116,0117,0120,
66	0121,0122,0356,0357,0360,0361,0362,0363,
67	0134,0237,0123,0124,0125,0126,0127,0130,
68	0131,0132,0364,0365,0366,0367,0370,0371,
69	0060,0061,0062,0063,0064,0065,0066,0067,
70	0070,0071,0372,0373,0374,0375,0376,0377,
71	};
72	char atoe[] = {
73	0000,0001,0002,0003,0067,0055,0056,0057,
74	0026,0005,0045,0013,0014,0015,0016,0017,
75	0020,0021,0022,0023,0074,0075,0062,0046,
76	0030,0031,0077,0047,0034,0035,0036,0037,
77	0100,0117,0177,0173,0133,0154,0120,0175,
78	0115,0135,0134,0116,0153,0140,0113,0141,
79	0360,0361,0362,0363,0364,0365,0366,0367,
80	0370,0371,0172,0136,0114,0176,0156,0157,
81	0174,0301,0302,0303,0304,0305,0306,0307,
82	0310,0311,0321,0322,0323,0324,0325,0326,
83	0327,0330,0331,0342,0343,0344,0345,0346,
84	0347,0350,0351,0112,0340,0132,0137,0155,
85	0171,0201,0202,0203,0204,0205,0206,0207,
86	0210,0211,0221,0222,0223,0224,0225,0226,
87	0227,0230,0231,0242,0243,0244,0245,0246,
88	0247,0250,0251,0300,0152,0320,0241,0007,
89	0040,0041,0042,0043,0044,0025,0006,0027,
90	0050,0051,0052,0053,0054,0011,0012,0033,
91	0060,0061,0032,0063,0064,0065,0066,0010,
92	0070,0071,0072,0073,0004,0024,0076,0341,
93	0101,0102,0103,0104,0105,0106,0107,0110,
94	0111,0121,0122,0123,0124,0125,0126,0127,
95	0130,0131,0142,0143,0144,0145,0146,0147,
96	0150,0151,0160,0161,0162,0163,0164,0165,
97	0166,0167,0170,0200,0212,0213,0214,0215,
98	0216,0217,0220,0232,0233,0234,0235,0236,
99	0237,0240,0252,0253,0254,0255,0256,0257,
100	0260,0261,0262,0263,0264,0265,0266,0267,
101	0270,0271,0272,0273,0274,0275,0276,0277,
102	0312,0313,0314,0315,0316,0317,0332,0333,
103	0334,0335,0336,0337,0352,0353,0354,0355,
104	0356,0357,0372,0373,0374,0375,0376,0377,
105	};
106	char atoibm[] =
107	{
108	0000,0001,0002,0003,0067,0055,0056,0057,
109	0026,0005,0045,0013,0014,0015,0016,0017,
110	0020,0021,0022,0023,0074,0075,0062,0046,
111	0030,0031,0077,0047,0034,0035,0036,0037,
112	0100,0132,0177,0173,0133,0154,0120,0175,
113	0115,0135,0134,0116,0153,0140,0113,0141,
114	0360,0361,0362,0363,0364,0365,0366,0367,
115	0370,0371,0172,0136,0114,0176,0156,0157,
116	0174,0301,0302,0303,0304,0305,0306,0307,
117	0310,0311,0321,0322,0323,0324,0325,0326,
118	0327,0330,0331,0342,0343,0344,0345,0346,
119	0347,0350,0351,0255,0340,0275,0137,0155,
120	0171,0201,0202,0203,0204,0205,0206,0207,
121	0210,0211,0221,0222,0223,0224,0225,0226,
122	0227,0230,0231,0242,0243,0244,0245,0246,
123	0247,0250,0251,0300,0117,0320,0241,0007,
124	0040,0041,0042,0043,0044,0025,0006,0027,
125	0050,0051,0052,0053,0054,0011,0012,0033,
126	0060,0061,0032,0063,0064,0065,0066,0010,
127	0070,0071,0072,0073,0004,0024,0076,0341,
128	0101,0102,0103,0104,0105,0106,0107,0110,
129	0111,0121,0122,0123,0124,0125,0126,0127,
130	0130,0131,0142,0143,0144,0145,0146,0147,
131	0150,0151,0160,0161,0162,0163,0164,0165,
132	0166,0167,0170,0200,0212,0213,0214,0215,
133	0216,0217,0220,0232,0233,0234,0235,0236,
134	0237,0240,0252,0253,0254,0255,0256,0257,
135	0260,0261,0262,0263,0264,0265,0266,0267,
136	0270,0271,0272,0273,0274,0275,0276,0277,
137	0312,0313,0314,0315,0316,0317,0332,0333,
138	0334,0335,0336,0337,0352,0353,0354,0355,
139	0356,0357,0372,0373,0374,0375,0376,0377,
140	};
141
142
143	main(argc, argv)
144	int argc;
145	char **argv;
146	{
147	int (*conv)();
148	register char *ip;
149	register c;
150	int ebcdic(), ibm(), ascii(), null(), cnull(), term();
151	int a;
152
153	conv = null;
154	for(c=1; c<argc; c++) {
155	string = argv[c];
156	if(match("ibs=")) {
157	ibs = number(BIG);
158	continue;
159	}
160	if(match("obs=")) {
161	obs = number(BIG);
162	continue;
163	}
164	if(match("cbs=")) {
165	cbs = number(BIG);
166	continue;
167	}
168	if (match("bs=")) {
169	bs = number(BIG);
170	continue;
171	}
172	if(match("if=")) {
173	ifile = string;
174	continue;
175	}
176	if(match("of=")) {
177	ofile = string;
178	continue;
179	}
180	if(match("skip=")) {
181	skip = number(BIG);
182	continue;
183	}
184	if(match("seek=")) {
185	seekn = number(BIG);
186	continue;
187	}
188	if(match("count=")) {
189	count = number(BIG);
190	continue;
191	}
192	if(match("files=")) {
193	files = number(BIG);
194	continue;
195	}
196	if(match("conv=")) {
197	cloop:
198	if(match(","))
199	goto cloop;
200	if(*string == '\0')
201	continue;
202	if(match("ebcdic")) {
203	conv = ebcdic;
204	goto cloop;
205	}
206	if(match("ibm")) {
207	conv = ibm;
208	goto cloop;
209	}
210	if(match("ascii")) {
211	conv = ascii;
212	goto cloop;
213	}
214	if(match("lcase")) {
215	cflag \|= LCASE;
216	goto cloop;
217	}
218	if(match("ucase")) {
219	cflag \|= UCASE;
220	goto cloop;
221	}
222	if(match("swab")) {
223	cflag \|= SWAB;
224	goto cloop;
225	}
226	if(match("noerror")) {
227	cflag \|= NERR;
228	goto cloop;
229	}
230	if(match("sync")) {
231	cflag \|= SYNC;
232	goto cloop;
233	}
234	}
235	fprintf(stderr,"bad arg: %s\n", string);
236	exit(0);
237	}
238	if(conv == null && cflag&(LCASE\|UCASE))
239	conv = cnull;
240	if (ifile)
241	ibf = open(ifile, 0);
242	else
243	ibf = dup(0);
244	if(ibf < 0) {
245	fprintf(stderr,"cannot open: %s\n", ifile);
246	exit(0);
247	}
248	if (ofile)
249	obf = creat(ofile, 0666);
250	else
251	obf = dup(1);
252	if(obf < 0) {
253	fprintf(stderr,"cannot create: %s\n", ofile);
254	exit(0);
255	}
256	if (bs) {
257	ibs = obs = bs;
258	if (conv == null)
259	fflag++;
260	}
261	if(ibs == 0 \|\| obs == 0) {
262	fprintf(stderr,"counts: cannot be zero\n");
263	exit(0);
264	}
265	ibuf = sbrk(ibs);
266	if (fflag)
267	obuf = ibuf;
268	else
269	obuf = sbrk(obs);
270	sbrk(64); /* For good measure */
271	if(ibuf == (char )-1 \|\| obuf == (char )-1) {
272	fprintf(stderr, "not enough memory\n");
273	exit(0);
274	}
275	ibc = 0;
276	obc = 0;
277	cbc = 0;
278	op = obuf;
279
280	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
281	signal(SIGINT, term);
282	while(skip) {
283	read(ibf, ibuf, ibs);
284	skip--;
285	}
286	while(seekn) {
287	lseek(obf, (long)obs, 1);
288	seekn--;
289	}
290
291	loop:
292	if(ibc-- == 0) {
293	ibc = 0;
294	if(count==0 \|\| nifr+nipr!=count) {
295	if(cflag&(NERR\|SYNC))
296	for(ip=ibuf+ibs; ip>ibuf;)
297	*--ip = 0;
298	ibc = read(ibf, ibuf, ibs);
299	}
300	if(ibc == -1) {
301	perror("read");
302	if((cflag&NERR) == 0) {
303	flsh();
304	term();
305	}
306	ibc = 0;
307	for(c=0; c<ibs; c++)
308	if(ibuf[c] != 0)
309	ibc = c;
310	stats();
311	}
312	if(ibc == 0 && --files<=0) {
313	flsh();
314	term();
315	}
316	if(ibc != ibs) {
317	nipr++;
318	if(cflag&SYNC)
319	ibc = ibs;
320	} else
321	nifr++;
322	ip = ibuf;
323	c = (ibc>>1) & ~1;
324	if(cflag&SWAB && c)
325	do {
326	a = *ip++;
327	ip[-1] = *ip;
328	*ip++ = a;
329	} while(--c);
330	ip = ibuf;
331	if (fflag) {
332	obc = ibc;
333	flsh();
334	ibc = 0;
335	}
336	goto loop;
337	}
338	c = 0;
339	c \|= *ip++;
340	c &= 0377;
341	(*conv)(c);
342	goto loop;
343	}
344
345	flsh()
346	{
347	register c;
348
349	if(obc) {
350	if(obc == obs)
351	nofr++; else
352	nopr++;
353	c = write(obf, obuf, obc);
354	if(c != obc) {
355	perror("write");
356	term();
357	}
358	obc = 0;
359	}
360	}
361
362	match(s)
363	char *s;
364	{
365	register char *cs;
366
367	cs = string;
368	while(cs++ == s)
369	if(*s++ == '\0')
370	goto true;
371	if(*s != '\0')
372	return(0);
373
374	true:
375	cs--;
376	string = cs;
377	return(1);
378	}
379
380	number(big)
381	{
382	register char *cs;
383	long n;
384
385	cs = string;
386	n = 0;
387	while(cs >= '0' && cs <= '9')
388	n = n10 + cs++ - '0';
389	for(;;)
390	switch(*cs++) {
391
392	case 'k':
393	n *= 1024;
394	continue;
395
396	case 'w':
397	n *= sizeof(int);
398	continue;
399
400	case 'b':
401	n *= 512;
402	continue;
403
404	case '*':
405	case 'x':
406	string = cs;
407	n *= number(BIG);
408
409	case '\0':
410	if (n>=big \|\| n<0) {
411	fprintf(stderr, "dd: argument %D out of range\n", n);
412	exit(1);
413	}
414	return(n);
415	}
416	/* never gets here */
417	}
418
419	cnull(cc)
420	{
421	register c;
422
423	c = cc;
424	if(cflag&UCASE && c>='a' && c<='z')
425	c += 'A'-'a';
426	if(cflag&LCASE && c>='A' && c<='Z')
427	c += 'a'-'A';
428	null(c);
429	}
430
431	null(c)
432	{
433
434	*op = c;
435	op++;
436	if(++obc >= obs) {
437	flsh();
438	op = obuf;
439	}
440	}
441
442	ascii(cc)
443	{
444	register c;
445
446	c = etoa[cc] & 0377;
447	if(cbs == 0) {
448	cnull(c);
449	return;
450	}
451	if(c == ' ') {
452	nspace++;
453	goto out;
454	}
455	while(nspace > 0) {
456	null(' ');
457	nspace--;
458	}
459	cnull(c);
460
461	out:
462	if(++cbc >= cbs) {
463	null('\n');
464	cbc = 0;
465	nspace = 0;
466	}
467	}
468
469	ebcdic(cc)
470	{
471	register c;
472
473	c = cc;
474	if(cflag&UCASE && c>='a' && c<='z')
475	c += 'A'-'a';
476	if(cflag&LCASE && c>='A' && c<='Z')
477	c += 'a'-'A';
478	c = atoe[c] & 0377;
479	if(cbs == 0) {
480	null(c);
481	return;
482	}
483	if(cc == '\n') {
484	while(cbc < cbs) {
485	null(atoe[' ']);
486	cbc++;
487	}
488	cbc = 0;
489	return;
490	}
491	if(cbc == cbs)
492	ntrunc++;
493	cbc++;
494	if(cbc <= cbs)
495	null(c);
496	}
497
498	ibm(cc)
499	{
500	register c;
501
502	c = cc;
503	if(cflag&UCASE && c>='a' && c<='z')
504	c += 'A'-'a';
505	if(cflag&LCASE && c>='A' && c<='Z')
506	c += 'a'-'A';
507	c = atoibm[c] & 0377;
508	if(cbs == 0) {
509	null(c);
510	return;
511	}
512	if(cc == '\n') {
513	while(cbc < cbs) {
514	null(atoibm[' ']);
515	cbc++;
516	}
517	cbc = 0;
518	return;
519	}
520	if(cbc == cbs)
521	ntrunc++;
522	cbc++;
523	if(cbc <= cbs)
524	null(c);
525	}
526
527	term()
528	{
529
530	stats();
531	exit(0);
532	}
533
534	stats()
535	{
536
537	fprintf(stderr,"%u+%u records in\n", nifr, nipr);
538	fprintf(stderr,"%u+%u records out\n", nofr, nopr);
539	if(ntrunc)
540	fprintf(stderr,"%u truncated records\n", ntrunc);
541	}