【华为鸿蒙开发技术】仓颉语言中的宏与嵌套应用机制指南

仓颉开发语言（Cangjie）是一种新兴的编程语言，其核心特性之一是宏系统。宏不仅可以提高代码的可重用性，还能在编译时生成动态的代码。本文将详细探讨仓颉语言中的宏实现，包括非属性宏和属性宏的定义与使用，以及嵌套宏的行为，并通过示例代码深入分析宏的实际应用。

1. 宏的基本概念

宏是一种在编译时进行代码替换的机制。仓颉语言支持两种类型的宏：非属性宏和属性宏。

1.1 非属性宏

非属性宏只接受被转换的代码，不接受其他参数。其定义格式如下：

import std.ast.*

public macro MacroName(args: Tokens): Tokens {
    ... // 宏体
}

宏的调用格式使用 @MacroName(...)，括号中的内容可以是任何合法的 tokens，甚至可以为空。下面是几个宏应用的典型示例：

示例 1：基本宏定义与调用

宏定义文件 macro_definition.cj：

macro package macro_definition

import std.ast.*

public macro TestDef(input: Tokens): Tokens {
    println("I'm in macro body")
    return input
}

宏调用文件 macro_call.cj：

package macro_calling

import macro_definition.*

main(): Int64 {
    println("I'm in function body")
    let a: Int64 = @TestDef(1 + 2)
    println("a = ${a}")
    return 0
}

编译过程：

在编译 macro_call.cj 时，输出将显示：

I'm in function body
a = 3

宏定义中的打印信息会在编译期间输出，宏调用将被展开为 let a: Int64 = 1 + 2。

1.2 属性宏

属性宏允许用户输入额外的信息，其定义格式为：

public macro Foo(attrTokens: Tokens, inputTokens: Tokens): Tokens {
    return attrTokens + inputTokens  // 拼接属性和输入 tokens
}

示例 2：属性宏的使用

宏定义文件 macro_definition.cj：

public macro Foo(attrTokens: Tokens, inputTokens: Tokens): Tokens {
    return attrTokens + inputTokens
}

宏调用文件 macro_call.cj：

package macro_calling

import macro_definition.*

var a: Int64 = @Foo[1 +](2 + 3)  // 调用带属性的宏

在这个例子中，Foo 宏将返回 1 + 2 + 3，通过宏展开生成合法的代码。

2. 宏的嵌套

仓颉语言允许宏的调用中嵌套其他宏，但不支持宏的定义嵌套。这种设计使得宏的调用更加灵活。

2.1 宏定义中嵌套宏调用

在一个宏定义中可以嵌套其他宏的调用。例如：

宏包 pkg1 中定义 GetIdent 宏：

macro package pkg1

import std.ast.*

public macro GetIdent(attr: Tokens, input: Tokens): Tokens {
    return quote(
        let decl = (parseDecl(input) as VarDecl).getOrThrow()
        let name = decl.identifier.value
        let size = name.size - 1
        let $(attr) = Token(TokenKind.IDENTIFIER, name[0..size])
    )
}

宏包 pkg2 中定义 Prop 宏，其中嵌套了 GetIdent 的调用：

macro package pkg2

import std.ast.*
import pkg1.*

public macro Prop(input: Tokens): Tokens {
    let v = parseDecl(input)
    @GetIdent[ident](input)
    return quote(
        $(input)
        public prop $(ident): $(v.declType) {
            get() {
                this.$(v.identifier)
            }
        }
    )
}

2.2 宏调用中嵌套宏调用

在一个宏调用中，也可以嵌套其他宏。例如：

package pkg3

import pkg1.*
import pkg2.*

@Foo
struct Data {
    let a = 2
    let b = @AddToMul(2 + 3)

    @Bar
    public func getA() {
        return a
    }

    public func getB() {
        return b
    }
}

main(): Int64 {
    let data = Data()
    var a = data.getA() // a = 2
    var b = data.getB() // b = 6
    println("a: ${a}, b: ${b}")
    return 0
}

在这个例子中，宏 Foo 修饰了 struct Data，而在 struct Data 内部调用了宏 AddToMul 和 Bar。这种嵌套宏的使用，提供了更强大的代码生成能力。

3. 宏的嵌套

仓颉语言在宏使用方面提供了灵活性，允许在宏调用和定义中进行嵌套操作，但需要遵循一定的规则。嵌套宏的使用场景在于通过组合多个宏来实现更复杂的代码生成和转换。

