logo

utils-std

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

paste.c (6918B)

    

  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 "../libutils/err.h"
  38. #include "../libutils/getopt_nolong.h"
  40. #include <assert.h>
  41. #include <errno.h>
  42. #include <limits.h>
  43. #include <locale.h>
  44. #include <stdint.h> // SIZE_MAX
  45. #include <stdio.h>
  46. #include <stdlib.h>
  47. #include <string.h>
  48. #include <sys/types.h>
  49. #include <unistd.h>
  50. #include <wchar.h>
  52. static wchar_t *delim;
  53. static int delimcnt;
  54. static wint_t linedelim = L'\n';
  56. static wchar_t tab[] = L"\t";
  57. const char *argv0 = "paste";
  59. typedef struct _list
  60. {
  61. 	struct _list *next;
  62. 	FILE *fp;
  63. 	int cnt;
  64. 	char *name;
  65. } LIST;
  67. static int
  68. parallel(char **argv)
  69. {
  70. 	LIST *lp;
  71. 	int cnt;
  72. 	wint_t ich;
  73. 	wchar_t ch;
  74. 	char *p;
  75. 	LIST *head, *tmp;
  76. 	int opencnt, output;
  77. 	int err = 0;
  79. 	for(cnt = 0, head = tmp = NULL; (p = *argv); ++argv, ++cnt)
  80. 	{
  81. 		if((lp = malloc(sizeof(LIST))) == NULL) utils_err(1, NULL);
  82. 		if(p[0] == '-' && !p[1])
  83. 			lp->fp = stdin;
  84. 		else
  85. 		{
  86. 			lp->fp = fopen(p, "r");
  87. 			if(!lp->fp) utils_err(1, "%s", p);
  88. 			assert(lp->fp != stdin);
  89. 		}
  90. 		lp->next = NULL;
  91. 		lp->cnt = cnt;
  92. 		lp->name = p;
  93. 		if(!head)
  94. 			head = tmp = lp;
  95. 		else
  96. 		{
  97. 			tmp->next = lp;
  98. 			tmp = lp;
  99. 		}
  100. 	}
  102. 	for(opencnt = cnt; opencnt;)
  103. 	{
  104. 		for(output = 0, lp = head; lp; lp = lp->next)
  105. 		{
  106. 			if(!lp->fp)
  107. 			{
  108. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  109. 				continue;
  110. 			}
  111. 			if((ich = getwc(lp->fp)) == WEOF)
  112. 			{
  113. 				if(!--opencnt) break;
  114. 				if(lp->fp && lp->fp != stdin)
  115. 				{
  116. 					if(fclose(lp->fp) != 0)
  117. 					{
  118. 						fprintf(stderr,
  119. 						        "%s: error: Failed closing file '%s': %s\n",
  120. 						        argv0,
  121. 						        lp->name,
  122. 						        strerror(errno));
  123. 						err = 1;
  124. 					}
  125. 				}
  126. 				lp->fp = NULL;
  127. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  128. 				continue;
  129. 			}
  130. 			/*
  131. 			 * make sure that we don't print any delimiters
  132. 			 * unless there's a non-empty file.
  133. 			 */
  134. 			if(!output)
  135. 			{
  136. 				output = 1;
  137. 				for(cnt = 0; cnt < lp->cnt; ++cnt)
  138. 					if((ch = delim[cnt % delimcnt])) putwchar(ch);
  139. 			}
  140. 			else if((ch = delim[(lp->cnt - 1) % delimcnt]))
  141. 				putwchar(ch);
  143. 			if(ich == linedelim) continue;
  145. 			do
  146. 			{
  147. 				putwchar(ich);
  148. 			} while((ich = getwc(lp->fp)) != WEOF && ich != linedelim);
  149. 		}
  150. 		if(output) putwchar(linedelim);
  151. 	}
  153. 	for(lp = head; lp;)
  154. 	{
  155. 		if(lp->fp && lp->fp != stdin)
  156. 		{
  157. 			if(fclose(lp->fp) != 0)
  158. 			{
  159. 				fprintf(
  160. 				    stderr, "%s: error: Failed closing file '%s': %s\n", argv0, lp->name, strerror(errno));
  161. 				err = 1;
  162. 			}
  163. 		}
  164. 		LIST *next = lp->next;
  165. 		free(lp);
  166. 		lp = next;
  167. 	}
  169. 	return err;
  170. }
  172. static int
  173. sequential(char **argv)
  174. {
  175. 	FILE *fp;
  176. 	int cnt, failed, needdelim;
  177. 	wint_t ch;
  178. 	char *p;
  180. 	failed = 0;
  181. 	for(; (p = *argv); ++argv)
  182. 	{
  183. 		if(p[0] == '-' && !p[1])
  184. 			fp = stdin;
  185. 		else if(!(fp = fopen(p, "r")))
  186. 		{
  187. 			utils_warn("%s", p);
  188. 			failed = 1;
  189. 			continue;
  190. 		}
  191. 		cnt = needdelim = 0;
  192. 		while((ch = getwc(fp)) != WEOF)
  193. 		{
  194. 			if(needdelim)
  195. 			{
  196. 				needdelim = 0;
  197. 				if(delim[cnt] != '\0') putwchar(delim[cnt]);
  198. 				if(++cnt == delimcnt) cnt = 0;
  199. 			}
  200. 			if(ch != linedelim)
  201. 				putwchar(ch);
  202. 			else
  203. 				needdelim = 1;
  204. 		}
  205. 		if(needdelim) putwchar(linedelim);
  206. 		if(fp != stdin)
  207. 		{
  208. 			if(fclose(fp) != 0)
  209. 			{
  210. 				fprintf(stderr, "%s: error: Failed closing file '%s': %s\n", argv0, p, strerror(errno));
  211. 				failed = 1;
  212. 			}
  213. 		}
  214. 	}
  216. 	return (failed != 0);
  217. }
  219. static int
  220. tr(wchar_t *arg)
  221. {
  222. 	int cnt;
  223. 	wchar_t ch, *p;
  225. 	for(p = arg, cnt = 0; (ch = *p++); ++arg, ++cnt)
  226. 		if(ch == '\\') switch(ch = *p++)
  227. 			{
  228. 			case 'n':
  229. 				*arg = '\n';
  230. 				break;
  231. 			case 't':
  232. 				*arg = '\t';
  233. 				break;
  234. 			case '0':
  235. 				*arg = '\0';
  236. 				break;
  237. 			default:
  238. 				*arg = ch;
  239. 				break;
  240. 			}
  241. 		else
  242. 			*arg = ch;
  244. 	if(!cnt) utils_errx(1, "no delimiters specified");
  245. 	return (cnt);
  246. }
  248. static void
  249. usage(void)
  250. {
  251. 	(void)fprintf(stderr, "usage: paste [-sz] [-d delimiters] [file...]\n");
  252. 	exit(1);
  253. }
  255. int
  256. main(int argc, char *argv[])
  257. {
  258. 	char *lc_all = setlocale(LC_ALL, "");
  259. 	if(lc_all == NULL)
  260. 	{
  261. 		fprintf(stderr,
  262. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  263. 		        argv0,
  264. 		        strerror(errno));
  265. 	}
  266. 	errno = 0;
  268. 	int seq = 0;
  270. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":d:sz")) != -1;)
  271. 	{
  272. 		switch(c)
  273. 		{
  274. 		case 'd':
  275. 		{
  276. 			const char *arg = optarg;
  277. 			size_t len = mbsrtowcs(NULL, &arg, 0, NULL);
  278. 			if(len == (size_t)-1) utils_err(1, "delimiters");
  280. 			if(len == SIZE_MAX) utils_err(1, NULL);
  281. 			wchar_t *warg = calloc((len + 1), sizeof(*warg));
  282. 			if(warg == NULL) utils_err(1, NULL);
  284. 			arg = optarg;
  285. 			len = mbsrtowcs(warg, &arg, len + 1, NULL);
  286. 			if(len == (size_t)-1) utils_err(1, "delimiters");
  288. 			delimcnt = tr(delim = warg);
  289. 			break;
  290. 		}
  291. 		case 's':
  292. 			seq = 1;
  293. 			break;
  294. 		case 'z':
  295. 			linedelim = L'\0';
  296. 			break;
  297. 		case ':':
  298. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  299. 			usage();
  300. 			return 1;
  301. 		case '?':
  302. 			GETOPT_UNKNOWN_OPT
  303. 			usage();
  304. 			return 1;
  305. 		default:
  306. 			abort();
  307. 		}
  308. 	}
  310. 	argc -= optind;
  311. 	argv += optind;
  313. 	char *dash[] = {(char *)"-", NULL};
  314. 	char **args = argc > 0 ? argv : dash;
  316. 	if(!delim)
  317. 	{
  318. 		delimcnt = 1;
  319. 		delim = tab;
  320. 	}
  322. 	if(seq)
  323. 		return sequential(args);
  324. 	else
  325. 		return parallel(args);
  326. }