logo

9utils

Collection of utilities inspired by Plan9 git clone https://anongit.hacktivis.me/git/9utils.git/

unicode.ha (3769B)

    

  1. // Collection of utilities inspired by Plan9
  2. // SPDX-FileCopyrightText: 2023 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. use fmt;
  6. use getopt;
  7. use io;
  8. use os;
  9. use strconv;
  10. use strings;
  11. use unix::tty;
  13. let numeric = false;
  14. let text = false;
  16. // print table from hexmin-hexmax
  17. fn table(args: []str) void = {
  18. 	const tsize = if(tty::isatty(os::stdout_file)) {
  19. 		yield match(tty::winsize(os::stdout_file)) {
  20. 		case let s: tty::ttysize =>
  21. 			yield s;
  22. 		case let e: tty::error =>
  23. 			fmt::errorfln("unicode: Warning: Can't get current terminal size: {}", tty::strerror(e))!;
  24. 		};
  25. 	} else {
  26. 		yield void;
  27. 	};
  29. 	for(let i = 0z; i < len(args); i += 1) {
  30. 		const arg = args[i];
  31. 		let (min, max) = strings::cut(arg, "-");
  33. 		let min = match(strconv::stou32(min, strconv::base::HEX)) {
  34. 			case let u: u32 => yield u;
  35. 			case strconv::overflow =>
  36. 				fmt::fatalf("unicode: Integer overflow with hexmin argument: {}", arg);
  37. 			case strconv::invalid =>
  38. 				fmt::fatalf("unicode: Expected hexadecimal for hexmin, got: {}", arg);
  39. 		};
  40. 		let max = match(strconv::stou32(max, strconv::base::HEX)) {
  41. 			case let u: u32 => yield u;
  42. 			case strconv::overflow =>
  43. 				fmt::fatalf("unicode: Integer overflow with hexmax argument: {}", arg);
  44. 			case strconv::invalid =>
  45. 				fmt::fatalf("unicode: Expected hexadecimal for hexmax, got: {}", arg);
  46. 		};
  48. 		if(min >= max) {
  49. 			fmt::fatalf("unicode: Error min({:x}) >= max({:x})", min, max);
  50. 		};
  52. 		const (cel_width, cel_fmt) = if(max < 0xFFFF) {
  53. 			// (4 hex, non-break space, 1 char, 2 space) = 8 chars
  54. 			yield (8u16, "{:.4X} {}  ");
  55. 		} else {
  56. 			// (8 hex, non-break space, 1 char, 2 space) = 12 chars
  57. 			yield (12u16, "{:.8X} {}  ");
  58. 		};
  60. 		match(tsize) {
  61. 		case void =>
  62. 			for(let c = min; c <= max; c += 1) {
  63. 				fmt::printf(cel_fmt, c, c: rune)!;
  64. 			};
  65. 			fmt::println()!;
  66. 		case let ts: tty::ttysize =>
  67. 			const row_width = ts.columns / cel_width;
  69. 			for(let r = min; r <= max; r += row_width) {
  70. 				for(let c = r; c < r+row_width && c <= max; c += 1) {
  71. 					fmt::printf(cel_fmt, c, c: rune)!;
  72. 				};
  73. 				fmt::println()!;
  74. 			};
  75. 		};
  76. 	};
  77. };
  79. // characters to codepoints
  80. fn decode(args: []str) void = {
  81. 	for(let i = 0z; i < len(args); i += 1) {
  82. 		const arg = args[i];
  83. 		const runes = strings::torunes(arg);
  85. 		for(let ri = 0z; ri < len(runes); ri += 1) {
  86. 			const r = runes[ri]: u32;
  87. 			// Print as 4 characters min to match UnicodeData.txt formatting
  88. 			fmt::printfln("{:.4X}", r)!;
  89. 		};
  90. 	};
  91. };
  93. // codepoints to characters
  94. fn encode(args: []str) void = {
  95. 	let chars: []rune = [];
  97. 	for(let i = 0z; i < len(args); i += 1) {
  98. 		const arg = args[i];
  100. 		const r = match(strconv::stou32(arg, strconv::base::HEX)) {
  101. 			case let u: u32 =>
  102. 				yield u: rune;
  103. 			case strconv::overflow =>
  104. 				fmt::fatalf("unicode: Integer overflow with codepoints argument: {}", arg);
  105. 			case strconv::invalid =>
  106. 				fmt::fatalf("unicode: Encoding failed, expected hexadecimal, got: {}", arg);
  107. 		};
  109. 		if(text) {
  110. 			fmt::print(r)!;
  111. 		} else {
  112. 			fmt::println(r)!;
  113. 		};
  114. 	};
  115. };
  117. export fn main() void = {
  118. 	const cmd = getopt::parse(os::args,
  119. 		"Encode/Decode unicode characters",
  120. 		('n', "Numeric output"),
  121. 		('t', "Running text. Newlines aren't inserted after each character."),
  122. 		"hexmin-hexmax ... | characters ... | codepoints ...",
  123. 	);
  124. 	defer getopt::finish(&cmd);
  126. 	for (let i = 0z; i < len(cmd.opts); i += 1) {
  127. 		const opt = cmd.opts[i];
  128. 		switch(opt.0) {
  129. 		case 'n' => numeric = true;
  130. 		case 't' => text = true;
  131. 		case => abort("unhandled option");
  132. 		};
  133. 	};
  135. 	if(len(cmd.args) == 0) {
  136. 		getopt::printusage(os::stderr, "unicode", cmd.help)!;
  137. 		return;
  138. 	};
  140. 	if(strings::contains(cmd.args[0], '-')) {
  141. 		table(cmd.args);
  142. 	} else {
  143. 		if(numeric) {
  144. 			decode(cmd.args);
  145. 		} else {
  146. 			encode(cmd.args);
  147. 		};
  148. 	};
  149. };