logo

utils-std

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

join.c (16033B)

    

  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 <assert.h>
  44. #include <errno.h>
  45. #include <limits.h>
  46. #include <locale.h>
  47. #include <stdio.h> // fgetln
  48. #include <stdlib.h>
  49. #include <string.h> // strsep, strerror
  50. #include <sys/param.h>
  51. #include <unistd.h>
  52. #include <wchar.h>
  54. /*
  55.  * There's a structure per input file which encapsulates the state of the
  56.  * file.  We repeatedly read lines from each file until we've read in all
  57.  * the consecutive lines from the file with a common join field.  Then we
  58.  * compare the set of lines with an equivalent set from the other file.
  59.  */
  60. typedef struct
  61. {
  62. 	char *line;               /* line */
  63. 	unsigned long linealloc;  /* line allocated count */
  64. 	char **fields;            /* line field(s) */
  65. 	unsigned long fieldcnt;   /* line field(s) count */
  66. 	unsigned long fieldalloc; /* line field(s) allocated count */
  67. } LINE;
  69. typedef struct
  70. {
  71. 	FILE *fp;             /* file descriptor */
  72. 	unsigned long joinf;  /* join field (-1, -2, -j) */
  73. 	int unpair;           /* output unpairable lines (-a) */
  74. 	unsigned long number; /* 1 for file 1, 2 for file 2 */
  76. 	LINE *set;              /* set of lines with same field */
  77. 	int pushbool;           /* if pushback is set */
  78. 	unsigned long pushback; /* line on the stack */
  79. 	unsigned long setcnt;   /* set count */
  80. 	unsigned long setalloc; /* set allocated count */
  81. } INPUT;
  82. static INPUT input1 = {NULL, 0, 0, 1, NULL, 0, 0, 0, 0}, input2 = {NULL, 0, 0, 2, NULL, 0, 0, 0, 0};
  84. typedef struct
  85. {
  86. 	unsigned long filenum; /* file number */
  87. 	unsigned long fieldno; /* field number */
  88. } OLIST;
  89. static OLIST *olist;             /* output field list */
  90. static unsigned long olistcnt;   /* output field list count */
  91. static unsigned long olistalloc; /* output field allocated count */
  93. static int joinout = 1; /* show lines with matched join fields (-v) */
  94. static int needsep;     /* need separator character */
  95. static int spans = 1;   /* span multiple delimiters (-t) */
  96. static char *empty;     /* empty field replacement string (-e) */
  97. static wchar_t default_tabchar[] = L" \t";
  98. static wchar_t *tabchar = default_tabchar; /* delimiter characters (-t) */
  100. static int cmp(LINE *, unsigned long, LINE *, unsigned long);
  101. static void fieldarg(char *);
  102. static void joinlines(INPUT *, INPUT *);
  103. static int mbscoll(const char *, const char *);
  104. static char *mbssep(char **, const wchar_t *);
  105. static void outfield(LINE *, unsigned long, int);
  106. static void outoneline(INPUT *, LINE *);
  107. static void outtwoline(INPUT *, LINE *, INPUT *, LINE *);
  108. static void slurp(INPUT *);
  109. static wchar_t *towcs(const char *);
  110. static void usage(void);
  112. const char *argv0 = "join";
  114. int
  115. main(int argc, char *argv[])
  116. {
  117. 	INPUT *F1, *F2;
  118. 	int aflag, ch, cval, vflag;
  119. 	char *end;
  121. 	char *lc_all = setlocale(LC_ALL, "");
  122. 	if(lc_all == NULL)
  123. 	{
  124. 		fprintf(stderr,
  125. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  126. 		        argv0,
  127. 		        strerror(errno));
  128. 	}
  130. 	F1 = &input1;
  131. 	F2 = &input2;
  133. 	aflag = vflag = 0;
  134. 	while((ch = getopt_nolong(argc, argv, ":a:e:j:1:2:o:t:v:")) != -1)
  135. 	{
  136. 		switch(ch)
  137. 		{
  138. 		case '1':
  139. 			if((F1->joinf = strtol(optarg, &end, 10)) < 1)
  140. 				utils_errx(1, "-1 option field number less than 1");
  141. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  142. 			--F1->joinf;
  143. 			break;
  144. 		case '2':
  145. 			if((F2->joinf = strtol(optarg, &end, 10)) < 1)
  146. 				utils_errx(1, "-2 option field number less than 1");
  147. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  148. 			--F2->joinf;
  149. 			break;
  150. 		case 'a':
  151. 			aflag = 1;
  152. 			switch(strtol(optarg, &end, 10))
  153. 			{
  154. 			case 1:
  155. 				F1->unpair = 1;
  156. 				break;
  157. 			case 2:
  158. 				F2->unpair = 1;
  159. 				break;
  160. 			default:
  161. 				utils_errx(1, "-a option file number not 1 or 2");
  162. 				break;
  163. 			}
  164. 			if(*end) utils_errx(1, "illegal file number -- %s", optarg);
  165. 			break;
  166. 		case 'e':
  167. 			empty = optarg;
  168. 			break;
  169. 		case 'j':
  170. 			if((F1->joinf = F2->joinf = strtol(optarg, &end, 10)) < 1)
  171. 				utils_errx(1, "-j option field number less than 1");
  172. 			if(*end) utils_errx(1, "illegal field number -- %s", optarg);
  173. 			--F1->joinf;
  174. 			--F2->joinf;
  175. 			break;
  176. 		case 'o':
  177. 			fieldarg(optarg);
  178. 			break;
  179. 		case 't':
  180. 			spans = 0;
  181. 			if(mbrtowc(&tabchar[0], optarg, MB_LEN_MAX, NULL) != strlen(optarg))
  182. 				utils_errx(1, "illegal tab character specification");
  183. 			tabchar[1] = L'\0';
  184. 			break;
  185. 		case 'v':
  186. 			vflag = 1;
  187. 			joinout = 0;
  188. 			switch(strtol(optarg, &end, 10))
  189. 			{
  190. 			case 1:
  191. 				F1->unpair = 1;
  192. 				break;
  193. 			case 2:
  194. 				F2->unpair = 1;
  195. 				break;
  196. 			default:
  197. 				utils_errx(1, "-v option file number not 1 or 2");
  198. 				break;
  199. 			}
  200. 			if(*end) utils_errx(1, "illegal file number -- %s", optarg);
  201. 			break;
  202. 		case ':':
  203. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  204. 			usage();
  205. 			return 1;
  206. 		case '?':
  207. 			GETOPT_UNKNOWN_OPT
  208. 			usage();
  209. 			return 1;
  210. 		default:
  211. 			abort();
  212. 		}
  213. 	}
  214. 	argc -= optind;
  215. 	argv += optind;
  217. 	if(aflag && vflag) utils_errx(1, "the -a and -v options are mutually exclusive");
  219. 	if(argc != 2)
  220. 	{
  221. 		fprintf(stderr, "%s: error: Need exactly 2 file operands, got %d instead\n", argv0, argc);
  222. 		usage();
  223. 	}
  225. 	/* Open the files; "-" means stdin. */
  226. 	if(!strcmp(*argv, "-"))
  227. 		F1->fp = stdin;
  228. 	else if((F1->fp = fopen(*argv, "r")) == NULL)
  229. 		utils_err(1, "%s", *argv);
  230. 	++argv;
  231. 	if(!strcmp(*argv, "-"))
  232. 		F2->fp = stdin;
  233. 	else if((F2->fp = fopen(*argv, "r")) == NULL)
  234. 		utils_err(1, "%s", *argv);
  235. 	if(F1->fp == stdin && F2->fp == stdin) utils_errx(1, "only one input file may be stdin");
  237. 	slurp(F1);
  238. 	slurp(F2);
  239. 	while(F1->setcnt && F2->setcnt)
  240. 	{
  241. 		cval = cmp(F1->set, F1->joinf, F2->set, F2->joinf);
  242. 		if(cval == 0)
  243. 		{
  244. 			/* Oh joy, oh rapture, oh beauty divine! */
  245. 			if(joinout) joinlines(F1, F2);
  246. 			slurp(F1);
  247. 			slurp(F2);
  248. 		}
  249. 		else if(cval < 0)
  250. 		{
  251. 			/* File 1 takes the lead... */
  252. 			if(F1->unpair) joinlines(F1, NULL);
  253. 			slurp(F1);
  254. 		}
  255. 		else
  256. 		{
  257. 			/* File 2 takes the lead... */
  258. 			if(F2->unpair) joinlines(F2, NULL);
  259. 			slurp(F2);
  260. 		}
  261. 	}
  263. 	/*
  264. 	 * Now that one of the files is used up, optionally output any
  265. 	 * remaining lines from the other file.
  266. 	 */
  267. 	if(F1->unpair)
  268. 		while(F1->setcnt)
  269. 		{
  270. 			joinlines(F1, NULL);
  271. 			slurp(F1);
  272. 		}
  273. 	if(F2->unpair)
  274. 		while(F2->setcnt)
  275. 		{
  276. 			joinlines(F2, NULL);
  277. 			slurp(F2);
  278. 		}
  279. 	exit(0);
  280. }
  282. static void
  283. slurp(INPUT *F)
  284. {
  285. 	LINE *lp, *lastlp, tmp;
  286. 	size_t len;
  287. 	int cnt;
  288. 	char *bp, *fieldp;
  290. 	/*
  291. 	 * Read all of the lines from an input file that have the same
  292. 	 * join field.
  293. 	 */
  294. 	F->setcnt = 0;
  295. 	for(lastlp = NULL;; ++F->setcnt)
  296. 	{
  297. 		/*
  298. 		 * If we're out of space to hold line structures, allocate
  299. 		 * more.  Initialize the structure so that we know that this
  300. 		 * is new space.
  301. 		 */
  302. 		if(F->setcnt == F->setalloc)
  303. 		{
  304. 			cnt = F->setalloc;
  305. 			F->setalloc += 50;
  306. 			if(F->setalloc <= 0) utils_errx(1, "slurp setalloc overflow");
  307. 			if((F->set = reallocarray(F->set, F->setalloc, sizeof(LINE))) == NULL)
  308. 				utils_err(1, "Failed (re)allocating slurp set");
  309. 			memset(F->set + cnt, 0, 50 * sizeof(LINE));
  311. 			/* re-set lastlp in case it moved */
  312. 			if(lastlp != NULL) lastlp = &F->set[F->setcnt - 1];
  313. 		}
  315. 		/*
  316. 		 * Get any pushed back line, else get the next line.  Allocate
  317. 		 * space as necessary.  If taking the line from the stack swap
  318. 		 * the two structures so that we don't lose space allocated to
  319. 		 * either structure.  This could be avoided by doing another
  320. 		 * level of indirection, but it's probably okay as is.
  321. 		 */
  322. 		lp = &F->set[F->setcnt];
  323. 		assert(lp);
  324. 		if(F->setcnt) lastlp = &F->set[F->setcnt - 1];
  325. 		if(F->pushbool)
  326. 		{
  327. 			tmp = F->set[F->setcnt];
  328. 			F->set[F->setcnt] = F->set[F->pushback];
  329. 			F->set[F->pushback] = tmp;
  330. 			F->pushbool = 0;
  331. 			continue;
  332. 		}
  333. 		if((bp = fgetln(F->fp, &len)) == NULL) return;
  334. 		if(lp->linealloc <= len + 1)
  335. 		{
  336. 			lp->linealloc += MAX(100, len + 1 - lp->linealloc);
  337. 			if(lp->linealloc <= 0) utils_errx(1, "slurp linealloc overflow");
  338. 			if((lp->line = realloc(lp->line, lp->linealloc)) == NULL)
  339. 				utils_err(1, "Failed (re)allocating slurp line");
  340. 		}
  341. 		memmove(lp->line, bp, len);
  343. 		/* Replace trailing newline, if it exists. */
  344. 		if(bp[len - 1] == '\n')
  345. 			lp->line[len - 1] = '\0';
  346. 		else
  347. 			lp->line[len] = '\0';
  348. 		bp = lp->line;
  350. 		/* Split the line into fields, allocate space as necessary. */
  351. 		lp->fieldcnt = 0;
  352. 		while((fieldp = mbssep(&bp, tabchar)) != NULL)
  353. 		{
  354. 			if(spans && *fieldp == '\0') continue;
  355. 			if(lp->fieldcnt == lp->fieldalloc)
  356. 			{
  357. 				lp->fieldalloc += 50;
  358. 				if(lp->fieldalloc < 0) utils_errx(1, "slurp fieldalloc overflow");
  359. 				if((lp->fields = reallocarray(lp->fields, lp->fieldalloc, sizeof(char *))) == NULL)
  360. 					utils_err(1, "Failed (re)allocating slurp fieldalloc");
  361. 			}
  362. 			lp->fields[lp->fieldcnt++] = fieldp;
  363. 		}
  365. 		/* See if the join field value has changed. */
  366. 		if(lastlp != NULL && cmp(lp, F->joinf, lastlp, F->joinf))
  367. 		{
  368. 			F->pushbool = 1;
  369. 			F->pushback = F->setcnt;
  370. 			break;
  371. 		}
  372. 	}
  373. }
  375. static char *
  376. mbssep(char **stringp, const wchar_t *delim)
  377. {
  378. 	char *s, *tok;
  379. 	const wchar_t *spanp;
  380. 	wchar_t c, sc;
  381. 	size_t n;
  383. 	if((s = *stringp) == NULL) return (NULL);
  384. 	for(tok = s;;)
  385. 	{
  386. 		n = mbrtowc(&c, s, MB_LEN_MAX, NULL);
  387. 		if(n == (size_t)-1 || n == (size_t)-2)
  388. 		{
  389. 			fprintf(stderr, "join: error: mbrtowc: Illegal byte sequence\n");
  390. 			exit(1);
  391. 		}
  392. 		s += n;
  393. 		spanp = delim;
  394. 		do
  395. 		{
  396. 			if((sc = *spanp++) == c)
  397. 			{
  398. 				if(c == 0)
  399. 					s = NULL;
  400. 				else
  401. 					s[-n] = '\0';
  402. 				*stringp = s;
  403. 				return (tok);
  404. 			}
  405. 		} while(sc != 0);
  406. 	}
  407. }
  409. static int
  410. cmp(LINE *lp1, unsigned long fieldno1, LINE *lp2, unsigned long fieldno2)
  411. {
  412. 	if(lp1->fieldcnt <= fieldno1) return (lp2->fieldcnt <= fieldno2 ? 0 : 1);
  413. 	if(lp2->fieldcnt <= fieldno2) return (-1);
  414. 	return (mbscoll(lp1->fields[fieldno1], lp2->fields[fieldno2]));
  415. }
  417. static int
  418. mbscoll(const char *s1, const char *s2)
  419. {
  420. 	wchar_t *w1, *w2;
  421. 	int ret;
  423. 	if(MB_CUR_MAX == 1) return (strcoll(s1, s2));
  424. 	if((w1 = towcs(s1)) == NULL || (w2 = towcs(s2)) == NULL) utils_err(1, NULL); /* XXX */
  425. 	ret = wcscoll(w1, w2);
  426. 	free(w1);
  427. 	free(w2);
  428. 	return (ret);
  429. }
  431. static wchar_t *
  432. towcs(const char *s)
  433. {
  434. 	wchar_t *wcs;
  435. 	size_t n;
  437. 	if((n = mbsrtowcs(NULL, &s, 0, NULL)) == (size_t)-1) return (NULL);
  438. 	n++;
  439. 	if(n <= 0) return (NULL);
  440. 	if((wcs = calloc(n, sizeof(*wcs))) == NULL) return (NULL);
  441. 	mbsrtowcs(wcs, &s, n, NULL);
  442. 	return (wcs);
  443. }
  445. static void
  446. joinlines(INPUT *F1, INPUT *F2)
  447. {
  448. 	unsigned long cnt1, cnt2;
  450. 	/*
  451. 	 * Output the results of a join comparison.  The output may be from
  452. 	 * either file 1 or file 2 (in which case the first argument is the
  453. 	 * file from which to output) or from both.
  454. 	 */
  455. 	if(F2 == NULL)
  456. 	{
  457. 		for(cnt1 = 0; cnt1 < F1->setcnt; ++cnt1)
  458. 			outoneline(F1, &F1->set[cnt1]);
  459. 		return;
  460. 	}
  461. 	for(cnt1 = 0; cnt1 < F1->setcnt; ++cnt1)
  462. 		for(cnt2 = 0; cnt2 < F2->setcnt; ++cnt2)
  463. 			outtwoline(F1, &F1->set[cnt1], F2, &F2->set[cnt2]);
  464. }
  466. static void
  467. outoneline(INPUT *F, LINE *lp)
  468. {
  469. 	unsigned long cnt;
  471. 	/*
  472. 	 * Output a single line from one of the files, according to the
  473. 	 * join rules.  This happens when we are writing unmatched single
  474. 	 * lines.  Output empty fields in the right places.
  475. 	 */
  476. 	if(olist)
  477. 		for(cnt = 0; cnt < olistcnt; ++cnt)
  478. 		{
  479. 			if(olist[cnt].filenum == (unsigned)F->number)
  480. 				outfield(lp, olist[cnt].fieldno, 0);
  481. 			else if(olist[cnt].filenum == 0)
  482. 				outfield(lp, F->joinf, 0);
  483. 			else
  484. 				outfield(lp, 0, 1);
  485. 		}
  486. 	else
  487. 	{
  488. 		/*
  489. 		 * Output the join field, then the remaining fields.
  490. 		 */
  491. 		outfield(lp, F->joinf, 0);
  492. 		for(cnt = 0; cnt < lp->fieldcnt; ++cnt)
  493. 			if(F->joinf != cnt) outfield(lp, cnt, 0);
  494. 	}
  495. 	(void)printf("\n");
  496. 	if(ferror(stdout)) utils_err(1, "stdout");
  497. 	needsep = 0;
  498. }
  500. static void
  501. outtwoline(INPUT *F1, LINE *lp1, INPUT *F2, LINE *lp2)
  502. {
  503. 	unsigned long cnt;
  505. 	/* Output a pair of lines according to the join list (if any). */
  506. 	if(olist)
  507. 		for(cnt = 0; cnt < olistcnt; ++cnt)
  508. 			if(olist[cnt].filenum == 0)
  509. 			{
  510. 				if(lp1->fieldcnt >= F1->joinf)
  511. 					outfield(lp1, F1->joinf, 0);
  512. 				else
  513. 					outfield(lp2, F2->joinf, 0);
  514. 			}
  515. 			else if(olist[cnt].filenum == 1)
  516. 				outfield(lp1, olist[cnt].fieldno, 0);
  517. 			else /* if (olist[cnt].filenum == 2) */
  518. 				outfield(lp2, olist[cnt].fieldno, 0);
  519. 	else
  520. 	{
  521. 		/*
  522. 		 * Output the join field, then the remaining fields from F1
  523. 		 * and F2.
  524. 		 */
  525. 		outfield(lp1, F1->joinf, 0);
  526. 		for(cnt = 0; cnt < lp1->fieldcnt; ++cnt)
  527. 			if(F1->joinf != cnt) outfield(lp1, cnt, 0);
  528. 		for(cnt = 0; cnt < lp2->fieldcnt; ++cnt)
  529. 			if(F2->joinf != cnt) outfield(lp2, cnt, 0);
  530. 	}
  531. 	(void)printf("\n");
  532. 	if(ferror(stdout)) utils_err(1, "stdout");
  533. 	needsep = 0;
  534. }
  536. static void
  537. outfield(LINE *lp, unsigned long fieldno, int out_empty)
  538. {
  539. 	if(needsep++) (void)printf("%lc", (wint_t)*tabchar);
  540. 	if(!ferror(stdout))
  541. 	{
  542. 		if(lp->fieldcnt <= fieldno || out_empty)
  543. 		{
  544. 			if(empty != NULL) (void)printf("%s", empty);
  545. 		}
  546. 		else
  547. 		{
  548. 			if(*lp->fields[fieldno] == '\0') return;
  549. 			(void)printf("%s", lp->fields[fieldno]);
  550. 		}
  551. 	}
  552. 	if(ferror(stdout)) utils_err(1, "stdout");
  553. }
  555. /*
  556.  * Convert an output list argument "2.1, 1.3, 2.4" into an array of output
  557.  * fields.
  558.  */
  559. static void
  560. fieldarg(char *option)
  561. {
  562. 	unsigned long fieldno, filenum;
  563. 	char *end, *token;
  565. 	while((token = strsep(&option, ", \t")) != NULL)
  566. 	{
  567. 		if(*token == '\0') continue;
  568. 		if(token[0] == '0')
  569. 			filenum = fieldno = 0;
  570. 		else if((token[0] == '1' || token[0] == '2') && token[1] == '.')
  571. 		{
  572. 			filenum = token[0] - '0';
  573. 			fieldno = strtol(token + 2, &end, 10);
  574. 			if(*end) utils_errx(1, "malformed -o option field");
  575. 			if(fieldno == 0) utils_errx(1, "field numbers are 1 based");
  576. 			--fieldno;
  577. 		}
  578. 		else
  579. 			utils_errx(1, "malformed -o option field");
  580. 		if(olistcnt == olistalloc)
  581. 		{
  582. 			olistalloc += 50;
  583. 			if(olistalloc <= 0) utils_errx(1, "fieldarg olistalloc overflow");
  584. 			if((olist = reallocarray(olist, olistalloc, sizeof(OLIST))) == NULL)
  585. 				utils_err(1, "Failed (re)allocating fieldarg");
  586. 		}
  587. 		olist[olistcnt].filenum = filenum;
  588. 		olist[olistcnt].fieldno = fieldno;
  589. 		++olistcnt;
  590. 	}
  591. }
  593. static void
  594. usage(void)
  595. {
  596. 	(void)fprintf(stderr,
  597. 	              "%s %s\n%s\n",
  598. 	              "usage: join [-a fileno | -v fileno ] [-e string] [-1 field]",
  599. 	              "[-2 field]",
  600. 	              "            [-o list] [-t char] file1 file2");
  601. 	exit(1);
  602. }