3.1 宏定义中嵌套宏调用

在宏定义中，可以嵌套调用其他宏。这种做法可以使得一个宏的输出成为另一个宏的输入，增强了宏的灵活性和复用性。以下是一个具体示例，展示了如何在宏定义中使用其他宏：

示例：嵌套宏调用

宏包 pkg1 中的 GetIdent 宏定义：

macro package pkg1

import std.ast.*

public macro GetIdent(attr: Tokens, input: Tokens): Tokens {
    return quote(
        let decl = (parseDecl(input) as VarDecl).getOrThrow()
        let name = decl.identifier.value
        let size = name.size - 1
        let $(attr) = Token(TokenKind.IDENTIFIER, name[0..size])
    )
}

宏包 pkg2 中的 Prop 宏定义：

macro package pkg2

import std.ast.*
import pkg1.*

public macro Prop(input: Tokens): Tokens {
    let v = parseDecl(input)
    @GetIdent[ident](input)
    return quote(
        $(input)
        public prop $(ident): $(v.declType) {
            get() {
                this.$(v.identifier)
            }
        }
    )
}

宏调用包 pkg3：

package pkg3

import pkg2.*

class A {
    @Prop
    private let a_: Int64 = 1
}

main() {
    let b = A()
    println("${b.a}")
}

在上述示例中，Prop 宏内部调用了 GetIdent 宏。GetIdent 宏用于解析输入的变量声明，提取变量的名称，并生成一个新的标识符。通过这种嵌套，宏的功能得到了增强。

编译顺序为：pkg1 -> pkg2 -> pkg3。在调用 Prop 宏时，首先将其展开为包含 GetIdent 宏调用的代码，随后再编译成最终的仓颉代码。

3.2 宏调用中的嵌套

嵌套宏调用也可以出现在宏修饰的代码块中。这通常用于对某个数据结构或函数的行为进行进一步的扩展。

示例：宏调用中的嵌套

宏包 pkg1 的定义：

macro package pkg1

import std.ast.*

public macro Foo(input: Tokens): Tokens {
    return input
}

public macro Bar(input: Tokens): Tokens {
    return input
}

宏包 pkg2 的 AddToMul 宏：

macro package pkg2

import std.ast.*

public macro AddToMul(inputTokens: Tokens): Tokens {
    var expr: BinaryExpr = match (parseExpr(inputTokens) as BinaryExpr) {
        case Some(v) => v
        case None => throw Exception()
    }
    var op0: Expr = expr.leftExpr
    var op1: Expr = expr.rightExpr
    return quote(($(op0)) * ($(op1)))
}

宏包 pkg3 中的使用示例：

package pkg3

import pkg1.*
import pkg2.*

@Foo
struct Data {
    let a = 2
    let b = @AddToMul(2 + 3)

    @Bar
    public func getA() {
        return a
    }

    public func getB() {
        return b
    }
}

main(): Int64 {
    let data = Data()
    var a = data.getA() // a = 2
    var b = data.getB() // b = 6
    println("a: ${a}, b: ${b}")
    return 0
}

在这个示例中，struct Data 使用了 @Foo 宏进行修饰，同时在其内部调用了 @AddToMul 和 @Bar 宏。AddToMul 宏将表达式 2 + 3 转换为 2 * 3 的形式，而 Bar 宏则是将函数 getA 的修饰与结构体结合。

3.3 嵌套宏的编译过程

在编译过程中，宏的展开遵循从内到外的顺序。这意味着首先会处理内层宏的展开，然后再展开外层宏。以 pkg3 中的例子为例，首先展开 AddToMul 宏，然后再处理 Foo 宏的展开。这种规则确保了嵌套宏的正确性与一致性。

4. 结论

仓颉语言中的宏功能强大，能够通过非属性宏和属性宏的定义和调用实现灵活的代码生成。通过嵌套宏调用，可以创建复杂而强大的功能，极大地提高了代码的可复用性和可维护性。宏的有效使用使得开发者可以在保证代码可读性的同时，提升编程效率。

在实际开发中，合理运用仓颉的宏特性，将帮助开发者简化代码结构，减少重复，增强代码逻辑的清晰度。希望这篇文章能为读者提供仓颉宏的深入理解及实际应用的启发。