anchor.diff:  
       rule method_declarations:
           "method" 
  -        ( "Type" method_name  [ "\\(" parameter "\\)" ]
  -            [ "if"  "\\(" method_predicate "\\)" ] ';'
  +        ( "Type" method_name  [ LPAREN parameter RPAREN ]
  +            [ "if"  LPAREN method_predicate RPAREN ] SEMICOLON
               [ method_body_statements
  -              "endmethod" [ ":" method_name]
  +              "endmethod" [ COLON method_name]
               ]
  -        | "Action" method_name  "\\(" parameter "\\)"
  -            [ "if"  "\\(" method_predicate "\\)" ] ';'
  +        | "Action" method_name  LPAREN parameter RPAREN
  +            [ "if"  LPAREN method_predicate RPAREN ] SEMICOLON
               [ method_body_statements
  -              "endmethod" [ ":" method_name]
  +              "endmethod" [ COLON method_name]
               ]
           | "ActionValue"
  -            [ "#" "\\(" expression "\\)" ]
  -            method_name "\\(" [ parameter ] "\\)"
  -            [ "if"  "\\(" method_predicate "\\)" ] ';'
  +            [ HASH LPAREN expression RPAREN ]
  +            method_name LPAREN [ parameter ] RPAREN
  +            [ "if"  LPAREN method_predicate RPAREN ] SEMICOLON
               [ method_body_statements
                 #return_statement
  -              "endmethod" [ ":" method_name]
  +              "endmethod" [ COLON method_name]
               ]
           | [ output_port ] method_name
  -            "\\(" "{" input_ports "}" "\\)"
  +            LPAREN LBRACE input_ports RBRACE RPAREN
               [ enable enable_port ]
               [ "ready" ready_port ] [ "clocked_by" clock_name ]
  -            [ "reset_by" clock_name] ';'
  +            [ "reset_by" clock_name] SEMICOLON
           )
   
       rule subinterface_declarations: "SUBINTER"
   
       rule interface_declarations:
           "interface" ifc_name 
  -        ( ';'
  +        ( SEMICOLON
               ( method_declarations
   # ";"
               #| subinterface_declarations
               )*
  -            "endinterface" [ ":" ifc_name ]
  -        | "#" "\\(" "type" Type_name "\\)" ';'
  +            "endinterface" [ COLON ifc_name ]
  +        | HASH LPAREN "type" Type_name RPAREN SEMICOLON
               ( method_declarations
   # ";"
               #| subinterface_declarations
               )*
  -            "endinterface" [ ":" ifc_name ]
  +            "endinterface" [ COLON ifc_name ]
           )
   
       rule variable_assignment:
           term<<[]>>
  -        ( '=' expression
  -        | '<=' expression
  -        )
  -        #VAR [ "\\[" expression [ ':' expression ] "\\]" ]
  -        #('=' | '<=') expression
  +        ( EQUAL | LEQ ) expression
  +        #VAR [ LBRACKET expression [ COLON expression ] RBRACKET ]
  +        #(EQUAL | LEQ) expression
   
       rule variable_declaration:
  -        Type_item_or_name VAR [ ( "=" | "<-" ) expression ] ';'
  +        Type_item_or_name VAR [ ( EQUAL | LARROW ) expression ] SEMICOLON
   
       rule variable_declaration_or_call:
  -        ( Type_item VAR [ ( "=" | "<-" ) expression ] ';'
  -        #| expression [ VAR [ ( "=" | "<-" ) expression {{ print "FOO" }} ] ] ';'
  -        | term<<[]>> ( VAR
  -                         ( "=" expression ';'
  -                         | "<-" expression ';'
  -                         | ';' 
  -                         ) 
  -                     | "=" expression ';'
  -                     | "<=" expression ';'
  -                     | ';'
  -                     )
  -        )
  +        ( Type_item VAR [ ( EQUAL | LARROW ) expression ]
  +        | term<<[]>> [   ( VAR [ ( EQUAL | LARROW ) expression ]
  +                         | ( EQUAL | LEQ ) expression
  +                         )
  +                     ]
  +        ) SEMICOLON
   
       rule variable_declaration_and_initializations:
           let_statement
  -        | variable_declaration
  +        | variable_declaration_or_call
   
       rule module_declarations:
  -        "module" [ "\\[" "Module" "\\]" ] module_name [ "#"  "\\(" parameter "\\)" ]
  -        "\\(" [ Ifc_type ] [ ifc_name ] [ "[*]" ] "\\)" [provisos] ';'
  +        "module" [ LBRACKET "Module" RBRACKET ] module_name [ HASH  LPAREN parameter RPAREN ]
  +        LPAREN [ Ifc_type ] [ ifc_name ] [ STAR ] RPAREN [provisos] SEMICOLON
           ( module_instantiations
           | rule_statements
           | interface_method_definitions
  
positive.code:         | for_statement
          | variable_declaration_and_initializations
          )*
          "endmodule" [ ":" module_name]
  
      rule package_statement:
          "package" Package_name ';'
          typedef_statements
          import_statements
          interface_declarations
          module_declarations
          "endpackage" [ ":"  Package_name]
  
  #    "Rules"
  #    "Tuple2#" "\\("t1 "," t2"\\)"  ... "Tuple7#" "\\("t1 ","... "," t7"\\)"
  #    "int" | "Nat" | "Maybe#" "\\(" t "\\)"
  #    Type_name
  #    Type_name "#" "\\(" type_variable "\\)"
  
  #    Ifc_type ifc_name "<-" module_name "\\("parameter"\\)" ';'
  #    Ifc_type ifc_name "<-" module_name "\\("[parameter ","
  #        "clocked_by" clock_name ","
  #        "reset_by" reset_name ] "\\)" ';'
  
      rule rule_statement:
          "rule" rule_name [rule_predicate] ';'
          action_statements
          "endrule" [ ":"  rule_name ]
  
      rule rules_statement:
          "rules" [ ":"  rules_name]
          rule_satements
          (variable_declaration_or_call ';')*
          "endrules" [ ":"  rules_name]
  
      rule action_statement:
          "action" [ ":"  action_name] [ ';' ]
          action_statements
          "endaction" [ ":" action_name]
  
      rule Type_name: VAR
  
      rule Type_item:
          ( "Bit#" | "Int#" | "Uint#" | "ComplexF#" | "Reg#" | "FIFO#" | "Maybe#" ) "\\(" expression "\\)"
          | "Integer" | "Bool" | "String" | "Action" | "ActionValue#" "\\(" VAR "\\)"
          | "Nat"
  
  #    "type identifier "<-" expression ';'
  #    identifier "<-" expression ';'
  
      rule let_statement:
          "let" VAR  ( "=" | "<-" ) expression ';'
  
  #    register_name "<=" expression ';'
  
      rule Typeclass: VAR
  
  
negative.code: 
      rule attribute:
          "synthesize"
          | "RST_N"  EQUAL STRING
          | "CLK"  EQUAL STRING
          | "always_ready" [ EQUAL interface_method ]
          | "always_enabled" [ EQUAL interface_method ]
          | "descending" "urgency" EQUAL LBRACE rule_names RBRACE
          | "preempts" [ EQUAL ] LBRACE rule_names COMMA  LPAREN list_rule_names RPAREN RBRACE
          | "doc" EQUAL STRING
          | "ready" EQUAL STRING
          | "enable" EQUAL STRING
          | "result" EQUAL STRING
          | "prefix" EQUAL STRING
          | "port"  EQUAL STRING
          | "noinline"
          | "fire_when_enabled"
          | "no_implicit_conditions"
  
      rule attribute_statement:
           "\\([*]" attribute [ EQUAL expression ] "[*]\\)"
  
      rule Type_item_or_name:
          Type_item
          | VAR [ HASH LPAREN expression (COMMA expression )* RPAREN ]
  
      rule Ifc_type: Type_item_or_name
  
      rule import_statements:
          "import"
          ( "BDPI" [ c_function_name  EQUAL ] "function" Return_type
              function_name [ LBRACE arguments RBRACE ] RPAREN  [ provisos ] SEMICOLON
          | "BVI" [verilog_module_name]  EQUAL
              "module" [ Type ] module_name [ HASH  LPAREN parameter RPAREN ]
              LPAREN Ifc_type ifc_name RPAREN  [ provisos ] SEMICOLON
              module_statements
              importBVI_statements
              "endmodule" [ COLON  module_name ]
          | Package_name  "::"  STAR SEMICOLON
          )
  
      rule for_statement:
          "for" LPAREN
              Type_item_or_name VAR EQUAL expression SEMICOLON
              expression SEMICOLON
              variable_assignment RPAREN
          BEGIN
              ( let_statement
              | if_statement
              | variable_declaration_or_call
              )*
          END
  
      rule method_body_statements:
          ( let_statement
  