GN build files are read as sequences of tokens.  While splitting the file
  into tokens, the next token is the longest sequence of characters that form a
  valid token.
1.
2.
3.

  White space is comprised of spaces (U+0020), horizontal tabs (U+0009),
  carriage returns (U+000D), and newlines (U+000A).

  Comments start at the character "#" and stop at the next newline.

  White space and comments are ignored except that they may separate tokens
  that would otherwise combine into a single token.
1.
2.
3.
4.
5.
6.
7.

  Identifiers name variables and functions.

      identifier = letter { letter | digit } .
      letter     = "A" ... "Z" | "a" ... "z" | "_" .
      digit      = "0" ... "9" .
1.
2.
3.
4.
5.

  The following keywords are reserved and may not be used as identifiers:

          else    false   if      true
1.
2.
3.

  An integer literal represents a decimal integer value.

      integer = [ "-" ] digit { digit } .

  Leading zeros and negative zero are disallowed.
1.
2.
3.
4.
5.

  A string literal represents a string value consisting of the quoted
  characters with possible escape sequences and variable expansions.

      string           = `"` { char | escape | expansion } `"` .
      escape           = `\` ( "$" | `"` | char ) .
      BracketExpansion = "{" ( identifier | ArrayAccess | ScopeAccess ) "}" .
      Hex              = "0x" [0-9A-Fa-f][0-9A-Fa-f]
      expansion        = "$" ( identifier | BracketExpansion | Hex ) .
      char             = /* any character except "$", `"`, or newline */ .

  After a backslash, certain sequences represent special characters:

          \"    U+0022    quotation mark
          \$    U+0024    dollar sign
          \\    U+005C    backslash

  All other backslashes represent themselves.

  To insert an arbitrary byte value, use $0xFF. For example, to insert a
  newline character: "Line one$0x0ALine two".

  An expansion will evaluate the variable following the '$' and insert a
  stringified version of it into the result. For example, to concat two path
  components with a slash separating them:
    "$var_one/$var_two"
  Use the "${var_one}" format to be explicitly deliniate the variable for
  otherwise-ambiguous cases.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

  The following character sequences represent punctuation:

          +       +=      ==      !=      (       )
          -       -=      <       <=      [       ]
          !       =       >       >=      {       }
                          &&      ||      .       ,
