logo

utils-std

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

echo.c (2799B)

    

  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 <stdbool.h>
  7. #include <stdio.h>  // perror
  8. #include <stdlib.h> // malloc
  9. #include <string.h> // strlen
  10. #include <unistd.h> // write
  12. int
  13. main(int argc, char *argv[])
  14. {
  15. 	size_t arg_len = 0;
  16. 	bool opt_n = false, opt_e = false;
  18. 	argc--;
  19. 	argv++;
  21. 	for(; argc > 0;)
  22. 	{
  23. 		if(argv[0][0] != '-') break;
  25. 		/* '-' and '--' needs to be passed as-is so no argc--,argv++ */
  26. 		if(argv[0][1] == '\0' || (argv[0][1] == '-' && argv[0][2] == '\0')) break;
  28. 		for(int i = 1; argv[0][i] != '\0'; i++)
  29. 		{
  30. 			switch(argv[0][i])
  31. 			{
  32. 			case 'n':
  33. 				opt_n = true;
  34. 				break;
  35. 			case 'e':
  36. 				opt_e = true;
  37. 				break;
  38. 			case 'E':
  39. 				opt_e = false;
  40. 				break;
  41. 			default:
  42. 				fprintf(stderr, "echo: warning: unknown option '-%c'\n", argv[0][i]);
  43. 				break;
  44. 			}
  45. 		}
  47. 		argc--;
  48. 		argv++;
  49. 	}
  51. 	for(int i = 0; i < argc; i++)
  52. 	{
  53. 		size_t len = strlen(argv[i]);
  54. 		argv[i][len] = ' ';
  55. 		arg_len += len + 1; // str + space
  56. 	}
  58. 	if(arg_len == 0)
  59. 	{
  60. 		if(opt_n) return 0;
  62. 		if(write(1, "\n", 1) < 1)
  63. 		{
  64. 			perror("echo: error: Failed writing");
  65. 			return 1;
  66. 		}
  68. 		return 0;
  69. 	}
  70. 	else
  71. 		argv[0][arg_len - 1] = '\n';
  73. 	if(opt_n) arg_len--; // no newline
  75. 	char *d = *argv;
  76. 	size_t d_len = arg_len;
  78. 	char *newd = NULL;
  79. 	if(opt_e)
  80. 	{
  81. 		newd = malloc(arg_len);
  82. 		if(!newd)
  83. 		{
  84. 			fprintf(stderr, "echo: error: Failed to allocate for a copy of the strings\n");
  85. 			return 1;
  86. 		}
  88. 		int di = 0;
  90. 		for(size_t argi = 0; argi < arg_len; argi++)
  91. 		{
  92. 			if(d[argi] != '\\')
  93. 			{
  94. 				newd[di++] = d[argi];
  95. 				continue;
  96. 			}
  98. 			switch(d[++argi])
  99. 			{
  100. 			case 'a':
  101. 				newd[di++] = '\a';
  102. 				break;
  103. 			case 'b':
  104. 				newd[di++] = '\b';
  105. 				break;
  106. 			case 'c':
  107. 				newd[di++] = '\0';
  108. 				goto p_break;
  109. 			case 'f':
  110. 				newd[di++] = '\f';
  111. 				break;
  112. 			case 'n':
  113. 				newd[di++] = '\n';
  114. 				break;
  115. 			case 'r':
  116. 				newd[di++] = '\r';
  117. 				break;
  118. 			case 't':
  119. 				newd[di++] = '\t';
  120. 				break;
  121. 			case 'v':
  122. 				newd[di++] = '\v';
  123. 				break;
  124. 			case '\\':
  125. 				newd[di++] = '\\';
  126. 				break;
  127. 			case '0': /* \0 \0n \0nn \0nnn */
  128. 			{
  129. 				int nl = 1; // skip leading 0
  130. 				int num = 0;
  131. 				for(; nl < 4; nl++)
  132. 				{
  133. 					if(d[argi + nl] >= '0' && d[argi + nl] <= '7')
  134. 					{
  135. 						num = (num * 8) + (d[argi + nl] - '0');
  136. 					}
  137. 					else
  138. 						break;
  139. 				}
  140. 				newd[di++] = num;
  141. 				argi += (nl - 1);
  142. 				break;
  143. 			}
  144. 			default:
  145. 				newd[di++] = d[argi];
  146. 				break;
  147. 			}
  148. 		}
  150. 		newd[di] = '\0';
  151. 	p_break:
  152. 		d = newd;
  153. 		d_len = di;
  154. 	}
  156. 	ssize_t nwrite = write(1, d, d_len);
  157. 	if(nwrite < (ssize_t)d_len)
  158. 	{
  159. 		perror("echo: error: Failed writing");
  160. 		if(opt_e) free(newd);
  161. 		return 1;
  162. 	}
  164. 	if(opt_e) free(newd);
  166. 	return 0;
  167. }