Yul语言及对象说明——Solidity中文文档（9）

时间  2019-11-21
标签 yul 语言 对象 说明 solidity 中文 文档 繁體版
原文   原文链接

image

写在前面：HiBlock区块链社区成立了翻译小组，翻译区块链相关的技术文档及资料，本文为Solidity文档翻译的第九部分《Yul语言及对象说明》，特发布出来邀请solidity爱好者、开发者作公开的审校，您能够添加微信baobaotalk_com，验证输入“solidity”，而后将您的意见和建议发送给咱们，也能够在文末“留言”区留言，有效的建议咱们会采纳及合并进下一版本，同时将送一份小礼物给您以示感谢。后端

Yul （先前被也被称为 JULIA 或 IULIA）是一种能够编译到各类不一样后端的中间语言（ 以太坊虚拟机Ethereum Virtual Machine(EVM) 1.0，以太坊虚拟机Ethereum Virtual Machine(EVM) 1.5，而 eWASM 也在计划中）。 正由于如此，它被设计成为这三种平台的可用的共同标准。 它已经能够用于 Solidity 内部的“内联汇编”，而且将来版本的 Solidity 编译器甚至会将 Yul 用做中间语言。 为 Yul 构建高级的优化器阶段也将会很容易。安全

image

Yul 的核心组件是函数，代码块，变量，字面量，for 循环，if 条件语句，switch 条件语句，表达式和变量赋值。微信

Yul 是强类型的，变量和字面量都须要经过前缀符号来指明类型。支持的类型有：bool， u8， s8， u32， s32， u64， s64， u128， s128， u256 和 s256。ide

Yul 自己甚至不提供操做符。若是目标平台是 以太坊虚拟机Ethereum Virtual Machine(EVM)，则操做码将做为内置函数提供，但若是后端平台发生了变化，则能够从新实现它们。 有关强制性的内置函数的列表，请参阅下面的章节。函数

如下示例程序假定 以太坊虚拟机Ethereum Virtual Machine(EVM) 操做码 mul，div 和 mo 是原生支持或能够做为函数用以计算指数的。oop

{
   function power(base:u256, exponent:u256) -> result:u256
   {
       switch exponent
       case 0:u256 { result := 1:u256 }
       case 1:u256 { result := base }
       default:
       {
           result := power(mul(base, base), div(exponent, 2:u256))
           switch mod(exponent, 2:u256)
               case 1:u256 { result := mul(base, result) }
       }
   }

}

也可用 for 循环代替递归来实现相同的功能。这里，咱们须要 以太坊虚拟机Ethereum Virtual Machine(EVM) 操做码 lt（小于）和 add 可用。

{
   function power(base:u256, exponent:u256) -> result:u256
   {
       result := 1:u256
       for { let i := 0:u256 } lt(i, exponent) { i := add(i, 1:u256) }
       {
           result := mul(result, base)
       }
   }

}

1

Yul语言说明

本章介绍 Yul 代码。Yul 代码一般放置在一个 Yul 对象中，它将在下一节中介绍。post

语法:学习

代码块 = '{' 语句* '}'

语句 =
   代码块 |
   函数定义 |
   变量声明 |
   赋值 |
   表达式 |
   Switch |
   For 循环 |
   循环中断

函数定义 =
   'function' 标识符 '(' 带类型的标识符列表? ')'
   ( '->' 带类型的标识符列表 )? 代码块

变量声明 =
   'let' 带类型的标识符列表 ( ':=' 表达式 )?

赋值 =
   标识符列表 ':=' 表达式

表达式 =
   函数调用 | 标识符 | 字面量

If 条件语句 =
   'if' 表达式 代码块

Switch 条件语句 =
   'switch' 表达式 Case* ( 'default' 代码块 )?

Case =
   'case' 字面量 代码块

For 循环 =
   'for' 代码块 表达式 代码块 代码块

循环中断 =
   'break' | 'continue'

函数调用 =
   标识符 '(' ( 表达式 ( ',' 表达式 )* )? ')'

标识符 = [a-zA-Z_$] [a-zA-Z_0-9]*

