anchor.diff:                                [Version, DistroStr]);
                   _ ->
                       io:format("Linux: ~s"
  -                              "~n   ~s"
  +                              "~n   Distro: ~s"
                                 "~n",
                                 [Version, "Fedora"])
               end,
               throw({distro, fedora});
           _ ->
  -            ignore
  -    end.
  -
  -do_linux_which_distro_suse(Version) ->
  +            throw({error, not_found})
  +    end.
  +
  +do_linux_which_distro_suse_release(Version) ->
       %% Check if its a SuSE
       case file:read_file_info("/etc/SuSE-release") of
           {ok, _} ->
  
positive.code:     end.
  
  do_linux_which_distro(Version) ->
      %% Many (linux) distro's use the /etc/issue file, so try that first.
      %% Then we just keep going until we are "done".
      DistroStr = do_linux_which_distro_issue(Version),
      %% Still not sure; try fedora
      _ = do_linux_which_distro_fedora(Version),
      %% Still not sure; try suse
      _ = do_linux_which_distro_suse(Version),
      %% And the fallback
      io:format("Linux: ~s"
                "~n   ~s"
                "~n",
                [Version, DistroStr]),
      other.
  
  do_linux_which_distro_issue(Version) ->
      case file:read_file_info("/etc/issue") of
          {ok, _} ->
              case [string:trim(S) ||
                       S <- string:tokens(os:cmd("cat /etc/issue"), [$\n])] of
                  [DistroStr | _] ->
                      case DistroStr of
                          "Wind River Linux" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, wind_river});
                          "MontaVista" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, montavista});
                          "Yellow Dog" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, yellow_dog});
                          "Ubuntu" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, ubuntu});
                          "Linux Mint" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, linux_mint});
                          _ ->
                              DistroStr
                      end;
                  X ->
                      X
              end;
          _ ->
              "Unknown"
      end.
                              
  do_linux_which_distro_fedora(Version) ->
      %% Check if fedora
      case file:read_file_info("/etc/fedora-release") of
          {ok, _} ->
  
negative.code:                                         [$\n])] of
                  ["SUSE Linux Enterprise Server" ++ _ = DistroStr | _] ->
                      io:format("Linux: ~s"
                                "~n   Distro: ~s"
                                "~n",
                                [Version, DistroStr]),
                      throw({distro, sles});
                  [DistroStr | _] ->
                      io:format("Linux: ~s"
                                "~n   Distro: ~s"
                                "~n",
                                [Version, DistroStr]),
                      throw({distro, suse});
                  _ ->
                      io:format("Linux: ~s"
                                "~n   Distro: ~s"
                                "~n",
                                [Version, "SuSE"]),
                      throw({distro, suse})
              end;
          _ ->
              throw({error, not_found})
      end.
  
  do_linux_which_distro_issue(Version) ->
      case file:read_file_info("/etc/issue") of
          {ok, _} ->
              case [string:trim(S) ||
                       S <- string:tokens(os:cmd("cat /etc/issue"), [$\n])] of
                  [DistroStr | _] ->
                      case DistroStr of
                          "Wind River Linux" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro: ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, wind_river});
                          "MontaVista" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro: ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, montavista});
                          "Yellow Dog" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro: ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, yellow_dog});
                          "Ubuntu" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro: ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, ubuntu});
                          "Linux Mint" ++ _ ->
                              io:format("Linux: ~s"
                                        "~n   Distro: ~s"
                                        "~n",
                                        [Version, DistroStr]),
                              throw({distro, linux_mint});
                          _ ->
                              DistroStr
                      end;
                  X ->
                      X
              end;
          _ ->
              throw({error, not_found})
      end.
                              
  
  analyze_and_print_linux_host_info(Version) ->
      Distro =
  