logo

utils-std

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

cut.c (9010B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _POSIX_C_SOURCE 202405L
  7. #include "../lib/getopt_nolong.h"
  8. #include "../lib/reallocarray.h"
  10. #include <assert.h>
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <locale.h>
  14. #include <stdbool.h>
  15. #include <stdint.h> // size_t
  16. #include <stdio.h>  // fprintf, fopen
  17. #include <string.h> // strerror
  18. #include <unistd.h> // getopt
  19. #include <wchar.h>
  21. #undef MIN
  22. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  24. enum cut_mode
  25. {
  26. 	CUT_MODE_NONE = 0,
  27. 	CUT_MODE_B = 1,
  28. 	CUT_MODE_C = 2,
  29. 	CUT_MODE_F = 3,
  30. };
  32. char delim = '\t';
  33. bool opt_n = false, opt_s = false;
  34. enum cut_mode mode = CUT_MODE_NONE;
  35. bool *list = NULL;
  36. size_t list_len = 0;
  37. bool nostop = false;
  38. const char *argv0 = "cut";
  40. static size_t
  41. parse_list_num(char **s)
  42. {
  43. 	char *endptr = NULL;
  44. 	errno = 0;
  45. 	size_t n = strtoul(*s, &endptr, 10);
  46. 	if(errno != 0)
  47. 	{
  48. 		fprintf(stderr, "%s: error: Failed parsing '%s' as a number: %s\n", argv0, *s, strerror(errno));
  49. 		return 0;
  50. 	}
  52. 	if(n < 1)
  53. 	{
  54. 		fprintf(stderr, "%s: error: Invalid number in list: %zu\n", argv0, n);
  55. 		return 0;
  56. 	}
  58. 	if(endptr != NULL && strchr(",-", *endptr) == NULL)
  59. 	{
  60. 		fprintf(stderr, "%s: error: Invalid character in list: %c\n", argv0, *endptr);
  61. 		return 0;
  62. 	}
  64. 	*s = endptr;
  66. 	return n;
  67. }
  69. static int
  70. parse_list(char *s)
  71. {
  72. 	while(true)
  73. 	{
  74. 		if(s == NULL || *s == '\0') break;
  76. 		if(*s == ',')
  77. 		{
  78. 			fprintf(stderr, "%s: error: Empty list element\n", argv0);
  79. 			return -1;
  80. 		}
  82. 		size_t min = 1;
  83. 		if(*s != '-')
  84. 		{
  85. 			min = parse_list_num(&s);
  86. 			if(min == 0) return -1;
  87. 		}
  89. 		// min-- as cut(1) is 1-indexed and max needs to be at least min+1
  90. 		size_t max = min--;
  92. 		if(s && *s == '-')
  93. 		{
  94. 			s++;
  96. 			if(!isdigit(*s))
  97. 			{
  98. 				nostop = true;
  99. 			}
  100. 			else
  101. 			{
  102. 				max = parse_list_num(&s);
  103. 				if(max == 0) return -1;
  105. 				if(max < min)
  106. 				{
  107. 					fprintf(stderr, "%s: error: Decreasing range: %zu-%zu\n", argv0, min, max);
  108. 					return -1;
  109. 				}
  110. 			}
  111. 		}
  113. 		// Needs to be after *s == '-'
  114. 		if(s && *s == ',') s++;
  116. 		if(max > list_len)
  117. 		{
  118. 			list = reallocarray(list, max, sizeof(*list));
  119. 			if(list == NULL)
  120. 			{
  121. 				fprintf(stderr, "%s: error: Failed memory allocation: %s\n", argv0, strerror(errno));
  122. 				return -1;
  123. 			}
  125. 			if(min > list_len)
  126. 			{
  127. 				memset(list + list_len, 0, min - list_len);
  128. 			}
  130. 			list_len = max;
  131. 		}
  133. 		memset(list + min, 1, max - min);
  134. 	}
  136. 	if(list_len == 0)
  137. 	{
  138. 		fprintf(stderr, "%s: error: Empty list\n", argv0);
  139. 		return -1;
  140. 	}
  142. 	return 0;
  143. }
  145. static int
  146. cut_b(FILE *in, const char *filename)
  147. {
  148. 	char *line = NULL;
  149. 	size_t line_len = 0;
  150. 	int err = 0;
  152. 	while(err == 0)
  153. 	{
  154. 		errno = 0;
  155. 		ssize_t nread = getline(&line, &line_len, in);
  157. 		if(nread < 0)
  158. 		{
  159. 			if(errno != 0)
  160. 			{
  161. 				fprintf(
  162. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  163. 				err = 1;
  164. 			}
  165. 			break;
  166. 		}
  168. 		if(nread == 0)
  169. 		{
  170. 			fputc('\n', stdout);
  171. 			continue;
  172. 		}
  174. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  176. 		for(size_t i = 0; i < MIN(list_len, (size_t)nread); i++)
  177. 			if(list[i]) fputc(line[i], stdout);
  179. 		if(nostop && (size_t)nread > list_len) fwrite(line + list_len, nread - list_len, 1, stdout);
  181. 		fputc('\n', stdout);
  182. 	}
  184. 	if(line_len != 0) free(line);
  186. 	return err;
  187. }
  189. static int
  190. cut_c(FILE *in, const char *filename)
  191. {
  192. 	char *line = NULL;
  193. 	size_t line_len = 0;
  194. 	int err = 0;
  195. 	wchar_t *line_w = NULL;
  196. 	ssize_t line_wsz = 0;
  198. 	while(err == 0)
  199. 	{
  200. 		errno = 0;
  201. 		ssize_t nread = getline(&line, &line_len, in);
  203. 		if(nread < 0)
  204. 		{
  205. 			if(errno != 0)
  206. 			{
  207. 				fprintf(
  208. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  209. 				err = 1;
  210. 			}
  211. 			break;
  212. 		}
  214. 		if(nread == 0)
  215. 		{
  216. 			fputwc(L'\n', stdout);
  217. 			continue;
  218. 		}
  220. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  222. 		if(nread > line_wsz)
  223. 		{
  224. 			line_w = reallocarray(line_w, nread, sizeof(*line_w));
  225. 			if(line_w == NULL)
  226. 			{
  227. 				fprintf(stderr, "%s: error: Failed memory allocation: %s\n", argv0, strerror(errno));
  228. 				return -1;
  229. 			}
  230. 			line_wsz = nread;
  231. 		}
  233. 		assert(line_wsz > 0);
  235. 		size_t wcread = mbstowcs(line_w, line, line_wsz);
  236. 		if(wcread == (size_t)-1)
  237. 		{
  238. 			fprintf(stderr,
  239. 			        "%s: error: Failed parsing characters in file '%s': %s\n",
  240. 			        argv0,
  241. 			        filename,
  242. 			        strerror(errno));
  243. 			err = 1;
  244. 			break;
  245. 		}
  247. 		//DEBUG fprintf(stderr, "cut: mbstowcs(_, _, %zu) => %zu\n", nread, wcread);
  249. 		size_t i = 0;
  250. 		for(; i < MIN(list_len, wcread); i++)
  251. 			if(list[i]) fputwc(line_w[i], stdout);
  253. 		if(nostop && wcread > list_len)
  254. 		{
  255. 			for(; i < wcread; i++)
  256. 				fputwc(line_w[i], stdout);
  257. 		}
  259. 		fputwc(L'\n', stdout);
  260. 	}
  262. 	if(line_len != 0) free(line);
  264. 	return err;
  265. }
  267. static int
  268. cut_f(FILE *in, const char *filename)
  269. {
  270. 	char *line = NULL;
  271. 	size_t line_len = 0;
  272. 	int err = 0;
  274. 	while(err == 0)
  275. 	{
  276. 		errno = 0;
  277. 		ssize_t nread = getline(&line, &line_len, in);
  279. 		if(nread < 0)
  280. 		{
  281. 			if(errno != 0)
  282. 			{
  283. 				fprintf(
  284. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  285. 				err = 1;
  286. 			}
  287. 			break;
  288. 		}
  290. 		if(nread == 0)
  291. 		{
  292. 			fputc('\n', stdout);
  293. 			continue;
  294. 		}
  296. 		if(line[nread - 1] == '\n') line[--nread] = '\0';
  298. 		size_t di = 0;
  299. 		for(; di < (size_t)nread; di++)
  300. 			if(line[di] == delim) break;
  302. 		if(di == (size_t)nread)
  303. 		{
  304. 			if(!opt_s) puts(line);
  306. 			continue;
  307. 		}
  309. 		bool need_sep = false;
  310. 		char *c = line;
  311. 		for(size_t pos = 0, i = 0; pos <= (size_t)nread; pos++)
  312. 		{
  313. 			if(pos < (size_t)nread && line[pos] != delim) continue;
  315. 			line[pos] = '\0';
  317. 			if(i >= list_len)
  318. 			{
  319. 				if(!nostop) break;
  321. 				if(need_sep) fputc(delim, stdout);
  323. 				fputs(c, stdout);
  324. 				need_sep = true;
  325. 			}
  326. 			else if(list[i])
  327. 			{
  328. 				if(need_sep) fputc(delim, stdout);
  330. 				fputs(c, stdout);
  331. 				need_sep = true;
  332. 			}
  334. 			i++;
  335. 			c = line + pos + 1;
  336. 		}
  338. 		fputc('\n', stdout);
  339. 	}
  341. 	if(line_len != 0) free(line);
  343. 	return err;
  344. }
  346. static int
  347. cut(FILE *in, const char *filename)
  348. {
  349. 	switch(mode)
  350. 	{
  351. 	case CUT_MODE_NONE:
  352. 		fprintf(stderr, "%s: error: No action (-b, -c, -f) specified\n", argv0);
  353. 		return 1;
  354. 	case CUT_MODE_B:
  355. 		return cut_b(in, filename);
  356. 	case CUT_MODE_C:
  357. 		return cut_c(in, filename);
  358. 	case CUT_MODE_F:
  359. 		return cut_f(in, filename);
  360. 	default:
  361. 		abort();
  362. 	}
  363. }
  365. int
  366. main(int argc, char *argv[])
  367. {
  368. 	char *opt_list = NULL;
  370. 	char *lc_all = setlocale(LC_ALL, "");
  371. 	if(lc_all == NULL)
  372. 	{
  373. 		fprintf(stderr,
  374. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  375. 		        argv0,
  376. 		        strerror(errno));
  377. 	}
  378. 	errno = 0;
  380. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":b:c:d:f:ns")) != -1;)
  381. 	{
  382. 		switch(c)
  383. 		{
  384. 		case 'b':
  385. 			if(opt_list != NULL)
  386. 			{
  387. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  388. 				return 1;
  389. 			}
  390. 			mode = CUT_MODE_B;
  391. 			opt_list = optarg;
  392. 			break;
  393. 		case 'c':
  394. 			if(opt_list != NULL)
  395. 			{
  396. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  397. 				return 1;
  398. 			}
  399. 			mode = CUT_MODE_C;
  400. 			opt_list = optarg;
  401. 			break;
  402. 		case 'f':
  403. 			if(opt_list != NULL)
  404. 			{
  405. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  406. 				return 1;
  407. 			}
  408. 			mode = CUT_MODE_F;
  409. 			opt_list = optarg;
  410. 			break;
  411. 		case 'd':
  412. 			if(optarg[0] != '\0' && optarg[1] != '\0')
  413. 			{
  414. 				fprintf(stderr,
  415. 				        "%s: error: Option '-d' only accepts single characters, got \"%s\"\n",
  416. 				        argv0,
  417. 				        optarg);
  418. 				return 1;
  419. 			}
  420. 			delim = optarg[0];
  421. 			break;
  422. 		case 'n':
  423. 			opt_n = true;
  424. 			break;
  425. 		case 's':
  426. 			opt_s = true;
  427. 			break;
  428. 		case ':':
  429. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  430. 			return 1;
  431. 		case '?':
  432. 			if(!got_long_opt) fprintf(stderr, "%s: error: Unhandled option '-%c'\n", argv0, optopt);
  433. 			return 1;
  434. 		default:
  435. 			fprintf(stderr, "%s: error: Unhandled getopt case '%c'\n", argv0, c);
  436. 			abort();
  437. 		}
  438. 	}
  440. 	argc -= optind;
  441. 	argv += optind;
  443. 	if(mode == CUT_MODE_NONE)
  444. 	{
  445. 		fprintf(stderr, "%s: error: No action (-b, -c, -f) specified\n", argv0);
  446. 		return 1;
  447. 	}
  449. 	if(parse_list(opt_list) < 0) return 1;
  451. #if 0
  452. 	fprintf(stderr, "[DEBUG] list: ");
  453. 	for(size_t i = 0; i < list_len; i++)
  454. 	{
  455. 		fputc(list[i] ? '1' : '0', stderr);
  456. 	}
  457. 	fputc('\n', stderr);
  458. #endif
  460. 	if(argc <= 0) return cut(stdin, "<stdin>");
  462. 	for(int i = 0; i < argc; i++)
  463. 	{
  464. 		FILE *in = fopen(argv[i], "r");
  465. 		if(in == NULL)
  466. 		{
  467. 			fprintf(stderr, "%s: error: Failed opening file '%s': %s\n", argv0, argv[i], strerror(errno));
  468. 			return 1;
  469. 		}
  471. 		int ret = cut(in, argv[i]);
  473. 		if(fclose(in) < 0)
  474. 		{
  475. 			fprintf(stderr, "%s: error: Failed closing file '%s': %s\n", argv0, argv[i], strerror(errno));
  476. 			return 1;
  477. 		}
  479. 		if(ret != 0) return 1;
  480. 	}
  482. 	if(fclose(stdin) != 0)
  483. 	{
  484. 		fprintf(stderr, "%s: error: Failed closing <stdin>: %s\n", argv0, strerror(errno));
  485. 		return 1;
  486. 	}
  488. 	if(fclose(stdout) != 0)
  489. 	{
  490. 		fprintf(stderr, "%s: error: Failed closing <stdout>: %s\n", argv0, strerror(errno));
  491. 		return 1;
  492. 	}
  494. 	return 0;
  495. }