附录 A：FluffOS LPC 快速参考卡

附录 A：FluffOS LPC 快速参考卡

本附录为 FluffOS LPC 语言的精简速查手册，涵盖类型、运算符、修饰符、函数、预处理器、特殊形式和内置函数分类。适合作为日常开发的随身参考。

A.1 基本类型速查

类型 大小/范围 语义 值/引用
int 64 位有符号整数（-2⁶³ ~ 2⁶³-1） 整数，溢出为二进制补码回绕（-fwrapv） 值类型
float C double，约 15 位有效数字 浮点数 值类型
string UTF-8 存储，长度按扩展字形簇计量 字符串，赋值复制 值类型
object 对象指针（32/64 位） 指向 LPC 对象的引用 引用类型
mapping 哈希表，键/值为 mixed 关联数组，赋值共享引用 引用类型
function 函数指针 一等函数，赋值共享引用 引用类型
buffer 字节数组，每元素 0-255 二进制缓冲区，赋值共享引用 引用类型
mixed — 任意类型，关闭类型检查 —
void — 仅用于函数返回值，表示无返回 —

数组声明： 类型名 * 或 类型名 array，如 int *nums、string array names。

Class 类型： class 类名，值类型结构体，不支持继承。

int *arr = ({ 1, 2, 3 });       // int 数组
mixed *stuff;                    // mixed 数组
class Person p = new(class Person);  // class 实例

A.2 运算符完整速查

算术运算符

运算符 说明 备注
+ 加法 也用于字符串拼接、数组合并、mapping 合并
- 减法 也用于数组差集
* 乘法 也用于 mapping 复合（数学意义）
/ 除法 INT_MIN / -1 为未定义行为
% 取模 INT_MIN % -1 为未定义行为

比较运算符

运算符 说明
== != 相等/不等（值类型比较值，引用类型比较指针）
< <= > >= 大小比较

逻辑运算符

运算符 说明 短路
&& 逻辑与 ✅
\|\| 逻辑或 ✅
! 逻辑非 —

位运算符

运算符 说明 备注
& 按位与
\| 按位或
^ 按位异或
~ 按位取反
<< >> 左移/右移 移位数截断到低 6 位（& 63）

赋值运算符

运算符 说明
= 简单赋值
+= -= *= /= %= 算术复合赋值
&= \|= ^= 位运算复合赋值
<<= >>= 移位复合赋值

逻辑赋值运算符（FluffOS 扩展，短路求值）

运算符 等价于 说明
\|\|= x = x \|\| val falsy（0 或 undefined）时赋值
&&= x = x && val truthy 时赋值
??= x = x ?? val 仅 undefined 时赋值

自增/自减

++x    --x    // 前置（先变后用）
x++    x--    // 后置（先用后变）

条件与空值运算符

运算符 说明 示例
? : 三元条件 max = (a > b) ? a : b
?? 空值合并（左侧 undefined 时返回右侧） val = m["k"] ?? "default"

可选链（FluffOS 扩展，仅 mapping）

