CangjieDocsHub

Section Text

通过一个简单的例子展示使用宏进行编译期求值，生成优化代码的应用。在计算幂 `n ^ e` 时，如果 `e` 是一个（比较大的）整数，可以通过重复取平方（而不是迭代相乘）的方式加速计算。这个算法可以直接使用 while 循环实现，例如：
 
<!-- run -->
 
然而，这个实现需要每次对 `e` 的值进行分析，在循环和条件判断中多次对 `ve` 进行判断和更新。此外，实现只支持 `n` 的类型为`Int64`的情况，如果要支持其他类型的 `n`，还要处理如何表达 `result = 1` 的问题。如果预先知道 `e` 的具体值，可以将这个代码写的更简单。例如，如果知道 `e` 的值为 10，可以展开整个循环如下：
 
<!-- run -->
 
当然，手动编写这些代码非常繁琐，希望在给定 `e` 的值之后，自动将这些代码生成出来。宏可以做到这一点。使用案例如下：
 
<!-- code_no_check -->
 
这个宏展开的代码是（根据 `.macrocall` 文件）：
 
<!-- code_no_check -->
 
下面是宏 `@power` 的实现。
 
<!-- verify -macro13 -->
<!-- cfg="--compile-macro" -->
 
这段代码的解释如下：
 
- 首先，确认输入的属性 `attrib` 是一个整数字面量，否则通过 `diagReport` 报错。将这个字面量解析为整数 `n`。
- 设 `result` 为当前积累的输出代码，首先添加 `var _power_vn` 的声明。这里为了避免变量名冲突，使用不易造成冲突的名字 `_power_vn`。
- 下面进入 while 循环，布尔变量 `flag` 表示 `var _power_result` 是否已经被初始化。其余的代码结构和之前展示的 `power` 函数的实现类似，但区别是使用 while 循环和 if 判断在编译时决定生成的代码是什么，而不是在运行时做这些判断。然后生成由 `_power_result *= _power_vn` 和 `_power_vn *= _power_vn` 适当组合的代码。
- 最后添加返回 `_power_result` 的代码，并将这段代码作为宏的输出值返回。
 
将这段代码放到 `macros/power.cj` 文件中，并在 `main.cj` 添加如下测试：
 
<!-- verify -macro13 -->
<!-- cfg="--debug-macro" -->
 
输出结果为：
 
<!-- verify -macro13 -->

Code 1 · cangjie

func power(n: Int64, e: Int64) {
    var result = 1
    var vn = n
    var ve = e
    while (ve > 0) {
        if (ve % 2 == 1) {
            result *= vn
        }
        ve /= 2
        if (ve > 0) {
            vn *= vn
        }
    }
    result
}

Code 2 · cangjie

func power_10(n: Int64) {
    var vn = n
    vn *= vn         // vn = n ^ 2
    var result = vn  // result = n ^ 2
    vn *= vn         // vn = n ^ 4
    vn *= vn         // vn = n ^ 8
    result *= vn     // result = n ^ 10
    result
}

Code 3 · cangjie

public func power_10(n: Int64) {
    @power[10](n)
}

Code 4 · cangjie

public func power_10(n: Int64) {
    /* ===== Emitted by MacroCall @power in main.cj:20:5 ===== */
    /* 20.1 */var _power_vn = n
    /* 20.2 */_power_vn *= _power_vn
    /* 20.3 */var _power_result = _power_vn
    /* 20.4 */_power_vn *= _power_vn
    /* 20.5 */_power_vn *= _power_vn
    /* 20.6 */_power_result *= _power_vn
    /* 20.7 */_power_result
/* ===== End of the Emit ===== */
}

Code 5 · cangjie

macro package define
 
import std.ast.*
import std.convert.*
 
public macro power(attrib: Tokens, input: Tokens) {
    let attribExpr = parseExpr(attrib)
    if (let Some(litExpr) <- (attribExpr as LitConstExpr)) {
        let lit = litExpr.literal
        if (lit.kind != TokenKind.INTEGER_LITERAL) {
            diagReport(DiagReportLevel.ERROR, attrib,
                       "Attribute must be integer literal",
                       "Expected integer literal")
        }
        var n = Int64.parse(lit.value)
        var result = quote(var _power_vn = $(input)
        )
        var flag = false
        while (n > 0) {
            if (n % 2 == 1) {
                if (!flag) {
                    result += quote(var _power_result = _power_vn
                    )
                    flag = true
                } else {
                    result += quote(_power_result *= _power_vn
                    )
                }
            }
            n /= 2
            if (n > 0) {
                result += quote(_power_vn *= _power_vn
                )
            }
        }
        result += quote(_power_result)
        return result
    } else {
        diagReport(DiagReportLevel.ERROR, attrib,
                   "Attribute must be integer literal",
                   "Expected integer literal")
    }
    return input
}

Code 6 · cangjie

import define.*
 
public func power_10(n: Int64) {
    @power[10](n)
}
 
main() {
    let a = 3
    println(power_10(a))
}

Code 7 · text

159049

Practical Examples

English

中文