@mirascript/mirascript 0.1.43 → 0.1.45

package/src/compiler/emit/index.ts

@@ -5,7 +5,7 @@ import type { ScriptInput, TranspileOptions } from '../types.js';
 import type { IRange } from '../diagnostic.js';
 import { readConsts, toJsLiteral } from './consts.js';
 import { createSourceMap } from './sourcemap.js';
-import { SCRIPT_PREFIX } from './constants.js';
+import { SCRIPT_PREFIX, SCRIPT_PREFIX_NO_GLOBAL, type ScriptPrefix } from './constants.js';
 
 /** 生成代码 */
 export function emit(
@@ -77,6 +77,8 @@ export class Emitter {
         return '  '.repeat(this.identCounter + len);
     }
 
+    /** 是否使用全局变量 */
+    private useGlobal = false;
     /** 读取全局变量 */
     private rg(constIdx: number): string {
         const constName = this.constVals[constIdx]!;
@@ -86,6 +88,7 @@ export class Emitter {
         } else {
             lit = toJsLiteral(toString(constName, undefined));
         }
+        this.useGlobal = true;
         return `global.get(${lit})`;
     }
 
@@ -182,6 +185,45 @@ export class Emitter {
         return this.readBlockEnd(OpCode.IfEnd);
     }
 
+    /** 读取 module */
+    private readModule(obj: number): void {
+        this.identCounter++;
+        while (this.codeOffset < this.codeSize) {
+            const opcode_raw = this.codeReader.getUint8(this.codeOffset++);
+            const opcode = opcode_raw & 0x7f;
+            const wide = opcode_raw >= 0x80;
+            const read = () => this.readParam(wide);
+            let code = '';
+            switch (opcode) {
+                case OpCode.Field: {
+                    const field = read();
+                    const field_name = this.constLits[field];
+                    /* c8 ignore next 3 */
+                    if (!field_name) {
+                        throw new Error(`Unknown field ${field}`);
+                    }
+                    const value = read();
+                    code = `[${field_name}]: () => $Upvalue(${this.rv(value)}),`;
+                    break;
+                }
+                case OpCode.Freeze: {
+                    this.identCounter--;
+                    code = `});`;
+                    break;
+                }
+                default: {
+                    code = `// ?${OpCode[opcode] ?? opcode}`;
+                    break;
+                }
+            }
+            const ident = this.ident();
+            this.codeLines.push(ident + code);
+            if (opcode === OpCode.Freeze) {
+                return;
+            }
+        }
+    }
+
     /** 读取 record */
     private readRecord(obj: number): void {
         this.identCounter++;
@@ -337,7 +379,7 @@ export class Emitter {
                 }
                 const script = startFunc && !varg && argn === 0;
                 if (script) {
-                    code = `${SCRIPT_PREFIX} var ${regs};`;
+                    code = `var ${regs};`;
                 } else {
                     if (this.options.sourceMap) {
                         this.functions.push(this.codeLines.length);
@@ -401,6 +443,7 @@ export class Emitter {
             case OpCode.InGlobal: {
                 reg = read();
                 const left = read();
+                this.useGlobal = true;
                 code = `${this.wv(reg)} = global.has($ToString(${this.rv(left)}));`;
                 break;
             }
@@ -540,6 +583,7 @@ export class Emitter {
             case OpCode.GetGlobalDyn: {
                 reg = read();
                 const name = read();
+                this.useGlobal = true;
                 code = `${this.wv(reg)} = global.get($ToString(${this.rv(name)}));`;
                 break;
             }
@@ -595,6 +639,13 @@ export class Emitter {
                 code = `${this.wv(reg)} = $SliceExclusive(${this.rv(obj)}, ${this.rv(start)}, ${this.rv(end)});`;
                 break;
             }
+            case OpCode.Module: {
+                reg = read();
+                const nameIdx = read();
+                const name = this.constLits[nameIdx];
+                code = `${this.wv(reg)} = $Module(${name}, {`;
+                break;
+            }
             case OpCode.Record: {
                 reg = read();
                 code = `${this.wv(reg)} = ({`;
@@ -704,6 +755,10 @@ export class Emitter {
                 this.readBlockEnd(OpCode.LoopEnd);
                 break;
             }
+            case OpCode.Module: {
+                this.readModule(reg);
+                break;
+            }
             case OpCode.Record: {
                 this.readRecord(reg);
                 break;
@@ -719,12 +774,14 @@ export class Emitter {
     read(): void {
         this.readConsts();
         this.readCode();
-        this.addSourceMap();
+        const prefix: ScriptPrefix = this.useGlobal ? SCRIPT_PREFIX : SCRIPT_PREFIX_NO_GLOBAL;
+        this.codeLines[0] = `${prefix} ${this.codeLines[0]}`;
+        this.addSourceMap(prefix);
     }
     /** 添加源映射 */
-    addSourceMap(): void {
+    addSourceMap(prefix: ScriptPrefix): void {
         if (this.options.sourceMap) {
-            createSourceMap(this.source, this.sourcemaps, this.codeLines, this.functions, this.options);
+            createSourceMap(this.source, prefix, this.sourcemaps, this.codeLines, this.functions, this.options);
         }
     }
 }

package/src/compiler/emit/sourcemap.ts

@@ -1,7 +1,7 @@
+import { SourceMapGenerator } from 'source-map-js';
 import type { IRange } from '../diagnostic.js';
 import type { ScriptInput, TranspileOptions } from '../types.js';
-import { SourceMapGenerator } from 'source-map-js';
-import { SCRIPT_PREFIX } from './constants.js';
+import type { ScriptPrefix } from './constants.js';
 import { toJsLiteral } from './consts.js';
 
 const ORIGIN = `mira://MiraScript/`;
@@ -38,6 +38,7 @@ let sourceId = 1;
 /** 创建源映射 */
 export function createSourceMap(
     source: ScriptInput | undefined,
+    scriptPrefix: ScriptPrefix,
     sourcemaps: readonly IRange[],
     codeLines: string[],
     functions: readonly number[],
@@ -82,7 +83,7 @@ export function createSourceMap(
         map.addMapping({
             generated: {
                 line: SOURCE_OFFSET,
-                column: SCRIPT_PREFIX.length - 'CpEnter();'.length,
+                column: scriptPrefix.length - 'CpEnter();'.length,
             },
             original: {
                 line: 1,

package/src/vm/lib/global/debug.ts

@@ -62,18 +62,24 @@ function buildFormatString(
     }
 }
 
-/** 默认的格式化函数 */
-const printFormatter: PrintOptions['formatter'] = function (args) {
+/** 默认解析函数 */
+const printParser: PrintOptions['parser'] = function (args) {
     const [format, values] = buildFormatString(this, args);
     const templates: string[] = [];
     const formats: SerializeFormat[] = [];
     let valIndex = 0;
     if (format.includes('%')) {
         const parts = format.split(/(%[%\w])/g);
+        let prevIsTemplate = true;
         for (let i = 0; i < parts.length; i++) {
             if (i % 2 === 0) {
                 // Regular string part
-                templates.push(parts[i]!);
+                if (prevIsTemplate && templates.length) {
+                    templates[templates.length - 1] += parts[i]!;
+                } else {
+                    templates.push(parts[i]!);
+                }
+                prevIsTemplate = true;
                 continue;
             }
             // Specifier part
@@ -85,8 +91,10 @@ const printFormatter: PrintOptions['formatter'] = function (args) {
                 } else {
                     templates[templates.length - 1] += specifier;
                 }
+                prevIsTemplate = true;
                 continue;
             }
+            prevIsTemplate = false;
             formats.push(specifier as SerializeFormat);
             valIndex++;
         }
@@ -113,69 +121,82 @@ const printFormatter: PrintOptions['formatter'] = function (args) {
     };
 };
 
-/** 默认的输出函数 */
-const createPrinter = (consoleMethod: (...args: unknown[]) => void): PrintOptions['printer'] => {
-    return function ({ templates, formats, values }: FormatResult) {
-        let format = '';
-        const formattedValues: unknown[] = [];
-        let needAwait = false;
-        for (let i = 0; i < templates.length; i++) {
-            format += templates[i]!;
-            if (i < values.length) {
-                const f = formats[i] ?? '';
-                const v = values[i]!;
-                const serialized = serializeValue(this, v, f);
-                if (serialized == null) {
-                    format += f || (typeof v == 'string' ? '%s' : '%o');
-                    formattedValues.push(v);
-                } else if (typeof serialized == 'string') {
-                    format += '%s';
-                    formattedValues.push(serialized);
-                } else {
-                    needAwait = true;
-                    format += '%s';
-                    formattedValues.push(serialized);
-                }
+/** 默认格式化函数 */
+const printFormatter: PrintOptions['formatter'] = function ({
+    templates,
+    formats,
+    values,
+}): unknown[] | PromiseLike<unknown[]> {
+    let format = '';
+    const formattedValues: unknown[] = [];
+    let needAwait = false;
+    for (let i = 0; i < templates.length; i++) {
+        format += templates[i]!.replaceAll('%', '%%');
+        if (i < values.length) {
+            const f = formats[i] ?? '';
+            const v = values[i]!;
+            const serialized = serializeValue(this, v, f);
+            if (serialized == null) {
+                format += f || (typeof v == 'string' ? '%s' : '%o');
+                formattedValues.push(v);
+            } else if (typeof serialized == 'string') {
+                format += '%s';
+                formattedValues.push(serialized);
+            } else {
+                needAwait = true;
+                format += '%s';
+                formattedValues.push(serialized);
             }
         }
-        if (!needAwait) {
-            consoleMethod(format, ...formattedValues);
-        } else {
-            void Promise.all(formattedValues).then((resolvedValues) => {
-                consoleMethod(format, ...resolvedValues);
-            });
-        }
+    }
+    if (!needAwait) {
+        return [format, ...formattedValues];
+    } else {
+        return Promise.all(formattedValues).then((resolvedValues) => {
+            return [format, ...resolvedValues];
+        });
+    }
+};
+
+/** 默认的输出选项 */
+const createPrintOptions = (consoleMethod: (...args: unknown[]) => void): PrintOptions => {
+    return {
+        prefix: ['MiraScript'],
+        serializer: defaultSerializer,
+        parser: printParser,
+        formatter: printFormatter,
+        logger: consoleMethod,
     };
 };
 
 /** 打印输出选项 */
-interface PrintOptions {
+type PrintOptions = {
     /** 输出时的固定前缀 */
-    prefix: readonly [prefix: string, ...additional: readonly string[]];
+    prefix: readonly [prefix?: string, ...additional: readonly string[]];
     /**
      * 序列化函数
      * @param arg 要序列化的值
      * @param format 序列化格式
-     * @returns 序列化后的字符串，或 null 表示直接将原值传递给控制台
+     * @returns 序列化后的字符串，或 null 表示直接将原值传递给 {@link printer}
      */
     serializer: (this: PrintOptions, arg: VmAny, format: SerializeFormat) => string | null | PromiseLike<string>;
-    /** 格式化函数 */
-    formatter: (this: PrintOptions, args: readonly VmAny[]) => FormatResult;
-    /** 输出函数 */
-    printer: (this: PrintOptions, format: FormatResult) => void;
-}
-
-const printOptions: PrintOptions = {
-    prefix: ['MiraScript'] as readonly [prefix: string, ...additional: readonly string[]],
-    serializer: defaultSerializer,
-    formatter: printFormatter,
-    printer: () => undefined,
+    /** 解析函数，解析输入并使用 {@link serializer} 序列化值，供 {@link formatter} 使用 */
+    parser: (this: PrintOptions, args: readonly VmAny[]) => FormatResult;
+    /** 格式化函数，进一步处理解析结果，供 {@link logger} 使用 */
+    formatter: (this: PrintOptions, format: FormatResult) => unknown[] | PromiseLike<unknown[]>;
+    /** 打印函数，打印格式化结果 */
+    logger: (this: PrintOptions, ...args: unknown[]) => void;
 };
 
+/** 进行输出 */
+function doPrint(opt: PrintOptions, args: readonly VmAny[]): void {
+    const formatResult = opt.parser(args);
+    void Promise.resolve(opt.formatter(formatResult)).then((printed) => opt.logger(...printed));
+}
+
 export const debug_print = VmLib(
     (...args) => {
-        const formatResult = debug_print.formatter(args);
-        debug_print.printer(formatResult);
+        doPrint(debug_print, args);
     },
     {
         summary: '打印调试信息到控制台',
@@ -184,17 +205,13 @@ export const debug_print = VmLib(
         returnsType: 'nil',
         examples: ['debug_print("value:", 42);'],
     },
-    {
-        ...printOptions,
-        // eslint-disable-next-line no-console
-        printer: createPrinter(console.log),
-    },
+    // eslint-disable-next-line no-console
+    createPrintOptions(console.log.bind(console)),
 );
 
 export const panic = VmLib(
     (message: VmAny) => {
-        const formatResult = message === undefined ? panic.formatter([]) : panic.formatter([message]);
-        panic.printer(formatResult);
+        doPrint(panic, message === undefined ? [] : [message]);
         const mgsStr = toString(message, null);
         const error = !mgsStr ? 'panic' : 'panic: ' + mgsStr;
         throw new VmError(error, undefined);
@@ -206,11 +223,8 @@ export const panic = VmLib(
         returnsType: 'never',
         examples: ['panic("boom");'],
     },
-    {
-        ...printOptions,
-        // eslint-disable-next-line no-console
-        printer: createPrinter(console.error),
-    },
+    // eslint-disable-next-line no-console
+    createPrintOptions(console.error.bind(console)),
 );
 
 if (typeof location != 'undefined') {

package/src/vm/lib/global/index.ts

@@ -1,4 +1,4 @@
-export * from './math.js';
+export * from './math/index.js';
 export * from './bit.js';
 export * from './sequence/index.js';
 export * from './debug.js';

package/src/vm/lib/global/{math-arr.ts → math/arr.ts}

@@ -1,5 +1,5 @@
-import type { VmAny } from '../../types/index.js';
-import { getNumbers, VmLib } from '../helpers.js';
+import type { VmAny } from '../../../types/index.js';
+import { getNumbers, VmLib } from '../../helpers.js';
 
 /** 生成函数 */
 function build(f: (...values: readonly number[]) => number): (...values: readonly VmAny[]) => number {

package/src/vm/lib/global/{math-const.ts → math/const.ts}

@@ -1,5 +1,5 @@
 import { DiagnosticCode } from '@mirascript/constants';
-import { VmLib } from '../helpers.js';
+import { VmLib } from '../../helpers.js';
 
 export const PI = VmLib(Math.PI, {
     summary: '圆周率',

package/src/vm/lib/global/math/gamma.ts

@@ -0,0 +1,245 @@
+/* eslint-disable no-loss-of-precision */
+
+import { NotNumber, PositiveInfinity, isNaN } from '../../../../helpers/utils.js';
+import { expectNumber, VmLib } from '../../helpers.js';
+const { PI, exp, floor, cos, sin, pow, trunc } = Math;
+
+const MEM = new DataView(new ArrayBuffer(8));
+/**
+ * Reinterpret the bits of a 64-bit float as a BigInt (unsigned 64-bit integer).
+ * This mirrors Rust's `f64::to_bits()`.
+ */
+function f64ToBits(value: number): bigint {
+    MEM.setFloat64(0, value, false);
+    return MEM.getBigUint64(0, false);
+}
+
+/**
+ * Reinterpret a BigInt (unsigned 64-bit integer) as a 64-bit float.
+ * This mirrors Rust's `f64::from_bits()`.
+ */
+function f64FromBits(bits: bigint): number {
+    MEM.setBigUint64(0, bits, false);
+    return MEM.getFloat64(0, false);
+}
+
+// From https://crates.io/crates/libm
+
+/*
+"A Precision Approximation of the Gamma Function" - Cornelius Lanczos (1964)
+"Lanczos Implementation of the Gamma Function" - Paul Godfrey (2001)
+"An Analysis of the Lanczos Gamma Approximation" - Glendon Ralph Pugh (2004)
+
+approximation method:
+
+                        (x - 0.5)         S(x)
+Gamma(x) = (x + g - 0.5)         *  ----------------
+                                    exp(x + g - 0.5)
+
+with
+                 a1      a2      a3            aN
+S(x) ~= [ a0 + ----- + ----- + ----- + ... + ----- ]
+               x + 1   x + 2   x + 3         x + N
+
+with a0, a1, a2, a3,.. aN constants which depend on g.
+for x < 0 the following reflection formula is used:
+
+Gamma(x)*Gamma(-x) = -pi/(x sin(pi x))
+
+most ideas and constants are from boost and python
+*/
+
+/**
+ * sin(pi * x) with x > 0, if sin(pi*x)==0 the sign is arbitrary.
+ */
+function sinpi(x: number): number {
+    /* argument reduction: x = |x| mod 2 */
+    /* spurious inexact when x is odd int */
+    x = x * 0.5;
+    x = 2 * (x - floor(x));
+
+    /* reduce x into [-.25,.25] */
+    let n = trunc(4 * x); // truncate to integer
+    n = trunc((n + 1) / 2); // integer division
+    x -= n * 0.5;
+
+    x *= PI;
+
+    switch (n) {
+        case 1:
+            return cos(x);
+        case 2:
+            return sin(-x);
+        case 3:
+            return -cos(x);
+        default:
+            // 0
+            return sin(x);
+    }
+}
+
+const N = 12;
+
+// static const double g = 6.024680040776729583740234375;
+const GMHALF = 5.524_680_040_776_729_583_740_234_375 as const;
+
+const SNUM = [
+    23_531_376_880.410_759_688_572_007_674_451_636_754_734_846_804_94,
+    42_919_803_642.649_098_768_957_899_047_001_988_850_926_355_848_959,
+    35_711_959_237.355_668_049_440_185_451_547_166_705_960_488_635_843,
+    17_921_034_426.037_209_699_919_755_754_458_931_112_671_403_265_39,
+    6_039_542_586.352_028_005_064_291_644_307_297_921_069_938_842_070_8,
+    1_439_720_407.311_721_673_663_223_072_794_912_393_971_548_578_677_2,
+    248_874_557.862_054_156_511_460_386_413_229_423_216_321_251_278_01,
+    31_426_415.585_400_194_380_614_231_628_318_205_362_874_684_987_64,
+    2_876_370.628_935_372_441_225_409_051_620_849_613_599_114_537_876_8,
+    186_056.265_395_223_495_040_294_989_716_045_699_282_207_842_363_28,
+    8071.672_002_365_816_210_638_002_902_272_250_613_821_851_632_502_4,
+    210.824_277_751_579_345_872_509_733_920_713_362_711_669_695_802_91,
+    2.506_628_274_631_000_270_164_908_177_133_837_338_626_431_079_340_8,
+] as const;
+
+const SDEN = [
+    0, 39_916_800, 120_543_840, 150_917_976, 105_258_076, 45_995_730, 13_339_535, 2_637_558, 357_423, 32670, 1925, 66,
+    1,
+] as const;
+
+/**
+ * S(x) rational function for positive x.
+ */
+function s(x: number): number {
+    let num = 0;
+    let den = 0;
+
+    /* to avoid overflow handle large x differently */
+    if (x < 8) {
+        for (let i = N; i >= 0; i--) {
+            num = num * x + SNUM[i]!;
+            den = den * x + SDEN[i]!;
+        }
+    } else {
+        for (let i = 0; i <= N; i++) {
+            num = num / x + SNUM[i]!;
+            den = den / x + SDEN[i]!;
+        }
+    }
+
+    return num / den;
+}
+
+/**
+ * The [Gamma function](https://en.wikipedia.org/wiki/Gamma_function) (f64).
+ */
+function tgamma(x: number): number {
+    const u = f64ToBits(x);
+    const ix = Number((u >> 32n) & 0x7fff_ffffn);
+    const sign = u >> 63n !== 0n;
+
+    /* special cases */
+    if (ix >= 0x7ff0_0000) {
+        /* tgamma(nan)=nan, tgamma(inf)=inf, tgamma(-inf)=nan with invalid */
+        return x + PositiveInfinity;
+    }
+
+    if (ix < (0x3ff - 54) << 20) {
+        /* |x| < 2^-54: tgamma(x) ~ 1/x, +-0 raises div-by-zero */
+        return 1 / x;
+    }
+
+    /* integer arguments */
+    /* raise inexact when non-integer */
+    if (x === floor(x)) {
+        if (sign) {
+            return NotNumber;
+        }
+        if (x <= FACT_MAX) {
+            return fact(trunc(x) - 1);
+        }
+    }
+
+    /* x >= 172: tgamma(x)=inf with overflow */
+    /* x =< -184: tgamma(x)=+-0 with underflow */
+    if (ix >= 0x4067_0000) {
+        /* |x| >= 184 */
+        if (sign) {
+            if (floor(x) * 0.5 === floor(x * 0.5)) {
+                return 0;
+            } else {
+                return -0;
+            }
+        }
+        const x1p1023 = f64FromBits(0x7fe0_0000_0000_0000n); // 2^1023
+        return x * x1p1023; // overflow to Infinity
+    }
+
+    const absx = sign ? -x : x;
+
+    /* handle the error of x + g - 0.5 */
+    const y = absx + GMHALF;
+    let dy: number;
+    if (absx > GMHALF) {
+        dy = y - absx;
+        dy -= GMHALF;
+    } else {
+        dy = y - GMHALF;
+        dy -= absx;
+    }
+
+    let z = absx - 0.5;
+    let r = s(absx) * exp(-y);
+
+    if (x < 0) {
+        /* reflection formula for negative x */
+        /* sinpi(absx) is not 0, integers are already handled */
+        r = -PI / (sinpi(absx) * absx * r);
+        dy = -dy;
+        z = -z;
+    }
+
+    r += (dy * (GMHALF + 0.5) * r) / y;
+    const zHalf = pow(y, 0.5 * z);
+    return r * zHalf * zHalf;
+}
+
+export const gamma = VmLib(
+    (x) => {
+        const n = expectNumber('x', x);
+        return tgamma(n);
+    },
+    {
+        summary: '返回 Gamma 函数的值',
+        params: { x: '要计算 Gamma 函数的数值' },
+        paramsType: { x: 'number' },
+        returnsType: 'number',
+        examples: ['gamma(5) // 24'],
+    },
+);
+
+const FACT_MAX = 171;
+const FACT: Array<number | undefined> = [1, 1];
+/** 计算整数的阶乘 */
+function fact(n: number): number {
+    const cached = FACT[n];
+    if (cached != null) return cached;
+    let r = 1n;
+    for (let i = 2; i <= n; i++) {
+        r *= BigInt(i);
+        FACT[i] = Number(r);
+    }
+    return FACT[n]!;
+}
+
+export const factorial = VmLib(
+    (x): number => {
+        const n = expectNumber('x', x);
+        if (isNaN(n) || n < 0) return NotNumber;
+        return tgamma(n + 1);
+    },
+    {
+        summary: '返回一个数的阶乘',
+        params: { x: '要计算阶乘的数值' },
+        paramsType: { x: 'number' },
+        returnsType: 'number',
+        examples: ['factorial(5) // 120'],
+    },
+);

package/src/vm/lib/global/{math.ts → math/index.ts}

@@ -1,4 +1,4 @@
-import { expectNumber, VmLib } from '../helpers.js';
+import { expectNumber, VmLib } from '../../helpers.js';
 const { atan2: _atan2, pow: _pow, random: _random } = Math;
 
 export const atan2 = VmLib((x, y) => _atan2(expectNumber(0, x), expectNumber(1, y)), {
@@ -20,7 +20,7 @@ export const random = VmLib(() => _random(), {
     returnsType: 'number',
 });
 
-export * from './math-arr.js';
-export * from './math-const.js';
-export * from './math-unary.js';
-export * from './math-additional.js';
+export * from './arr.js';
+export * from './const.js';
+export * from './unary.js';
+export { gamma, factorial } from './gamma.js';

package/src/vm/lib/global/{math-unary.ts → math/unary.ts}

@@ -1,5 +1,5 @@
-import type { VmAny } from '../../index.js';
-import { expectNumber, VmLib } from '../helpers.js';
+import type { VmAny } from '../../../index.js';
+import { expectNumber, VmLib } from '../../helpers.js';
 
 /** 生成函数 */
 function build(f: (x: number) => number): (x: VmAny) => number {

package/src/vm/lib/global/string.ts

@@ -2,7 +2,7 @@ import { expectArray, expectString, VmLib } from '../helpers.js';
 
 export const chars = VmLib(
     (str) => {
-        return [...expectString('str', str)];
+        return Array.from(expectString('str', str));
     },
     {
         summary: '将字符串转换为字符数组',