mapping m = 0;
mixed v = m?.key;        // 安全返回 0，不报错
mixed v2 = m?.["key"];   // 等价写法
mixed v3 = m.?[\"key\"]; // 另一种写法

注意： 0 和 "" 不是 undefined，?? 不会替换它们。

逗号运算符

a = (x = 1, y = 2, x + y);  // a = 3

运算符优先级（从低到高）

优先级 运算符 结合性
最低 = += -= 等赋值 右结合
? : 三元 右结合
?? 空值合并 左结合
\|\| 逻辑或 左结合
&& 逻辑与 左结合
\| 按位或 左结合
^ 按位异或 左结合
& 按位与 左结合
== != 左结合
> >= < <= 左结合
<< >> 左结合
+ - 左结合
* / % 左结合
最高 ! ~ 一元 - —

A.3 类型修饰符

修饰符 作用域 说明
private 函数/变量 不可被其他对象通过 -> 调用，不可被继承者访问
protected 函数/变量 类似 private（旧风格兼容）
public 函数/变量 即使私有继承也可访问
static 函数 不可被 -> 调用（仅本对象内部可用）
static 变量 不参与 save_object/restore_object 序列化
nomask 函数 禁止被继承覆盖或 shadow()
nosave 变量 不参与序列化保存（同 static 变量效果）
varargs 函数 可接受可变数量参数（未传的参数为 0）
virtual 函数/变量 虚函数/虚变量

组合使用：

private static int internal_counter;
public varargs mixed query(string key, mixed def) { ... }
static nosave int temp_data;

访问控制段落：

private:     // 后续定义默认为 private
int secret;
public:      // 后续定义默认为 public
void api() { ... }

A.4 函数语法速查

标准定义

int add(int a, int b) {
    return a + b;
}

前向声明（原型）

int add(int, int);     // 类型必须，参数名可选
void greet(string);

可变参数（varargs）

varargs mixed query(string key, mixed def) {
    // def 未传时为 0
    return def;
}

// ... 语法收集剩余参数为数组
varargs void debug(string fmt, mixed *args...) {
    // args 包含 fmt 之后的所有参数
}

默认参数

void greet(string name, string title : (: "friend" :)) {
    write("Hello, " + title + " " + name + "!\n");
}
greet("Alice");          // title = "friend"
greet("Bob", "Sir");     // title = "Sir"

默认值使用函数指针语法 (: expr :)，在调用时于调用者上下文中求值。

按引用传递（ref / &）

// 声明处
void increment(int ref value) { value++; }
void append(mixed & arr, mixed item) { arr += ({ item }); }

// 调用处
int x = 10;
increment(ref x);     // x = 11
increment(& x);       // x = 12

限制： 声明和调用处必须同时使用 ref/&；参数必须是左值。

函数调用方式

add(1, 2);                    // 本对象函数
ob->query("name");            // 其他对象方法
call_other(ob, "query", "name");  // 等价写法
efun::write("hello");         // 绕过 simul_efun，直接调用驱动内置
f(1, 2);                      // 通过函数指针调用
(*f)(1, 2);                   // 旧式写法
evaluate(f, 1, 2);            // 等价写法

函数名称限定

foo()                   // 本对象或全局函数
::foo()                 // 绕过继承，直接调用本对象的版本
Parent::foo()           // 调用指定继承类的方法
int::to_string(42)      // 内置类型方法

A.5 函数指针五种类型

类型 语法 参数求值时机 示例
本地函数 (: func :) 或 func 创建时 function f = add;
efun 指针 (: efun :) 创建时 function f = (: write :);
call_other (: object, "method" :) 创建时 function f = (: ob, "query_name" :);
表达式函数 (: $1 + $2 :) 使用时 function f = (: $1 + $2 :);
匿名函数 function(type arg) { ... } 使用时 function f = function(int x) { return x*2; };

简化语法（新）

function f = add;              // 直接赋值函数名
function f = write;            // efun 也适用
int result = f(5, 3);          // 直接调用，无需 evaluate()

带绑定参数

function f = (: write, "Hello!\n" :);
f();  // 输出 "Hello!\n"

$N 参数占位符与 $() 捕获

function cmp = (: $1 - $2 :);              // $1, $2 引用调用时参数
function f = (: tell_object($1,            // $1 调用时求值
    $(this_player()->query_name()) + " bows.\n") :);  // $() 创建时求值

A.6 预处理器指令

宏定义

#define MAX_HP 100                        // 对象宏
#define SQUARE(x) ((x) * (x))            // 函数宏（括号紧跟名称）
#define STR(x) #x                         // 字符串化
#define CONCAT(a, b) a ## b              // 标记粘合
#define LONG(x) do { write(x); } while (0)  // 多行宏（反斜杠续行）
#undef MAX_HP                            // 取消定义

文件包含

#include "defs.h"       // 先相对当前文件，再搜索 include path
#include <mudlib.h>     // 只搜索 include path
#include CONFIG         // 文件名可由宏产生

条件编译

#ifdef FEATURE_X
    // FEATURE_X 已定义时编译
#endif

#ifndef GUARD_H
#define GUARD_H
    // include guard 模式
#endif

#if EXPRESSION
#elif OTHER_EXPR
#else
#endif

#if 表达式扩展：

  • defined(NAME) — 宏是否已定义
  • efun_defined(name) — 驱动是否编译了该 efun
#if defined(__PACKAGE_CRYPTO__) && efun_defined(hash)
string h = hash("sha256", data);
#endif

编译控制

#pragma strict_types       // 强制类型检查（强烈推荐每个文件开头使用）
#pragma warnings           // 启用警告
#pragma no_warnings        // 禁用警告
#pragma save_types         // 保存类型信息（供继承者类型检查）
#pragma optimize           // 启用额外优化

错误与警告

#error "This configuration is not supported"
#warn "This function is deprecated, use new_func instead"

预定义宏

宏 说明
__FILE__ 当前文件名
__LINE__ 当前行号
__DIR__ 当前文件目录
FLUFFOS FluffOS 版本号
MAX_INT 最大整数值
__PACKAGE_*__ 各功能包是否编译（如 __PACKAGE_DB__、__PACKAGE_CRYPTO__）

A.7 特殊内置形式

catch — 异常捕获

// 捕获表达式
string err = catch(some_dangerous_call());
if (err) write("Error: " + err + "\n");

// 捕获代码块
string err = catch {
    load_object("/dangerous");
    do_something();
};

sscanf — 字符串解析

string input = "Alice 25";
string name;
int age;
sscanf(input, "%s %d", name, age);
// name = "Alice", age = 25

parse_command — 命令解析

parse_command(cmd, env, fmt, lvalue, ...);

time_expression — 计时

int ticks = time_expression {
    some_expensive_operation();
};
write("Operation took " + ticks + " ticks.\n");

new — 克隆对象 / 创建 class 实例

object ob = new("/npc/goblin");                                    // 克隆对象
object ob = new("/npc/goblin", "Goblin King");                    // 带参数克隆
class Person p = new(class Person, name : "Alice", level : 10);  // class 实例

A.8 Efun 分类速查

FluffOS 提供约 250+ 个内置函数（efun），按功能分类：

数组操作

函数 说明
allocate(size) 分配指定大小的数组（初始化为 0）
sizeof(arr) 数组/字符串/mapping/buffer 长度
member_array(item, arr) 查找元素索引（未找到返回 -1）
filter(arr, func) 过滤数组
map(arr, func) 映射数组
sort_array(arr, func) 排序
distinct_array(arr) 去重
flatten_array(arr) 展平嵌套数组
intersect_array(a, b) 交集
union_array(a, b) 并集
unique_array(arr, func) 按函数分组

字符串操作

函数 说明
sprintf(fmt, ...) 格式化输出
sscanf(str, fmt, ...) 格式化解析
explode(str, delim) 分割为数组
implode(arr, delim) 合并为字符串
strsrch(str, target) 搜索子串位置
replace_string(str, old, new) 替换子串
strlen(str) 字符数（字形簇）
strwidth(str) 显示宽度（全角占 2 列）
lower_case(str) 转小写
capitalize(str) 首字母大写
trim(str) 去首尾空白
crypt(str, seed) 加密

正则表达式

函数 说明
pcre_match(str, pattern) PCRE 正则匹配
pcre_replace(str, pattern, rep) PCRE 替换
pcre_extract(str, pattern) PCRE 提取
regexp(arr, pattern) 用正则过滤数组

对象操作

函数 说明
clone_object(path) 克隆对象（等价 new）
destruct(ob) 销毁对象
move_object(ob, env) 移动对象到新环境
environment(ob) 获取所在环境
all_inventory(ob) 获取所有内容物
find_object(path) 查找已加载对象
object_name(ob) / file_name(ob) 获取对象名/文件名
living(ob) / userp(ob) / interactive(ob) 类型判断

玩家交互

函数 说明
write(str) 向当前玩家输出
tell_object(ob, str) 向指定对象输出
say(str) 向***间所有人输出
input_to(func) 等待玩家输入
add_action(func, verb) 注册命令动词
this_player() 当前玩家对象
this_object() 当前对象

数学函数

函数 说明
abs(x) 绝对值
sqrt(x) 平方根
random(n) 随机数 0..n-1
to_int(x) / to_float(x) 类型转换
sin/cos/tan/asin/acos/atan 三角函数
pow(x, y) / log(x) / exp(x) 幂/对数/指数
floor(x) / ceil(x) 取整

文件操作

函数 说明
read_file(path) 读文件
write_file(path, str) 写文件
file_size(path) 文件大小（-1 不存在，-2 为目录）
rename(old, new) 重命名
rm(path) 删除文件
mkdir(path) 创建目录
get_dir(pattern) 列目录（支持通配符）

数据库

函数 说明
db_connect(host, user, pass) 连接数据库
db_exec(conn, sql) 执行 SQL
db_fetch(result, row) 获取结果行
db_close(conn) 关闭连接
db_status() 数据库状态

系统函数

函数 说明
time() 当前 Unix 时间戳
uptime() 驱动运行时间（秒）
memory_info() 内存使用信息
debug_info(level) 调试信息
call_out(func, delay) 延时调用（返回 ID）
remove_call_out(id) 取消延时调用

函数指针操作

函数 说明
evaluate(func, args...) 调用函数指针
function_owner(func) 获取函数所属对象

A.9 字面量速查

// 整数
42                  // 十进制
0xFF                // 十六进制（0x 前缀）
0777                // 八进制（0 前缀）
0b1010              // 二进制（0b 前缀）
1_000_000           // 下划线分隔符

// 浮点
3.14                // 标准形式
1.                  // 等价 1.0
2.5e6               // 科学记数法

// 字符串
"hello"             // 双引号
"hello" " world"    // 相邻自动拼接
"line1\nline2"      // 转义序列
"\u20ac"            // Unicode 转义
"\x41"              // 十六进制转义
"\101"              // 八进制转义

// 字符字面量（返回整数）
'A'                 // 65
'\n'                // 10

// 模板字面量（反引号）
`Hello, ${name}!`   // 支持 ${} 插值
`price is \$100`    // 美元转义

// Heredoc
@END                // 单个字符串（含末尾换行）
多行内容
END

@@END               // 字符串数组（每行一个元素）
第一行
第二行
END

// 复合字面量
({ })               // 空数组
({ 1, 2, 3 })       // 数组（支持尾逗号）
([])                 // 空 mapping
([ "k": v ])        // mapping（支持尾逗号）

A.10 控制流速查

// 条件
if (cond) { } else if (cond) { } else { }

// 循环
while (cond) { }
do { } while (cond);
for (init; cond; step) { }
foreach (var in expr) { }
foreach (k, v in expr) { }         // 带索引
foreach (int ref n in arr) { }     // 按引用遍历（可修改数组元素）

// 分支
switch (expr) {
    case "string": ...; break;     // 字符串 case
    case 1..10: ...; break;        // 整数范围
    case 51..: ...; break;         // 到无穷
    default: ...;
}

// 跳转
break; continue; return; return expr;

A.11 索引与切片速查

arr[0]              // 正向索引（第一个）
arr[<1]             // 反向索引（最后一个）
arr[<3]             // 倒数第三个
arr[0..4]           // 范围切片（包含两端）
arr[2..<1]          // 第三个到最后一个
arr[<3..<1]         // 倒数第三到倒数第二
arr[2..]            // 第三个到末尾
arr[..<2]           // 开头到倒数第三个
arr[1..3] = ({10}); // 范围赋值（可改变长度）
str[0]              // 返回 Unicode 码点（整数）
str[0..0]           // 返回子串（字符串）
m["key"]            // mapping 键查找
m->key              // mapping 箭头语法

A.12 继承速查

inherit "/std/object";              // 公有继承（默认）
private inherit "/std/internal";    // 私有继承
public inherit "/std/weapon";       // 公有继承（显式）

// 访问被覆盖的父函数
::query_long();                     // 当前对象中被覆盖的版本
Object::reset();                    // 指定继承类的方法

A.13 编码风格速查

项目 规范
缩进 2 空格，不用 Tab
行宽 100 列
花括号 K&R 风格
函数/变量名 lower_snake_case
宏/常量 ALL_CAPS
类名 PascalCase
类型检查 每个文件开头 #pragma strict_types
头文件保护 #ifndef / #define / #endif
宏参数 加括号：#define SQ(x) ((x)*(x))
多语句宏 用 do { ... } while(0) 包裹

本参考卡基于 FluffOS 源码 src/compiler/internal/grammar.y、docs/lpc/ 官方文档和 src/packages/*.spec 编写。更多细节请参阅正文各章节。

京ICP备13031296号-4