1.
2.
3.
4.
5.
6.

  The input tokens form a syntax tree following a context-free grammar:

      File = StatementList .                                         // 文件

      Statement     = Assignment | Call | Condition .                // 语句
      LValue        = identifier | ArrayAccess | ScopeAccess .       // 左值赋值
      Assignment    = LValue AssignOp Expr . // 赋值
      Call          = identifier "(" [ ExprList ] ")" [ Block ] .    // 函数调用
      Condition     = "if" "(" Expr ")" Block                        // 条件
                      [ "else" ( Condition | Block ) ] .
      Block         = "{" StatementList "}" .                        // 语句块
      StatementList = { Statement } .                               // 语句列表

      ArrayAccess = identifier "[" Expr "]" .                       // 数组下标访问
      ScopeAccess = identifier "." identifier .                     // 作用域访问
      Expr        = UnaryExpr | Expr BinaryOp Expr .               // 表达式
      UnaryExpr   = PrimaryExpr | UnaryOp UnaryExpr .              // 一元表达式
      PrimaryExpr = identifier | integer | string | Call            // 初等表达式、基本表达式
                  | ArrayAccess | ScopeAccess | Block
                  | "(" Expr ")"
                  | "[" [ ExprList [ "," ] ] "]" .
      ExprList    = Expr { "," Expr } .                             // 表达式列表

      AssignOp = "=" | "+=" | "-=" .        // 赋值操作
      UnaryOp  = "!" .                      // 一元操作符
      BinaryOp = "+" | "-"                  // highest priority  // 二元操作符 高优先级
               | "<" | "<=" | ">" | ">="
               | "==" | "!="
               | "&&"
               | "||" .                     // lowest priority  // 低优先级

  All binary operators are left-associative.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

  The GN language is dynamically typed. The following types are used:

   - Boolean: Uses the keywords "true" and "false". There is no implicit
     conversion between booleans and integers.
     

   - Integers: All numbers in GN are signed 64-bit integers.

   - Strings: Strings are 8-bit with no enforced encoding. When a string is
     used to interact with other systems with particular encodings (like the
     Windows and Mac filesystems) it is assumed to be UTF-8. See "String
     literals" above for more.

   - Lists: Lists are arbitrary-length ordered lists of values. See "Lists"
     below for more.

   - Scopes: Scopes are like dictionaries that use variable names for keys. See
     "Scopes" below for more.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

  Lists are created with [] and using commas to separate items:

       mylist = [ 0, 1, 2, "some string" ]

  A comma after the last item is optional. Lists are dereferenced using 0-based
  indexing:

       mylist[0] += 1
       var = mylist[2]

  Lists can be concatenated using the '+' and '+=' operators. Bare values can
  not be concatenated with lists, to add a single item, it must be put into a
  list of length one.

  Items can be removed from lists using the '-' and '-=' operators. This will
  remove all occurrences of every item in the right-hand list from the
  left-hand list. It is an error to remove an item not in the list. This is to
  prevent common typos and to detect dead code that is removing things that no
  longer apply.

  It is an error to use '=' to replace a nonempty list with another nonempty
  list. This is to prevent accidentally overwriting data when in most cases
  '+=' was intended. To overwrite a list on purpose, first assign it to the
  empty list:

    mylist = []
    mylist = otherlist
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

  All execution happens in the context of a scope which holds the current state
  (like variables). With the exception of loops and conditions, '{' introduces
  a new scope.

  所有的构建运行在作用域的上下文内，作用域包含当前的运行状态，类似变量。除了循环和条件，花括号'{'引入新的作用域。


  Most scopes have a parent reference to the old scope. Variable reads
  recursively search all parent scopes until the variable is found or there are
  no more scopes. Variable writes always go into the current scope. This means
  that after the closing '}' (again excepting loops and conditions), all local
  variables will be restored to the previous values.  This also means that "foo
  = foo" can do useful work by copying a variable into the current scope that
  was defined in a containing scope.

  大部分作用域拥有一个父级引用到老的作用域。变量读取会递归搜索所有的父级作用域，直至发现变量或者搜索到最顶级作用域；变量写入会写入当前的作用域。意味着，在右括号'}'后，所有的本地变量会恢复到之前的值。也意味着"foo = foo"可以用于从一个包含该值定义的作业域中复制值。

  Scopes can be assigned to variables. Examples of such scopes are the
  implicitly-created "invoker" when invoking a template (which refers to the
  variables set by the invoking code), scopes created by functions like
  exec_script, and scopes explicitly created like
  作用域可以赋值给变量。这样的作用域的例子有：调用模板时隐式创建的"invoker"，exec_script函数创建的作用域，还有就是显式创建的作业域，如下所示：

    empty_scope = {}
    myvalues = {
      foo = 21
      bar = "something"
    }

  In the case of explicitly created scopes and scopes created by functions like
  exec_script, there is no reference to the parent scope. Such scopes are fully
  self-contained and do not "inherit" values from their defining scope.

  显式创建的作用域，exec_script等函数创建的作用域，没有父级作用域。这些作用域是自包含的，不会从定义它们的作业域中继承值。

  Inside an explicit scope definition can be any GN code including conditionals
  and function calls. After the close of the scope, it will contain all
  variables explicitly set by the code contained inside it. After this, the
  values can be read, modified, or added to:

  在显式作用域定义内，可以是任何GN代码，包含条件和函数调用。在作业域设置后， 它包含全部显式设置的变量，然后变量值可以读取、修改或者添加：

    myvalues.foo += 2
    empty_scope.new_thing = [ 1, 2, 3 ]

  Scope equality is defined as single-level scopes identical within the current
  scope. That is, all values in the first scope must be present and identical
  within the second, and vice versa. Note that this means inherited scopes are
  always unequal by definition.

  作用域是否相等定义为和当前作用域同一级相等，指的是，，第一个作用域的所有值存在且与第二个作用域的值相等，反之亦然。需要注意，继承的作用域一直和定义它的作用域不相等。
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.