logo

utils-std

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

cut.c (8448B)

    

  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/reallocarray.h"
  9. #include <assert.h>
  10. #include <ctype.h>
  11. #include <errno.h>
  12. #include <locale.h>
  13. #include <stdbool.h>
  14. #include <stdint.h> // size_t
  15. #include <stdio.h>  // fprintf, fopen
  16. #include <string.h> // strerror
  17. #include <unistd.h> // getopt
  18. #include <wchar.h>
  20. #undef MIN
  21. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  23. enum cut_mode
  24. {
  25. 	CUT_MODE_NONE = 0,
  26. 	CUT_MODE_B = 1,
  27. 	CUT_MODE_C = 2,
  28. 	CUT_MODE_F = 3,
  29. };
  31. char delim = '\t';
  32. bool opt_n = false, opt_s = false;
  33. enum cut_mode mode = CUT_MODE_NONE;
  34. bool *list = NULL;
  35. size_t list_len = 0;
  36. bool nostop = false;
  38. static ssize_t
  39. parse_list_num(char **s)
  40. {
  41. 	char *endptr = NULL;
  42. 	errno = 0;
  43. 	size_t n = strtoul(*s, &endptr, 10);
  44. 	if(errno != 0)
  45. 	{
  46. 		fprintf(stderr, "cut: Error while parsing '%s' as a number: %s\n", *s, strerror(errno));
  47. 		return -1;
  48. 	}
  50. 	if(n < 1)
  51. 	{
  52. 		fprintf(stderr, "cut: Invalid number in list: %zu\n", n);
  53. 		return -1;
  54. 	}
  56. 	if(endptr != NULL && strchr(",-", *endptr) == NULL)
  57. 	{
  58. 		fprintf(stderr, "cut: Invalid character in list: %c\n", *endptr);
  59. 		return -1;
  60. 	}
  62. 	*s = endptr;
  64. 	return n;
  65. }
  67. static int
  68. parse_list(char *s)
  69. {
  70. 	while(true)
  71. 	{
  72. 		if(s == NULL || *s == '\0') break;
  74. 		if(*s == ',')
  75. 		{
  76. 			fprintf(stderr, "cut: Error: empty list element\n");
  77. 			return -1;
  78. 		}
  80. 		ssize_t min = 1;
  81. 		if(*s != '-')
  82. 		{
  83. 			min = parse_list_num(&s);
  84. 			if(min < 0) return -1;
  85. 		}
  87. 		// min-- as cut(1) is 1-indexed and max needs to be at least min+1
  88. 		ssize_t max = min--;
  90. 		if(s && *s == '-')
  91. 		{
  92. 			s++;
  94. 			if(!isdigit(*s))
  95. 			{
  96. 				nostop = true;
  97. 			}
  98. 			else
  99. 			{
  100. 				max = parse_list_num(&s);
  101. 				if(max < 0) return -1;
  103. 				if(max < min)
  104. 				{
  105. 					fprintf(stderr, "cut: Error: decreasing range: %zu-%zu\n", min, max);
  106. 					return -1;
  107. 				}
  108. 			}
  109. 		}
  111. 		// Needs to be after *s == '-'
  112. 		if(s && *s == ',') s++;
  114. 		if((size_t)max > list_len)
  115. 		{
  116. 			list = reallocarray(list, (size_t)max, sizeof(*list));
  117. 			if(list == NULL)
  118. 			{
  119. 				fprintf(stderr, "cut: Memory allocation error: %s\n", strerror(errno));
  120. 				return -1;
  121. 			}
  123. 			if((size_t)min > list_len)
  124. 			{
  125. 				memset(list + list_len, 0, min - list_len);
  126. 			}
  128. 			list_len = max;
  129. 		}
  131. 		memset(list + min, 1, max - min);
  132. 	}
  134. 	if(list_len == 0)
  135. 	{
  136. 		fprintf(stderr, "cut: Error: empty list\n");
  137. 		return -1;
  138. 	}
  140. 	return 0;
  141. }
  143. static int
  144. cut_b(FILE *in, const char *filename)
  145. {
  146. 	char *line = NULL;
  147. 	size_t line_len = 0;
  148. 	int err = 0;
  150. 	while(err == 0)
  151. 	{
  152. 		errno = 0;
  153. 		ssize_t nread = getline(&line, &line_len, in);
  155. 		if(nread < 0)
  156. 		{
  157. 			if(errno != 0)
  158. 			{
  159. 				fprintf(stderr, "cut: Error while reading file '%s': %s\n", filename, strerror(errno));
  160. 				err = 1;
  161. 			}
  162. 			break;
  163. 		}
  165. 		if(nread == 0)
  166. 		{
  167. 			fputc('\n', stdout);
  168. 			continue;
  169. 		}
  171. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  173. 		for(size_t i = 0; i < MIN(list_len, (size_t)nread); i++)
  174. 			if(list[i]) fputc(line[i], stdout);
  176. 		if(nostop && (size_t)nread > list_len) fwrite(line + list_len, nread - list_len, 1, stdout);
  178. 		fputc('\n', stdout);
  179. 	}
  181. 	if(line_len != 0) free(line);
  183. 	return err;
  184. }
  186. static int
  187. cut_c(FILE *in, const char *filename)
  188. {
  189. 	char *line = NULL;
  190. 	size_t line_len = 0;
  191. 	int err = 0;
  192. 	wchar_t *line_w = NULL;
  193. 	ssize_t line_wsz = 0;
  195. 	while(err == 0)
  196. 	{
  197. 		errno = 0;
  198. 		ssize_t nread = getline(&line, &line_len, in);
  200. 		if(nread < 0)
  201. 		{
  202. 			if(errno != 0)
  203. 			{
  204. 				fprintf(stderr, "cut: Error while reading file '%s': %s\n", filename, strerror(errno));
  205. 				err = 1;
  206. 			}
  207. 			break;
  208. 		}
  210. 		if(nread == 0)
  211. 		{
  212. 			fputc('\n', stdout);
  213. 			continue;
  214. 		}
  216. 		if(line[nread - 1] == '\n') line[nread--] = '\0';
  218. 		if(nread > line_wsz)
  219. 		{
  220. 			line_w = reallocarray(line_w, nread, sizeof(*line_w));
  221. 			if(line_w == NULL)
  222. 			{
  223. 				fprintf(stderr, "cut: Memory allocation error: %s\n", strerror(errno));
  224. 				return -1;
  225. 			}
  226. 			line_wsz = nread;
  227. 		}
  229. 		assert(line_wsz > 0);
  231. 		size_t wcread = mbstowcs(line_w, line, line_wsz);
  232. 		if(wcread == (size_t)-1)
  233. 		{
  234. 			fprintf(stderr,
  235. 			        "cut: Error while parsing characters in file '%s': %s\n",
  236. 			        filename,
  237. 			        strerror(errno));
  238. 			err = 1;
  239. 			break;
  240. 		}
  242. 		//DEBUG fprintf(stderr, "cut: mbstowcs(_, _, %zu) => %zu\n", nread, wcread);
  244. 		size_t i = 0;
  245. 		for(; i < MIN(list_len, wcread); i++)
  246. 			if(list[i]) fputwc(line_w[i], stdout);
  248. 		if(nostop && wcread > list_len)
  249. 		{
  250. 			for(; i < wcread; i++)
  251. 				fputwc(line_w[i], stdout);
  252. 		}
  254. 		fputc('\n', stdout);
  255. 	}
  257. 	if(line_len != 0) free(line);
  259. 	return err;
  260. }
  262. static int
  263. cut_f(FILE *in, const char *filename)
  264. {
  265. 	char *line = NULL;
  266. 	size_t line_len = 0;
  267. 	int err = 0;
  269. 	while(err == 0)
  270. 	{
  271. 		errno = 0;
  272. 		ssize_t nread = getline(&line, &line_len, in);
  274. 		if(nread < 0)
  275. 		{
  276. 			if(errno != 0)
  277. 			{
  278. 				fprintf(stderr, "cut: Error while reading file '%s': %s\n", filename, strerror(errno));
  279. 				err = 1;
  280. 			}
  281. 			break;
  282. 		}
  284. 		if(nread == 0)
  285. 		{
  286. 			fputc('\n', stdout);
  287. 			continue;
  288. 		}
  290. 		if(line[nread - 1] == '\n') line[--nread] = '\0';
  292. 		size_t di = 0;
  293. 		for(; di < (size_t)nread; di++)
  294. 			if(line[di] == delim) break;
  296. 		if(di == (size_t)nread)
  297. 		{
  298. 			if(!opt_s) puts(line);
  300. 			continue;
  301. 		}
  303. 		bool need_sep = false;
  304. 		char *c = line;
  305. 		for(size_t pos = 0, i = 0; pos <= (size_t)nread; pos++)
  306. 		{
  307. 			if(pos < (size_t)nread && line[pos] != delim) continue;
  309. 			line[pos] = '\0';
  311. 			if(i >= list_len)
  312. 			{
  313. 				if(!nostop) break;
  315. 				if(need_sep) fputc(delim, stdout);
  317. 				fputs(c, stdout);
  318. 				need_sep = true;
  319. 			}
  320. 			else if(list[i])
  321. 			{
  322. 				if(need_sep) fputc(delim, stdout);
  324. 				fputs(c, stdout);
  325. 				need_sep = true;
  326. 			}
  328. 			i++;
  329. 			c = line + pos + 1;
  330. 		}
  332. 		fputc('\n', stdout);
  333. 	}
  335. 	if(line_len != 0) free(line);
  337. 	return err;
  338. }
  340. static int
  341. cut(FILE *in, const char *filename)
  342. {
  343. 	switch(mode)
  344. 	{
  345. 	case CUT_MODE_NONE:
  346. 		fprintf(stderr, "cut: No action (-b, -c, -f) specified\n");
  347. 		return 1;
  348. 	case CUT_MODE_B:
  349. 		return cut_b(in, filename);
  350. 	case CUT_MODE_C:
  351. 		return cut_c(in, filename);
  352. 	case CUT_MODE_F:
  353. 		return cut_f(in, filename);
  354. 	default:
  355. 		abort();
  356. 	}
  357. }
  359. int
  360. main(int argc, char *argv[])
  361. {
  362. 	char *opt_list = NULL;
  364. 	errno = 0;
  365. 	setlocale(LC_ALL, "");
  366. 	if(errno != 0)
  367. 	{
  368. 		fprintf(stderr, "cut: Warning: Failed to initialize locales: %s\n", strerror(errno));
  369. 		errno = 0;
  370. 	}
  372. 	int c = -1;
  373. 	while((c = getopt(argc, argv, ":b:c:d:f:ns")) != -1)
  374. 	{
  375. 		switch(c)
  376. 		{
  377. 		case 'b':
  378. 			if(opt_list != NULL)
  379. 			{
  380. 				fprintf(stderr, "cut: Only one list may be specified\n");
  381. 				return 1;
  382. 			}
  383. 			mode = CUT_MODE_B;
  384. 			opt_list = optarg;
  385. 			break;
  386. 		case 'c':
  387. 			if(opt_list != NULL)
  388. 			{
  389. 				fprintf(stderr, "cut: Only one list may be specified\n");
  390. 				return 1;
  391. 			}
  392. 			mode = CUT_MODE_C;
  393. 			opt_list = optarg;
  394. 			break;
  395. 		case 'f':
  396. 			if(opt_list != NULL)
  397. 			{
  398. 				fprintf(stderr, "cut: Only one list may be specified\n");
  399. 				return 1;
  400. 			}
  401. 			mode = CUT_MODE_F;
  402. 			opt_list = optarg;
  403. 			break;
  404. 		case 'd':
  405. 			if(optarg[0] != '\0' && optarg[1] != '\0')
  406. 			{
  407. 				fprintf(stderr, "cut: Option '-d' only accepts single characters, got \"%s\"\n", optarg);
  408. 				return 1;
  409. 			}
  410. 			delim = optarg[0];
  411. 			break;
  412. 		case 'n':
  413. 			opt_n = true;
  414. 			break;
  415. 		case 's':
  416. 			opt_s = true;
  417. 			break;
  418. 		case ':':
  419. 			fprintf(stderr, "cut: Option '-%c' requires an operand\n", optopt);
  420. 			return 1;
  421. 		default:
  422. 			fprintf(stderr, "cut: Unhandled option '-%c'\n", optopt);
  423. 			return 1;
  424. 		}
  425. 	}
  427. 	argc -= optind;
  428. 	argv += optind;
  430. 	if(mode == CUT_MODE_NONE)
  431. 	{
  432. 		fprintf(stderr, "cut: No action (-b, -c, -f) specified\n");
  433. 		return 1;
  434. 	}
  436. 	if(parse_list(opt_list) < 0) return 1;
  438. #if 0
  439. 	fprintf(stderr, "[DEBUG] list: ");
  440. 	for(size_t i = 0; i < list_len; i++)
  441. 	{
  442. 		fputc(list[i] ? '1' : '0', stderr);
  443. 	}
  444. 	fputc('\n', stderr);
  445. #endif
  447. 	if(argc <= 0) return cut(stdin, "<stdin>");
  449. 	for(int i = 0; i < argc; i++)
  450. 	{
  451. 		FILE *in = fopen(argv[i], "r");
  452. 		if(in == NULL)
  453. 		{
  454. 			fprintf(stderr, "cut: Failed opening file '%s': %s\n", argv[i], strerror(errno));
  455. 			return 1;
  456. 		}
  458. 		int ret = cut(in, argv[i]);
  460. 		if(fclose(in) < 0)
  461. 		{
  462. 			fprintf(stderr, "cut: Failed closing file '%s': %s\n", argv[i], strerror(errno));
  463. 			return 1;
  464. 		}
  466. 		if(ret != 0) return 1;
  467. 	}
  469. 	if(fclose(stdin) != 0)
  470. 	{
  471. 		fprintf(stderr, "cut: Error closing <stdin>: %s\n", strerror(errno));
  472. 		return 1;
  473. 	}
  475. 	if(fclose(stdout) != 0)
  476. 	{
  477. 		fprintf(stderr, "cut: Error closing <stdout>: %s\n", strerror(errno));
  478. 		return 1;
  479. 	}
  481. 	return 0;
  482. }