anchor.diff:                                string:tokens(X, " "))
                   end,
                   TokenStrs),
  +    % Zip it back together into a Tokens list that might look like...
  +    %   [given, i, have, entered, "Joe Armstrong", as, my, name]
  +    % or
  +    %   ['when', i, have, installed, erlang]
  +    % or
  +    %   ['then', i, should, see, someone, calling, me]
  +    % Some atoms are reserved words in erlang ('when', 'if', 'then', etc)
  +    % and need single quoting.
       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};
  +    {Section2, GWT2, Result} =
  +        case {Section, 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;
  
positive.code: %
  cucumber(FilePath)              -> cucumber(FilePath, []).
  cucumber(FilePath, StepModules) -> cucumber(FilePath, StepModules, 1).
  cucumber(FilePath, StepModules, StartNum) ->
      StepModulesX = StepModules ++ [?MODULE],
      Lines = lines(FilePath),
      cucumber_lines(Lines, StepModulesX, StartNum).
  
  cucumber_lines(Lines, StepModules, StartNum) ->
      {_, _, _} =
          lists:foldl(
            fun (Line, {Mode, GWT, LineNum} = Acc) ->
                case LineNum >= StartNum of
                    true  -> process_line(Line, Acc, StepModules);
                    false -> {Mode, GWT, LineNum + 1}
                end
            end,
            {undefined, undefined, 1}, Lines),
      ok.
  
  process_line(Line, {Mode, GWT, LineNum}, StepModules) ->
      % GWT stands for given-when-then.
      % GWT is the previous line's given-when-then atom.
      io:format("~s:~s ",
  
negative.code:                         {GWT, TokensHead} -> TokensHead
                      end,
                  R = lists:foldl(
                        fun (StepModule, Acc) ->
                            case Acc of
                                true  -> Acc;
                                false ->
                                    S = StepModule:step([G | TokensTail], Line),
                                    S =/= undefined
                            end
                        end,
                        false, StepModules),
                  {Section, G, R}
          end,
      case {Section2, Result} of
          {scenario, true}  -> io:format("ok~n");
          {scenario, false} -> io:format("NO-STEP~n");
          _                 -> io:format("~n")
      end,
      {Section2, GWT2, LineNum + 1}.
  
  step(['feature:' | _], _Line)  -> true;
  step(['scenario:' | _], _Line) -> true;
  