logo

utils-std

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

paste.c (5980B)

    

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