Go 获取终端尺寸的实用方法

Go 中获取终端尺寸的挑战

在 C 语言中，获取终端的行数和列数通常通过调用 ioctl 函数，并结合 TIOCGWINSZ 命令来实现。例如：

#include 
#include 

struct ttysize {
    unsigned short ts_lines;
    unsigned short ts_cols;
    unsigned short ts_xpixel;
    unsigned short ts_ypixel;
};

int main() {
    struct ttysize ts;
    if (ioctl(0, TIOCGWINSZ, &ts) == 0) {
        printf("Terminal size: %d rows, %d columns\n", ts.ts_lines, ts.ts_cols);
    } else {
        perror("ioctl");
    }
    return 0;
}

然而，当尝试在 Go 语言中使用 cgo 调用类似的 C 函数时，会遇到两个主要挑战：

1. 宏定义 (TIOCGWINSZ)： TIOCGWINSZ 通常是一个预处理器宏，cgo 无法直接解析 C 头文件中定义的宏。
2. 变参函数 (ioctl)： ioctl 函数的第三个参数是可变的，其类型取决于第二个参数（命令）。cgo 目前不支持直接调用 C 语言的变参函数。

因此，直接通过 #include 并调用 C.ioctl 的方式在 Go 中是不可行的。

解决方案：绕过 cgo 的限制

为了解决上述问题，我们需要采取两种策略：

1. 处理宏定义：替换为常量值

TIOCGWINSZ 宏实际上是一个特定的无符号长整型值。在许多 Unix-like 系统（包括 Linux 和 macOS）上，TIOCGWINSZ 的值通常是 0x5413。我们可以将这个值作为常量直接在 Go 代码中定义，而不是依赖于 C 头文件中的宏。

// #include 
// typedef struct ttysize ttysize; // 假设系统定义了ttysize，或需要自己定义
import "C"

const TIOCGWINSZ C.ulong = 0x5413 // TIOCGWINSZ 的常量值

请注意，ttysize 结构体需要与系统定义的保持一致。在现代 Linux 系统中，更常见的是 struct winsize，其定义如下：

struct winsize {
    unsigned short ws_row;    /* rows, in characters */
    unsigned short ws_col;    /* columns, in characters */
    unsigned short ws_xpixel; /* horizontal size, in pixels */
    unsigned short ws_ypixel; /* vertical size, in pixels */
};

如果您的系统使用 winsize，则应在 cgo 注释中定义 typedef struct winsize ttysize; 并相应地使用 C.winsize。为了与原始问题保持一致，本文仍使用 ttysize。

2. 封装变参函数：创建 C 辅助函数

由于 cgo 无法直接处理 ioctl 的变参特性，我们需要在 cgo 的 C 代码块中定义一个固定参数的辅助函数，由这个辅助函数来调用 ioctl。

// #include 
// typedef struct ttysize ttysize;
// void myioctl(int i, unsigned long l, ttysize * t){ioctl(i,l,t);} // 封装 ioctl
import "C"

// ... (Go code)

在这个例子中，myioctl 是一个简单的 C 函数，它接收三个明确类型的参数，然后内部调用真正的 ioctl。Go 代码将调用 C.myioctl，从而避免了 cgo 对变参函数的限制。

完整示例代码

结合上述两点，以下是在 Go 中获取终端尺寸的完整实现：

package main

import (
    "fmt"
    "os"
    "syscall"
)

/*
#include 

// 定义 ttysize 结构体，与系统保持一致
// 注意：在现代 Linux 系统中，通常是 struct winsize
// 为了兼容原始问题，这里使用 ttysize
typedef struct ttysize {
    unsigned short ts_lines;
    unsigned short ts_cols;
    unsigned short ts_xpixel;
    unsigned short ts_ypixel;
} ttysize;

// 封装 ioctl 函数，避免 cgo 处理变参的限制
void myioctl(int fd, unsigned long request, ttysize *ts) {
    ioctl(fd, request, ts);
}
*/
import "C"

