← 都来码 / Dolaima← 例程索引kotlin/demo/demo_std.kt 原文

kotlin/demo/demo_std.kt · 9837 字节 · 下载原文

// demo_std.kt —— **第 1 层:标准输入输出**(Kotlin 的 `print` / `println`)
// demo_std.kt — **Layer 1: standard input/output** (Kotlin's `print` / `println`)
//
// 这一层是每门语言自己的"往标准输出写文本"。
// This layer is each language's own way of "writing text to stdout".
//
// ## `+` 字符串拼接**已修好**(2026-10-04 复验)
// ## `+` string concatenation is **fixed** (re-verified 2026-10-04)
//
// ~~写之前先量过:Kotlin 前端的 `+` 字符串拼接不可用~~ —— 2026-09-24 那一版实测会打出一串数字,
// ~~Measured before writing: the Kotlin frontend's `+` could not concatenate strings~~ -- the 2026-09-24 build printed a run of digits,
// 根因是模板/拼接那段按 `$` 现拆、每一段发一条 `print_int`(2026-09-30 已修,见 `FRONTEND_DEFECTS.md` 的 Kotlin 一节)。
// because the template/concat path split on `$` and emitted one `print_int` per segment (fixed 2026-09-30; see the Kotlin section of `FRONTEND_DEFECTS.md`).
//
// 实测(2026-10-04,`vmlcli Examples/kotlin/demo_std.kt` 的最小探针):
// Measured (2026-10-04, minimal probes against `vmlcli`):
//     print("num=" + n + " str=" + s + "\n")   ⇒ num=7 str=hello    (之前是那串数字)
//     print("num=" + n + " str=" + s + "\n")   => num=7 str=hello    (was that run of digits)
//     println("n=$n")                           ⇒ n=7
//     println("t=${a + b}")                     ⇒ t=3
//     println("a" + "b")                        ⇒ ab
//
// 本 demo 仍按 `print(标签)` + `print(值)` 分开写 —— 那一直是好的,**能跑就别动;新写的代码不必再绕**。
// This demo still writes `print(label)` + `print(value)` separately — that was always fine; **leave working code alone; new code need not work around it**.
//
// ## 转义序列:`\uXXXX` 仍不认,`\n` / `\t` 都可以
// ## Escape sequences: `\uXXXX` is still unsupported; `\n` / `\t` both work
//
// `print("\u001b[31m")` 仍会原样打出 `u001b[31m`(2026-10-04 复验);而 ~~`\t` 同样不可靠~~ ——
// `print("\u001b[31m")` still prints `u001b[31m` literally (re-verified 2026-10-04); but ~~`\t` is just as unreliable~~ --
// 实测 `print("A\tB")` 打出的就是真正的 0x09 制表符(2026-10-04)。
// measured: `print("A\tB")` emits a real 0x09 tab (2026-10-04).
// 要发 ESC 仍只能 `putchar(27)`(见 `demo_tty.kt`)。本 demo 只用 `\n`。
// Emitting ESC still needs `putchar(27)` (see `demo_tty.kt`). This demo uses only `\n`.
//
// ## 判据
// ## Criteria
//
//     vmlcli Examples/kotlin/demo_std.kt
//
// 期望 stdout 逐字节等于文件末尾那段「期望输出」。
// Expects stdout to equal the "expected output" block at the end of the file, byte for byte.

// Kotlin 调库函数**不用声明**(对不认识的函数名发裸标签 CALL、实参右到左)——
// Kotlin library calls **need no declaration** (unknown function names become bare-label CALLs with arguments right-to-left) —
// 与 Java(必须 `static native`)/ Dart(必须 `external`)都不一样。
// Unlike Java (which requires `static native`) / Dart (which requires `external`).
// `println_str` / `println_int` 这些由 `Lib/shared/io.vml` 提供,
// `println_str` / `println_int` and the like are provided by `Lib/shared/io.vml`,
// 经 `builtins.vml`(`vmltool.config.xml` 的 `DefaultLibs`)进每一门语言的链接。
// They enter every language's link through `builtins.vml` (`DefaultLibs` in `vmltool.config.xml`).

// ── 显式引用:下面用到的 `ui_*` 来自共享库 vmlui.vml ──────────────────
// ── Explicit reference: the `ui_*` used below come from the shared library vmlui.vml ──
// ⚠ `.*` 必须有:`import vmlui`(无 `.*`)会被 `ExtractImports` 的正则**静默忽略**。
// ⚠ The `.*` is required: `import vmlui` (without `.*`) is silently ignored by `ExtractImports`.
// ⚠ 但整行删掉也照样编、照样跑 —— 前端靠 `ui_` 前缀**自动**链 `vmlui.vml`。
// ⚠ But deleting the whole line still compiles and runs — the frontend auto-links `vmlui.vml` from the `ui_` prefix.
// ⇒ 所以这条是**文档级**的显式声明,不是强制开关(判据见 `FRONTEND_DEFECTS.md` 的 Kotlin 一节)。
// ⇒ So this is a **documentation-level** explicit reference, not a hard switch (see the Kotlin section of `FRONTEND_DEFECTS.md`).
// ✅ 2026-10-04 复验仍成立:三种写法(`import vmlui` / `import vmlui.*` / 整行删掉)产出的指令数完全相同(59377 条)。
// ✅ Re-verified 2026-10-04, still holds: all three forms (`import vmlui` / `import vmlui.*` / line deleted) produce the identical instruction count (59377).
#include <vml_ui.kt>
import vmlui.*

