logo

utils-std

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

paste.c (7458B)

    

  1. /*-
  2.  * SPDX-License-Identifier: BSD-3-Clause
  3.  *
  4.  * Copyright (c) 1989, 1993
  5.  *	The Regents of the University of California.  All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Adam S. Moskowitz of Menlo Consulting.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. Neither the name of the University nor the names of its contributors
  19.  *    may be used to endorse or promote products derived from this software
  20.  *    without specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  35. #define _POSIX_C_SOURCE 200809L
  37. #include "../config.h"
  38. #include "../libutils/err.h"
  39. #include "../libutils/getopt_nolong.h"
  41. #include <assert.h>
  42. #include <errno.h>
  43. #include <limits.h>
  44. #include <locale.h>
  45. #include <stdint.h> // SIZE_MAX
  46. #include <stdio.h>
  47. #include <stdlib.h>
  48. #include <string.h>
  49. #include <sys/types.h>
  50. #include <unistd.h>
  51. #include <wchar.h>
  52. #ifdef HAS_GETOPT_LONG
  53. #include <getopt.h>
  54. #endif
  56. static wchar_t *delim;
  57. static int delimcnt;
  58. static wint_t linedelim = L'\n';
  60. static wchar_t tab[] = L"\t";
  61. const char *argv0 = "paste";
  63. typedef struct _list
  64. {
  65. 	struct _list *next;
  66. 	FILE *fp;
  67. 	int cnt;
  68. 	char *name;
  69. } LIST;
  71. static int
  72. parallel(char **argv)
  73. {
  74. 	LIST *lp;
  75. 	int cnt;
  76. 	wint_t ich;
  77. 	wchar_t ch;
  78. 	char *p;
  79. 	LIST *head, *tmp;
  80. 	int opencnt, output;
  81. 	int err = 0;
  83. 	for(cnt = 0, head = tmp = NULL; (p = *argv); ++argv, ++cnt)
  84. 	{
  85. 		if((lp = malloc(sizeof(LIST))) == NULL) utils_err(1, NULL);
  86. 		if(p[0] == '-' && !p[1])
  87. 			lp->fp = stdin;
  88. 		else
  89. 		{
  90. 			lp->fp = fopen(p, "r");
  91. 			if(!lp->fp) utils_err(1, "%s", p);
  92. 			assert(lp->fp != stdin);
  93. 		}
  94. 		lp->next = NULL;
  95. 		lp->cnt = cnt;
  96. 		lp->name = p;
  97. 		if(!head)
  98. 			head = tmp = lp;
  99. 		else
  100. 		{
  101. 			tmp->next = lp;
  102. 			tmp = lp;
  103. 		}
  104. 	}
  106. 	for(opencnt = cnt; opencnt;)
  107. 	{
  108. 		for(output = 0, lp = head; lp; lp = lp->next)
  109. 		{
  110. 			if(!lp->fp)
  111. 			{
  112. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  113. 				continue;
  114. 			}
  115. 			if((ich = getwc(lp->fp)) == WEOF)
  116. 			{
  117. 				if(!--opencnt) break;
  118. 				if(lp->fp && lp->fp != stdin)
  119. 				{
  120. 					if(fclose(lp->fp) != 0)
  121. 					{
  122. 						fprintf(stderr,
  123. 						        "%s: error: Failed closing file '%s': %s\n",
  124. 						        argv0,
  125. 						        lp->name,
  126. 						        strerror(errno));
  127. 						err = 1;
  128. 					}
  129. 				}
  130. 				lp->fp = NULL;
  131. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  132. 				continue;
  133. 			}
  134. 			/*
  135. 			 * make sure that we don't print any delimiters
  136. 			 * unless there's a non-empty file.
  137. 			 */
  138. 			if(!output)
  139. 			{
  140. 				output = 1;
  141. 				for(cnt = 0; cnt < lp->cnt; ++cnt)
  142. 					if((ch = delim[cnt % delimcnt])) putwchar(ch);
  143. 			}
  144. 			else if((ch = delim[(lp->cnt - 1) % delimcnt]))
  145. 				putwchar(ch);
  147. 			if(ich == linedelim) continue;
  149. 			do
  150. 			{
  151. 				putwchar(ich);
  152. 			} while((ich = getwc(lp->fp)) != WEOF && ich != linedelim);
  153. 		}
  154. 		if(output) putwchar(linedelim);
  155. 	}
  157. 	for(lp = head; lp;)
  158. 	{
  159. 		if(lp->fp && lp->fp != stdin)
  160. 		{
  161. 			if(fclose(lp->fp) != 0)
  162. 			{
  163. 				fprintf(
  164. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, lp->name, strerror(errno));
  165. 				err = 1;
  166. 			}
  167. 		}
  168. 		LIST *next = lp->next;
  169. 		free(lp);
  170. 		lp = next;
  171. 	}
  173. 	return err;
  174. }
  176. static int
  177. sequential(char **argv)
  178. {
  179. 	FILE *fp;
  180. 	int cnt, failed, needdelim;
  181. 	wint_t ch;
  182. 	char *p;
  184. 	failed = 0;
  185. 	for(; (p = *argv); ++argv)
  186. 	{
  187. 		if(p[0] == '-' && !p[1])
  188. 			fp = stdin;
  189. 		else if(!(fp = fopen(p, "r")))
  190. 		{
  191. 			utils_warn("%s", p);
  192. 			failed = 1;
  193. 			continue;
  194. 		}
  195. 		cnt = needdelim = 0;
  196. 		while((ch = getwc(fp)) != WEOF)
  197. 		{
  198. 			if(needdelim)
  199. 			{
  200. 				needdelim = 0;
  201. 				if(delim[cnt] != '\0') putwchar(delim[cnt]);
  202. 				if(++cnt == delimcnt) cnt = 0;
  203. 			}
  204. 			if(ch != linedelim)
  205. 				putwchar(ch);
  206. 			else
  207. 				needdelim = 1;
  208. 		}
  209. 		if(needdelim) putwchar(linedelim);
  210. 		if(fp != stdin)
  211. 		{
  212. 			if(fclose(fp) != 0)
  213. 			{
  214. 				fprintf(stderr, "%s: error: Failed closing file '%s': %s\n", argv0, p, strerror(errno));
  215. 				failed = 1;
  216. 			}
  217. 		}
  218. 	}
  220. 	return (failed != 0);
  221. }
  223. static int
  224. tr(wchar_t *arg)
  225. {
  226. 	int cnt;
  227. 	wchar_t ch, *p;
  229. 	for(p = arg, cnt = 0; (ch = *p++); ++arg, ++cnt)
  230. 		if(ch == '\\') switch(ch = *p++)
  231. 			{
  232. 			case 'n':
  233. 				*arg = '\n';
  234. 				break;
  235. 			case 't':
  236. 				*arg = '\t';
  237. 				break;
  238. 			case '0':
  239. 				*arg = '\0';
  240. 				break;
  241. 			default:
  242. 				*arg = ch;
  243. 				break;
  244. 			}
  245. 		else
  246. 			*arg = ch;
  248. 	if(!cnt) utils_errx(1, "no delimiters specified");
  249. 	return (cnt);
  250. }
  252. static void
  253. usage(void)
  254. {
  255. 	(void)fprintf(stderr, "usage: paste [-sz] [-d delimiters] [file...]\n");
  256. 	exit(1);
  257. }
  259. int
  260. main(int argc, char *argv[])
  261. {
  262. 	char *lc_all = setlocale(LC_ALL, "");
  263. 	if(lc_all == NULL)
  264. 	{
  265. 		fprintf(stderr,
  266. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  267. 		        argv0,
  268. 		        strerror(errno));
  269. 	}
  270. 	errno = 0;
  272. 	int seq = 0;
  274. #ifdef HAS_GETOPT_LONG
  275. 	// Strictly for GNUisms compatibility so no long-only options
  276. 	// clang-format off
  277. 	static struct option opts[] = {
  278. 		{"delimiter", required_argument, NULL, 'd'},
  279. 		{"serial", no_argument, NULL, 's'},
  280. 		{"zero-terminated", no_argument, NULL, 'z'},
  281. 		{0, 0, 0, 0},
  282. 	};
  283. 	// clang-format on
  285. 	// Need + as first character to get POSIX-style option parsing
  286. 	for(int c = -1; (c = getopt_long(argc, argv, "+:d:sz", opts, NULL)) != -1;)
  287. #else
  288. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":d:sz")) != -1;)
  289. #endif
  290. 	{
  291. 		switch(c)
  292. 		{
  293. 		case 'd':
  294. 		{
  295. 			const char *arg = optarg;
  296. 			size_t len = mbsrtowcs(NULL, &arg, 0, NULL);
  297. 			if(len == (size_t)-1) utils_err(1, "delimiters");
  299. 			if(len == SIZE_MAX) utils_err(1, NULL);
  300. 			wchar_t *warg = calloc((len + 1), sizeof(*warg));
  301. 			if(warg == NULL) utils_err(1, NULL);
  303. 			arg = optarg;
  304. 			len = mbsrtowcs(warg, &arg, len + 1, NULL);
  305. 			if(len == (size_t)-1) utils_err(1, "delimiters");
  307. 			delimcnt = tr(delim = warg);
  308. 			break;
  309. 		}
  310. 		case 's':
  311. 			seq = 1;
  312. 			break;
  313. 		case 'z':
  314. 			linedelim = L'\0';
  315. 			break;
  316. 		case ':':
  317. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  318. 			usage();
  319. 			return 1;
  320. 		case '?':
  321. 			GETOPT_UNKNOWN_OPT
  322. 			usage();
  323. 			return 1;
  324. 		default:
  325. 			abort();
  326. 		}
  327. 	}
  329. 	argc -= optind;
  330. 	argv += optind;
  332. 	char *dash[] = {(char *)"-", NULL};
  333. 	char **args = argc > 0 ? argv : dash;
  335. 	if(!delim)
  336. 	{
  337. 		delimcnt = 1;
  338. 		delim = tab;
  339. 	}
  341. 	if(seq)
  342. 		return sequential(args);
  343. 	else
  344. 		return parallel(args);
  345. }