logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

join.c (15999B)

    

  1. /*-
  2.  * SPDX-License-Identifier: BSD-3-Clause
  3.  *
  4.  * Copyright (c) 1991, 1993, 1994
  5.  *	The Regents of the University of California.  All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Steve Hayman of the Computer Science Department, Indiana University,
  9.  * Michiro Hikida and David Goodenough.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions and the following disclaimer.
  16.  * 2. Redistributions in binary form must reproduce the above copyright
  17.  *    notice, this list of conditions and the following disclaimer in the
  18.  *    documentation and/or other materials provided with the distribution.
  19.  * 3. Neither the name of the University nor the names of its contributors
  20.  *    may be used to endorse or promote products derived from this software
  21.  *    without specific prior written permission.
  22.  *
  23.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33.  * SUCH DAMAGE.
  34.  */
  36. #define _POSIX_C_SOURCE 202405L
  37. #define _BSD_SOURCE // fgetln, strsep
  39. #include "../lib/reallocarray.h"
  40. #include "../libutils/err.h"
  41. #include "../libutils/getopt_nolong.h"
  43. #include <errno.h>
  44. #include <limits.h>
  45. #include <locale.h>
  46. #include <stdio.h> // fgetln
  47. #include <stdlib.h>
  48. #include <string.h> // strsep, strerror
  49. #include <sys/param.h>
  50. #include <unistd.h>
  51. #include <wchar.h>
  53. /*
  54.  * There's a structure per input file which encapsulates the state of the
  55.  * file.  We repeatedly read lines from each file until we've read in all
  56.  * the consecutive lines from the file with a common join field.  Then we
  57.  * compare the set of lines with an equivalent set from the other file.
  58.  */
  59. typedef struct
  60. {
  61. 	char *line;               /* line */
  62. 	unsigned long linealloc;  /* line allocated count */
  63. 	char **fields;            /* line field(s) */
  64. 	unsigned long fieldcnt;   /* line field(s) count */
  65. 	unsigned long fieldalloc; /* line field(s) allocated count */
  66. } LINE;
  68. typedef struct
  69. {
  70. 	FILE *fp;             /* file descriptor */
  71. 	unsigned long joinf;  /* join field (-1, -2, -j) */
  72. 	int unpair;           /* output unpairable lines (-a) */
  73. 	unsigned long number; /* 1 for file 1, 2 for file 2 */
  75. 	LINE *set;              /* set of lines with same field */
  76. 	int pushbool;           /* if pushback is set */
  77. 	unsigned long pushback; /* line on the stack */
  78. 	unsigned long setcnt;   /* set count */
  79. 	unsigned long setalloc; /* set allocated count */
  80. } INPUT;
  81. static INPUT input1 = {NULL, 0, 0, 1, NULL, 0, 0, 0, 0}, input2 = {NULL, 0, 0, 2, NULL, 0, 0, 0, 0};
  83. typedef struct
  84. {
  85. 	unsigned long filenum; /* file number */
  86. 	unsigned long fieldno; /* field number */
  87. } OLIST;
  88. static OLIST *olist;             /* output field list */
  89. static unsigned long olistcnt;   /* output field list count */
  90. static unsigned long olistalloc; /* output field allocated count */
  92. static int joinout = 1; /* show lines with matched join fields (-v) */
  93. static int needsep;     /* need separator character */
  94. static int spans = 1;   /* span multiple delimiters (-t) */
  95. static char *empty;     /* empty field replacement string (-e) */
  96. static wchar_t default_tabchar[] = L" \t";
  97. static wchar_t *tabchar = default_tabchar; /* delimiter characters (-t) */
  99. static int cmp(LINE *, unsigned long, LINE *, unsigned long);
  100. static void fieldarg(char *);
  101. static void joinlines(INPUT *, INPUT *);
  102. static int mbscoll(const char *, const char *);
  103. static char *mbssep(char **, const wchar_t *);
  104. static void outfield(LINE *, unsigned long, int);
  105. static void outoneline(INPUT *, LINE *);
  106. static void outtwoline(INPUT *, LINE *, INPUT *, LINE *);
  107. static void slurp(INPUT *);
  108. static wchar_t *towcs(const char *);
  109. static void usage(void);
  111. const char *argv0 = "join";
  113. int
  114. main(int argc, char *argv[])
  115. {
  116. 	INPUT *F1, *F2;
  117. 	int aflag, ch, cval, vflag;
  118. 	char *end;
  120. 	char *lc_all = setlocale(LC_ALL, "");
  121. 	if(lc_all == NULL)
  122. 	{
  123. 		fprintf(stderr,
  124. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  125. 		        argv0,
  126. 		        strerror(errno));
  127. 	}
  129. 	F1 = &input1;
  130. 	F2 = &input2;
  132. 	aflag = vflag = 0;
  133. 	while((ch = getopt_nolong(argc, argv, ":a:e:j:1:2:o:t:v:")) != -1)
  134. 	{
  135. 		switch(ch)
  136. 		{
  137. 		case '1':
  138. 			if((F1->joinf = strtol(optarg, &end, 10)) < 1)
  139. 				utils_errx(1, "-1 option field number less than 1");
  140. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  141. 			--F1->joinf;
  142. 			break;
  143. 		case '2':
  144. 			if((F2->joinf = strtol(optarg, &end, 10)) < 1)
  145. 				utils_errx(1, "-2 option field number less than 1");
  146. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  147. 			--F2->joinf;
  148. 			break;
  149. 		case 'a':
  150. 			aflag = 1;
  151. 			switch(strtol(optarg, &end, 10))
  152. 			{
  153. 			case 1:
  154. 				F1->unpair = 1;
  155. 				break;
  156. 			case 2:
  157. 				F2->unpair = 1;
  158. 				break;
  159. 			default:
  160. 				utils_errx(1, "-a option file number not 1 or 2");
  161. 				break;
  162. 			}
  163. 			if(*end) utils_errx(1, "illegal file number -- %s", optarg);
  164. 			break;
  165. 		case 'e':
  166. 			empty = optarg;
  167. 			break;
  168. 		case 'j':
  169. 			if((F1->joinf = F2->joinf = strtol(optarg, &end, 10)) < 1)
  170. 				utils_errx(1, "-j option field number less than 1");
  171. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  172. 			--F1->joinf;
  173. 			--F2->joinf;
  174. 			break;
  175. 		case 'o':
  176. 			fieldarg(optarg);
  177. 			break;
  178. 		case 't':
  179. 			spans = 0;
  180. 			if(mbrtowc(&tabchar[0], optarg, MB_LEN_MAX, NULL) != strlen(optarg))
  181. 				utils_errx(1, "illegal tab character specification");
  182. 			tabchar[1] = L'\0';
  183. 			break;
  184. 		case 'v':
  185. 			vflag = 1;
  186. 			joinout = 0;
  187. 			switch(strtol(optarg, &end, 10))
  188. 			{
  189. 			case 1:
  190. 				F1->unpair = 1;
  191. 				break;
  192. 			case 2:
  193. 				F2->unpair = 1;
  194. 				break;
  195. 			default:
  196. 				utils_errx(1, "-v option file number not 1 or 2");
  197. 				break;
  198. 			}
  199. 			if(*end) utils_errx(1, "illegal file number -- %s", optarg);
  200. 			break;
  201. 		case ':':
  202. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  203. 			usage();
  204. 			return 1;
  205. 		case '?':
  206. 			GETOPT_UNKNOWN_OPT
  207. 			usage();
  208. 			return 1;
  209. 		default:
  210. 			abort();
  211. 		}
  212. 	}
  213. 	argc -= optind;
  214. 	argv += optind;
  216. 	if(aflag && vflag) utils_errx(1, "the -a and -v options are mutually exclusive");
  218. 	if(argc != 2)
  219. 	{
  220. 		fprintf(stderr, "%s: error: Need exactly 2 file operands, got %d instead\n", argv0, argc);
  221. 		usage();
  222. 	}
  224. 	/* Open the files; "-" means stdin. */
  225. 	if(!strcmp(*argv, "-"))
  226. 		F1->fp = stdin;
  227. 	else if((F1->fp = fopen(*argv, "r")) == NULL)
  228. 		utils_err(1, "%s", *argv);
  229. 	++argv;
  230. 	if(!strcmp(*argv, "-"))
  231. 		F2->fp = stdin;
  232. 	else if((F2->fp = fopen(*argv, "r")) == NULL)
  233. 		utils_err(1, "%s", *argv);
  234. 	if(F1->fp == stdin && F2->fp == stdin) utils_errx(1, "only one input file may be stdin");
  236. 	slurp(F1);
  237. 	slurp(F2);
  238. 	while(F1->setcnt && F2->setcnt)
  239. 	{
  240. 		cval = cmp(F1->set, F1->joinf, F2->set, F2->joinf);
  241. 		if(cval == 0)
  242. 		{
  243. 			/* Oh joy, oh rapture, oh beauty divine! */
  244. 			if(joinout) joinlines(F1, F2);
  245. 			slurp(F1);
  246. 			slurp(F2);
  247. 		}
  248. 		else if(cval < 0)
  249. 		{
  250. 			/* File 1 takes the lead... */
  251. 			if(F1->unpair) joinlines(F1, NULL);
  252. 			slurp(F1);
  253. 		}
  254. 		else
  255. 		{
  256. 			/* File 2 takes the lead... */
  257. 			if(F2->unpair) joinlines(F2, NULL);
  258. 			slurp(F2);
  259. 		}
  260. 	}
  262. 	/*
  263. 	 * Now that one of the files is used up, optionally output any
  264. 	 * remaining lines from the other file.
  265. 	 */
  266. 	if(F1->unpair)
  267. 		while(F1->setcnt)
  268. 		{
  269. 			joinlines(F1, NULL);
  270. 			slurp(F1);
  271. 		}
  272. 	if(F2->unpair)
  273. 		while(F2->setcnt)
  274. 		{
  275. 			joinlines(F2, NULL);
  276. 			slurp(F2);
  277. 		}
  278. 	exit(0);
  279. }
  281. static void
  282. slurp(INPUT *F)
  283. {
  284. 	LINE *lp, *lastlp, tmp;
  285. 	size_t len;
  286. 	int cnt;
  287. 	char *bp, *fieldp;
  289. 	/*
  290. 	 * Read all of the lines from an input file that have the same
  291. 	 * join field.
  292. 	 */
  293. 	F->setcnt = 0;
  294. 	for(lastlp = NULL;; ++F->setcnt)
  295. 	{
  296. 		/*
  297. 		 * If we're out of space to hold line structures, allocate
  298. 		 * more.  Initialize the structure so that we know that this
  299. 		 * is new space.
  300. 		 */
  301. 		if(F->setcnt == F->setalloc)
  302. 		{
  303. 			cnt = F->setalloc;
  304. 			F->setalloc += 50;
  305. 			if(F->setalloc <= 0) utils_errx(1, "slurp setalloc overflow");
  306. 			if((F->set = reallocarray(F->set, F->setalloc, sizeof(LINE))) == NULL)
  307. 				utils_err(1, "Failed (re)allocating slurp set");
  308. 			memset(F->set + cnt, 0, 50 * sizeof(LINE));
  310. 			/* re-set lastlp in case it moved */
  311. 			if(lastlp != NULL) lastlp = &F->set[F->setcnt - 1];
  312. 		}
  314. 		/*
  315. 		 * Get any pushed back line, else get the next line.  Allocate
  316. 		 * space as necessary.  If taking the line from the stack swap
  317. 		 * the two structures so that we don't lose space allocated to
  318. 		 * either structure.  This could be avoided by doing another
  319. 		 * level of indirection, but it's probably okay as is.
  320. 		 */
  321. 		lp = &F->set[F->setcnt];
  322. 		if(F->setcnt) lastlp = &F->set[F->setcnt - 1];
  323. 		if(F->pushbool)
  324. 		{
  325. 			tmp = F->set[F->setcnt];
  326. 			F->set[F->setcnt] = F->set[F->pushback];
  327. 			F->set[F->pushback] = tmp;
  328. 			F->pushbool = 0;
  329. 			continue;
  330. 		}
  331. 		if((bp = fgetln(F->fp, &len)) == NULL) return;
  332. 		if(lp->linealloc <= len + 1)
  333. 		{
  334. 			lp->linealloc += MAX(100, len + 1 - lp->linealloc);
  335. 			if(lp->linealloc <= 0) utils_errx(1, "slurp linealloc overflow");
  336. 			if((lp->line = realloc(lp->line, lp->linealloc)) == NULL)
  337. 				utils_err(1, "Failed (re)allocating slurp line");
  338. 		}
  339. 		memmove(lp->line, bp, len);
  341. 		/* Replace trailing newline, if it exists. */
  342. 		if(bp[len - 1] == '\n')
  343. 			lp->line[len - 1] = '\0';
  344. 		else
  345. 			lp->line[len] = '\0';
  346. 		bp = lp->line;
  348. 		/* Split the line into fields, allocate space as necessary. */
  349. 		lp->fieldcnt = 0;
  350. 		while((fieldp = mbssep(&bp, tabchar)) != NULL)
  351. 		{
  352. 			if(spans && *fieldp == '\0') continue;
  353. 			if(lp->fieldcnt == lp->fieldalloc)
  354. 			{
  355. 				lp->fieldalloc += 50;
  356. 				if(lp->fieldalloc < 0) utils_errx(1, "slurp fieldalloc overflow");
  357. 				if((lp->fields = reallocarray(lp->fields, lp->fieldalloc, sizeof(char *))) == NULL)
  358. 					utils_err(1, "Failed (re)allocating slurp fieldalloc");
  359. 			}
  360. 			lp->fields[lp->fieldcnt++] = fieldp;
  361. 		}
  363. 		/* See if the join field value has changed. */
  364. 		if(lastlp != NULL && cmp(lp, F->joinf, lastlp, F->joinf))
  365. 		{
  366. 			F->pushbool = 1;
  367. 			F->pushback = F->setcnt;
  368. 			break;
  369. 		}
  370. 	}
  371. }
  373. static char *
  374. mbssep(char **stringp, const wchar_t *delim)
  375. {
  376. 	char *s, *tok;
  377. 	const wchar_t *spanp;
  378. 	wchar_t c, sc;
  379. 	size_t n;
  381. 	if((s = *stringp) == NULL) return (NULL);
  382. 	for(tok = s;;)
  383. 	{
  384. 		n = mbrtowc(&c, s, MB_LEN_MAX, NULL);
  385. 		if(n == (size_t)-1 || n == (size_t)-2)
  386. 		{
  387. 			fprintf(stderr, "join: error: mbrtowc: Illegal byte sequence\n");
  388. 			exit(1);
  389. 		}
  390. 		s += n;
  391. 		spanp = delim;
  392. 		do
  393. 		{
  394. 			if((sc = *spanp++) == c)
  395. 			{
  396. 				if(c == 0)
  397. 					s = NULL;
  398. 				else
  399. 					s[-n] = '\0';
  400. 				*stringp = s;
  401. 				return (tok);
  402. 			}
  403. 		} while(sc != 0);
  404. 	}
  405. }
  407. static int
  408. cmp(LINE *lp1, unsigned long fieldno1, LINE *lp2, unsigned long fieldno2)
  409. {
  410. 	if(lp1->fieldcnt <= fieldno1) return (lp2->fieldcnt <= fieldno2 ? 0 : 1);
  411. 	if(lp2->fieldcnt <= fieldno2) return (-1);
  412. 	return (mbscoll(lp1->fields[fieldno1], lp2->fields[fieldno2]));
  413. }
  415. static int
  416. mbscoll(const char *s1, const char *s2)
  417. {
  418. 	wchar_t *w1, *w2;
  419. 	int ret;
  421. 	if(MB_CUR_MAX == 1) return (strcoll(s1, s2));
  422. 	if((w1 = towcs(s1)) == NULL || (w2 = towcs(s2)) == NULL) utils_err(1, NULL); /* XXX */
  423. 	ret = wcscoll(w1, w2);
  424. 	free(w1);
  425. 	free(w2);
  426. 	return (ret);
  427. }
  429. static wchar_t *
  430. towcs(const char *s)
  431. {
  432. 	wchar_t *wcs;
  433. 	size_t n;
  435. 	if((n = mbsrtowcs(NULL, &s, 0, NULL)) == (size_t)-1) return (NULL);
  436. 	n++;
  437. 	if(n <= 0) return (NULL);
  438. 	if((wcs = calloc(n, sizeof(*wcs))) == NULL) return (NULL);
  439. 	mbsrtowcs(wcs, &s, n, NULL);
  440. 	return (wcs);
  441. }
  443. static void
  444. joinlines(INPUT *F1, INPUT *F2)
  445. {
  446. 	unsigned long cnt1, cnt2;
  448. 	/*
  449. 	 * Output the results of a join comparison.  The output may be from
  450. 	 * either file 1 or file 2 (in which case the first argument is the
  451. 	 * file from which to output) or from both.
  452. 	 */
  453. 	if(F2 == NULL)
  454. 	{
  455. 		for(cnt1 = 0; cnt1 < F1->setcnt; ++cnt1)
  456. 			outoneline(F1, &F1->set[cnt1]);
  457. 		return;
  458. 	}
  459. 	for(cnt1 = 0; cnt1 < F1->setcnt; ++cnt1)
  460. 		for(cnt2 = 0; cnt2 < F2->setcnt; ++cnt2)
  461. 			outtwoline(F1, &F1->set[cnt1], F2, &F2->set[cnt2]);
  462. }
  464. static void
  465. outoneline(INPUT *F, LINE *lp)
  466. {
  467. 	unsigned long cnt;
  469. 	/*
  470. 	 * Output a single line from one of the files, according to the
  471. 	 * join rules.  This happens when we are writing unmatched single
  472. 	 * lines.  Output empty fields in the right places.
  473. 	 */
  474. 	if(olist)
  475. 		for(cnt = 0; cnt < olistcnt; ++cnt)
  476. 		{
  477. 			if(olist[cnt].filenum == (unsigned)F->number)
  478. 				outfield(lp, olist[cnt].fieldno, 0);
  479. 			else if(olist[cnt].filenum == 0)
  480. 				outfield(lp, F->joinf, 0);
  481. 			else
  482. 				outfield(lp, 0, 1);
  483. 		}
  484. 	else
  485. 	{
  486. 		/*
  487. 		 * Output the join field, then the remaining fields.
  488. 		 */
  489. 		outfield(lp, F->joinf, 0);
  490. 		for(cnt = 0; cnt < lp->fieldcnt; ++cnt)
  491. 			if(F->joinf != cnt) outfield(lp, cnt, 0);
  492. 	}
  493. 	(void)printf("\n");
  494. 	if(ferror(stdout)) utils_err(1, "stdout");
  495. 	needsep = 0;
  496. }
  498. static void
  499. outtwoline(INPUT *F1, LINE *lp1, INPUT *F2, LINE *lp2)
  500. {
  501. 	unsigned long cnt;
  503. 	/* Output a pair of lines according to the join list (if any). */
  504. 	if(olist)
  505. 		for(cnt = 0; cnt < olistcnt; ++cnt)
  506. 			if(olist[cnt].filenum == 0)
  507. 			{
  508. 				if(lp1->fieldcnt >= F1->joinf)
  509. 					outfield(lp1, F1->joinf, 0);
  510. 				else
  511. 					outfield(lp2, F2->joinf, 0);
  512. 			}
  513. 			else if(olist[cnt].filenum == 1)
  514. 				outfield(lp1, olist[cnt].fieldno, 0);
  515. 			else /* if (olist[cnt].filenum == 2) */
  516. 				outfield(lp2, olist[cnt].fieldno, 0);
  517. 	else
  518. 	{
  519. 		/*
  520. 		 * Output the join field, then the remaining fields from F1
  521. 		 * and F2.
  522. 		 */
  523. 		outfield(lp1, F1->joinf, 0);
  524. 		for(cnt = 0; cnt < lp1->fieldcnt; ++cnt)
  525. 			if(F1->joinf != cnt) outfield(lp1, cnt, 0);
  526. 		for(cnt = 0; cnt < lp2->fieldcnt; ++cnt)
  527. 			if(F2->joinf != cnt) outfield(lp2, cnt, 0);
  528. 	}
  529. 	(void)printf("\n");
  530. 	if(ferror(stdout)) utils_err(1, "stdout");
  531. 	needsep = 0;
  532. }
  534. static void
  535. outfield(LINE *lp, unsigned long fieldno, int out_empty)
  536. {
  537. 	if(needsep++) (void)printf("%lc", (wint_t)*tabchar);
  538. 	if(!ferror(stdout))
  539. 	{
  540. 		if(lp->fieldcnt <= fieldno || out_empty)
  541. 		{
  542. 			if(empty != NULL) (void)printf("%s", empty);
  543. 		}
  544. 		else
  545. 		{
  546. 			if(*lp->fields[fieldno] == '\0') return;
  547. 			(void)printf("%s", lp->fields[fieldno]);
  548. 		}
  549. 	}
  550. 	if(ferror(stdout)) utils_err(1, "stdout");
  551. }
  553. /*
  554.  * Convert an output list argument "2.1, 1.3, 2.4" into an array of output
  555.  * fields.
  556.  */
  557. static void
  558. fieldarg(char *option)
  559. {
  560. 	unsigned long fieldno, filenum;
  561. 	char *end, *token;
  563. 	while((token = strsep(&option, ", \t")) != NULL)
  564. 	{
  565. 		if(*token == '\0') continue;
  566. 		if(token[0] == '0')
  567. 			filenum = fieldno = 0;
  568. 		else if((token[0] == '1' || token[0] == '2') && token[1] == '.')
  569. 		{
  570. 			filenum = token[0] - '0';
  571. 			fieldno = strtol(token + 2, &end, 10);
  572. 			if(*end) utils_errx(1, "malformed -o option field");
  573. 			if(fieldno == 0) utils_errx(1, "field numbers are 1 based");
  574. 			--fieldno;
  575. 		}
  576. 		else
  577. 			utils_errx(1, "malformed -o option field");
  578. 		if(olistcnt == olistalloc)
  579. 		{
  580. 			olistalloc += 50;
  581. 			if(olistalloc <= 0) utils_errx(1, "fieldarg olistalloc overflow");
  582. 			if((olist = reallocarray(olist, olistalloc, sizeof(OLIST))) == NULL)
  583. 				utils_err(1, "Failed (re)allocating fieldarg");
  584. 		}
  585. 		olist[olistcnt].filenum = filenum;
  586. 		olist[olistcnt].fieldno = fieldno;
  587. 		++olistcnt;
  588. 	}
  589. }
  591. static void
  592. usage(void)
  593. {
  594. 	(void)fprintf(stderr,
  595. 	              "%s %s\n%s\n",
  596. 	              "usage: join [-a fileno | -v fileno ] [-e string] [-1 field]",
  597. 	              "[-2 field]",
  598. 	              "            [-o list] [-t char] file1 file2");
  599. 	exit(1);
  600. }