Lua 5.4 Number 类型深度剖析
引言：数值计算的幕后引擎
在 Lua 脚本中，local health = 100、local pi = 3.14159这样的数值定义随处可见。但当我们用这些数值进行运算时，是否思考过：Lua 如何在内存中同时存储整数与浮点数？混合运算时的类型转换如何实现？为何0.1 + 0.2不等于0.3？这些问题的答案，藏在 Lua 精心设计的Number类型实现中。
在上一篇《Lua 5.4 布尔值类型深度剖析》中，我们深入探讨了布尔值的底层实现。本文将进一步揭示 Number 类型的设计哲学、存储机制与运算逻辑，展现 Lua 在数值处理领域的精妙设计。
Number 类型的数据结构：藏在 TValue 里的双重身份
在 Lua 中，所有类型的值都通过统一的 TValue 结构体存储，Number 类型也不例外。它如同拥有双重身份的特工，既能以整数形态执行精确计算，又能以浮点数形态处理复杂运算。这种灵活性源于 Lua 底层的「带标签联合体」设计 —— 通过类型标签和联合体组合，实现内存利用的最大化。
TValue 结构体：Number 类型的统一载体
Lua 的数值类型与其他基础类型共享 TValue 载体，其核心定义于 lobject.h 文件中：
/*
** Tagged Values. This is the basic representation of values in Lua:
** an actual value plus a tag with its type.
*/
#define TValuefields Value value_; lu_byte tt_
typedef struct TValue {
TValuefields;
} TValue;
#define val_(o) ((o)->value_)
#define valraw(o) (val_(o))
Lua 的 带标签联合体（Tagged Union） 的设计模式，在上篇文章已有细致讲述，此下简单讲述。
TValue看似简单的结构体，实则包含两个关键成员：
- 联合体（Union） ：
TValue中的value_是一个联合体 (union)，占用 8 字节内存，用于存储具体的值。联合体的特点是所有成员共享同一块内存空间，这使得 Lua 可以用固定大小的内存存储不同类型的值。 - 类型标签（Type Tag） ：
TValue中的tt_成员是一个lu_byte类型是一个 8 位无符号整数，用于存储类型标签 (Type Tag)。这个标签是 Lua 动态类型系统的核心，通过它可以在运行时确定一个值的具体类型。
Value 联合体：Number 类型的存储核心
Value 联合体定义了 Lua 支持的所有基本值类型：
/*
** Union of all Lua values
*/
typedef union Value {
struct GCObject *gc; /* collectable objects */
void *p; /* light userdata */
lua_CFunction f; /* light C functions */
lua_Integer i; /* integer numbers */
lua_Number n; /* float numbers */
/* not used, but may avoid warnings for uninitialized value */
lu_byte ub;
} Value;
对于 Number 类型，我们主要关注其中的两个成员：
- lua_Integer i：用于存储整数值，通常为 64 位有符号整数 (long long)。这种设计使得 Lua 可以处理非常大的整数，范围从
-9223372036854775808到9223372036854775807。 - lua_Number n：用于存储浮点数值，通常为 64 位双精度浮点数 (double)。双精度浮点数可以提供约
15-17位十进制数字的精度，足以满足大多数应用场景的需求。
这种设计使得整数和浮点数可以在同一存储单元中切换，既节省内存又提高类型转换效率。
Number 类型的双重身份标识
Lua 通过类型标签区分整数与浮点数的 "双重身份"，通过 tt_ 字段的位运算编码实现了高效的类型识别机制，在lua.h中明确定义：
/*
** basic types
*/
#define LUA_TNONE (-1)
#define LUA_TNIL 0
#define LUA_TBOOLEAN 1
#define LUA_TLIGHTUSERDATA 2
#define LUA_TNUMBER 3
#define LUA_TSTRING 4
#define LUA_TTABLE 5
#define LUA_TFUNCTION 6
#define LUA_TUSERDATA 7
#define LUA_TTHREAD 8
#define LUA_NUMTYPES 9
对于 Number 类型，标签值为 3，但这只是基础类型。实际上，Number 类型还分为整数和浮点数两种变体，通过变体位进一步区分。
/*
** {==================================================================
** Numbers
** ===================================================================
*/
/* Variant tags for numbers */
#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */
#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */
#define ttisnumber(o) checktype((o), LUA_TNUMBER)
#define ttisfloat(o) checktag((o), LUA_VNUMFLT)
#define ttisinteger(o) checktag((o), LUA_VNUMINT)
#define nvalue(o) check_exp(ttisnumber(o), \
(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n)
#define ivalue(o) check_exp(ttisinteger(o), val_(o).i)
#define fltvalueraw(v) ((v).n)
#define ivalueraw(v) ((v).i)
#define setfltvalue(obj,x) \
{ TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); }
#define chgfltvalue(obj,x) \
{ TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
#define setivalue(obj,x) \
{ TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); }
#define chgivalue(obj,x) \
{ TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
/* }================================================================== */
LUA_VNUMINT 和 LUA_VNUMFLT 这两种变体位的设计是 Lua 类型系统的精妙之处，通过 2 位二进制数 (00-11)，Lua 可以在同一基础类型下表示最多 4 种不同的变体，既节省了内存，又提高了类型判断的效率。
makevariant宏的实现揭示了 Lua 紧凑的位布局策略：
/*
** tags for Tagged Values have the following use of bits:
** bits 0-3: actual tag (a LUA_T* constant)
** bits 4-5: variant bits
** bit 6: whether value is collectable
*/
/* add variant bits to a type */
#define makevariant(t,v) ((t) | ((v) << 4))
通过位运算组合后的数值类型标签具有明确的二进制模式：
- 整数类型标签 (LUA_VNUMINT) ：
3 | (0 << 4) = 3→ 二进制00000011 - 浮点数类型标签 (LUA_VNUMFLT) ：
3 | (1 << 4) = 19→ 二进制00010011
这种编码方式使得类型判断可以通过简单的整数比较完成，例如ttisinteger(o)宏最终会转换为(o->tt_ == 3)的底层操作，这在现代 CPU 上仅需一个时钟周期即可完成。
Number 类型的数值操作与判断：高效的位运算
为了高效操作数值，Lua 源码提供了分层宏定义：高层功能接口（如ttisnumber、nvalue）提供直观类型判断与数值存取，底层实现宏（如checktag、settt_）通过位运算直接操作内存
高层功能接口：面向开发者的「语义化操作层」
Lua 为 Number 类型提供了一组高层宏，形成了用户直接使用的功能接口：
类型判断宏：数值类型的「语义化检查」
高层类型判断宏提供直观的布尔结果，确定一个值是否为数值，以及具体是整数还是浮点数。
ttisnumber(o)：判断对象是否为数值类型（整数或浮点数）。它调用底层的checktype宏，仅检查类型标签的低 4 位（基础类型位）是否等于LUA_TNUMBER（值为 3）。例如，整数标签LUA_VNUMINT（值为 3）和浮点数标签LUA_VNUMFLT（值为 19）的低 4 位均为 3，因此都被判定为数值类型。
ttisfloat(o)：判断对象是否为浮点数。它调用底层的checktag宏，比较完整的类型标签（包括变体位）是否为LUA_VNUMFLT（值为 19，二进制00010011）。例如，若o->tt_为 19，则ttisfloat(o)返回真。
ttisinteger(o)：判断对象是否为整数。同理，它检查类型标签是否为LUA_VNUMINT（值为 3，二进制00000011）。例如，若o->tt_为 3，则ttisinteger(o)返回真。
这些宏使类型判断只需一次整数比较（O (1) 时间复杂度），高效且语义清晰。
数值提取宏：类型安全的「值访问」
数值提取宏负责从TValue中获取具体数值，并确保类型匹配：
nvalue(o)：统一提取数值，自动处理类型转换。它先通过ttisnumber确认对象是数值类型，再根据ttisinteger判断是整数还是浮点数：
- 若为整数，通过
ivalue(o)提取lua_Integer，并通过cast_num转换为lua_Number（浮点数）； - 若为浮点数，直接通过
fltvalue(o)提取lua_Number。
fltvalue(o)：精确提取浮点数值。它通过check_exp断言对象为浮点数，然后调用底层的val_(o).n直接访问联合体中的浮点数值。例如，若o为浮点数3.14，fltvalue(o)返回3.14。
ivalue(o)：精确提取整数值。同理，它断言为整数后，通过val_(o).i访问整数值。例如，若o为整数100，ivalue(o)返回100。
check_exp在调试模式下会触发断言错误（如尝试从整数中提取浮点值），确保类型安全；在发布模式下则直接返回值，不影响性能。
数值设置宏：类型安全的「值赋值」
数值设置宏用于创建或修改数值，确保类型标签与存储值一致。
setfltvalue(obj, x)：初始化浮点数值。它将x存储到obj的value_.n（浮点数字段），并通过settt_将类型标签设置为LUA_VNUMFLT（浮点数标签）。例如：
setfltvalue(obj, 3.14); // obj.value_.n = 3.14, obj.tt_ = 19
etivalue(obj, x)：初始化整数值。 同理，它将x存储到value_.i（整数字段），标签设置为LUA_VNUMINT（整数标签）。例如：
setivalue(obj, 100); // obj.value_.i = 100, obj.tt_ = 3
chgfltvalue(obj, x)：修改已有浮点数值（不改变类型）。它假设obj已为浮点数（通过lua_assert在调试时断言），直接修改value_.n的值。例如：
chgfltvalue(obj, 3.14159); // 假设obj已是浮点数，直接更新值
chgivalue(obj, x)：修改已有整数值（不改变类型）。同理，假设为整数，修改value_.i的值。例如：
chgivalue(obj, 200); // 假设obj已是整数，直接更新值
与set*value的区别在于：chg*value不更新类型标签，适用于已知类型的场景（如循环中更新计数器），减少不必要的标签修改。
底层实现宏：面向虚拟机的「位操作核心」
底层实现宏是高层接口的技术支撑，直接操作内存和类型标签，注重效率和硬件适配。它们处理位运算、内存访问等底层细节，对开发者透明，确保虚拟机高效运行。
类型标签生成宏：位运算的「底层编码」
类型标签生成宏通过位运算实现类型信息的压缩存储，用最少的内存表示最多的类型
makevariant(t, v)：生成带变体的完整类型标签。它将基础类型t（低 4 位）与变体值v（左移 4 位后占据高 2 位）通过按位或（|）组合。例如：上述通过位运算组合后的数值类型标签的二进制模式（LUA_VNUMINT和LUA_VNUMFLT）。
这种设计用 6 位（低 4 位类型 + 高 2 位变体）存储完整类型信息，仅占 1 字节（tt_字段）的一部分，节省内存。
类型检查宏：高效的「标签比较」
类型检查宏是类型判断宏（如ttisnumber）的底层实现，通过位运算和整数比较快速确定类型。
checktype(o, t)：检查基础类型（低 4 位）。它通过掩码0x0F（二进制00001111）与类型标签按位与（&），提取低 4 位（基础类型），再与t比较。
checktag(o, tag)：检查完整类型标签（包括变体位）。 它直接比较o->tt_与tag是否相等，无需掩码，更精确。
两者均为整数比较操作，在现代 CPU 上仅需一个时钟周期，确保类型判断高效。
内存访问宏：直接操作「联合体」
val_(o) ：获取TValue的Value联合体指针。它是((TValue*)(o))->value_的缩写，避免重复转换类型。例如，fltvalue(o)底层通过val_(o).n访问浮点数值。
fltvalueraw(v)：直接读取浮点数值。 它返回v.n（浮点数字段），不进行类型检查。
ivalueraw(v)：直接读取整数值。同理，它返回v.i（整数字段）。
这些宏需确保v的类型正确（如已通过ttisfloat判断），用于虚拟机内部已知类型的场景（如数值运算中间步骤），避免重复检查开销。
标签设置宏：更新「类型标识」
标签设置宏用于修改TValue的类型标签，确保标签与存储值一致。
settt_(o, tag)：直接设置类型标签。它将tag赋值给o->tt_，是setfltvalue和setivalue更新标签的底层实现。该宏确保新创建或修改的数值类型标签正确，避免类型标签与实际值不匹配的问题。
类型转换宏：整数与浮点数的「无缝切换」
类型转换宏处理整数与浮点数之间的转换，确保数值在不同类型间的一致性。
cast_num(x)：整数转浮点数的类型转换。 它将lua_Integer类型的x强制转换为lua_Number（浮点数），底层实现为(lua_Number)(x)。例如，nvalue对整数调用cast_num(ivalue(o))，将整数值转为浮点数统一返回。这种转换在整数可被浮点数精确表示时（如2^53以内的整数）无精度损失；超出范围时可能产生舍入误差（但 Lua 5.4 的整数为 64 位，大部分场景可精确表示）。
安全检查宏：调试模式的「错误拦截」
check_exp(cond, val)：条件检查与值返回。在调试模式下，若cond为假（如类型不匹配），触发
luaG_runerror抛出错误；在发布模式下，直接返回val（无检查开销）。例如，fltvalue(o)通过check_exp(ttisfloat(o), val_(o).n)确保仅对浮点数执行访问。
lua_assert(cond)：调试断言。在调试模式下，若cond为假，触发断言失败（如chgfltvalue中通过lua_assert(ttisfloat(io))确保只修改浮点数）；发布模式下通常为空宏，不影响性能。
Number 类型的特殊存储机制：位运算的精巧魔术
Number 类型在 Lua 中的存储方式展现了设计者对效率的极致追求。与布尔类型类似，数值类型的变体信息也被编码在类型标签中，但Number 类型的实际值需要存储在Value联合体中。Lua 的 Number 类型的存储机制堪称位运算的艺术杰作，仅用 1 字节的tt_标签就完成了类型标识、变体区分等多重功能，实现了存储效率与运算效率的完美平衡。
内存布局：Number 在内存中的实际存储方式
在 64 位系统上，一个包含整数值 100 的 TValue 内存布局如下：
+-------------------------+-----------------+
| value_.i=100 | tt_=0x30 |
| （8字节64位整数） | （整数类型标签） |
+-------------------------+-----------------+
而包含浮点数值 3.14 的 TValue 内存布局则是：
+-------------------------+-----------------+
| value_.n=3.14 | tt_=0x31 |
| （8字节双精度浮点数） | （浮点数类型标签）|
+-------------------------+-----------------+
这种内存布局的设计使得 Lua 可以在运行时通过简单的类型标签检查来确定一个值的类型，然后根据类型正确解析联合体中的数据。整个过程高效且内存占用极小，充分体现了 Lua 对性能和资源利用的极致追求。
浮点数的数值（value_.n）表示：IEEE 754 双精度标准
lua_Number 默认定义为 double 类型（64 位双精度浮点数），遵循 IEEE 754-2008 双精度标准。这一标准未在源码中直接体现（C 语言和 CPU 已经提供高效实现，LUA 无需重复）。
IEEE 754 双精度浮点数的二进制编码分为三部分：
符号位 (1位) | 指数位 (11位) | 尾数位 (52位)
[63] [62:52] [51:0]
- 符号位（Sign）：第 63 位（最高位），0 表示正数，1 表示负数；符号位直接决定数值的正负，不影响数值大小。
- 指数位（Exponent）：第 62-52 位（共 11 位），存储 偏移指数（Biased Exponent） ；偏移指数 = 实际指数 + 1023（偏移量，
2^(11-1) - 1 = 1023）；偏移量的作用是将实际指数（可正可负）转换为无符号整数（0-2047），便于硬件比较大小。 - 尾数位（Mantissa/Fraction）：第 51-0 位（共 52 位），存储 小数部分的二进制表示；采用 隐含前导 1（Hidden Leading 1） 规则，规范化的浮点数可表示为
1.尾数 × 2^指数（如3.14 = 1.57 × 2^1），因此整数位的1被隐含，不存储在尾数位中，从而节省 1 位精度。实际尾数 =1.尾数位（二进制）。
IEEE 754 双精度编码，其对应的十进制值计算公式为：
V = (-1)^符号位 × (1.尾数位) × 2^(指数位-1023)
数字的跨平台护照：整数与浮点数的类型定义艺术
在 Lua 的世界里，数值如同拥有双重身份的旅行者，既能以整数形态精确计数，又能以浮点数形态处理连续量。这种灵活性源于 Lua 设计的「数字护照系统」—— 通过类型定义宏为数值颁发跨平台通用的 "护照"，确保其在不同架构中被正确识别。本文将解析这套系统的设计哲学与源码实现。
整数类型的「跨平台身份证」定义
在lua.h头文件中，lua_Integer类型是通过LUA_INTEGER宏定义的。
/* type for integer functions */
typedef LUA_INTEGER lua_Integer;
整数类型定义与跨平台适配机制
LUA_INTEGER宏的具体定义通常在luaconf.h头文件中，并没有直接在lua.h中。Lua 通过条件编译适配不同平台的整数类型，实现如下：
/*
@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
@@ LUAI_UACINT is the result of a 'default argument promotion'
@@ over a LUA_INTEGER.
@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
@@ LUA_INTEGER_FMT is the format for writing integers.
@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
@@ lua_integer2str converts an integer to a string.
*/
/* The following definitions are good for most cases here */
#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
#define LUAI_UACINT LUA_INTEGER
#define lua_integer2str(s,sz,n) \
l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
/*
** use LUAI_UACINT here to avoid problems with promotions (which
** can turn a comparison between unsigneds into a signed comparison)
*/
#define LUA_UNSIGNED unsigned LUAI_UACINT
/* now the variable definitions */
#if LUA_INT_TYPE == LUA_INT_INT /* { int */
#define LUA_INTEGER int
#define LUA_INTEGER_FRMLEN ""
#define LUA_MAXINTEGER INT_MAX
#define LUA_MININTEGER INT_MIN
#define LUA_MAXUNSIGNED UINT_MAX
#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
#define LUA_INTEGER long
#define LUA_INTEGER_FRMLEN "l"
#define LUA_MAXINTEGER LONG_MAX
#define LUA_MININTEGER LONG_MIN
#define LUA_MAXUNSIGNED ULONG_MAX
#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
/* use presence of macro LLONG_MAX as proxy for C99 compliance */
#if defined(LLONG_MAX) /* { */
/* use ISO C99 stuff */
#define LUA_INTEGER long long
#define LUA_INTEGER_FRMLEN "ll"
#define LUA_MAXINTEGER LLONG_MAX
#define LUA_MININTEGER LLONG_MIN
#define LUA_MAXUNSIGNED ULLONG_MAX
#elif defined(LUA_USE_WINDOWS) /* }{ */
/* in Windows, can use specific Windows types */
#define LUA_INTEGER __int64
#define LUA_INTEGER_FRMLEN "I64"
#define LUA_MAXINTEGER _I64_MAX
#define LUA_MININTEGER _I64_MIN
#define LUA_MAXUNSIGNED _UI64_MAX
#else /* }{ */
#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
#endif /* } */
#else /* }{ */
#error "numeric integer type not defined"
#endif /* } */
/* }================================================================== */
这段代码是 Lua 源码中关于整数类型定义的核心部分，主要实现了跨平台的整数类型抽象、范围定义和格式化处理。其设计目标是在不同编译器和操作系统环境中，为 Lua 提供统一的整数操作接口，同时确保性能和类型安全。
核心宏定义与类型抽象
Lua 通过宏定义构建整数类型的抽象层，以下是核心源码实现：
LUA_INTEGER_FMT通过拼接LUA_INTEGER_FRMLEN生成适配的格式化字符串（如64 位 Linux 下为"%lld"，Windows 下为"%I64d"），实现平台适配，确保整数输出格式一致。LUAI_UACINT定义为LUA_INTEGER，用于类型提升处理，避免 C 语言默认参数提升导致的比较错误，保证整数运算类型一致性。lua_integer2str利用格式化字符串和安全的l_sprintf函数实现整数到字符串的安全转换。LUA_UNSIGNED通过unsigned LUAI_UACINT定义无符号整数类型，确保与有符号整数位数一致，避免符号扩展问题。
l_sprintf是 Lua 内部实现的安全格式化函数，其作用类似于标准 C 库的snprintf，但增加了平台兼容性处理：
/*
@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
** (All uses in Lua have only one format item.)
*/
#if !defined(LUA_USE_C89)
#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
#else
#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
#endif
条件编译与平台适配逻辑
Lua 通过三层条件编译实现整数类型的跨平台适配：
在 32 位 int 模式（LUA_INT_INT）下，使用int类型，无长度修饰符，范围为INT_MAX到INT_MIN，适用于内存受限场景。
64 位 long 模式（LUA_INT_LONG）使用系统long类型，长度修饰符为l，范围扩展到LONG_MAX，自动适配系统字长。
64 位 long long 模式（LUA_INT_LONGLONG）针对 C99 平台使用long long类型，Windows 平台特化为__int64类型，提供最大整数范围，通过LLONG_MAX和_I64_MAX定义 64 位整数范围（±9223372036854775807），适用于大整数运算场景。
对于不支持 64 位整数的平台，通过#error提示降级配置，确保编译阶段拦截不支持的平台。
边界值定义与跨平台一致性保障
Lua 通过标准库宏定义整数边界值，确保跨平台一致性：
有符号边界：LUA_MAXINTEGER和LUA_MININTEGER直接映射INT_MAX、LONG_MAX等标准宏，例如 64 位模式下LUA_MAXINTEGER为LLONG_MAX（9223372036854775807）
无符号边界：LUA_MAXUNSIGNED对应UINT_MAX、ULLONG_MAX，64 位无符号最大值为18446744073709551615（2^64-1）
一致性保障：无论在 32 位还是 64 位平台，相同 Lua 脚本处理整数时的范围和行为一致，例如用户 ID 自增运算在不同平台不会因整数溢出导致逻辑错误
浮点数类型的「跨平台身份证」定义
在lua.h头文件中，lua_Number类型是通过LUA_NUMBER宏定义的。
/* type of numbers in Lua */
typedef LUA_NUMBER lua_Number;
浮点数类型定义与跨平台适配机制
LUA_NUMBER宏的具体定义通常在luaconf.h头文件中，并没有直接在lua.h中。Lua 通过条件编译适配不同平台的浮点数类型，实现如下：
/*
@@ lua_numbertointeger converts a float number with an integral value
** to an integer, or returns 0 if float is not within the range of
** a lua_Integer. (The range comparisons are tricky because of
** rounding. The tests here assume a two-complement representation,
** where MININTEGER always has an exact representation as a float;
** MAXINTEGER may not have one, and therefore its conversion to float
** may have an ill-defined value.)
*/
#define lua_numbertointeger(n,p) \
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
(*(p) = (LUA_INTEGER)(n), 1))
/* now the variable definitions */
#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
#define LUA_NUMBER float
#define l_floatatt(n) (FLT_##n)
#define LUAI_UACNUMBER double
#define LUA_NUMBER_FRMLEN ""
#define LUA_NUMBER_FMT "%.7g"
#define l_mathop(op) op##f
#define lua_str2number(s,p) strtof((s), (p))
#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
#define LUA_NUMBER long double
#define l_floatatt(n) (LDBL_##n)
#define LUAI_UACNUMBER long double
#define LUA_NUMBER_FRMLEN "L"
#define LUA_NUMBER_FMT "%.19Lg"
#define l_mathop(op) op##l
#define lua_str2number(s,p) strtold((s), (p))
#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
#define LUA_NUMBER double
#define l_floatatt(n) (DBL_##n)
#define LUAI_UACNUMBER double
#define LUA_NUMBER_FRMLEN ""
#define LUA_NUMBER_FMT "%.14g"
#define l_mathop(op) op
#define lua_str2number(s,p) strtod((s), (p))
#else /* }{ */
#error "numeric float type not defined"
#endif /* } */
核心宏定义与精度抽象
Lua 通过宏定义实现浮点数精度的抽象与分级：
类型定义：LUA_NUMBER可定义为float（单精度）、double（双精度）或long double（长双精度），上层代码统一使用LUA_NUMBER操作，无需关心底层精度。
属性获取：l_floatatt(n)通过拼接FLT_、DBL_或LDBL_前缀获取浮点属性，例如l_floatatt(MIN_NORMAL)在双精度模式下为DBL_MIN_NORMAL。
格式化与解析：根据精度生成不同格式符（如%.7g、%.14g），并选择对应解析函数（strtof、strtod），确保输入输出一致性
条件编译与精度选择策略
Lua 通过三层条件编译实现浮点数精度的跨平台适配：
单精度模式（LUA_FLOAT_FLOAT）： 使用 4 字节float类型，保留 7 位有效数字，适用于移动设备或传感器数据处理。例如在 Arduino 等内存受限平台，单精度可减少 50% 内存占用，同时满足一般数据采集精度需求。
双精度模式（LUA_FLOAT_DOUBLE）：作为默认模式，使用 8 字节double类型，保留 15-17 位有效数字，平衡精度与硬件加速。现代 CPU 普遍支持双精度浮点指令，在游戏物理引擎或金融计算中可保证足够精度。
长双精度模式（LUA_FLOAT_LONGDOUBLE）：使用 12-16 字节long double类型，保留 18-19 位有效数字，适用于密码学或气象模拟。在 GCC 平台可通过-mlong-double-128选项启用 128 位精度，减少高精度计算的累积误差。
数值转换安全机制与精度控制
lua_numbertointeger宏通过双重边界检查实现浮点数到整数的安全转换：
下界检查：(n) >= (LUA_NUMBER)(LUA_MININTEGER)确保浮点数不小于最小整数（如 64 位系统中为-9223372036854775808），防止下溢。
上界检查：(n) < -(LUA_NUMBER)(LUA_MININTEGER)使用LUA_MININTEGER的负数形式（即LUA_MAXINTEGER + 1），避免因浮点数无法精确表示整数最大值（如 64 位系统中为9223372036854775809）导致的判断错误。之所以用-(LUA_MININTEGER)而非直接用LUA_MAXINTEGER，是因为整数最大值可能无法被浮点数精确表示（如 64 位整数9223372036854775807在双精度浮点数中需 53 位精度，超出了 IEEE 754 双精度的 52 位尾数范围）。
安全转换：仅当数值在整数范围内时，通过(*(p) = (LUA_INTEGER)(n), 1)执行转换并返回成功，确保跨平台转换逻辑一致。
后续预告
本次解析了 Number 类型的底层实现，后续将继续探索 Lua 源码世界，揭秘其他基础类型的设计奥秘：
- 字符串类型（String） ：Lua 如何通过紧凑结构实现高效内存管理与子串快速查找；
- 表类型（Table） ：作为 Lua 的核心数据结构，解析其哈希表与数组的融合实现，以及元表（Metatable）的动态扩展机制；
- 函数类型（Function） ：深入闭包原理，解读 Lua 函数与 C 函数的交互接口设计；
- 线程类型（Thread） ：揭秘协程的底层实现，分析非抢占式多任务调度的具体机制。
每一种类型的源码设计都凝结着 Lua 开发者的匠心巧思，让我们透过代码细节，还原这些设计背后的技术哲学与工程智慧。
