anchor.diff:                          {GWT, TokensHead} -> TokensHead
                       end,
                   R = lists:foldl(
  -                      fun (SM, Acc) ->
  +                      fun (StepModule, Acc) ->
                             case Acc of
                                 true  -> Acc;
                                 false ->
  -                                  S = SM:step([G | TokensTail], Line),
  +                                  S = StepModule:step([G | TokensTail], Line),
                                     S =/= undefined
                             end
                         end,
                         false, StepModules),
  -                {Mode, G, R}
  +                {Section, G, R}
           end,
  -    case {Mode2, Result} of
  +    case {Section2, Result} of
           {scenario, true}  -> io:format("ok~n");
           {scenario, false} -> io:format("NO-STEP~n");
           _                 -> io:format("~n")
       end,
  -    {Mode2, GWT2, LineNum + 1}.
  +    {Section2, GWT2, LineNum + 1}.
   
   step(['feature:' | _], _Line)  -> true;
   step(['scenario:' | _], _Line) -> true;
  
positive.code:                               string:tokens(X, " "))
                  end,
                  TokenStrs),
      Tokens = zip_odd_even(TokenAtoms, QuotedStrs, 1, []),
      {Mode2, GWT2, Result} =
          case {Mode, Tokens} of
              {_, ['feature:' | _]}  ->
                  {feature, undefined, undefined};
              {_, ['scenario:' | _]} ->
                  {scenario, undefined, undefined};
              {_, []}                ->
                  {undefined, undefined, undefined};
              {undefined, _}         ->
                  {undefined, undefined, undefined};
              {scenario, [TokensHead | TokensTail]} ->
                  G = case {GWT, TokensHead} of
                          {undefined, _}    -> TokensHead;
  
negative.code: %
  cucumber(FilePath)              -> cucumber(FilePath, []).
  cucumber(FilePath, StepModules) -> cucumber(FilePath, StepModules, 1).
  cucumber(FilePath, StepModules, LineNumStart) ->
      StepModulesX = StepModules ++ [?MODULE],
      Lines = lines(FilePath),
      cucumber_lines(Lines, StepModulesX, LineNumStart).
  
  cucumber_lines(Lines, StepModules, LineNumStart) ->
      {_, _, _} =
          lists:foldl(
            fun (Line, {Section, GWT, LineNum} = Acc) ->
                case LineNum >= LineNumStart of
                    true  -> process_line(Line, Acc, StepModules);
                    false -> {Section, GWT, LineNum + 1}
                end
            end,
            {undefined, undefined, 1}, Lines),
      ok.
  
  process_line(Line, {Section, GWT, LineNum}, StepModules) ->
      % GWT stands for given-when-then.
      % GWT is the previous line's given-when-then atom.
      io:format("~s:~s ",
  