标识符列表 = 标识符 ( ',' 标识符)*

类型名 = 标识符 | 内置的类型名

内置的类型名 = 'bool' | [us] ( '8' | '32' | '64' | '128' | '256' )

带类型的标识符列表 = 标识符 ':' 类型名 ( ',' 标识符 ':' 类型名 )*

字面量 =
   (数字字面量 | 字符串字面量 | 十六进制字面量 | True字面量 | False字面量) ':' 类型名

数字字面量 = 十六进制数字 | 十进制数字

十六进制字面量 = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'')字符串字面量 = '"' ([^"\r\n\\] | '\\' .)* '"'

True字面量 = 'true'

False字面量 = 'false'

十六进制数字 = '0x' [0-9a-fA-F]+

十进制数字 = [0-9]+

语法层面的限制区块链

Switches 必须至少有一个 case（包括 default ）。 若是表达式的全部可能值都被覆盖了，那么不该该容许使用 default （即带 bool 表达式的 switch 语句同时具备 true case 和 false case 的状况下不该再有 default 语句）。优化

每一个表达式都求值为零个或多个值。 标识符和字面量求值为一个值，函数调用求值为所调用函数的返回值。

在变量声明和赋值中，右侧表达式（若是存在）求值后，必须得出与左侧变量数量相等的值。 这是惟一容许求值出多个值的表达式。

那种同时又是语句的表达式（即在代码块的层次）求值结果必须只有零个值。

在其余全部状况中，表达式求值后必须仅有一个值。

continue 和 break 语句只能用在循环体中，而且必须与循环处于同一个函数中（或者二者都必须在顶层）。

for 循环的条件部分的求值结果只能为一个值。

字面量不能够大于它们自己的类型。已定义的最大类型宽度为 256 比特。

做用域规则

Yul 中的做用域是与块（除了函数和 for 循环，以下所述）和全部引入新的标识符到做用域中的声明 （ FunctionDefinition ，VariableDeclaration ）紧密绑定的。

标识符在将其定义的块中可见（包括全部子节点和子块）。 做为例外，for 循环的 “init” 部分中（第一个块）定义的标识符在 for 循环的全部其余部分（但不在循环以外）中都是可见的。 在 for 循环的其余部分声明的标识符遵照常规的做用域语法规则。 函数的参数和返回参数在函数体中可见，而且它们的名称不能相同。

变量只能在声明后引用。 尤为是，变量不能在它们本身的变量声明的右边被引用。 函数能够在声明以前被引用（若是它们是可见的）。

Shadowing 是不被容许的，便是说，你不能在同名标识符已经可见的状况下又定义该标识符，即便它是不可访问的。

在函数内，不可能访问声明在函数外的变量。

形式规范

咱们经过在 AST 的各个节点上提供重载的求值函数 E 来正式指定 Yul。 任何函数均可能有反作用，因此 E 接受两个状态对象和 AST 节点做为它的参数，并返回两个新的状态对象和数量可变的其余值。

这两个状态对象是全局状态对象（在 以太坊虚拟机Ethereum Virtual Machine(EVM) 的上下文中是 内存memory，存储storage 和区块链的状态）和本地状态对象（局部变量的状态，即 以太坊虚拟机Ethereum Virtual Machine(EVM) 中堆栈的某个段）。 若是 AST 节点是一个语句，E 将返回两个状态对象和一个用于 break 和 continue 语句的 “mode”。 若是 AST 节点是表达式，则 E 返回两个状态对象，并返回与表达式求值结果相同数量的值。

在这份高层次的描述中，并无对全局状态的确切本质进行说明。 本地状态 L 是标识符 i 到值 v 的映射，表示为 L[i] = v。 对于标识符 v, 咱们用 $v 做为标识符的名字。

咱们将为 AST 节点使用解构符号。

E(G, L, <{St1, ..., Stn}>: Block) =
   let G1, L1, mode = E(G, L, St1, ..., Stn)
   let L2 be a restriction of L1 to the identifiers of L
   G1, L2, modeE(G, L, St1, ..., Stn: Statement) =
   if n is zero:
       G, L, regular
   else:
       let G1, L1, mode = E(G, L, St1)
       if mode is regular then
           E(G1, L1, St2, ..., Stn)
       otherwise
           G1, L1, modeE(G, L, FunctionDefinition) =
   G, L, regularE(G, L, <let var1, ..., varn := rhs>: VariableDeclaration) =
   E(G, L, <var1, ..., varn := rhs>: Assignment)E(G, L, <let var1, ..., varn>: VariableDeclaration) =
   let L1 be a copy of L where L1[$vari] = 0 for i = 1, ..., n
   G, L1, regularE(G, L, <var1, ..., varn := rhs>: Assignment) =
   let G1, L1, v1, ..., vn = E(G, L, rhs)
   let L2 be a copy of L1 where L2[$vari] = vi for i = 1, ..., n
   G, L2, regularE(G, L, <for { i1, ..., in } condition post body>: ForLoop) =
   if n >= 1:
       let G1, L1, mode = E(G, L, i1, ..., in)
       // 因为语法限制，mode 必须是规则的
       let G2, L2, mode = E(G1, L1, for {} condition post body)
       // 因为语法限制，mode 必须是规则的
       let L3 be the restriction of L2 to only variables of L
       G2, L3, regular
   else:
       let G1, L1, v = E(G, L, condition)
       if v is false:
           G1, L1, regular
       else:
           let G2, L2, mode = E(G1, L, body)
           if mode is break:
               G2, L2, regular
           else:
               G3, L3, mode = E(G2, L2, post)
               E(G3, L3, for {} condition post body)E(G, L, break: BreakContinue) =
   G, L, breakE(G, L, continue: BreakContinue) =
   G, L, continueE(G, L, <if condition body>: If) =
   let G0, L0, v = E(G, L, condition)
   if v is true:
       E(G0, L0, body)
   else:
       G0, L0, regularE(G, L, <switch condition case l1:t1 st1 ... case ln:tn stn>: Switch) =
   E(G, L, switch condition case l1:t1 st1 ... case ln:tn stn default {})E(G, L, <switch condition case l1:t1 st1 ... case ln:tn stn default st'>: Switch) =    let G0, L0, v = E(G, L, condition)    // i = 1 .. n    // 对字面量求值，上下文无关    let _, _, v1 = E(G0, L0, l1)    ...    let _, _, vn = E(G0, L0, ln)    if there exists smallest i such that vi = v:        E(G0, L0, sti)    else:        E(G0, L0, st')E(G, L, <name>: Identifier) =
   G, L, L[$name]E(G, L, <fname(arg1, ..., argn)>: FunctionCall) =
   G1, L1, vn = E(G, L, argn)
   ...
   G(n-1), L(n-1), v2 = E(G(n-2), L(n-2), arg2)
   Gn, Ln, v1 = E(G(n-1), L(n-1), arg1)
   Let <function fname (param1, ..., paramn) -> ret1, ..., retm block>
   be the function of name $fname visible at the point of the call.
   Let L' be a new local state such that    L'[$parami] = vi and L'[$reti] = 0 for all i.    Let G'', L'', mode = E(Gn, L', block)
   G'', Ln, L''[$ret1], ..., L''[$retm]E(G, L, l: HexLiteral) = G, L, hexString(l),
   where hexString decodes l from hex and left-aligns it into 32 bytesE(G, L, l: StringLiteral) = G, L, utf8EncodeLeftAligned(l),
   where utf8EncodeLeftAligned performs a utf8 encoding of l
   and aligns it left into 32 bytesE(G, L, n: HexNumber) = G, L, hex(n)
   where hex is the hexadecimal decoding functionE(G, L, n: DecimalNumber) = G, L, dec(n),
   where dec is the decimal decoding function

类型转换函数

Yul 不支持隐式类型转换，所以存在提供显式转换的函数。 在将较大类型转换为较短类型时，若是发生溢出，则可能会发生运行时异常。

下列类型的“截取式”转换是容许的：

  • bool

  • u32

  • u64

  • u256

  • s256

image

低级函数

如下函数必须可用:

微信图片_20180808000833.jpg

后端

后端或目标负责将 Yul 翻译到特定字节码。 每一个后端均可以暴露之后端名称为前缀的函数。 咱们为两个建议的后端保留 evm_ 和 ewasm_ 前缀。

后端: EVM

目标 以太坊虚拟机Ethereum Virtual Machine(EVM) 将具备全部用 evm_ 前缀暴露的 以太坊虚拟机Ethereum Virtual Machine(EVM) 底层操做码。

后端: "EVM 1.5"

TBD

后端: eWASM

TBD

2

Yul对象说明

语法:

顶层对象 = 'object' '{' 代码? ( 对象 | 数据 )* '}'

对象 = 'object' 字符串字面量 '{' 代码? ( 对象 | 数据 )* '}'

代码 = 'code' 代码块

数据 = 'data' 字符串字面量 十六进制字面量

十六进制字面量 = 'hex' ('"' ([0-9a-fA-F]{2})* '"' | '\'' ([0-9a-fA-F]{2})* '\'')

字符串字面量 = '"' ([^"\r\n\\] | '\\' .)* '"'

在上面，代码块 指的是前一章中解释的 Yul 代码语法中的 代码块。

Yul 对象示例以下:

..code:

// 代码由单个对象组成。 单个 “code” 节点是对象的代码。// 每一个（其余）命名的对象或数据部分都被序列化// 并可供特殊内置函数：datacopy / dataoffset / datasize 用于访问object {
   code {
       let size = datasize("runtime")
       let offset = allocate(size)
       // 这里，对于 eWASM 变为一个内存到内存的拷贝，对于 EVM 则至关于 codecopy
       datacopy(dataoffset("runtime"), offset, size)
       // 这是一个构造函数，而且运行时代码会被返回
       return(offset, size)
   }

   data "Table2" hex"4123"

   object "runtime" {
       code {
           // 运行时代码

           let size = datasize("Contract2")
           let offset = allocate(size)
           // 这里，对于 eWASM 变为一个内存到内存的拷贝，对于 EVM 则至关于 codecopy
           datacopy(dataoffset("Contract2"), offset, size)
           // 构造函数参数是一个数字 0x1234
           mstore(add(offset, size), 0x1234)
           create(offset, add(size, 32))
       }

       // 内嵌对象。使用场景是，外层是一个工厂合约，而 Contract2 将是由工厂生成的代码
       object "Contract2" {
           code {
               // 代码在这 ...
           }

           object "runtime" {
               code {
                   // 代码在这 ...
               }
            }

            data "Table1" hex"4123"
       }
   }

}

延伸阅读：智能合约-Solidity官方文档（1）

安装Solidity编译器-Solidity官方文档（2）

根据例子学习Solidity-Solidity官方文档（3）

深刻理解Solidity之源文件及合约结构——Solidity中文文档（4）

安全考量——Solidity中文文档（5）

合约的元数据——Solidity中文文档（6）

应用二进制接口(ABI) 说明——Solidity中文文档（7）

使用编译器——Solidity中文文档（8）

点击“阅读原文”便可查看完整中文文档

image

注：本文为solidity翻译的第九部分****《Yul语言及对象说明》，特发布出来邀请solidity爱好者、开发者作公开的审校，您能够添加微信baobaotalk_com，验证输入“solidity”，而后将您的意见和建议发送给咱们，也可在文末“留言”区留言，或经过原文连接访问咱们的Github。有效的建议咱们会收纳并及时改进，同时将送一份小礼物给您以示感谢。

本文内容来源于HiBlock区块链社区翻译小组，感谢全体译者的辛苦工做。点击“阅读原文”便可查看完整中文文档。

线上课程推荐

线上课程：《8小时区块链智能合约开发实践》

培训讲师：《白话区块链》做者 蒋勇

课程原价：999元，现价 399元

更多福利：

  • @全部人，识别下图二维码转发课程邀请好友报名，便可得到报名费50%返利

  • @学员，报名学习课程并在规定时间内完成考试便可瓜分10000元奖金

image

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程