anchor.diff:  Variables can also be referenced using curly braces like `${in}`.
   
   Variables might better be called "bindings", in that a given variable
  -cannot be changed, only shadowed.
  +cannot be changed, only shadowed.  More on how shadowing works
  +follows.
  +
   
   
   Rules
   ~~~~~
   
  -Rules begin with a line consisting of the `rule` keyword and a name
  -for the rule.  Then follows an indented set of `variable = value` lines.
  +Rules declare a short name for a command line.  They begin with a line
  +consisting of the `rule` keyword and a name for the rule.  Then
  +follows an indented set of `variable = value` lines.
   
   The basic example above declares a new rule named `cc`, along with the
   command to run.  (In the context of a rule, the `command` variable is
  
positive.code: 
  
  Creating .ninja files
  ~~~~~~~~~~~~~~~~~~~~~
  Here's a basic `.ninja` file that demonstrates most of the syntax.
  
  ---------------------------------
  cflags = -Wall
  
negative.code: build foo.o: cc foo.c
  
  # But you can can shadow variables like cflags for a particular build.
  build special.o: cc special.c
    cflags = -Wall
  
  # The variable was only shadowed for the scope of special.o;
  # Subsequent build lines get the outer (original) cflags.
  build bar.o: cc bar.c
  
  ----------------
  
  For more discussion of how scoping works, consult <<ref_scope,the
  reference>>.
  
  If you need more complicated information passed from the build
  statement to the rule (for example, if the rule needs "the file
  extension of the first input"), pass that through as an extra
  variable, like how `cflags` is passed above.
  
  
  Ninja file reference
  --------------------
  A file is a series of declarations.  A declaration can be one of:
  
  1. A rule declaration, which begins with +rule _rulename_+, and
     then has a series of indented lines defining variables.
  
  2. A build edge, which looks like +build _output1_ _output2_:
     _rulename_ _input1_ _input2_+. +
     Implicit dependencies may be tacked on the end with +|
     _dependency1_ _dependency2_+.
     Order-only dependencies may be tacked on the end with +||
     _dependency1_ _dependency2_+.
  
  3. Variable declarations, which look like +_variable_ = _value_+.
  