533 lines
14 KiB
Plaintext
533 lines
14 KiB
Plaintext
/* text.cm - text conversion and formatting utilities */
|
|
|
|
/* -------- helper functions ----------------------------------------- */
|
|
|
|
var blob = use('blob')
|
|
|
|
// Convert number to string with given radix
|
|
function to_radix(num, radix) {
|
|
if (radix < 2 || radix > 36) return null;
|
|
|
|
var digits = "0123456789abcdefghijklmnopqrstuvwxyz";
|
|
var result = "";
|
|
var n = Math.trunc(num);
|
|
var negative = n < 0;
|
|
n = Math.abs(n);
|
|
|
|
if (n === 0) return "0";
|
|
|
|
while (n > 0) {
|
|
result = digits[n % radix] + result;
|
|
n = Math.floor(n / radix);
|
|
}
|
|
|
|
return negative ? "-" + result : result;
|
|
}
|
|
|
|
// Insert separator every n digits from right
|
|
function add_separator(str, sep, n) {
|
|
if (!n || n === 0) return str;
|
|
|
|
var negative = str[0] === '-';
|
|
if (negative) str = str.substring(1);
|
|
|
|
var parts = str.split('.');
|
|
var integer = parts[0];
|
|
var decimal = parts[1] || '';
|
|
|
|
// Add separators to integer part
|
|
var result = "";
|
|
for (var i = integer.length - 1, count = 0; i >= 0; i--) {
|
|
if (count === n && i !== integer.length - 1) {
|
|
result = sep + result;
|
|
count = 0;
|
|
}
|
|
result = integer[i] + result;
|
|
count++;
|
|
}
|
|
|
|
if (decimal) result += '.' + decimal;
|
|
return negative ? '-' + result : result;
|
|
}
|
|
|
|
// Format number with separator from left
|
|
function add_separator_left(str, sep, n) {
|
|
if (!n || n === 0) return str;
|
|
|
|
var negative = str[0] === '-';
|
|
if (negative) str = str.substring(1);
|
|
|
|
var result = "";
|
|
for (var i = 0, count = 0; i < str.length; i++) {
|
|
if (count === n && i !== 0) {
|
|
result += sep;
|
|
count = 0;
|
|
}
|
|
result += str[i];
|
|
count++;
|
|
}
|
|
|
|
return negative ? '-' + result : result;
|
|
}
|
|
|
|
/* -------- main text function --------------------------------------- */
|
|
|
|
function text() {
|
|
var arg = arguments[0];
|
|
|
|
// Handle blob conversion
|
|
if (arg instanceof blob) {
|
|
if (!stone.p(arg))
|
|
throw new Error("text: blob must be stone for reading");
|
|
|
|
var format = arguments[1];
|
|
var bit_length = arg.length;
|
|
var result = "";
|
|
|
|
if (typeof format === 'string') {
|
|
// Extract style from format
|
|
var style = '';
|
|
for (var i = 0; i < format.length; i++) {
|
|
if ((format[i] >= 'a' && format[i] <= 'z') || (format[i] >= 'A' && format[i] <= 'Z')) {
|
|
style = format[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Handle blob encoding styles
|
|
switch (style) {
|
|
case 'h': // hexadecimal
|
|
// Read 8 bits at a time for full bytes
|
|
var hex_digits = "0123456789ABCDEF";
|
|
for (var i = 0; i < bit_length; i += 8) {
|
|
var byte_val = 0;
|
|
for (var j = 0; j < 8 && i + j < bit_length; j++) {
|
|
var bit = arg.read_logical(i + j);
|
|
if (bit) byte_val |= (1 << j);
|
|
}
|
|
result += hex_digits[(byte_val >> 4) & 0xF];
|
|
result += hex_digits[byte_val & 0xF];
|
|
}
|
|
return result;
|
|
|
|
case 't': // base32
|
|
var b32_digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
|
|
var bits = 0;
|
|
var value = 0;
|
|
|
|
// Read bits from LSB to MSB within each byte
|
|
for (var byte_idx = 0; byte_idx < Math.ceil(bit_length / 8); byte_idx++) {
|
|
for (var bit_in_byte = 0; bit_in_byte < 8 && byte_idx * 8 + bit_in_byte < bit_length; bit_in_byte++) {
|
|
var bit_pos = byte_idx * 8 + bit_in_byte;
|
|
var bit = arg.read_logical(bit_pos);
|
|
|
|
// Accumulate bits from MSB to LSB for base32
|
|
value = (value << 1) | (bit ? 1 : 0);
|
|
bits++;
|
|
|
|
if (bits === 5) {
|
|
result += b32_digits[value];
|
|
bits = 0;
|
|
value = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle remaining bits
|
|
if (bits > 0) {
|
|
value = value << (5 - bits);
|
|
result += b32_digits[value];
|
|
}
|
|
|
|
// Add padding to make length multiple of 8
|
|
while (result.length % 8 !== 0) {
|
|
result += '=';
|
|
}
|
|
|
|
return result;
|
|
|
|
case 'b': // binary
|
|
for (var i = 0; i < bit_length; i++) {
|
|
result += arg.read_logical(i) ? '1' : '0';
|
|
}
|
|
return result;
|
|
|
|
case 'o': // octal
|
|
var bits = 0;
|
|
var value = 0;
|
|
|
|
for (var i = 0; i < bit_length; i++) {
|
|
var bit = arg.read_logical(i);
|
|
value = (value << 1) | (bit ? 1 : 0);
|
|
bits++;
|
|
|
|
if (bits === 3) {
|
|
result += value.toString();
|
|
bits = 0;
|
|
value = 0;
|
|
}
|
|
}
|
|
|
|
// Handle remaining bits
|
|
if (bits > 0) {
|
|
value = value << (3 - bits);
|
|
result += value.toString();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// Default: interpret as UTF-8 text
|
|
var byte_count = Math.floor(bit_length / 8);
|
|
var bytes = [];
|
|
|
|
// Read bytes from the blob
|
|
for (var i = 0; i < byte_count; i++) {
|
|
var byte_val = 0;
|
|
for (var j = 0; j < 8; j++) {
|
|
var bit_pos = i * 8 + j;
|
|
var bit = arg.read_logical(bit_pos);
|
|
if (bit) byte_val |= (1 << j);
|
|
}
|
|
bytes.push(byte_val);
|
|
}
|
|
|
|
// Convert bytes to UTF-8 string
|
|
var result = "";
|
|
var i = 0;
|
|
while (i < bytes.length) {
|
|
var b1 = bytes[i];
|
|
var codepoint;
|
|
var nextI;
|
|
|
|
if (b1 < 0x80) {
|
|
// 1-byte ASCII
|
|
codepoint = b1;
|
|
nextI = i + 1;
|
|
} else if (b1 < 0xC0) {
|
|
// Invalid start byte, treat as replacement character
|
|
codepoint = 0xFFFD;
|
|
nextI = i + 1;
|
|
} else if (b1 < 0xE0) {
|
|
// 2-byte sequence
|
|
if (i + 1 < bytes.length && (bytes[i + 1] & 0xC0) === 0x80) {
|
|
codepoint = ((b1 & 0x1F) << 6) | (bytes[i + 1] & 0x3F);
|
|
nextI = i + 2;
|
|
} else {
|
|
codepoint = 0xFFFD;
|
|
nextI = i + 1;
|
|
}
|
|
} else if (b1 < 0xF0) {
|
|
// 3-byte sequence
|
|
if (i + 2 < bytes.length &&
|
|
(bytes[i + 1] & 0xC0) === 0x80 &&
|
|
(bytes[i + 2] & 0xC0) === 0x80) {
|
|
codepoint = ((b1 & 0x0F) << 12) |
|
|
((bytes[i + 1] & 0x3F) << 6) |
|
|
(bytes[i + 2] & 0x3F);
|
|
nextI = i + 3;
|
|
} else {
|
|
codepoint = 0xFFFD;
|
|
nextI = i + 1;
|
|
}
|
|
} else if (b1 < 0xF8) {
|
|
// 4-byte sequence
|
|
if (i + 3 < bytes.length &&
|
|
(bytes[i + 1] & 0xC0) === 0x80 &&
|
|
(bytes[i + 2] & 0xC0) === 0x80 &&
|
|
(bytes[i + 3] & 0xC0) === 0x80) {
|
|
codepoint = ((b1 & 0x07) << 18) |
|
|
((bytes[i + 1] & 0x3F) << 12) |
|
|
((bytes[i + 2] & 0x3F) << 6) |
|
|
(bytes[i + 3] & 0x3F);
|
|
nextI = i + 4;
|
|
} else {
|
|
codepoint = 0xFFFD;
|
|
nextI = i + 1;
|
|
}
|
|
} else {
|
|
// Invalid start byte
|
|
codepoint = 0xFFFD;
|
|
nextI = i + 1;
|
|
}
|
|
|
|
// Convert codepoint to string
|
|
if (codepoint <= 0xFFFF) {
|
|
result += String.fromCharCode(codepoint);
|
|
} else if (codepoint <= 0x10FFFF) {
|
|
// Convert to surrogate pair for JavaScript
|
|
codepoint -= 0x10000;
|
|
result += String.fromCharCode(0xD800 + (codepoint >> 10));
|
|
result += String.fromCharCode(0xDC00 + (codepoint & 0x3FF));
|
|
} else {
|
|
result += String.fromCharCode(0xFFFD); // Replacement character
|
|
}
|
|
|
|
i = nextI;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// Handle array conversion
|
|
if (Array.isArray(arg)) {
|
|
var separator = arguments[1] || "";
|
|
var result = "";
|
|
for (var i = 0; i < arg.length; i++) {
|
|
if (i > 0) result += separator;
|
|
|
|
var item = arg[i];
|
|
if (typeof item === 'number' && item >= 0 && item <= 0x10FFFF && item === Math.floor(item)) {
|
|
// Unicode codepoint
|
|
result += String.fromCharCode(item);
|
|
} else {
|
|
result += String(item);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Handle number conversion
|
|
if (typeof arg === 'number') {
|
|
var format = arguments[1];
|
|
|
|
// Simple radix conversion
|
|
if (typeof format === 'number') {
|
|
return to_radix(arg, format);
|
|
}
|
|
|
|
// Format string conversion
|
|
if (typeof format === 'string') {
|
|
return format_number(arg, format);
|
|
}
|
|
|
|
// Default conversion
|
|
return String(arg);
|
|
}
|
|
|
|
// Handle text operations
|
|
if (typeof arg === 'string') {
|
|
if (arguments.length === 1) return arg;
|
|
|
|
var from = arguments[1];
|
|
var to = arguments[2];
|
|
|
|
if (typeof from !== 'number' || typeof to !== 'number') return arg;
|
|
|
|
var len = arg.length;
|
|
|
|
// Adjust negative indices
|
|
if (from < 0) from += len;
|
|
if (to < 0) to += len;
|
|
|
|
// Default values
|
|
if (from === undefined) from = 0;
|
|
if (to === undefined) to = len;
|
|
|
|
// Validate range
|
|
if (from < 0 || from > to || to > len) return null;
|
|
|
|
return arg.substring(from, to);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/* -------- number formatting ---------------------------------------- */
|
|
|
|
function format_number(num, format) {
|
|
// Parse format string
|
|
var separation = 0;
|
|
var style = '';
|
|
var places = 0;
|
|
|
|
var i = 0;
|
|
|
|
// Parse separation digit
|
|
if (i < format.length && format[i] >= '0' && format[i] <= '9') {
|
|
separation = parseInt(format[i]);
|
|
i++;
|
|
}
|
|
|
|
// Parse style letter
|
|
if (i < format.length) {
|
|
style = format[i];
|
|
i++;
|
|
} else {
|
|
return null;
|
|
}
|
|
|
|
// Parse places digits
|
|
if (i < format.length && format[i] >= '0' && format[i] <= '9') {
|
|
places = parseInt(format[i]);
|
|
i++;
|
|
if (i < format.length && format[i] >= '0' && format[i] <= '9') {
|
|
places = places * 10 + parseInt(format[i]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
// Invalid format if there's more
|
|
if (i < format.length) return null;
|
|
|
|
// Real number styles
|
|
if (style === 'e' || style === 'n' || style === 's' ||
|
|
style === 'u' || style === 'd' || style === 'v' || style === 'l') {
|
|
|
|
var decimal_point = '.';
|
|
var separator = '';
|
|
var default_separation = 0;
|
|
var default_places = 0;
|
|
|
|
switch (style) {
|
|
case 'e': // exponential
|
|
decimal_point = '.';
|
|
separator = '';
|
|
default_separation = 0;
|
|
default_places = 0;
|
|
break;
|
|
case 'n': // number
|
|
decimal_point = '.';
|
|
separator = '';
|
|
default_separation = 0;
|
|
default_places = 0;
|
|
break;
|
|
case 's': // space
|
|
decimal_point = '.';
|
|
separator = ' ';
|
|
default_separation = 3;
|
|
default_places = 0;
|
|
break;
|
|
case 'u': // underbar
|
|
decimal_point = '.';
|
|
separator = '_';
|
|
default_separation = 0;
|
|
default_places = 0;
|
|
break;
|
|
case 'd': // decimal
|
|
decimal_point = '.';
|
|
separator = ',';
|
|
default_separation = 3;
|
|
default_places = 2;
|
|
break;
|
|
case 'v': // comma (European style)
|
|
decimal_point = ',';
|
|
separator = '.';
|
|
default_separation = 0;
|
|
default_places = 0;
|
|
break;
|
|
case 'l': // locale (default to 'd' style for now)
|
|
decimal_point = '.';
|
|
separator = ',';
|
|
default_separation = 3;
|
|
default_places = 2;
|
|
break;
|
|
}
|
|
|
|
if (separation === 0) separation = default_separation;
|
|
if (places === 0 && style !== 'e' && style !== 'n') places = default_places;
|
|
|
|
// Format the number
|
|
if (style === 'e') {
|
|
// Scientific notation
|
|
var str = places > 0 ? num.toExponential(places) : num.toExponential();
|
|
return str;
|
|
} else if (style === 'n' && (Math.abs(num) >= 1e21 || (Math.abs(num) < 1e-6 && num !== 0))) {
|
|
// Use scientific notation for extreme values
|
|
return num.toExponential();
|
|
} else {
|
|
// Regular decimal formatting
|
|
var str;
|
|
if (places > 0) {
|
|
str = num.toFixed(places);
|
|
} else {
|
|
str = num.toString();
|
|
}
|
|
|
|
// Replace decimal point if needed
|
|
if (decimal_point !== '.') {
|
|
str = str.replace('.', decimal_point);
|
|
}
|
|
|
|
// Add separators
|
|
if (separation > 0 && separator) {
|
|
str = add_separator(str, separator, separation);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
}
|
|
|
|
// Integer styles
|
|
if (style === 'i' || style === 'b' || style === 'o' ||
|
|
style === 'h' || style === 't') {
|
|
|
|
var radix = 10;
|
|
var default_separation = 0;
|
|
var default_places = 1;
|
|
|
|
switch (style) {
|
|
case 'i': // integer
|
|
radix = 10;
|
|
default_separation = 0;
|
|
default_places = 1;
|
|
break;
|
|
case 'b': // binary
|
|
radix = 2;
|
|
default_separation = 0;
|
|
default_places = 1;
|
|
break;
|
|
case 'o': // octal
|
|
radix = 8;
|
|
default_separation = 0;
|
|
default_places = 1;
|
|
break;
|
|
case 'h': // hexadecimal
|
|
radix = 16;
|
|
default_separation = 0;
|
|
default_places = 1;
|
|
break;
|
|
case 't': // base32
|
|
radix = 32;
|
|
default_separation = 0;
|
|
default_places = 1;
|
|
break;
|
|
}
|
|
|
|
if (separation === 0) separation = default_separation;
|
|
if (places === 0) places = default_places;
|
|
|
|
// Convert to integer
|
|
var n = Math.trunc(num);
|
|
var str = to_radix(n, radix).toUpperCase();
|
|
|
|
// Pad with zeros if needed
|
|
var negative = str[0] === '-';
|
|
if (negative) str = str.substring(1);
|
|
|
|
while (str.length < places) {
|
|
str = '0' + str;
|
|
}
|
|
|
|
// Add separators
|
|
if (separation > 0) {
|
|
str = add_separator_left(str, '_', separation);
|
|
}
|
|
|
|
return negative ? '-' + str : str;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/* -------- documentation -------------------------------------------- */
|
|
|
|
text[cell.DOC] = {
|
|
doc: "Text conversion and formatting utilities",
|
|
text: "text(value, ...) → formatted text string"
|
|
};
|
|
|
|
/* -------- exports -------------------------------------------------- */
|
|
|
|
return text; |