logo

utils-std

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

uniq.c (6518B)

    

  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 200809L
  6. #include "../config.h"
  7. #include "../libutils/getopt_nolong.h"
  9. #include <ctype.h> // isblank
  10. #include <errno.h>
  11. #include <stdbool.h>
  12. #include <stdio.h>  // getline
  13. #include <stdlib.h> // atoi
  14. #include <string.h> // strncmp
  15. #include <unistd.h> // getopt
  16. #ifdef HAS_GETOPT_LONG
  17. #include <getopt.h>
  18. #endif
  20. enum uniq_mode
  21. {
  22. 	UNIQ, // default
  23. 	COUNT,
  24. 	ONLY_REPEAT,
  25. 	NO_REPEAT,
  26. };
  28. const char *argv0 = "uniq";
  30. int
  31. main(int argc, char *argv[])
  32. {
  33. 	enum uniq_mode mode = UNIQ;
  34. 	unsigned long field = 0, shift = 0;
  36. 	char *endptr = NULL;
  38. #ifdef HAS_GETOPT_LONG
  39. 	// Strictly for GNUisms compatibility so no long-only options
  40. 	// clang-format off
  41. 	static struct option opts[] = {
  42. 		{"count", no_argument, NULL, 'c'},
  43. 		{"repeated", no_argument, NULL, 'd'},
  44. 		{"skip-fields", required_argument, NULL, 'f'},
  45. 		{"skip-chars", required_argument, NULL, 's'},
  46. 		{"unique", no_argument, NULL, 'u'},
  47. 		{0, 0, 0, 0},
  48. 	};
  49. 	// clang-format on
  51. 	// Need + as first character to get POSIX-style option parsing
  52. 	for(int c = -1; (c = getopt_long(argc, argv, "+:cdf:s:u", opts, NULL)) != -1;)
  53. #else
  54. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":cdf:s:u")) != -1;)
  55. #endif
  56. 	{
  57. 		switch(c)
  58. 		{
  59. 		case 'c':
  60. 			if(mode != UNIQ)
  61. 			{
  62. 				fprintf(stderr, "%s: error: can only pass one of [-c|-d|-u]\n", argv0);
  63. 				return 1;
  64. 			}
  65. 			mode = COUNT;
  66. 			break;
  67. 		case 'd':
  68. 			if(mode != UNIQ)
  69. 			{
  70. 				fprintf(stderr, "%s: error: can only pass one of [-c|-d|-u]\n", argv0);
  71. 				return 1;
  72. 			}
  73. 			mode = ONLY_REPEAT;
  74. 			break;
  75. 		case 'f':
  76. 			errno = 0;
  77. 			field = strtoul(optarg, &endptr, 0);
  78. 			if(errno != 0)
  79. 			{
  80. 				fprintf(stderr, "%s: error: Failed parsing '-f %s': %s\n", argv0, optarg, strerror(errno));
  81. 				return 1;
  82. 			}
  83. 			if(endptr != NULL && endptr[0] != 0)
  84. 			{
  85. 				fprintf(stderr,
  86. 				        "%s: error: Non-numeric characters passed to '-f %s': %s\n",
  87. 				        argv0,
  88. 				        optarg,
  89. 				        endptr);
  90. 				return 1;
  91. 			}
  92. 			break;
  93. 		case 's':
  94. 			errno = 0;
  95. 			shift = strtoul(optarg, &endptr, 0);
  96. 			if(errno != 0)
  97. 			{
  98. 				fprintf(stderr, "%s: error: Failed parsing '-f %s': %s\n", argv0, optarg, strerror(errno));
  99. 				return 1;
  100. 			}
  101. 			if(endptr != NULL && endptr[0] != 0)
  102. 			{
  103. 				fprintf(stderr,
  104. 				        "%s: error: Non-numeric characters passed to '-f %s': %s\n",
  105. 				        argv0,
  106. 				        optarg,
  107. 				        endptr);
  108. 				return 1;
  109. 			}
  110. 			break;
  111. 		case 'u':
  112. 			if(mode != UNIQ)
  113. 			{
  114. 				fprintf(stderr, "%s: error: can only pass one of [-c|-d|-u]\n", argv0);
  115. 				return 1;
  116. 			}
  117. 			mode = NO_REPEAT;
  118. 			break;
  119. 		case ':':
  120. 			fprintf(stderr, "%s: error: Option '-%c' requires an operand\n", argv0, optopt);
  121. 			return 1;
  122. 		case '?':
  123. 			GETOPT_UNKNOWN_OPT
  124. 			return 1;
  125. 		default:
  126. 			fprintf(stderr, "%s: error: Unhandled getopt case '%c'\n", argv0, c);
  127. 			abort();
  128. 		}
  129. 	}
  131. 	argc -= optind;
  132. 	argv += optind;
  134. 	FILE *input = stdin;
  135. 	char *input_name = NULL;
  136. 	FILE *output = stdout;
  137. 	char *output_name = NULL;
  139. 	switch(argc)
  140. 	{
  141. 	case 0:
  142. 		break;
  143. 	case 1:
  144. 		if(strcmp(argv[0], "-") != 0)
  145. 		{
  146. 			input = fopen(argv[0], "r");
  147. 			input_name = argv[0];
  148. 			if(input == NULL)
  149. 			{
  150. 				fprintf(
  151. 				    stderr, "uniq: error: Failed opening input file '%s': %s\n", argv[0], strerror(errno));
  152. 				return 1;
  153. 			}
  154. 		}
  155. 		break;
  156. 	case 2:
  157. 		if(strcmp(argv[0], "-") != 0)
  158. 		{
  159. 			input = fopen(argv[0], "r");
  160. 			input_name = argv[0];
  161. 			if(input == NULL)
  162. 			{
  163. 				fprintf(
  164. 				    stderr, "uniq: error: Failed opening input file '%s': %s\n", argv[0], strerror(errno));
  165. 				return 1;
  166. 			}
  167. 		}
  168. 		if(strcmp(argv[1], "-") != 0)
  169. 		{
  170. 			output = fopen(argv[1], "w");
  171. 			output_name = argv[1];
  172. 			if(output == NULL)
  173. 			{
  174. 				fprintf(
  175. 				    stderr, "uniq: error: Failed opening output file '%s': %s\n", argv[1], strerror(errno));
  177. 				if(fclose(input) != 0)
  178. 					fprintf(stderr,
  179. 					        "uniq: error: Failed closing input file '%s': %s\n",
  180. 					        input_name,
  181. 					        strerror(errno));
  183. 				return 1;
  184. 			}
  185. 		}
  186. 		break;
  187. 	default:
  188. 		fprintf(stderr, "uniq: error: Invalid number of arguments (%d), expected [0..2]\n", argc);
  189. 		return 1;
  190. 	}
  192. 	char *first = NULL;
  193. 	ssize_t first_len = 0;
  194. 	size_t first_shift = 0;
  195. 	unsigned counter = 1;
  197. 	errno = 0;
  198. 	while(true)
  199. 	{
  200. 		char *cur = NULL;
  201. 		size_t cur_size = 0;
  202. 		ssize_t cur_len = getline(&cur, &cur_size, input);
  204. 		size_t cur_shift = shift;
  206. 		if(cur_len > 0 && cur[cur_len - 1] == '\n')
  207. 		{
  208. 			cur[cur_len - 1] = 0;
  209. 			cur_len--;
  210. 		}
  212. 		if(field != 0)
  213. 		{
  214. 			ssize_t field_shift = 0;
  216. 			for(unsigned long i = 0; i < field; i++)
  217. 			{
  218. 				while(field_shift < cur_len && isblank(cur[field_shift]))
  219. 					field_shift++;
  221. 				while(field_shift < cur_len && !isblank(cur[field_shift]))
  222. 					field_shift++;
  223. 			}
  225. 			cur_shift += field_shift;
  226. 		}
  228. 		if(cur_shift > (size_t)cur_len)
  229. 		{
  230. 			free(cur);
  231. 			cur_size = 0;
  232. 			cur = NULL;
  233. 			break;
  234. 		}
  236. 		//fprintf(stderr, "[debug] {cur_shift:%d} <%s>\n", cur_shift, cur+cur_shift);
  238. 		if(first != NULL)
  239. 		{
  240. 			if(cur != NULL && (cur_len - cur_shift == first_len - first_shift) &&
  241. 			   strncmp(cur + cur_shift, first + first_shift, cur_len - cur_shift) == 0)
  242. 			{
  243. 				counter += 1;
  244. 			}
  245. 			else
  246. 			{
  247. 				switch(mode)
  248. 				{
  249. 				case UNIQ:
  250. 					fwrite(first, first_len, 1, output);
  251. 					fprintf(output, "\n");
  252. 					break;
  253. 				case ONLY_REPEAT:
  254. 					if(counter > 1)
  255. 					{
  256. 						fwrite(first, first_len, 1, output);
  257. 						fprintf(output, "\n");
  258. 					}
  259. 					break;
  260. 				case NO_REPEAT:
  261. 					if(counter == 1)
  262. 					{
  263. 						fwrite(first, first_len, 1, output);
  264. 						fprintf(output, "\n");
  265. 					}
  266. 					break;
  267. 				case COUNT:
  268. 					fprintf(output, "%d %s\n", counter, first);
  269. 					break;
  270. 				}
  271. 				counter = 1;
  272. 				free(first);
  273. 			}
  274. 		}
  276. 		if(cur_len < 0)
  277. 		{
  278. 			if(cur_size > 0) free(cur);
  280. 			break;
  281. 		}
  283. 		if(counter == 1)
  284. 		{
  285. 			first = cur;
  286. 			first_len = cur_len;
  287. 			first_shift = cur_shift;
  288. 		}
  289. 	}
  291. 	int ret = 0;
  293. 	if(errno != 0)
  294. 	{
  295. 		fprintf(stderr, "uniq: error: Failed reading: %s\n", strerror(errno));
  296. 		ret = 1;
  297. 	}
  299. 	if(input != stdin)
  300. 	{
  301. 		if(fclose(input) != 0)
  302. 		{
  303. 			fprintf(
  304. 			    stderr, "uniq: error: Failed closing input file '%s': %s\n", input_name, strerror(errno));
  305. 			ret = 1;
  306. 		}
  307. 	}
  309. 	if(output != stdout)
  310. 	{
  311. 		if(fclose(output) != 0)
  312. 		{
  313. 			fprintf(stderr,
  314. 			        "uniq: error: Failed closing output file '%s': %s\n",
  315. 			        output_name,
  316. 			        strerror(errno));
  317. 			ret = 1;
  318. 		}
  319. 	}
  321. 	return ret;
  322. }