// TIOCGWINSZ 的常量值，通常为 0x5413
// 这个值可能因操作系统或架构而异，但 0x5413 在许多 Unix-like 系统上是通用的。
const TIOCGWINSZ C.ulong = 0x5413

// GetTerminalSize 获取终端的行数和列数
func GetTerminalSize() (rows, cols int, err error) {
    var ts C.ttysize
    // 使用 os.Stdin.Fd() 获取标准输入的描述符
    fd := int(os.Stdin.Fd())

    // 调用封装后的 C 函数
    C.myioctl(C.int(fd), TIOCGWINSZ, &ts)

    // 检查 ioctl 调用是否成功（虽然 myioctl 封装后没有返回错误，
    // 但通常 ioctl 会返回 -1 表示失败，并设置 errno）
    // 我们可以通过检查 Go 的 syscall.Errno 来判断
    if errno := syscall.Errno(C.myioctl(C.int(fd), TIOCGWINSZ, &ts)); errno != 0 {
        return 0, 0, fmt.Errorf("ioctl failed: %w", errno)
    }

    return int(ts.ts_lines), int(ts.ts_cols), nil
}

func main() {
    rows, cols, err := GetTerminalSize()
    if err != nil {
        fmt.Printf("Error getting terminal size: %v\n", err)
        return
    }
    fmt.Printf("Terminal size: %d rows, %d columns\n", rows, cols)
}

代码说明：

• import "C" 上方的注释块： 这是 cgo 的特殊语法，用于包含 C 头文件和定义 C 代码。
  • #include 引入 ioctl 函数的声明。
  • typedef struct ttysize { ... } ttysize; 显式定义了 ttysize 结构体，确保 Go 和 C 之间的结构体布局一致。请根据您的系统实际使用的结构体（如 winsize）进行调整。
  • void myioctl(int fd, unsigned long request, ttysize *ts) { ioctl(fd, request, ts); } 定义了辅助函数 myioctl，它以固定参数调用 ioctl。
• const TIOCGWINSZ C.ulong = 0x5413;： 将 TIOCGWINSZ 的值硬编码为常量。
• GetTerminalSize 函数：
  • 声明一个 C.ttysize 类型的变量 ts 用于接收终端尺寸信息。
  • 使用 os.Stdin.Fd() 获取标准输入的文件描述符，通常终端会关联到标准输入。
  • 调用 C.myioctl 来执行实际的 ioctl 操作。
  • 通过再次调用 C.myioctl 并将其结果转换为 syscall.Errno 来检查错误。这是因为 myioctl 是 void 返回类型，但 ioctl 本身会返回错误码并设置 errno。

注意事项与总结

1. 跨平台兼容性： TIOCGWINSZ 的具体值和 ttysize/winsize 结构体的定义可能在不同的操作系统（如 Linux、macOS、BSD）之间存在细微差异。上述 0x5413 在许多 Unix-like 系统上是通用的，但若遇到问题，请查阅对应系统的 ioctl 手册页 (man ioctl) 以获取正确的宏值和结构体定义。
2. cgo 的开销： cgo 调用会带来一定的性能开销。对于频繁调用的场景，需要考虑这种开销。然而，获取终端尺寸通常不是一个高频操作，因此这种开销可以接受。
3. 替代方案： 在一些场景下，也可以考虑使用第三方库（如 golang.org/x/term），它们可能已经封装了这些系统调用，提供了更高级、更易用的接口，并处理了跨平台兼容性问题。然而，理解 cgo 的底层机制对于深入学习 Go 与 C 互操作性非常有益。
4. 错误处理： 示例中的错误检查通过再次调用 C.myioctl 并检查 syscall.Errno 来实现，这是一种间接的方式。更健壮的 C 封装函数应该直接返回 ioctl 的返回值，以便 Go 端可以更直接地判断成功与否。

通过上述方法，我们成功克服了 cgo 在处理 C 语言宏和变参函数时的限制，实现了在 Go 语言中获取终端尺寸的功能。这种模式也适用于其他需要通过 cgo 调用复杂 C API 的场景。