logo

9utils

Collection of utilities inspired by Plan9

freq.ha (2795B)

    

  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 getopt;
  6. use fmt;
  7. use os;
  8. use io;
  9. use ascii;
  10. use types;
  11. use strings;
  12. use encoding::utf8;
  14. fn is_unicode_cc(r: rune) bool = {
  15. 	let r = r: u32;
  16. 	if(r <= 0x0000 && r >= 0x001F) { return true; }; // C0 Controls
  17. 	if(r == 0x007F) { return true; }; // Delete
  18. 	if(r <= 0x0080 && r >= 0x009F) { return true; }; // C1 Controls
  20. 	return false;
  21. };
  23. export fn main() void = {
  24. 	let runic = false;
  26. 	const cmd = getopt::parse(os::args,
  27. 		"Print histogram frequency of bytes/characters",
  28. 		('r', "Rune (unicode character) frequency instead of byte frequency"),
  29. 		"file ...",
  30. 	);
  31. 	defer getopt::finish(&cmd);
  33. 	for (let i = 0z; i < len(cmd.opts); i += 1) {
  34. 		const opt = cmd.opts[i];
  35. 		switch(opt.0) {
  36. 		case 'r' => runic = true;
  37. 		case => abort("unhandled option");
  38. 		};
  39. 	};
  41. 	if(runic) {
  42. 		let runes_count: [](rune, size) = [];
  43. 		let buf: [32]u8 = [0...];
  45. 		for(true) {
  46. 			let s = match(io::read(os::stdin, &buf)) {
  47. 			case let s: size =>
  48. 				yield s;
  49. 			case io::EOF =>
  50. 				break;
  51. 			case let e: io::error =>
  52. 				fmt::fatal("freq: I/O error: {}", io::strerror(e));
  53. 			};
  55. 			let buf_s = match(strings::fromutf8(buf[0..s])) {
  56. 			case let s: str =>
  57. 				yield s;
  58. 			case utf8::invalid =>
  59. 				fmt::fatal("freq: Invalid UTF-8");
  60. 			};
  62. 			let buf_iter = strings::iter(buf_s);
  64. 			for(true) {
  65. 				const r = match(strings::next(&buf_iter)) {
  66. 				case let r: rune =>
  67. 					yield r;
  68. 				case void =>
  69. 					break;
  70. 				};
  72. 				for(let i = 0z; true; i += 1) {
  73. 					if(i < len(runes_count)) {
  74. 						if(runes_count[i].0 == r) {
  75. 							runes_count[i].1 += 1;
  76. 							break;
  77. 						};
  78. 					} else {
  79. 						append(runes_count, (r, 1));
  80. 						break;
  81. 					};
  82. 				};
  83. 			};
  84. 		};
  86. 		for(let i = 0z; i < len(runes_count); i += 1) {
  87. 			const rune_c = runes_count[i];
  88. 			let c = if(!is_unicode_cc(rune_c.0)) {
  89. 				yield rune_c.0;
  90. 			} else {
  91. 				yield "-";
  92. 			};
  94. 			// 1114109 4177775 10fffd
  95. 			fmt::printfln("{0:7} {0:7o} {0:6x} {1}    {2}", rune_c.0: u32, c, rune_c.1)!;
  96. 		};
  97. 	} else {
  98. 		// Stupid table of all bytes
  99. 		let bytes_count: [256]size = [0...];
  100. 		let buf: [32]u8 = [0...];
  102. 		for(true) {
  103. 			let s = match(io::read(os::stdin, &buf)) {
  104. 			case let s: size =>
  105. 				yield s;
  106. 			case io::EOF =>
  107. 				break;
  108. 			case let e: io::error =>
  109. 				fmt::fatal("freq: I/O error: {}", io::strerror(e));
  110. 			};
  112. 			for(let i = 0z; i < s; i += 1) {
  113. 				bytes_count[buf[i]] += 1;
  114. 			};
  115. 		};
  117. 		for(let i = 0u32; i < len(bytes_count); i += 1) {
  118. 			if(bytes_count[i] != 0) {
  119. 				let c = i: rune;
  120. 				let c = if(ascii::isprint(c)) {
  121. 					yield c;
  122. 				} else {
  123. 					yield "-";
  124. 				};
  126. 				fmt::printfln("{0:3} {0:03o} {0:02x} {1}	{2}", i, c, bytes_count[i])!;
  127. 			};
  128. 		};
  129. 	};
  130. };