logo

utils-std

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

seq.c (3401B)

    

  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>   // isdigit
  10. #include <errno.h>   // errno
  11. #include <math.h>    // fabs
  12. #include <stdbool.h> // bool, true, false
  13. #include <stdio.h>   // fprintf
  14. #include <stdlib.h>  // exit, strtod
  15. #include <string.h>  // strerror
  16. #include <unistd.h>  // getopt, optarg, optind
  17. #ifdef HAS_GETOPT_LONG
  18. #include <getopt.h>
  19. #endif
  21. const char *argv0 = "seq";
  22. const char *sep = "\n";
  23. const char *term = "\n";
  25. int len = 0;
  27. bool opt_w = false;
  28. double g_last = 1.0;
  30. static void
  31. seq(double i, double step, double last)
  32. {
  33. 	printf("%0*g", len, i);
  35. 	if(i < last)
  36. 	{
  37. 		while((i + step) <= last)
  38. 			printf("%s%0*g", sep, len, i += step);
  39. 	}
  40. 	else if(i > last)
  41. 	{
  42. 		while((i - step) >= last)
  43. 			printf("%s%0*g", sep, len, i -= step);
  44. 	}
  46. 	printf("%s", term);
  48. 	if(opt_w && i != g_last)
  49. 		fprintf(stderr, "seq: error: Failed to guess last, got: %g; expected: %g\n", i, g_last);
  50. }
  52. static double
  53. get_num(char *str)
  54. {
  55. 	errno = 0;
  57. 	char *endptr = NULL;
  59. 	double num = strtod(str, &endptr);
  61. 	if(errno != 0)
  62. 	{
  63. 		fprintf(stderr, "seq: error: strtod(\"%s\"): %s\n", str, strerror(errno));
  64. 		exit(1);
  65. 	}
  67. 	if(!(endptr == NULL || endptr[0] == 0))
  68. 	{
  69. 		fprintf(stderr,
  70. 		        "seq: error: strtod(\"%s\"), invalid remaining characters found '%s'\n",
  71. 		        str,
  72. 		        endptr);
  73. 		exit(1);
  74. 	}
  76. 	return num;
  77. }
  79. static void
  80. usage(void)
  81. {
  82. 	fprintf(stderr, "usage: seq [-w] [-s separator] [first [step]] last\n");
  83. }
  85. int
  86. main(int argc, char *argv[])
  87. {
  88. #ifdef HAS_GETOPT_LONG
  89. 	// Strictly for GNUisms compatibility so no long-only options
  90. 	// clang-format off
  91. 	static struct option opts[] = {
  92. 		{"equal-width", no_argument, NULL, 'w'},
  93. 		{"separator", required_argument, NULL, 's'},
  94. 		{0, 0, 0, 0},
  95. 	};
  96. 	// clang-format on
  98. 	// Need + as first character to get POSIX-style option parsing
  99. 	for(int c = -1; (c = getopt_long(argc, argv, "+:ws:t:", opts, NULL)) != -1;)
  100. #else
  101. 	for(int c = -1; (c = getopt_nolong(argc, argv, ":ws:t:")) != -1;)
  102. #endif
  103. 	{
  104. 		switch(c)
  105. 		{
  106. 		case 'w':
  107. 			opt_w = true;
  108. 			break;
  109. 		case 's':
  110. 			sep = optarg;
  111. 			break;
  112. 		case 't':
  113. 			term = optarg;
  114. 			break;
  115. 		case ':':
  116. 			fprintf(stderr, "seq: error: Option -%c requires an operand\n", optopt);
  117. 			usage();
  118. 			return 1;
  119. 		case '?':
  120. 			if(!got_long_opt)
  121. 				if(isdigit(optopt))
  122. 				{
  123. 					fprintf(stderr,
  124. 					        "seq: warning: Pass -- if the first non-option argument starts with a dash(-)\n");
  125. 					optind--;
  126. 					goto getopt_end;
  127. 				}
  128. 			usage();
  129. 			return 1;
  130. 		}
  131. 	}
  132. getopt_end:
  134. 	argc -= optind;
  135. 	argv += optind;
  137. 	double first = 1.0;
  138. 	double step = 1.0;
  139. 	double last = 1.0;
  141. 	switch(argc)
  142. 	{
  143. 	case 1:
  144. 		last = get_num(argv[0]);
  145. 		break;
  146. 	case 2:
  147. 		first = get_num(argv[0]);
  148. 		last = get_num(argv[1]);
  149. 		break;
  150. 	case 3:
  151. 		first = get_num(argv[0]);
  152. 		step = fabs(get_num(argv[1]));
  153. 		last = get_num(argv[2]);
  154. 		break;
  155. 	default:
  156. 		usage();
  157. 		return 1;
  158. 	}
  160. 	if(opt_w)
  161. 	{
  162. 		double f_mod = fmod(first, step);
  163. 		double l_mod = fmod(last, step);
  165. 		g_last = last - l_mod + f_mod;
  167. 		int f_len = snprintf(NULL, 0, "%g", first);
  168. 		int l_len = snprintf(NULL, 0, "%g", g_last);
  170. 		len = f_len > l_len ? f_len : l_len;
  171. 	}
  173. 	seq(first, step, last);
  175. 	return 0;
  176. }