logo

utils-std

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

cut.c (10976B)

    

  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 "../config.h"
  8. #include "../lib/reallocarray.h"
  9. #include "../libutils/getopt_nolong.h"
  11. #include <assert.h>
  12. #include <ctype.h>
  13. #include <errno.h>
  14. #include <locale.h>
  15. #include <stdbool.h>
  16. #include <stdint.h> // size_t
  17. #include <stdio.h>  // fprintf, fopen
  18. #include <string.h> // strerror
  19. #include <unistd.h> // getopt
  20. #include <wchar.h>
  21. #ifdef HAS_GETOPT_LONG
  22. #include <getopt.h>
  23. #endif
  25. #undef MIN
  26. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  28. enum cut_mode
  29. {
  30. 	CUT_MODE_NONE = 0,
  31. 	CUT_MODE_B = 1,
  32. 	CUT_MODE_C = 2,
  33. 	CUT_MODE_F = 3,
  34. };
  36. char delim = '\t';
  37. char line_delim = '\n';
  38. wchar_t line_delim_w = L'\n';
  39. bool opt_n = false, opt_s = false;
  40. enum cut_mode mode = CUT_MODE_NONE;
  41. bool *list = NULL;
  42. size_t list_len = 0;
  43. bool nostop = false;
  44. const char *argv0 = "cut";
  46. static size_t
  47. parse_list_num(char **s)
  48. {
  49. 	char *endptr = NULL;
  50. 	errno = 0;
  51. 	size_t n = strtoul(*s, &endptr, 10);
  52. 	if(errno != 0)
  53. 	{
  54. 		fprintf(stderr, "%s: error: Failed parsing '%s' as a number: %s\n", argv0, *s, strerror(errno));
  55. 		return 0;
  56. 	}
  58. 	if(n < 1)
  59. 	{
  60. 		fprintf(stderr, "%s: error: Invalid number in list: %zu\n", argv0, n);
  61. 		return 0;
  62. 	}
  64. 	if(endptr != NULL && strchr(",-", *endptr) == NULL)
  65. 	{
  66. 		fprintf(stderr, "%s: error: Invalid character in list: %c\n", argv0, *endptr);
  67. 		return 0;
  68. 	}
  70. 	*s = endptr;
  72. 	return n;
  73. }
  75. static int
  76. parse_list(char *s)
  77. {
  78. 	while(true)
  79. 	{
  80. 		if(s == NULL || *s == '\0') break;
  82. 		if(*s == ',')
  83. 		{
  84. 			fprintf(stderr, "%s: error: Empty list element\n", argv0);
  85. 			return -1;
  86. 		}
  88. 		size_t min = 1;
  89. 		if(*s != '-')
  90. 		{
  91. 			min = parse_list_num(&s);
  92. 			if(min == 0) return -1;
  93. 		}
  95. 		// min-- as cut(1) is 1-indexed and max needs to be at least min+1
  96. 		size_t max = min--;
  98. 		if(s && *s == '-')
  99. 		{
  100. 			s++;
  102. 			if(!isdigit(*s))
  103. 			{
  104. 				nostop = true;
  105. 			}
  106. 			else
  107. 			{
  108. 				max = parse_list_num(&s);
  109. 				if(max == 0) return -1;
  111. 				if(max < min)
  112. 				{
  113. 					fprintf(stderr, "%s: error: Decreasing range: %zu-%zu\n", argv0, min, max);
  114. 					return -1;
  115. 				}
  116. 			}
  117. 		}
  119. 		// Needs to be after *s == '-'
  120. 		if(s && *s == ',') s++;
  122. 		if(max > list_len)
  123. 		{
  124. 			list = reallocarray(list, max, sizeof(*list));
  125. 			if(list == NULL)
  126. 			{
  127. 				fprintf(stderr, "%s: error: Failed memory allocation: %s\n", argv0, strerror(errno));
  128. 				return -1;
  129. 			}
  131. 			if(min > list_len)
  132. 			{
  133. 				memset(list + list_len, 0, min - list_len);
  134. 			}
  136. 			list_len = max;
  137. 		}
  139. 		memset(list + min, 1, max - min);
  140. 	}
  142. 	if(list_len == 0)
  143. 	{
  144. 		fprintf(stderr, "%s: error: Empty list\n", argv0);
  145. 		return -1;
  146. 	}
  148. 	return 0;
  149. }
  151. static int
  152. cut_b(FILE *in, const char *filename)
  153. {
  154. 	char *line = NULL;
  155. 	size_t line_len = 0;
  156. 	int err = 0;
  158. 	while(err == 0)
  159. 	{
  160. 		errno = 0;
  161. 		ssize_t nread = getdelim(&line, &line_len, line_delim, in);
  163. 		if(nread < 0)
  164. 		{
  165. 			if(errno != 0)
  166. 			{
  167. 				fprintf(
  168. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  169. 				err = 1;
  170. 			}
  171. 			break;
  172. 		}
  174. 		if(nread == 0)
  175. 		{
  176. 			fputc(line_delim, stdout);
  177. 			continue;
  178. 		}
  180. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  182. 		for(size_t i = 0; i < MIN(list_len, (size_t)nread); i++)
  183. 			if(list[i]) fputc(line[i], stdout);
  185. 		if(nostop && (size_t)nread > list_len) fwrite(line + list_len, nread - list_len, 1, stdout);
  187. 		fputc(line_delim, stdout);
  188. 	}
  190. 	free(line);
  192. 	return err;
  193. }
  195. static int
  196. cut_b_n(FILE *in, const char *filename)
  197. {
  198. 	char *line = NULL;
  199. 	size_t line_len = 0;
  200. 	int err = 0;
  202. 	while(err == 0)
  203. 	{
  204. 		errno = 0;
  205. 		ssize_t sread = getdelim(&line, &line_len, line_delim, in);
  206. 		if(sread < 0)
  207. 		{
  208. 			if(errno != 0)
  209. 			{
  210. 				fprintf(
  211. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  212. 				err = 1;
  213. 			}
  214. 			break;
  215. 		}
  216. 		size_t nread = (size_t)sread;
  218. 		if(nread == 0)
  219. 		{
  220. 			fputc(line_delim, stdout);
  221. 			continue;
  222. 		}
  224. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  226. 		for(size_t i = 0; i < MIN(list_len, nread); i++)
  227. 		{
  228. 			size_t isz = mbrlen(line + i, nread, NULL);
  230. 			if(isz == 0 || isz == (size_t)-2 || isz == (size_t)-1) continue;
  232. 			/*
  233. 			 * Check that last byte is part of the low-high selection.
  234. 			 * Per POSIX.1-2024 high and low only decrements, and otherwise drops the character.
  235. 			 */
  236. 			if(list[i + isz - 1])
  237. 			{
  238. 				fwrite(line + i, isz, 1, stdout);
  239. 				if(isz > 1) i += isz - 1;
  240. 			}
  241. 		}
  243. 		if(nostop && nread > list_len) fwrite(line + list_len, nread - list_len, 1, stdout);
  245. 		fputc(line_delim, stdout);
  246. 	}
  248. 	free(line);
  250. 	return err;
  251. }
  253. static int
  254. cut_c(FILE *in, const char *filename)
  255. {
  256. 	char *line = NULL;
  257. 	size_t line_len = 0;
  258. 	int err = 0;
  259. 	wchar_t *line_w = NULL;
  260. 	ssize_t line_wsz = 0;
  262. 	while(err == 0)
  263. 	{
  264. 		errno = 0;
  265. 		ssize_t nread = getdelim(&line, &line_len, line_delim, in);
  267. 		if(nread < 0)
  268. 		{
  269. 			if(errno != 0)
  270. 			{
  271. 				fprintf(
  272. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  273. 				err = 1;
  274. 			}
  275. 			break;
  276. 		}
  278. 		if(nread == 0)
  279. 		{
  280. 			fputwc(line_delim_w, stdout);
  281. 			continue;
  282. 		}
  284. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  286. 		if(nread > line_wsz)
  287. 		{
  288. 			line_w = reallocarray(line_w, nread, sizeof(*line_w));
  289. 			if(line_w == NULL)
  290. 			{
  291. 				fprintf(stderr, "%s: error: Failed memory allocation: %s\n", argv0, strerror(errno));
  292. 				err = 1;
  293. 				break;
  294. 			}
  295. 			line_wsz = nread;
  296. 		}
  298. 		assert(line_wsz > 0);
  300. 		size_t wcread = mbstowcs(line_w, line, line_wsz);
  301. 		if(wcread == (size_t)-1)
  302. 		{
  303. 			fprintf(stderr,
  304. 			        "%s: error: Failed parsing characters in file '%s': %s\n",
  305. 			        argv0,
  306. 			        filename,
  307. 			        strerror(errno));
  308. 			err = 1;
  309. 			break;
  310. 		}
  312. 		//DEBUG fprintf(stderr, "cut: mbstowcs(_, _, %zu) => %zu\n", nread, wcread);
  314. 		size_t i = 0;
  315. 		for(; i < MIN(list_len, wcread); i++)
  316. 			if(list[i]) fputwc(line_w[i], stdout);
  318. 		if(nostop && wcread > list_len)
  319. 		{
  320. 			for(; i < wcread; i++)
  321. 				fputwc(line_w[i], stdout);
  322. 		}
  324. 		fputwc(line_delim_w, stdout);
  325. 	}
  327. 	free(line);
  328. 	free(line_w);
  330. 	return err;
  331. }
  333. static int
  334. cut_f(FILE *in, const char *filename)
  335. {
  336. 	char *line = NULL;
  337. 	size_t line_len = 0;
  338. 	int err = 0;
  340. 	while(err == 0)
  341. 	{
  342. 		errno = 0;
  343. 		ssize_t nread = getdelim(&line, &line_len, line_delim, in);
  345. 		if(nread < 0)
  346. 		{
  347. 			if(errno != 0)
  348. 			{
  349. 				fprintf(
  350. 				    stderr, "%s: error: Failed reading file '%s': %s\n", argv0, filename, strerror(errno));
  351. 				err = 1;
  352. 			}
  353. 			break;
  354. 		}
  356. 		if(nread == 0)
  357. 		{
  358. 			fputc(line_delim, stdout);
  359. 			continue;
  360. 		}
  362. 		if(line[nread - 1] == '\n') line[--nread] = '\0';
  364. 		size_t di = 0;
  365. 		for(; di < (size_t)nread; di++)
  366. 			if(line[di] == delim) break;
  368. 		if(di == (size_t)nread)
  369. 		{
  370. 			if(!opt_s) puts(line);
  372. 			continue;
  373. 		}
  375. 		bool need_sep = false;
  376. 		char *c = line;
  377. 		for(size_t pos = 0, i = 0; pos <= (size_t)nread; pos++)
  378. 		{
  379. 			if(pos < (size_t)nread && line[pos] != delim) continue;
  381. 			line[pos] = '\0';
  383. 			if(i >= list_len)
  384. 			{
  385. 				if(!nostop) break;
  387. 				if(need_sep) fputc(delim, stdout);
  389. 				fputs(c, stdout);
  390. 				need_sep = true;
  391. 			}
  392. 			else if(list[i])
  393. 			{
  394. 				if(need_sep) fputc(delim, stdout);
  396. 				fputs(c, stdout);
  397. 				need_sep = true;
  398. 			}
  400. 			i++;
  401. 			c = line + pos + 1;
  402. 		}
  404. 		fputc(line_delim, stdout);
  405. 	}
  407. 	free(line);
  409. 	return err;
  410. }
  412. static int
  413. cut(FILE *in, const char *filename)
  414. {
  415. 	switch(mode)
  416. 	{
  417. 	case CUT_MODE_NONE:
  418. 		fprintf(stderr, "%s: error: No action (-b, -c, -f) specified\n", argv0);
  419. 		return 1;
  420. 	case CUT_MODE_B:
  421. 		return opt_n ? cut_b_n(in, filename) : cut_b(in, filename);
  422. 	case CUT_MODE_C:
  423. 		return cut_c(in, filename);
  424. 	case CUT_MODE_F:
  425. 		return cut_f(in, filename);
  426. 	default:
  427. 		abort();
  428. 	}
  429. }
  431. int
  432. main(int argc, char *argv[])
  433. {
  434. 	char *opt_list = NULL;
  436. 	char *lc_all = setlocale(LC_ALL, "");
  437. 	if(lc_all == NULL)
  438. 	{
  439. 		fprintf(stderr,
  440. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  441. 		        argv0,
  442. 		        strerror(errno));
  443. 	}
  444. 	errno = 0;
  446. #ifdef HAS_GETOPT_LONG
  447. 	// Strictly for GNUisms compatibility so no long-only options
  448. 	// clang-format off
  449. 	static struct option opts[] = {
  450. 		{"bytes", required_argument, NULL, 'b'},
  451. 		{"characters", required_argument, NULL, 'c'},
  452. 		{"delimiter", required_argument, NULL, 'd'},
  453. 		{"fields", required_argument, NULL, 'f'},
  454. 		{"only-delimited", no_argument, NULL, 's'},
  455. 		{"zero-terminated", no_argument, NULL, 'z'},
  456. 		{0, 0, 0, 0},
  457. 	};
  458. 	// clang-format on
  460. 	// Need + as first character to get POSIX-style option parsing
  461. 	for(int c = -1; (c = getopt_long(argc, argv, "+:b:c:d:f:nsz", opts, NULL)) != -1;)
  462. #else
  463. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":b:c:d:f:nsz")) != -1;)
  464. #endif
  465. 	{
  466. 		switch(c)
  467. 		{
  468. 		case 'b':
  469. 			if(opt_list != NULL)
  470. 			{
  471. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  472. 				return 1;
  473. 			}
  474. 			mode = CUT_MODE_B;
  475. 			opt_list = optarg;
  476. 			break;
  477. 		case 'c':
  478. 			if(opt_list != NULL)
  479. 			{
  480. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  481. 				return 1;
  482. 			}
  483. 			mode = CUT_MODE_C;
  484. 			opt_list = optarg;
  485. 			break;
  486. 		case 'f':
  487. 			if(opt_list != NULL)
  488. 			{
  489. 				fprintf(stderr, "%s: error: Only one list may be specified\n", argv0);
  490. 				return 1;
  491. 			}
  492. 			mode = CUT_MODE_F;
  493. 			opt_list = optarg;
  494. 			break;
  495. 		case 'd':
  496. 			if(optarg[0] != '\0' && optarg[1] != '\0')
  497. 			{
  498. 				fprintf(stderr,
  499. 				        "%s: error: Option '-d' only accepts single characters, got \"%s\"\n",
  500. 				        argv0,
  501. 				        optarg);
  502. 				return 1;
  503. 			}
  504. 			delim = optarg[0];
  505. 			break;
  506. 		case 'n':
  507. 			opt_n = true;
  508. 			break;
  509. 		case 's':
  510. 			opt_s = true;
  511. 			break;
  512. 		case 'z':
  513. 			line_delim = '\0';
  514. 			line_delim_w = L'\0';
  515. 			break;
  516. 		case ':':
  517. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  518. 			return 1;
  519. 		case '?':
  520. 			GETOPT_UNKNOWN_OPT
  521. 			return 1;
  522. 		default:
  523. 			fprintf(stderr, "%s: error: Unhandled getopt case '%c'\n", argv0, c);
  524. 			abort();
  525. 		}
  526. 	}
  528. 	argc -= optind;
  529. 	argv += optind;
  531. 	if(mode == CUT_MODE_NONE)
  532. 	{
  533. 		fprintf(stderr, "%s: error: No action (-b, -c, -f) specified\n", argv0);
  534. 		return 1;
  535. 	}
  537. 	if(parse_list(opt_list) < 0) return 1;
  539. #if 0
  540. 	fprintf(stderr, "[DEBUG] list: ");
  541. 	for(size_t i = 0; i < list_len; i++)
  542. 	{
  543. 		fputc(list[i] ? '1' : '0', stderr);
  544. 	}
  545. 	fputc('\n', stderr);
  546. #endif
  548. 	if(argc <= 0) return cut(stdin, "<stdin>");
  550. 	for(int i = 0; i < argc; i++)
  551. 	{
  552. 		FILE *in = fopen(argv[i], "r");
  553. 		if(in == NULL)
  554. 		{
  555. 			fprintf(stderr, "%s: error: Failed opening file '%s': %s\n", argv0, argv[i], strerror(errno));
  556. 			return 1;
  557. 		}
  559. 		int ret = cut(in, argv[i]);
  561. 		if(fclose(in) < 0)
  562. 		{
  563. 			fprintf(stderr, "%s: error: Failed closing file '%s': %s\n", argv0, argv[i], strerror(errno));
  564. 			return 1;
  565. 		}
  567. 		if(ret != 0) return 1;
  568. 	}
  570. 	if(fclose(stdin) != 0)
  571. 	{
  572. 		fprintf(stderr, "%s: error: Failed closing <stdin>: %s\n", argv0, strerror(errno));
  573. 		return 1;
  574. 	}
  576. 	if(fclose(stdout) != 0)
  577. 	{
  578. 		fprintf(stderr, "%s: error: Failed closing <stdout>: %s\n", argv0, strerror(errno));
  579. 		return 1;
  580. 	}
  582. 	return 0;
  583. }