logo

9utils

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

unicode.ha (3911B)

    

  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 = match(strings::torunes(arg)) {
  84. 		case let r: []rune =>
  85. 			yield r;
  86. 		case nomem =>
  87. 			fmt::fatal("unicode: error: Out of Memory while decoding to codepoints");
  88. 		};
  90. 		for(let ri = 0z; ri < len(runes); ri += 1) {
  91. 			const r = runes[ri]: u32;
  92. 			// Print as 4 characters min to match UnicodeData.txt formatting
  93. 			fmt::printfln("{:.4X}", r)!;
  94. 		};
  95. 	};
  96. };
  98. // codepoints to characters
  99. fn encode(args: []str) void = {
  100. 	let chars: []rune = [];
  102. 	for(let i = 0z; i < len(args); i += 1) {
  103. 		const arg = args[i];
  105. 		const r = match(strconv::stou32(arg, strconv::base::HEX)) {
  106. 			case let u: u32 =>
  107. 				yield u: rune;
  108. 			case strconv::overflow =>
  109. 				fmt::fatalf("unicode: Integer overflow with codepoints argument: {}", arg);
  110. 			case strconv::invalid =>
  111. 				fmt::fatalf("unicode: Encoding failed, expected hexadecimal, got: {}", arg);
  112. 		};
  114. 		if(text) {
  115. 			fmt::print(r)!;
  116. 		} else {
  117. 			fmt::println(r)!;
  118. 		};
  119. 	};
  120. };
  122. export fn main() void = {
  123. 	const cmd = getopt::parse(os::args,
  124. 		"Encode/Decode unicode characters",
  125. 		('n', "Numeric output"),
  126. 		('t', "Running text. Newlines aren't inserted after each character."),
  127. 		"hexmin-hexmax ... | characters ... | codepoints ...",
  128. 	);
  129. 	defer getopt::finish(&cmd);
  131. 	for (let i = 0z; i < len(cmd.opts); i += 1) {
  132. 		const opt = cmd.opts[i];
  133. 		switch(opt.0) {
  134. 		case 'n' => numeric = true;
  135. 		case 't' => text = true;
  136. 		case => abort("unhandled option");
  137. 		};
  138. 	};
  140. 	if(len(cmd.args) == 0) {
  141. 		getopt::printusage(os::stderr, "unicode", cmd.help)!;
  142. 		return;
  143. 	};
  145. 	if(strings::contains(cmd.args[0], '-')) {
  146. 		table(cmd.args);
  147. 	} else {
  148. 		if(numeric) {
  149. 			decode(cmd.args);
  150. 		} else {
  151. 			encode(cmd.args);
  152. 		};
  153. 	};
  154. };