logo

utils-std

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

wc.c (6971B)

    

  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" // HAS_*
  7. #include "../lib/bitmasks.h"
  8. #include "../libutils/getopt_nolong.h"
  10. #include <ctype.h> // isspace
  11. #include <errno.h>
  12. #include <fcntl.h>  // posix_fadvise
  13. #include <locale.h> // setlocale
  14. #include <stdbool.h>
  15. #include <stdint.h> // uint8_t
  16. #include <stdio.h>  // fprintf
  17. #include <stdlib.h> // abort
  18. #include <string.h> // strchr, strerror
  19. #include <sys/stat.h>
  20. #include <unistd.h> // getopt
  21. #include <wchar.h>
  22. #include <wctype.h> // iswspace
  23. #ifdef HAS_GETOPT_LONG
  24. #include <getopt.h>
  25. #endif
  27. #define WC_BUFSIZ 16320
  28. static char buf[WC_BUFSIZ] = "";
  30. const char *argv0 = "wc";
  32. static enum {
  33. 	WC_OPT_C = 1 << 0,
  34. 	WC_OPT_L = 1 << 1,
  35. 	WC_OPT_W = 1 << 2,
  36. 	WC_OPT_ALL = WC_OPT_C | WC_OPT_L | WC_OPT_W,
  37. } wc_opts = 0;
  39. off_t total_bytes = 0, total_lines = 0, total_words = 0;
  41. static void
  42. print_counts(off_t lines, off_t words, off_t bytes, const char *filename)
  43. {
  44. 	const char *fmt = "%ld";
  45. 	if(FIELD_MATCH(wc_opts, WC_OPT_L))
  46. 	{
  47. 		printf(fmt, lines);
  48. 		fmt = " %ld";
  49. 	}
  50. 	if(FIELD_MATCH(wc_opts, WC_OPT_W))
  51. 	{
  52. 		printf(fmt, words);
  53. 		fmt = " %ld";
  54. 	}
  55. 	if(FIELD_MATCH(wc_opts, WC_OPT_C))
  56. 	{
  57. 		printf(fmt, bytes);
  58. 	}
  60. 	if(filename != NULL) printf(" %s", filename);
  61. 	printf("\n");
  62. }
  64. static int
  65. wc_file_bytes(int fd, char *filename)
  66. {
  67. 	off_t bytes = 0, lines = 0, words = 0, wordlen = 0;
  69. 	ssize_t nread = -1;
  70. 	if(FIELD_MATCH(wc_opts, WC_OPT_W))
  71. 	{
  72. 		while((nread = read(fd, buf, WC_BUFSIZ)) > 0)
  73. 		{
  74. 			bytes += nread;
  76. 			for(ssize_t i = 0; i < nread; i++)
  77. 			{
  78. 				int c = buf[i];
  80. 				if(c == '\n') lines++;
  82. 				if(isspace(c))
  83. 				{
  84. 					if(wordlen > 0)
  85. 					{
  86. 						words++;
  87. 						wordlen = 0;
  88. 					}
  89. 				}
  90. 				else
  91. 				{
  92. 					wordlen++;
  93. 				}
  94. 			}
  95. 		}
  96. 	}
  97. 	else if(FIELD_MATCH(wc_opts, WC_OPT_L))
  98. 	{
  99. 		while((nread = read(fd, buf, WC_BUFSIZ)) > 0)
  100. 		{
  101. 			bytes += nread;
  103. 			for(ssize_t i = 0; i < nread; i++)
  104. 				if(buf[i] == '\n') lines++;
  105. 		}
  106. 	}
  107. 	else
  108. 	{
  109. 		struct stat status;
  110. 		if(fstat(fd, &status) < 0)
  111. 		{
  112. 			fprintf(stderr,
  113. 			        "%s: error: Failed getting status for file '%s': %s\n",
  114. 			        argv0,
  115. 			        filename,
  116. 			        strerror(errno));
  117. 			return 1;
  118. 		}
  120. 		if(S_ISREG(status.st_mode) && status.st_size != 0)
  121. 		{
  122. 			bytes += status.st_size;
  123. 		}
  124. 		else
  125. 		{
  126. 			while((nread = read(fd, buf, WC_BUFSIZ)) > 0)
  127. 				bytes += nread;
  128. 		}
  129. 	}
  131. 	if(nread < 0 && errno != 0)
  132. 	{
  133. 		fprintf(stderr,
  134. 		        "%s: error: Failed reading from file '%s': %s\n",
  135. 		        argv0,
  136. 		        filename != NULL ? filename : "<stdin>",
  137. 		        strerror(errno));
  138. 		return -1;
  139. 	}
  141. 	if(wordlen > 0) words++;
  143. 	total_bytes += bytes, total_lines += lines, total_words += words;
  145. 	print_counts(lines, words, bytes, filename);
  147. 	return 0;
  148. }
  150. static int
  151. wc_file_chars(int fd, char *filename)
  152. {
  153. 	off_t chars = 0, lines = 0, words = 0, wordlen = 0;
  155. 	FILE *file = fdopen(fd, "r");
  156. 	if(file == NULL)
  157. 	{
  158. 		fprintf(stderr,
  159. 		        "%s: error: Failed getting file stream for file '%s': %s\n",
  160. 		        argv0,
  161. 		        filename,
  162. 		        strerror(errno));
  163. 		return -1;
  164. 	}
  166. 	if(setvbuf(file, buf, _IOFBF, WC_BUFSIZ) != 0)
  167. 	{
  168. 		fprintf(stderr,
  169. 		        "%s: warning: Failed setting a new buffer for <stdin>: %s\n",
  170. 		        argv0,
  171. 		        strerror(errno));
  172. 		errno = 0;
  173. 	}
  175. 	while(true)
  176. 	{
  177. 		errno = 0;
  178. 		wint_t c = getwc(file);
  179. 		if(c == WEOF)
  180. 		{
  181. 			if(errno != 0)
  182. 			{
  183. 				fprintf(stderr,
  184. 				        "%s: error: Failed reading from file '%s': %s\n",
  185. 				        argv0,
  186. 				        filename != NULL ? filename : "<stdin>",
  187. 				        strerror(errno));
  189. 				fclose(file);
  191. 				return -1;
  192. 			}
  193. 			break;
  194. 		}
  195. 		chars++;
  197. 		if(c == '\n') lines++;
  199. 		if(iswspace(c))
  200. 		{
  201. 			if(wordlen > 0)
  202. 			{
  203. 				words++;
  204. 				wordlen = 0;
  205. 			}
  206. 		}
  207. 		else
  208. 		{
  209. 			wordlen++;
  210. 		}
  211. 	}
  213. 	if(wordlen > 0) words++;
  215. 	print_counts(lines, words, chars, filename);
  217. 	fclose(file);
  218. 	return 0;
  219. }
  221. static void
  222. usage(void)
  223. {
  224. 	fprintf(stderr, "Usage: wc [-c|-m] [-lw] [file...]\n");
  225. }
  227. int
  228. main(int argc, char *argv[])
  229. {
  230. 	char *lc_all = setlocale(LC_ALL, "");
  231. 	if(lc_all == NULL)
  232. 	{
  233. 		fprintf(stderr,
  234. 		        "%s: warning: Failed loading locales. setlocale(LC_ALL, \"\"): %s\n",
  235. 		        argv0,
  236. 		        strerror(errno));
  237. 	}
  238. 	errno = 0;
  239. 	int (*wc_file)(int, char *) = &wc_file_bytes;
  241. #ifdef HAS_GETOPT_LONG
  242. 	// Strictly for GNUisms compatibility so no long-only options
  243. 	// clang-format off
  244. 	static struct option opts[] = {
  245. 		{"bytes", no_argument, NULL, 'c'},
  246. 		{"lines", no_argument, NULL, 'l'},
  247. 		{"chars", no_argument, NULL, 'm'},
  248. 		{"words", no_argument, NULL, 'w'},
  249. 		{0, 0, 0, 0},
  250. 	};
  251. 	// clang-format on
  253. 	// Need + as first character to get POSIX-style option parsing
  254. 	for(int c = -1; (c = getopt_long(argc, argv, "+:clmw", opts, NULL)) != -1;)
  255. #else
  256. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":clmw")) != -1;)
  257. #endif
  258. 	{
  259. 		switch(c)
  260. 		{
  261. 		case 'c':
  262. 			wc_opts |= WC_OPT_C;
  263. 			wc_file = wc_file_bytes;
  264. 			break;
  265. 		case 'l':
  266. 			wc_opts |= WC_OPT_L;
  267. 			break;
  268. 		case 'm':
  269. 			wc_opts |= WC_OPT_C;
  270. 			wc_file = wc_file_chars;
  271. 			break;
  272. 		case 'w':
  273. 			wc_opts |= WC_OPT_W;
  274. 			break;
  275. 		case ':':
  276. 			fprintf(stderr, "%s: error: Missing operand for option: '-%c'\n", argv0, optopt);
  277. 			usage();
  278. 			return 1;
  279. 		case '?':
  280. 			GETOPT_UNKNOWN_OPT
  281. 			usage();
  282. 			return 1;
  283. 		default:
  284. 			abort();
  285. 		}
  286. 	}
  287. 	if(wc_opts == 0) wc_opts = WC_OPT_ALL;
  289. 	argc -= optind;
  290. 	argv += optind;
  292. 	if((errno = posix_fadvise(STDIN_FILENO, 0, 0, POSIX_FADV_SEQUENTIAL)) != 0)
  293. 	{
  294. 		if(errno != ESPIPE)
  295. 		{
  296. 			fprintf(stderr,
  297. 			        "%s: warning: Failure from posix_fadvise sequential for <stdin>: %s\n",
  298. 			        argv0,
  299. 			        strerror(errno));
  300. 		}
  301. 		errno = 0;
  302. 	}
  304. 	if(argc < 1)
  305. 	{
  306. 		if(wc_file(STDIN_FILENO, NULL) < 0) return 1;
  307. 	}
  309. 	for(int i = 0; i < argc; i++)
  310. 	{
  311. 		char *path = argv[i];
  312. 		if(path[0] == '-' && path[1] == 0)
  313. 		{
  314. 			if(wc_file(STDIN_FILENO, NULL) < 0) return 1;
  316. 			continue;
  317. 		}
  319. 		// https://www.austingroupbugs.net/view.php?id=251
  320. 		if(strchr(path, '\n') != NULL)
  321. 			fprintf(
  322. 			    stderr,
  323. 			    "%s: warning: Filename '%s' contains a newline while wc(1) uses newlines as separators\n",
  324. 			    argv0,
  325. 			    path);
  327. 		int arg_fd = open(path, O_RDONLY | O_NOCTTY);
  328. 		if(arg_fd < 0)
  329. 		{
  330. 			fprintf(stderr, "%s: error: Failed opening file '%s': %s\n", argv0, path, strerror(errno));
  331. 			return 1;
  332. 		}
  334. 		if((errno = posix_fadvise(arg_fd, 0, 0, POSIX_FADV_SEQUENTIAL)) != 0)
  335. 		{
  336. 			fprintf(stderr,
  337. 			        "%s: warning: Failure from posix_fadvise sequential for file '%s': %s\n",
  338. 			        argv0,
  339. 			        path,
  340. 			        strerror(errno));
  341. 			errno = 0;
  342. 		}
  344. 		if(wc_file(arg_fd, path) < 0) return 1;
  346. 		if(close(arg_fd) < 0)
  347. 		{
  348. 			fprintf(stderr, "%s: error: Failed closing file '%s': %s\n", argv0, path, strerror(errno));
  349. 			return 1;
  350. 		}
  351. 	}
  353. 	if(argc > 1) print_counts(total_lines, total_words, total_bytes, "total");
  355. 	return 0;
  356. }