fun main() {
    var a = 17
    var b = 25
    var i = 0
    var sum = 0

    // 界面语言:开局查一次(`ui_scr_get_language` 是 syscall,别每处都调)
    // UI language: queried once at start (`ui_scr_get_language` is a syscall, do not call it everywhere)
    var lang = ui_scr_get_language()

    // ⚠ 语言分支写成**单行 `if/else`** —— **C 风格三目 `cond ? a : b` 仍然不能用**
    // ⚠ Language branches are written as a **one-line `if/else`** -- the **C-style ternary `cond ? a : b` still cannot be used**
    //   (2026-10-04 复验:**实参位置**静默错编 —— 两个字符串都不进数据段、传下去的是条件 0/1,其余实参整体错位一格;
    //   (re-verified 2026-10-04: in **argument position** it silently miscompiles -- neither string reaches the data section, the condition 0/1 is passed and the remaining args shift by one;
    //    `print(...)` / 赋值位置则直接报 `Expected ')'`)。~~`?:` 也不支持~~ —— Kotlin 的 Elvis `?:` **已经能用**
    //    in `print(...)` / assignment position it errors `Expected ')'`). ~~`?:` is unsupported too~~ -- Kotlin's Elvis `?:` **works now**
    //   (实测 `ui_2d_text(0,0,u ?: "FALLBACK",…)` 正确渲染、`println(null ?: 7)` 得 7)。
    //   (measured: `ui_2d_text(0,0,u ?: "FALLBACK",…)` renders correctly, `println(null ?: 7)` gives 7).

    // ── 1. 字符串 ──
    // ── 1. Strings ──
    print("=== demo_std (Kotlin) ===\n")
    if (lang == 0) { print("纯字面量一行\n") } else { print("a plain literal, one line\n") }

    // ── 2. 标签 + 值 分开写(本来就好的写法;`+` 拼接 2026-10-04 复验也已修,见文件头)──
    // ── 2. Label + value written separately (always fine; `+` concatenation is fixed too, re-verified 2026-10-04 — see the header) ──
    print("a=");       println(a)
    print("b=");       println(b)
    print("a+b=");     println(a + b)
    print("a-b=");     println(a - b)
    print("a*b=");     println(a * b)
    print("a/b=");     println(a / b)
    print("a%b=");     println(a % b)
    if (lang == 0) { print("负数:") } else { print("Negative: ") };    println(0 - a)

    // ── 3. 进制与宽度(这里只演示值;格式化宽度在 Kotlin 侧没有等价物)──
    // ── 3. Number bases and widths (only values are demonstrated here; Kotlin has no equivalent of formatted width) ──
    if (lang == 0) { print("十进制=") } else { print("Decimal=") };   println(255)
    if (lang == 0) { print("十六进制=") } else { print("Hex=") }; println(255)

    // ── 4. 局部函数 + 递归 ──
    // ── 4. Local functions + recursion ──
    print("square(9)="); println(square(9))
    print("fib(10)=");   println(fib(10))

    // ── 5. 数组 + 循环 ──
    // ── 5. Arrays + loops ──
    //   ~~数组必须留在 main 里(`catch.kt` 记的实测:文件级 `arrayOf` 读回 0)~~ —— 2026-10-04 复验**已修**:
    //   ~~Arrays must stay inside main (the `catch.kt` measurement: a file-level `arrayOf` reads back 0)~~ -- **fixed**, re-verified 2026-10-04:
    //     文件级 `var A = arrayOf(0,1,2,3,4)` 的 `A[0]+A[3]` 得 **10**。本 demo 的状态与逻辑仍在 main 内(能跑就别动)。
    //     a file-level `var A = arrayOf(0,1,2,3,4)` gives `A[0]+A[3]` = **10**. This demo's state and logic still live inside main (leave working code alone).
    var v = arrayOf(1, 4, 9, 16, 25, 36)
    while (i < 6) {
        sum = sum + v[i]
        i = i + 1
    }
    print("1^2+...+6^2 = "); println(sum)

    // ── 6. 九九表的一小段 ──
    // ── 6. A small slice of the multiplication table ──
    i = 1
    while (i <= 5) {
        print(i)
        print(" x 7 = ")
        println(i * 7)
        i = i + 1
    }

    if (lang == 0) { print("=== 完成 ===\n") } else { print("=== done ===\n") }
}

// 纯函数可以抽出去(不碰任何数组/全局状态)
// Pure functions can be pulled out (they touch no arrays/global state)
fun square(v: Int): Int {
    return v * v
}

fun fib(n: Int): Int {
    if (n < 2) {
        return n
    }
    return fib(n - 1) + fib(n - 2)
}

// ── 期望输出(逐字节)────────────────────────────────────────────
// === demo_std (Kotlin) ===
// 纯字面量一行
// A plain literal, one line
// a=17
// b=25
// a+b=42
// a-b=-8
// a*b=425
// a/b=0
// a%b=17
// 负数:-17
// Negative: -17
// 十进制=255
// Decimal=255
// 十六进制=255
// square(9)=81
// fib(10)=55
// 1^2+...+6^2 = 91
// 1 x 7 = 7
// 2 x 7 = 14
// 3 x 7 = 21
// 4 x 7 = 28
// 5 x 7 = 35
// === 完成 ===
// === done ===
// ────────────────────────────────────────────────────────────────