logo

utils-std

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

paste.c (6048B)

    

  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. #include <err.h>
  36. #include <errno.h>
  37. #include <limits.h>
  38. #include <locale.h>
  39. #include <stdint.h> // SIZE_MAX
  40. #include <stdio.h>
  41. #include <stdlib.h>
  42. #include <string.h>
  43. #include <sys/types.h>
  44. #include <unistd.h>
  45. #include <wchar.h>
  47. static wchar_t *delim;
  48. static int delimcnt;
  49. static wint_t linedelim = L'\n';
  51. static wchar_t tab[] = L"\t";
  52. const char *argv0 = "paste";
  54. typedef struct _list
  55. {
  56. 	struct _list *next;
  57. 	FILE *fp;
  58. 	int cnt;
  59. 	char *name;
  60. } LIST;
  62. static int
  63. parallel(char **argv)
  64. {
  65. 	LIST *lp;
  66. 	int cnt;
  67. 	wint_t ich;
  68. 	wchar_t ch;
  69. 	char *p;
  70. 	LIST *head, *tmp;
  71. 	int opencnt, output;
  73. 	for(cnt = 0, head = tmp = NULL; (p = *argv); ++argv, ++cnt)
  74. 	{
  75. 		if((lp = malloc(sizeof(LIST))) == NULL) err(1, NULL);
  76. 		if(p[0] == '-' && !p[1])
  77. 			lp->fp = stdin;
  78. 		else if(!(lp->fp = fopen(p, "r")))
  79. 			err(1, "error: %s", p);
  80. 		lp->next = NULL;
  81. 		lp->cnt = cnt;
  82. 		lp->name = p;
  83. 		if(!head)
  84. 			head = tmp = lp;
  85. 		else
  86. 		{
  87. 			tmp->next = lp;
  88. 			tmp = lp;
  89. 		}
  90. 	}
  92. 	for(opencnt = cnt; opencnt;)
  93. 	{
  94. 		for(output = 0, lp = head; lp; lp = lp->next)
  95. 		{
  96. 			if(!lp->fp)
  97. 			{
  98. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  99. 				continue;
  100. 			}
  101. 			if((ich = getwc(lp->fp)) == WEOF)
  102. 			{
  103. 				if(!--opencnt) break;
  104. 				lp->fp = NULL;
  105. 				if(output && lp->cnt && (ch = delim[(lp->cnt - 1) % delimcnt])) putwchar(ch);
  106. 				continue;
  107. 			}
  108. 			/*
  109. 			 * make sure that we don't print any delimiters
  110. 			 * unless there's a non-empty file.
  111. 			 */
  112. 			if(!output)
  113. 			{
  114. 				output = 1;
  115. 				for(cnt = 0; cnt < lp->cnt; ++cnt)
  116. 					if((ch = delim[cnt % delimcnt])) putwchar(ch);
  117. 			}
  118. 			else if((ch = delim[(lp->cnt - 1) % delimcnt]))
  119. 				putwchar(ch);
  120. 			if(ich == linedelim) continue;
  121. 			do
  122. 			{
  123. 				putwchar(ich);
  124. 			} while((ich = getwc(lp->fp)) != WEOF && ich != linedelim);
  125. 		}
  126. 		if(output) putwchar(linedelim);
  127. 	}
  129. 	return (0);
  130. }
  132. static int
  133. sequential(char **argv)
  134. {
  135. 	FILE *fp;
  136. 	int cnt, failed, needdelim;
  137. 	wint_t ch;
  138. 	char *p;
  140. 	failed = 0;
  141. 	for(; (p = *argv); ++argv)
  142. 	{
  143. 		if(p[0] == '-' && !p[1])
  144. 			fp = stdin;
  145. 		else if(!(fp = fopen(p, "r")))
  146. 		{
  147. 			warn("%s", p);
  148. 			failed = 1;
  149. 			continue;
  150. 		}
  151. 		cnt = needdelim = 0;
  152. 		while((ch = getwc(fp)) != WEOF)
  153. 		{
  154. 			if(needdelim)
  155. 			{
  156. 				needdelim = 0;
  157. 				if(delim[cnt] != '\0') putwchar(delim[cnt]);
  158. 				if(++cnt == delimcnt) cnt = 0;
  159. 			}
  160. 			if(ch != linedelim)
  161. 				putwchar(ch);
  162. 			else
  163. 				needdelim = 1;
  164. 		}
  165. 		if(needdelim) putwchar(linedelim);
  166. 		if(fp != stdin) (void)fclose(fp);
  167. 	}
  169. 	return (failed != 0);
  170. }
  172. static int
  173. tr(wchar_t *arg)
  174. {
  175. 	int cnt;
  176. 	wchar_t ch, *p;
  178. 	for(p = arg, cnt = 0; (ch = *p++); ++arg, ++cnt)
  179. 		if(ch == '\\') switch(ch = *p++)
  180. 			{
  181. 			case 'n':
  182. 				*arg = '\n';
  183. 				break;
  184. 			case 't':
  185. 				*arg = '\t';
  186. 				break;
  187. 			case '0':
  188. 				*arg = '\0';
  189. 				break;
  190. 			default:
  191. 				*arg = ch;
  192. 				break;
  193. 			}
  194. 		else
  195. 			*arg = ch;
  197. 	if(!cnt) errx(1, "error: no delimiters specified");
  198. 	return (cnt);
  199. }
  201. static void
  202. usage(void)
  203. {
  204. 	(void)fprintf(stderr, "usage: paste [-sz] [-d delimiters] [file...]\n");
  205. 	exit(1);
  206. }
  208. int
  209. main(int argc, char *argv[])
  210. {
  211. 	errno = 0;
  212. 	setlocale(LC_ALL, "");
  213. 	if(errno != 0)
  214. 	{
  215. 		fprintf(stderr, "%s: warning: Failed to initialize locales: %s\n", argv0, strerror(errno));
  216. 		errno = 0;
  217. 	}
  219. 	int c = -1, seq = 0;
  220. 	while((c = getopt(argc, argv, ":d:sz")) != -1)
  221. 	{
  222. 		switch(c)
  223. 		{
  224. 		case 'd':
  225. 		{
  226. 			const char *arg = optarg;
  227. 			size_t len = mbsrtowcs(NULL, &arg, 0, NULL);
  228. 			if(len == (size_t)-1) err(1, "error: delimiters");
  229. 			if(len == SIZE_MAX) err(1, NULL);
  230. 			wchar_t *warg = calloc((len + 1), sizeof(*warg));
  231. 			if(warg == NULL) err(1, NULL);
  232. 			arg = optarg;
  233. 			len = mbsrtowcs(warg, &arg, len + 1, NULL);
  234. 			if(len == (size_t)-1) err(1, "error: delimiters");
  235. 			delimcnt = tr(delim = warg);
  236. 			break;
  237. 		}
  238. 		case 's':
  239. 			seq = 1;
  240. 			break;
  241. 		case 'z':
  242. 			linedelim = L'\0';
  243. 			break;
  244. 		case ':':
  245. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  246. 			usage();
  247. 			return 1;
  248. 		case '?':
  249. 			fprintf(stderr, "%s: error: Unrecognised option: '-%c'\n", argv0, optopt);
  250. 			usage();
  251. 			return 1;
  252. 		default:
  253. 			abort();
  254. 		}
  255. 	}
  257. 	argc -= optind;
  258. 	argv += optind;
  260. 	char *dash[] = {(char *)"-", NULL};
  261. 	char **args = argc > 0 ? argv : dash;
  263. 	if(!delim)
  264. 	{
  265. 		delimcnt = 1;
  266. 		delim = tab;
  267. 	}
  269. 	if(seq)
  270. 		return sequential(args);
  271. 	else
  272. 		return parallel(args);
  273. }