Files
likang 7e01147566
CI / typecheck + test + build (push) Has been cancelled
Initial commit: import VibeMake PCB Studio
2026-11-03 11:20:08 +08:00

1276 lines
40 KiB
TypeScript

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 ZiroEDA and contributors.
// Portions derived from KiCad, copyright The KiCad Developers. See NOTICE.md.
/**
* `common/text_eval/text_eval_parser.cpp` with its header
* `include/text_eval/text_eval_parser.h`: the `calc_parser` AST (`NODE`,
* `DOC`), the value conversions (`VALUE_UTILS`), the date and E-series
* helpers, and `EVAL_VISITOR` - every function an `@{...}` expression can call.
*
* Number to text follows `{fmt}`, not JavaScript: `fixed` is `{:.Nf}` and
* `shortest` is `{}` (`plotters/fmt.ts`, the one implementation of each).
* `std::pow` is `std_pow` below, because V8's `Math.pow(10, -5)` is one ulp
* off the correctly rounded value glibc returns.
*/
import { fixed, shortest } from '../plotters/fmt.js';
import * as TEXT_EVAL_VCS from './text_eval_vcs.js';
import {
ERROR_COLLECTOR,
MakeError,
MakeValue,
type Result,
type Value,
} from './text_eval_types.js';
// ---------------------------------------------------------------------------
// C++ numeric helpers
/** `static_cast<int>( double )`: truncation; out of range is x86's INT_MIN. */
export function toInt(aValue: number): number {
if (!Number.isFinite(aValue) || aValue >= 2147483648 || aValue <= -2147483649) return -2147483648;
return Math.trunc(aValue) | 0;
}
// Exact doubles: 10^k is representable for k <= 22.
const POW10: readonly number[] = Array.from({ length: 23 }, (_, k) => Number(`1e${k}`));
/**
* `std::pow`. glibc's pow is correctly rounded; V8's is not always
* (`Math.pow(10, -5)` is 9.999999999999999e-6), and the E-series and
* `round()` scale by exact powers of ten, so those are computed exactly.
*/
export function std_pow(aBase: number, aExp: number): number {
if (aBase === 10 && Number.isInteger(aExp) && Math.abs(aExp) <= 22)
return aExp >= 0 ? POW10[aExp]! : 1 / POW10[-aExp]!;
return aBase ** aExp;
}
/** `std::round`: half away from zero, keeping the sign of zero. */
export function std_round(aValue: number): number {
return Math.sign(aValue) * Math.round(Math.abs(aValue)) || aValue * 0;
}
/**
* `std::stoi`: skip leading whitespace, an optional sign, then digits up to the
* first non-digit. Throws when there are no digits or the value overflows int.
*/
export function stoi(aStr: string): number {
const match = /^[ \t\n\v\f\r]*([+-]?\d+)/.exec(aStr);
if (!match) throw new Error('stoi: no conversion');
const value = Number(match[1]);
if (value > 2147483647 || value < -2147483648) throw new Error('stoi: out of range');
return value;
}
/**
* `fast_float::from_chars` over the whole string, as `VALUE_UTILS::ToDouble`
* and the tokenizer use it: an optional minus (never a plus), a decimal or
* `inf` / `infinity` / `nan`, and nothing after it.
*/
export function fromCharsWhole(aStr: string): number | null {
if (/^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(aStr)) return Number(aStr);
const special = /^(-?)(inf|infinity|nan)$/i.exec(aStr);
if (special) {
if (special[2]!.toLowerCase() === 'nan') return Number.NaN;
return special[1] === '-' ? -Infinity : Infinity;
}
return null;
}
/** `fmt::format( "{:0Nd}", n )`: zero padding after the sign. */
function padInt(aValue: number, aWidth: number): string {
const sign = aValue < 0 ? '-' : '';
return sign + String(Math.abs(aValue)).padStart(aWidth - sign.length, '0');
}
// ---------------------------------------------------------------------------
// TOKEN_TYPE
/** `calc_parser::TOKEN_TYPE`. `text` is the C++'s 256-byte buffer. */
export interface TOKEN_TYPE {
text: string;
dValue: number;
isString: boolean;
}
const utf8 = new TextEncoder();
/**
* What `strncpy( token.text, value, 255 )` leaves: the text up to its first
* NUL, and at most 255 UTF-8 bytes of it. A cut through a multi-byte character
* drops the whole character here; the C++ keeps its leading bytes.
*/
export function tokenBufferText(aValue: string): string {
const nul = aValue.indexOf('\0');
let text = nul >= 0 ? aValue.slice(0, nul) : aValue;
if (text.length * 3 <= 255 || utf8.encode(text).length <= 255) return text;
let bytes = 0;
let out = '';
for (const ch of text) {
const n = utf8.encode(ch).length;
if (bytes + n > 255) break;
bytes += n;
out += ch;
}
text = out;
return text;
}
export function MakeStringToken(aStr: string): TOKEN_TYPE {
return { text: tokenBufferText(aStr), dValue: 0.0, isString: true };
}
export function MakeNumberToken(aVal: number): TOKEN_TYPE {
return { text: '', dValue: aVal, isString: false };
}
export function GetTokenString(aToken: TOKEN_TYPE): string {
return aToken.text;
}
export function GetTokenDouble(aToken: TOKEN_TYPE): number {
return aToken.dValue;
}
// ---------------------------------------------------------------------------
// VALUE_UTILS
/** `calc_parser::VALUE_UTILS`. */
export const VALUE_UTILS = {
/** Convert Value to double (for arithmetic operations). */
ToDouble(aVal: Value): Result<number> {
if (typeof aVal === 'number') return MakeValue(aVal);
const value = fromCharsWhole(aVal);
if (value === null) return MakeError<number>(`Cannot convert '${aVal}' to number`);
return MakeValue(value);
},
/** Convert Value to string (for display/concatenation). */
ToString(aVal: Value): string {
if (typeof aVal === 'string') return aVal;
const num = aVal;
// Smart number formatting with tolerance for floating-point precision
const tolerance = 1e-10;
const rounded = std_round(num);
// If the number is very close to a whole number, treat it as such
if (Math.abs(num - rounded) < tolerance && Math.abs(rounded) < 1e15) return fixed(rounded, 0);
return shortest(num);
},
/**
* The first byte of the string, or a space. A byte above 0x7F is a UTF-8
* lead byte, which `wxUniChar( char )` cannot convert and reads as `?`.
*/
ToChar(aVal: Value): string {
const str = VALUE_UTILS.ToString(aVal);
if (str === '') return ' ';
return str.charCodeAt(0) < 0x80 ? str[0]! : '?';
},
/** Check if Value represents a "truthy" value for conditionals. */
IsTruthy(aVal: Value): boolean {
if (typeof aVal === 'number') return aVal !== 0.0;
return aVal !== '';
},
/** Arithmetic operation with type coercion. */
ArithmeticOp(aLeft: Value, aRight: Value, aOp: BinOp): Result<Value> {
const leftNum = VALUE_UTILS.ToDouble(aLeft);
const rightNum = VALUE_UTILS.ToDouble(aRight);
if (!leftNum.HasValue()) return MakeError<Value>(leftNum.GetError());
if (!rightNum.HasValue()) return MakeError<Value>(rightNum.GetError());
const leftVal = leftNum.GetValue();
const rightVal = rightNum.GetValue();
switch (aOp) {
case '+':
return MakeValue<Value>(leftVal + rightVal);
case '-':
return MakeValue<Value>(leftVal - rightVal);
case '*':
return MakeValue<Value>(leftVal * rightVal);
case '/':
if (rightVal === 0.0) return MakeError<Value>('Division by zero');
return MakeValue<Value>(leftVal / rightVal);
case '%':
if (rightVal === 0.0) return MakeError<Value>('Modulo by zero');
return MakeValue<Value>(leftVal % rightVal); // std::fmod
case '^':
return MakeValue<Value>(std_pow(leftVal, rightVal));
case '<':
return MakeValue<Value>(leftVal < rightVal ? 1.0 : 0.0);
case '>':
return MakeValue<Value>(leftVal > rightVal ? 1.0 : 0.0);
case 1:
return MakeValue<Value>(leftVal <= rightVal ? 1.0 : 0.0); // <=
case 2:
return MakeValue<Value>(leftVal >= rightVal ? 1.0 : 0.0); // >=
case 3:
return MakeValue<Value>(leftVal === rightVal ? 1.0 : 0.0); // ==
case 4:
return MakeValue<Value>(leftVal !== rightVal ? 1.0 : 0.0); // !=
default:
return MakeError<Value>('Unknown operator');
}
},
/** String concatenation (special case of '+' for strings). */
ConcatStrings(aLeft: Value, aRight: Value): Value {
return VALUE_UTILS.ToString(aLeft) + VALUE_UTILS.ToString(aRight);
},
};
// ---------------------------------------------------------------------------
// AST
/** `NodeType`. */
export enum NodeType {
Text,
Calc,
Var,
Number,
String,
BinOp,
Function,
}
/**
* `BIN_OP_DATA::op`, a `char`: the operator's own character, or 1-4 for
* `<=`, `>=`, `==`, `!=` as the grammar spells them; `=` marks a Calc.
*/
export type BinOp = '+' | '-' | '*' | '/' | '%' | '^' | '<' | '>' | '=' | 1 | 2 | 3 | 4;
/** `BIN_OP_DATA`. */
export interface BIN_OP_DATA {
left: NODE;
right: NODE | null;
op: BinOp;
}
/** `FUNC_DATA`. */
export interface FUNC_DATA {
name: string;
args: NODE[];
}
/** `calc_parser::NODE`. */
export class NODE {
type: NodeType;
data: string | number | BIN_OP_DATA | FUNC_DATA;
private constructor(aType: NodeType, aData: string | number | BIN_OP_DATA | FUNC_DATA) {
this.type = aType;
this.data = aData;
}
static CreateText(aText: string): NODE {
return new NODE(NodeType.Text, aText);
}
static CreateCalc(aExpr: NODE): NODE {
return new NODE(NodeType.Calc, { left: aExpr, op: '=', right: null });
}
static CreateVar(aName: string): NODE {
return new NODE(NodeType.Var, aName);
}
static CreateNumber(aValue: number): NODE {
return new NODE(NodeType.Number, aValue);
}
static CreateString(aValue: string): NODE {
return new NODE(NodeType.String, aValue);
}
static CreateBinOp(aLeft: NODE, aOp: BinOp, aRight: NODE): NODE {
return new NODE(NodeType.BinOp, { left: aLeft, op: aOp, right: aRight });
}
static CreateFunction(aName: string, aArgs: NODE[]): NODE {
return new NODE(NodeType.Function, { name: aName, args: aArgs });
}
Accept(aVisitor: EVAL_VISITOR): Result<Value> {
return aVisitor.Visit(this);
}
}
/** `calc_parser::DOC`. */
export class DOC {
nodes: NODE[] = [];
errors = new ERROR_COLLECTOR();
AddNode(aNode: NODE): void {
this.nodes.push(aNode);
}
HasErrors(): boolean {
return this.errors.HasErrors();
}
GetErrors(): readonly string[] {
return this.errors.GetErrors();
}
GetErrorSummary(): string {
return this.errors.GetAllMessages();
}
GetNodes(): readonly NODE[] {
return this.nodes;
}
}
/**
* `calc_parser::g_errorCollector`: where the grammar's `%syntax_error` and
* `%parse_failure` report. `thread_local` upstream; a worker is a thread here.
*/
export let g_errorCollector: ERROR_COLLECTOR | null = null;
export function SetErrorCollector(aCollector: ERROR_COLLECTOR | null): void {
g_errorCollector = aCollector;
}
// ---------------------------------------------------------------------------
// DATE_UTILS
const epochYear = 1970;
const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
const monthNames = [
'January',
'February',
'March',
'April',
'May',
'June',
'July',
'August',
'September',
'October',
'November',
'December',
];
const monthAbbrev = [
'Jan',
'Feb',
'Mar',
'Apr',
'May',
'Jun',
'Jul',
'Aug',
'Sep',
'Oct',
'Nov',
'Dec',
];
const weekdayNames = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
function isLeapYear(aYear: number): boolean {
return (aYear % 4 === 0 && aYear % 100 !== 0) || aYear % 400 === 0;
}
function daysInYear(aYear: number): number {
return isLeapYear(aYear) ? 366 : 365;
}
function daysInMonthForYear(aMonth: number, aYear: number): number {
if (aMonth === 2 && isLeapYear(aYear)) return 29;
// Out of range is undefined behaviour upstream (an unchecked std::array
// read, reachable only from an 8-digit date with a month above 12).
return daysInMonth[aMonth - 1] ?? 0;
}
/** `calc_parser::DATE_UTILS`. */
export const DATE_UTILS = {
DaysToYmd(aDaysSinceEpoch: number): [number, number, number] {
let year = epochYear;
let remainingDays = aDaysSinceEpoch;
if (remainingDays >= 0) {
while (remainingDays >= daysInYear(year)) {
remainingDays -= daysInYear(year);
year++;
}
} else {
while (remainingDays < 0) {
year--;
remainingDays += daysInYear(year);
}
}
let month = 1;
while (month <= 12 && remainingDays >= daysInMonthForYear(month, year)) {
remainingDays -= daysInMonthForYear(month, year);
month++;
}
const day = remainingDays + 1;
return [year, month, day];
},
YmdToDays(aYear: number, aMonth: number, aDay: number): number {
let totalDays = 0;
if (aYear >= epochYear) {
for (let y = epochYear; y < aYear; ++y) totalDays += daysInYear(y);
} else {
for (let y = aYear; y < epochYear; ++y) totalDays -= daysInYear(y);
}
for (let m = 1; m < aMonth; ++m) totalDays += daysInMonthForYear(m, aYear);
totalDays += aDay - 1;
return totalDays;
},
ParseDate(aDateStr: string): number | null {
let parts: number[] = [];
let separator = '';
let isCjkFormat = false;
// Check for CJK date formats first (Chinese, Korean, or mixed)
const hasChineseYear = aDateStr.includes('年');
const hasChineseMonth = aDateStr.includes('月');
const hasChineseDay = aDateStr.includes('日');
const hasKoreanYear = aDateStr.includes('년');
const hasKoreanMonth = aDateStr.includes('월');
const hasKoreanDay = aDateStr.includes('일');
if (
(hasChineseYear || hasKoreanYear) &&
(hasChineseMonth || hasKoreanMonth) &&
(hasChineseDay || hasKoreanDay)
) {
isCjkFormat = true;
const yearPos = hasChineseYear ? aDateStr.indexOf('年') : aDateStr.indexOf('년');
const monthPos = hasChineseMonth ? aDateStr.indexOf('月') : aDateStr.indexOf('월');
const dayPos = hasChineseDay ? aDateStr.indexOf('日') : aDateStr.indexOf('일');
// Upstream skips 3 UTF-8 bytes per marker; each is one UTF-16 unit here.
// A negative length is std::string::substr's npos-clamped "to the end".
const substr = (aPos: number, aLen: number) =>
aLen < 0 ? aDateStr.slice(aPos) : aDateStr.slice(aPos, aPos + aLen);
try {
const year = stoi(aDateStr.slice(0, yearPos));
const month = stoi(substr(yearPos + 1, monthPos - yearPos - 1));
const day = stoi(substr(monthPos + 1, dayPos - monthPos - 1));
parts = [year, month, day];
} catch {
return null;
}
} else if (aDateStr.includes('-')) separator = '-';
else if (aDateStr.includes('/')) separator = '/';
else if (aDateStr.includes('.')) separator = '.';
if (separator) {
// std::getline: no token after a trailing separator.
const tokens = aDateStr.split(separator);
if (tokens.length > 1 && tokens[tokens.length - 1] === '') tokens.pop();
for (const token of tokens) {
try {
parts.push(stoi(token));
} catch {
return null;
}
}
} else if (!isCjkFormat && utf8.encode(aDateStr).length === 8) {
// std::string::length() counts UTF-8 bytes: '2024年02月' is 12, not 8.
try {
const dateNum = stoi(aDateStr);
const year = Math.trunc(dateNum / 10000);
const month = Math.trunc(dateNum / 100) % 100;
const day = dateNum % 100;
return DATE_UTILS.YmdToDays(year, month, day);
} catch {
return null;
}
} else if (!isCjkFormat) {
return null;
}
if (parts.length === 0 || parts.length > 3) return null;
let year: number;
let month: number;
let day: number;
if (parts.length === 1) {
year = parts[0]!;
month = 1;
day = 1;
} else if (parts.length === 2) {
year = parts[0]!;
month = parts[1]!;
day = 1;
} else if (isCjkFormat) {
year = parts[0]!;
month = parts[1]!;
day = parts[2]!;
} else if (separator === '/' && parts[0]! <= 12 && parts[1]! <= 31) {
month = parts[0]!;
day = parts[1]!;
year = parts[2]!;
} else if (separator === '/' && parts[1]! <= 12) {
day = parts[0]!;
month = parts[1]!;
year = parts[2]!;
} else {
year = parts[0]!;
month = parts[1]!;
day = parts[2]!;
}
if (month < 1 || month > 12) return null;
if (day < 1 || day > daysInMonthForYear(month, year)) return null;
return DATE_UTILS.YmdToDays(year, month, day);
},
FormatDate(aDaysSinceEpoch: number, aFormat: string): string {
const [year, month, day] = DATE_UTILS.DaysToYmd(aDaysSinceEpoch);
if (aFormat === 'ISO' || aFormat === 'iso')
return `${padInt(year, 4)}-${padInt(month, 2)}-${padInt(day, 2)}`;
if (aFormat === 'US' || aFormat === 'us')
return `${padInt(month, 2)}/${padInt(day, 2)}/${padInt(year, 4)}`;
if (aFormat === 'EU' || aFormat === 'european')
return `${padInt(day, 2)}/${padInt(month, 2)}/${padInt(year, 4)}`;
if (aFormat === 'long') return `${monthNames[month - 1]} ${day}, ${year}`;
if (aFormat === 'short') return `${monthAbbrev[month - 1]} ${day}, ${year}`;
if (
aFormat === 'Chinese' ||
aFormat === 'chinese' ||
aFormat === 'CN' ||
aFormat === 'cn' ||
aFormat === '中文'
)
return `${year}年${padInt(month, 2)}月${padInt(day, 2)}日`;
if (
aFormat === 'Japanese' ||
aFormat === 'japanese' ||
aFormat === 'JP' ||
aFormat === 'jp' ||
aFormat === '日本語'
)
return `${year}年${padInt(month, 2)}月${padInt(day, 2)}日`;
if (
aFormat === 'Korean' ||
aFormat === 'korean' ||
aFormat === 'KR' ||
aFormat === 'kr' ||
aFormat === '한국어'
)
return `${year}년 ${padInt(month, 2)}월 ${padInt(day, 2)}일`;
return `${padInt(year, 4)}-${padInt(month, 2)}-${padInt(day, 2)}`;
},
GetWeekdayName(aDaysSinceEpoch: number): string {
let weekday = (aDaysSinceEpoch + 3) % 7; // +3 because epoch was Thursday (Monday = 0)
if (weekday < 0) weekday += 7;
return weekdayNames[weekday]!;
},
/** `time_t / ( 24 * 3600 )`: integer division of whole seconds. */
GetCurrentDays(): number {
return Math.trunc(Math.trunc(Date.now() / 1000) / (24 * 3600));
},
GetCurrentTimestamp(): number {
return Math.trunc(Date.now() / 1000);
},
/** `localtime_r`: the browser's local time zone is the machine's. */
FormatTime(aSecondsSinceEpoch: number, aFormat: string): string {
const tm = new Date(Math.trunc(aSecondsSinceEpoch) * 1000);
const hour = tm.getHours();
const min = tm.getMinutes();
const sec = tm.getSeconds();
if (aFormat === '24h' || aFormat === 'ISO' || aFormat === 'iso')
return `${padInt(hour, 2)}:${padInt(min, 2)}:${padInt(sec, 2)}`;
if (aFormat === '12h') {
const ampm = hour >= 12 ? 'PM' : 'AM';
let hour12 = hour % 12;
if (hour12 === 0) hour12 = 12;
return `${hour12}:${padInt(min, 2)}:${padInt(sec, 2)} ${ampm}`;
}
if (aFormat === 'HH_MM_SS' || aFormat === 'filename')
return `${padInt(hour, 2)}h${padInt(min, 2)}m${padInt(sec, 2)}s`;
if (aFormat === 'short') return `${padInt(hour, 2)}:${padInt(min, 2)}`;
return `${padInt(hour, 2)}:${padInt(min, 2)}:${padInt(sec, 2)}`;
},
};
// ---------------------------------------------------------------------------
// ESERIES_UTILS
// Data: KiCad's E24 and E192 tables, 100-999 decade.
const s_e24 = [
100, 110, 120, 130, 150, 160, 180, 200, 220, 240, 270, 300, 330, 360, 390, 430, 470, 510, 560,
620, 680, 750, 820, 910,
];
const s_e192 = [
100, 101, 102, 104, 105, 106, 107, 109, 110, 111, 113, 114, 115, 117, 118, 120, 121, 123, 124,
126, 127, 129, 130, 132, 133, 135, 137, 138, 140, 142, 143, 145, 147, 149, 150, 152, 154, 156,
158, 160, 162, 164, 165, 167, 169, 172, 174, 176, 178, 180, 182, 184, 187, 189, 191, 193, 196,
198, 200, 203, 205, 208, 210, 213, 215, 218, 221, 223, 226, 229, 232, 234, 237, 240, 243, 246,
249, 252, 255, 258, 261, 264, 267, 271, 274, 277, 280, 284, 287, 291, 294, 298, 301, 305, 309,
312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 357, 361, 365, 370, 374, 379, 383, 388,
392, 397, 402, 407, 412, 417, 422, 427, 432, 437, 442, 448, 453, 459, 464, 470, 475, 481, 487,
493, 499, 505, 511, 517, 523, 530, 536, 542, 549, 556, 562, 569, 576, 583, 590, 597, 604, 612,
619, 626, 634, 642, 649, 657, 665, 673, 681, 690, 698, 706, 715, 723, 732, 741, 750, 759, 768,
777, 787, 796, 806, 816, 825, 835, 845, 856, 866, 876, 887, 898, 909, 920, 931, 942, 953, 965,
976, 988,
];
function parseSeriesString(aSeries: string): number {
if (aSeries === 'E3' || aSeries === 'e3') return 3;
if (aSeries === 'E6' || aSeries === 'e6') return 6;
if (aSeries === 'E12' || aSeries === 'e12') return 12;
if (aSeries === 'E24' || aSeries === 'e24') return 24;
if (aSeries === 'E48' || aSeries === 'e48') return 48;
if (aSeries === 'E96' || aSeries === 'e96') return 96;
if (aSeries === 'E192' || aSeries === 'e192') return 192;
return -1; // Invalid series
}
function getSeriesValue(aSeries: number, aIndex: number): number {
// E1, E3, E6, E12, E24 are derived from E24
if (aSeries <= 24) return s_e24[aIndex * (24 / aSeries)]!;
// E48, E96, E192 are derived from E192
return s_e192[aIndex * (192 / aSeries)]!;
}
/** The value scaled into the 100-999 decade, and that decade. */
function normalise(aValue: number): { decade: number; normalized: number } {
const logValue = Math.log10(aValue);
const decade = Math.floor(logValue);
const scaledValue = aValue / std_pow(10.0, decade);
return { decade, normalized: scaledValue * 100.0 };
}
/** `calc_parser::ESERIES_UTILS`. */
export const ESERIES_UTILS = {
FindNearest(aValue: number, aSeries: string): number | null {
const series = parseSeriesString(aSeries);
if (series < 0) return null;
if (aValue <= 0.0) return null;
const { decade, normalized } = normalise(aValue);
let minDiff = Number.MAX_VALUE;
let nearest = 100;
for (let i = 0; i < series; ++i) {
const val = getSeriesValue(series, i);
const diff = Math.abs(normalized - val);
if (diff < minDiff) {
minDiff = diff;
nearest = val;
}
}
return (nearest / 100.0) * std_pow(10.0, decade);
},
FindUp(aValue: number, aSeries: string): number | null {
const series = parseSeriesString(aSeries);
if (series < 0) return null;
if (aValue <= 0.0) return null;
const { decade, normalized } = normalise(aValue);
for (let i = 0; i < series; ++i) {
const val = getSeriesValue(series, i);
if (val > normalized) return (val / 100.0) * std_pow(10.0, decade);
}
// Wrap to next decade
const firstVal = getSeriesValue(series, 0);
return (firstVal / 100.0) * std_pow(10.0, decade + 1);
},
FindDown(aValue: number, aSeries: string): number | null {
const series = parseSeriesString(aSeries);
if (series < 0) return null;
if (aValue <= 0.0) return null;
const { decade, normalized } = normalise(aValue);
for (let i = series - 1; i >= 0; --i) {
const val = getSeriesValue(series, i);
if (val < normalized) return (val / 100.0) * std_pow(10.0, decade);
}
// Wrap to previous decade
const lastVal = getSeriesValue(series, series - 1);
return (lastVal / 100.0) * std_pow(10.0, decade - 1);
},
};
// ---------------------------------------------------------------------------
// EVAL_VISITOR
/** `EVAL_VISITOR::VariableCallback`. */
export type VariableCallback = (aVariableName: string) => Result<Value>;
/** `fmt::format( "{:.{}f}", value, decimals )`: fmt throws on a negative precision. */
function fmtFixed(aValue: number, aDecimals: number): string {
if (aDecimals < 0) throw new Error('negative precision');
return fixed(aValue, aDecimals);
}
/** `std::toupper` / `std::tolower` under the C locale: ASCII only, byte by byte. */
function asciiUpper(aStr: string): string {
return aStr.replace(/[a-z]+/g, (m) => m.toUpperCase());
}
function asciiLower(aStr: string): string {
return aStr.replace(/[A-Z]+/g, (m) => m.toLowerCase());
}
/** `wxString::BeforeFirst`: the whole string when the character is absent. */
function beforeFirst(aStr: string, aCh: string): string {
const i = aStr.indexOf(aCh);
return i < 0 ? aStr : aStr.slice(0, i);
}
/** `wxString::BeforeLast`: empty when the character is absent. */
function beforeLast(aStr: string, aCh: string): string {
const i = aStr.lastIndexOf(aCh);
return i < 0 ? '' : aStr.slice(0, i);
}
/** `wxString::AfterFirst`: empty when the character is absent. */
function afterFirst(aStr: string, aCh: string): string {
const i = aStr.indexOf(aCh);
return i < 0 ? '' : aStr.slice(i + 1);
}
/** `wxString::AfterLast`: the whole string when the character is absent. */
function afterLast(aStr: string, aCh: string): string {
const i = aStr.lastIndexOf(aCh);
return i < 0 ? aStr : aStr.slice(i + 1);
}
/** `calc_parser::EVAL_VISITOR`. */
export class EVAL_VISITOR {
private readonly m_variableCallback: VariableCallback | null;
readonly m_errors: ERROR_COLLECTOR;
constructor(aVariableCallback: VariableCallback | null, aErrorCollector: ERROR_COLLECTOR) {
this.m_variableCallback = aVariableCallback;
this.m_errors = aErrorCollector;
}
/** `operator()( const NODE& )`. */
Visit(aNode: NODE): Result<Value> {
switch (aNode.type) {
case NodeType.Number:
return MakeValue<Value>(aNode.data as number);
case NodeType.String:
return MakeValue<Value>(aNode.data as string);
case NodeType.Var: {
const varName = aNode.data as string;
// Use callback to resolve variable
if (this.m_variableCallback) return this.m_variableCallback(varName);
return MakeError<Value>(`No variable resolver configured for: ${varName}`);
}
case NodeType.BinOp: {
const binop = aNode.data as BIN_OP_DATA;
const leftResult = binop.left.Accept(this);
if (!leftResult.HasValue()) return leftResult;
const rightResult = binop.right ? binop.right.Accept(this) : MakeValue<Value>(0.0);
if (!rightResult.HasValue()) return rightResult;
const leftVal = leftResult.GetValue();
const rightVal = rightResult.GetValue();
// Special handling for string concatenation with +
if (binop.op === '+') {
// If either operand is a string, concatenate
if (typeof leftVal === 'string' || typeof rightVal === 'string')
return MakeValue<Value>(VALUE_UTILS.ConcatStrings(leftVal, rightVal));
}
// Special handling for string comparisons with == and !=
if (binop.op === 3 || binop.op === 4) {
// If both operands are strings, do string comparison
if (typeof leftVal === 'string' && typeof rightVal === 'string') {
const equal = leftVal === rightVal;
const result = binop.op === 3 ? (equal ? 1.0 : 0.0) : equal ? 0.0 : 1.0;
return MakeValue<Value>(result);
}
}
// Otherwise, perform arithmetic
return VALUE_UTILS.ArithmeticOp(leftVal, rightVal, binop.op);
}
case NodeType.Function:
return this.evaluateFunction(aNode.data as FUNC_DATA);
default:
return MakeError<Value>('Cannot evaluate this node type');
}
}
private evaluateFunction(aFunc: FUNC_DATA): Result<Value> {
const name = aFunc.name;
const args = aFunc.args;
// Zero-argument functions
if (args.length === 0) {
if (name === 'today') return MakeValue<Value>(DATE_UTILS.GetCurrentDays());
if (name === 'now') return MakeValue<Value>(DATE_UTILS.GetCurrentTimestamp());
if (name === 'random') return MakeValue<Value>(Math.random());
}
// Evaluate arguments to mixed types
const argValues: Value[] = [];
for (const arg of args) {
const result = arg.Accept(this);
if (!result.HasValue()) return result;
argValues.push(result.GetValue());
}
const argc = argValues.length;
const toDouble = (aIndex: number) => VALUE_UTILS.ToDouble(argValues[aIndex]!);
const argString = (aIndex: number) => VALUE_UTILS.ToString(argValues[aIndex]!);
// String formatting functions (return strings!)
if ((name === 'format' || name === 'fixed') && argc >= 1) {
const numResult = toDouble(0);
if (!numResult.HasValue()) return MakeError<Value>(numResult.GetError());
let decimals = 2;
if (argc > 1) {
const decResult = toDouble(1);
if (decResult.HasValue()) decimals = toInt(decResult.GetValue());
}
return MakeValue<Value>(fmtFixed(numResult.GetValue(), decimals));
}
if (name === 'currency' && argc >= 1) {
const numResult = toDouble(0);
if (!numResult.HasValue()) return MakeError<Value>(numResult.GetError());
const symbol = argc > 1 ? argString(1) : '$';
return MakeValue<Value>(`${symbol}${fmtFixed(numResult.GetValue(), 2)}`);
}
// Date formatting functions (return strings!)
if (name === 'dateformat' && argc >= 1) {
const dateResult = toDouble(0);
if (!dateResult.HasValue()) return MakeError<Value>(dateResult.GetError());
const days = toInt(dateResult.GetValue());
const format = argc > 1 ? argString(1) : 'ISO';
return MakeValue<Value>(DATE_UTILS.FormatDate(days, format));
}
if (name === 'datestring' && argc === 1) {
const dateStr = argString(0);
const daysResult = DATE_UTILS.ParseDate(dateStr);
if (daysResult === null) return MakeError<Value>(`Invalid date format: ${dateStr}`);
return MakeValue<Value>(daysResult);
}
if (name === 'weekdayname' && argc === 1) {
const dateResult = toDouble(0);
if (!dateResult.HasValue()) return MakeError<Value>(dateResult.GetError());
return MakeValue<Value>(DATE_UTILS.GetWeekdayName(toInt(dateResult.GetValue())));
}
if (name === 'timeformat' && argc >= 1) {
const timeResult = toDouble(0);
if (!timeResult.HasValue()) return MakeError<Value>(timeResult.GetError());
const format = argc > 1 ? argString(1) : 'ISO';
return MakeValue<Value>(DATE_UTILS.FormatTime(timeResult.GetValue(), format));
}
// VCS functions (return strings!)
// Empty results from the VCS layer mean "not in a repository" or "no data available"
const vcsResult = (aResult: string) => (aResult === '' ? '<unknown>' : aResult);
/** An optional numeric flag argument, read only when it converts. */
const flagArg = (aIndex: number): boolean | null => {
const r = toDouble(aIndex);
return r.HasValue() ? r.GetValue() !== 0.0 : null;
};
if (name === 'vcsidentifier' && argc <= 1) {
let length = 40; // Full identifier by default
if (argc === 1) {
const lenResult = toDouble(0);
if (lenResult.HasValue()) length = toInt(lenResult.GetValue());
}
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitHash('.', length)));
}
if (name === 'vcsnearestlabel' && argc <= 2) {
const match = argc >= 1 ? argString(0) : '';
const anyTags = argc >= 2 ? (flagArg(1) ?? false) : false;
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetNearestTag(match, anyTags)));
}
if (name === 'vcslabeldistance' && argc <= 2) {
const match = argc >= 1 ? argString(0) : '';
const anyTags = argc >= 2 ? (flagArg(1) ?? false) : false;
return MakeValue<Value>(String(TEXT_EVAL_VCS.GetDistanceFromTag(match, anyTags)));
}
if (name === 'vcsdirty' && argc <= 1) {
const includeUntracked = argc === 1 ? (flagArg(0) ?? false) : false;
return MakeValue<Value>(TEXT_EVAL_VCS.IsDirty(includeUntracked) ? '1' : '0');
}
if (name === 'vcsdirtysuffix' && argc <= 2) {
const suffix = argc >= 1 ? argString(0) : '-dirty';
const includeUntracked = argc >= 2 ? (flagArg(1) ?? false) : false;
return MakeValue<Value>(TEXT_EVAL_VCS.IsDirty(includeUntracked) ? suffix : '');
}
if (name === 'vcsauthor' && argc === 0)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetAuthor('.')));
if (name === 'vcsauthoremail' && argc === 0)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetAuthorEmail('.')));
if (name === 'vcscommitter' && argc === 0)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitter('.')));
if (name === 'vcscommitteremail' && argc === 0)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitterEmail('.')));
if (name === 'vcsbranch' && argc === 0)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetBranch()));
if (name === 'vcscommitdate' && argc <= 1) {
const format = argc === 1 ? argString(0) : 'ISO';
const timestamp = TEXT_EVAL_VCS.GetCommitTimestamp('.');
if (timestamp === 0) return MakeValue<Value>(vcsResult(''));
return MakeValue<Value>(
DATE_UTILS.FormatDate(toInt(Math.trunc(timestamp / (24 * 3600))), format),
);
}
// VCS file functions (file-specific versions)
if (name === 'vcsfileidentifier' && argc >= 1 && argc <= 2) {
const filePath = argString(0);
let length = 40;
if (argc === 2) {
const lenResult = toDouble(1);
if (lenResult.HasValue()) length = toInt(lenResult.GetValue());
}
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitHash(filePath, length)));
}
if (name === 'vcsfileauthor' && argc === 1)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetAuthor(argString(0))));
if (name === 'vcsfileauthoremail' && argc === 1)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetAuthorEmail(argString(0))));
if (name === 'vcsfilecommitter' && argc === 1)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitter(argString(0))));
if (name === 'vcsfilecommitteremail' && argc === 1)
return MakeValue<Value>(vcsResult(TEXT_EVAL_VCS.GetCommitterEmail(argString(0))));
if (name === 'vcsfilecommitdate' && argc >= 1 && argc <= 2) {
const filePath = argString(0);
const format = argc === 2 ? argString(1) : 'ISO';
const timestamp = TEXT_EVAL_VCS.GetCommitTimestamp(filePath);
if (timestamp === 0) return MakeValue<Value>(vcsResult(''));
return MakeValue<Value>(
DATE_UTILS.FormatDate(toInt(Math.trunc(timestamp / (24 * 3600))), format),
);
}
// String functions (return strings!)
if (name === 'upper' && argc === 1) return MakeValue<Value>(asciiUpper(argString(0)));
if (name === 'lower' && argc === 1) return MakeValue<Value>(asciiLower(argString(0)));
if (name === 'concat' && argc >= 2) {
let result = '';
for (const val of argValues) result += VALUE_UTILS.ToString(val);
return MakeValue<Value>(result);
}
if (name === 'beforefirst' && argc === 2)
return MakeValue<Value>(beforeFirst(argString(0), VALUE_UTILS.ToChar(argValues[1]!)));
if (name === 'beforelast' && argc === 2)
return MakeValue<Value>(beforeLast(argString(0), VALUE_UTILS.ToChar(argValues[1]!)));
if (name === 'afterfirst' && argc === 2)
return MakeValue<Value>(afterFirst(argString(0), VALUE_UTILS.ToChar(argValues[1]!)));
if (name === 'afterlast' && argc === 2)
return MakeValue<Value>(afterLast(argString(0), VALUE_UTILS.ToChar(argValues[1]!)));
// Conditional functions (handle mixed types)
if (name === 'if' && argc === 3) {
// Convert only the condition to a number
const conditionResult = toDouble(0);
if (!conditionResult.HasValue()) return MakeError<Value>(conditionResult.GetError());
const condition = conditionResult.GetValue() !== 0.0;
return MakeValue<Value>(condition ? argValues[1]! : argValues[2]!);
}
// E-series functions (handle value as number, series as string)
if ((name === 'enearest' || name === 'eup' || name === 'edown') && argc >= 1 && argc <= 2) {
const valueResult = toDouble(0);
if (!valueResult.HasValue()) return MakeError<Value>(valueResult.GetError());
const value = valueResult.GetValue();
const series = argc > 1 ? argString(1) : 'E24';
let result: number | null = null;
if (name === 'enearest') result = ESERIES_UTILS.FindNearest(value, series);
else if (name === 'eup') result = ESERIES_UTILS.FindUp(value, series);
else if (name === 'edown') result = ESERIES_UTILS.FindDown(value, series);
if (result === null) return MakeError<Value>(`Invalid E-series: ${series}`);
return MakeValue<Value>(result);
}
// Mathematical functions (return numbers) - convert args to doubles first
const numArgs: number[] = [];
for (const val of argValues) {
const numResult = VALUE_UTILS.ToDouble(val);
if (!numResult.HasValue()) return MakeError<Value>(numResult.GetError());
numArgs.push(numResult.GetValue());
}
const sumOf = () => numArgs.reduce((a, b) => a + b, 0.0);
if (name === 'abs' && argc === 1) return MakeValue<Value>(Math.abs(numArgs[0]!));
if (name === 'sum' && argc >= 1) return MakeValue<Value>(sumOf());
if (name === 'round' && argc >= 1) {
const value = numArgs[0]!;
const precision = argc > 1 ? toInt(numArgs[1]!) : 0;
const multiplier = std_pow(10.0, precision);
return MakeValue<Value>(std_round(value * multiplier) / multiplier);
}
if (name === 'sqrt' && argc === 1) {
if (numArgs[0]! < 0) return MakeError<Value>('Square root of negative number');
return MakeValue<Value>(Math.sqrt(numArgs[0]!));
}
if (name === 'pow' && argc === 2) return MakeValue<Value>(std_pow(numArgs[0]!, numArgs[1]!));
if (name === 'floor' && argc === 1) return MakeValue<Value>(Math.floor(numArgs[0]!));
if (name === 'ceil' && argc === 1) return MakeValue<Value>(Math.ceil(numArgs[0]!));
// std::min_element / max_element: the first of equals, and NaN never compares.
if (name === 'min' && argc >= 1)
return MakeValue<Value>(numArgs.reduce((best, v) => (v < best ? v : best)));
if (name === 'max' && argc >= 1)
return MakeValue<Value>(numArgs.reduce((best, v) => (best < v ? v : best)));
if (name === 'avg' && argc >= 1) return MakeValue<Value>(sumOf() / argc);
if (name === 'shunt' && argc === 2) {
const r1 = numArgs[0]!;
const r2 = numArgs[1]!;
const sum = r1 + r2;
// Calculate parallel resistance: (r1*r2)/(r1+r2)
// If sum is not positive, return 0.0 (handles edge cases like shunt(0,0))
if (sum > 0.0) return MakeValue<Value>((r1 * r2) / sum);
return MakeValue<Value>(0.0);
}
if (name === 'db' && argc === 1) {
// Power ratio to dB: 10*log10(ratio)
if (numArgs[0]! <= 0.0) return MakeError<Value>('db() argument must be positive');
return MakeValue<Value>(10.0 * Math.log10(numArgs[0]!));
}
if (name === 'dbv' && argc === 1) {
// Voltage/current ratio to dB: 20*log10(ratio)
if (numArgs[0]! <= 0.0) return MakeError<Value>('dbv() argument must be positive');
return MakeValue<Value>(20.0 * Math.log10(numArgs[0]!));
}
// dB to power ratio: 10^(dB/10)
if (name === 'fromdb' && argc === 1) return MakeValue<Value>(std_pow(10.0, numArgs[0]! / 10.0));
// dB to voltage/current ratio: 10^(dB/20)
if (name === 'fromdbv' && argc === 1)
return MakeValue<Value>(std_pow(10.0, numArgs[0]! / 20.0));
return MakeError<Value>(`Unknown function: ${name} with ${argc} arguments`);
}
}
// ---------------------------------------------------------------------------
// DOC_PROCESSOR
/** `calc_parser::DOC_PROCESSOR`. */
export const DOC_PROCESSOR = {
/** Process document using callback for variable resolution: `[result, hadErrors]`. */
Process(aDoc: DOC, aVariableCallback: VariableCallback | null): [string, boolean] {
let result = '';
const localErrors = new ERROR_COLLECTOR();
const evaluator = new EVAL_VISITOR(aVariableCallback, localErrors);
let hadErrors = aDoc.HasErrors();
for (const node of aDoc.GetNodes()) {
switch (node.type) {
case NodeType.Text:
result += node.data as string;
break;
case NodeType.Calc: {
const calcData = node.data as BIN_OP_DATA;
const evalResult = calcData.left.Accept(evaluator);
if (evalResult.HasValue()) result += VALUE_UTILS.ToString(evalResult.GetValue());
else {
// Don't add error formatting to result - errors go to error vector only
// The higher level will return original input unchanged if there are errors
hadErrors = true;
}
break;
}
default:
result += '[Unknown node type]';
hadErrors = true;
break;
}
}
return [result, hadErrors || localErrors.HasErrors()];
},
/** Process document with detailed error reporting: `[result, errors, hadErrors]`. */
ProcessWithDetails(
aDoc: DOC,
aVariableCallback: VariableCallback | null,
): [string, readonly string[], boolean] {
const [result, hadErrors] = DOC_PROCESSOR.Process(aDoc, aVariableCallback);
return [result, aDoc.GetErrors(), hadErrors];
},
};