C++ displayer::show_error方法代码示例

void pragma_environment_save::run(const data::command::iterator&,
                                  const data::command::iterator&,
                                  const data::command::iterator& args_begin_,
                                  const data::command::iterator& args_end_,
                                  iface::displayer& displayer_) const
{
    if (_config.saving_enabled)
    {
        const std::string fn =
            boost::algorithm::trim_copy(tokens_to_string(args_begin_, args_end_));

        if (fn.empty())
        {
            displayer_.show_error(
                "Filename to save the environment into is missing.");
        }
        else
        {
            std::ofstream f(fn.c_str());
            f << _env.get_all() << std::endl;
            if (f.fail() || f.bad())
            {
                displayer_.show_error("Failed to save the environment into file " + fn);
            }
        }
    }
    else
    {
        displayer_.show_error(
            "Saving is disabled by the --disable_saving command line argument.");
    }
}

  void mdb_shell::line_available(const std::string& line_arg,
                                 iface::displayer& displayer_,
                                 iface::history& history_)
  {

    try
    {
      using boost::algorithm::all;
      using boost::is_space;

      std::string line = line_arg;

      if (line != prev_line && !line.empty())
      {
        history_.add(line);
      }

      if (line.empty())
      {
        if (!last_command_repeatable)
        {
          return;
        }
        line = prev_line;
      }
      else
      {
        prev_line = line;
      }

      if (all(line, is_space()))
      {
        return;
      }

      auto command_arg_pair = command_handler.get_command_for_line(line);
      if (!command_arg_pair)
      {
        displayer_.show_error("Command parsing failed\n");
        last_command_repeatable = false;
        return;
      }

      mdb_command cmd;
      std::string args;
      std::tie(cmd, args) = *command_arg_pair;

      last_command_repeatable = cmd.is_repeatable();

      cmd.get_func()(*this, args, displayer_);
    }
    catch (const std::exception& ex)
    {
      displayer_.show_error(std::string("Error: ") + ex.what() + "\n");
    }
    catch (...)
    {
      displayer_.show_error("Unknown error\n");
    }
  }

void pragma_switch::run(const data::command::iterator&,
                        const data::command::iterator&,
                        const data::command::iterator& args_begin_,
                        const data::command::iterator& args_end_,
                        iface::displayer& displayer_) const
{
  auto i = args_begin_;

  if (i != args_end_)
  {
    const std::string v = i->value().value();
    if (valid_argument(v))
    {
      ++i;
      if (i == args_end_)
      {
        _update(element_of(true_values, v));
      }
      else
      {
        displayer_.show_error("Invalid arguments after " + v + ": " +
                              tokens_to_string(i, args_end_).value());
      }
    }
    else
    {
      displayer_.show_error("Invalid argument " + v + ". Valid values are: " +
                            valid_arguments());
    }
  }
  displayer_.show_comment(
      data::text(_name + " is " + (_query() ? "on" : "off")));
}

  void mdb_shell::command_frame(const std::string& arg,
                                iface::displayer& displayer_)
  {
    if (!require_running_or_errored_metaprogram(displayer_))
    {
      return;
    }

    const auto frame_index = parse_mandatory_integer(arg);
    if (!frame_index)
    {
      display_argument_parsing_failed(displayer_);
      return;
    }

    auto backtrace = mp->get_backtrace();

    if (frame_index < 0 || *frame_index >= static_cast<int>(backtrace.size()))
    {
      displayer_.show_error("Frame index out of range");
      return;
    }

    display_frame(backtrace[*frame_index], displayer_);
  }

  bool mdb_shell::run_metaprogram_with_templight(
      const boost::optional<std::string>& expression,
      metaprogram::mode_t mode,
      iface::displayer& displayer_)
  {
    const boost::filesystem::path output_path = _mdb_temp_dir / "templight.pb";

    data::type_or_error evaluation_result =
        run_metaprogram(expression, output_path, displayer_);

    // Opening in binary mode, because some platforms interpret some characters
    // specially in text mode, which caused parsing to fail.
    std::ifstream protobuf_stream(output_path.string() + ".trace.pbf",
                                  std::ios_base::in | std::ios_base::binary);

    if (!protobuf_stream)
    {
      if (evaluation_result.is_error())
      {
        displayer_.show_error(evaluation_result.get_error());
      }
      else
      {
        // Shouldn't happen
        displayer_.show_error("Unexpected type type_or_error result");
      }
      mp = boost::none;
      return false;
    }

    mp = metaprogram::create_from_protobuf_stream(
        protobuf_stream, mode, expression ? *expression : "<environment>",
        data::file_location{}, // TODO something sensible here?
        evaluation_result);

    assert(mp);
    if (mp->is_empty() && evaluation_result.is_error())
    {
      // Most errors will cause templight to generate an empty trace
      // We're only intrested in non-empty traces
      displayer_.show_error(evaluation_result.get_error());
      mp = boost::none;
      return false;
    }

    return true;
  }

  void mdb_shell::command_help(const std::string& arg,
                               iface::displayer& displayer_)
  {
    if (arg.empty())
    {
      displayer_.show_raw_text("List of available commands:");
      displayer_.show_raw_text("");
      for (const mdb_command& cmd : command_handler.get_commands())
      {
        displayer_.show_raw_text(cmd.get_keys().front() + " -- " +
                                 cmd.get_short_description());
      }
      displayer_.show_raw_text("");
      displayer_.show_raw_text(
          "Type \"help\" followed by a command name for more information.");
      displayer_.show_raw_text(
          "Command name abbreviations are allowed if unambiguous.");
      displayer_.show_raw_text(
          "A blank line as an input will repeat the last command,"
          " if it makes sense.");
      return;
    }

    auto command_arg_pair = command_handler.get_command_for_line(arg);
    if (!command_arg_pair)
    {
      displayer_.show_error("Command not found\n");
      return;
    }

    using boost::algorithm::join;

    mdb_command cmd;
    std::string command_args;
    std::tie(cmd, command_args) = *command_arg_pair;

    if (!command_args.empty())
    {
      displayer_.show_error("Only one argument expected\n");
      return;
    }

    displayer_.show_raw_text(join(cmd.get_keys(), "|") + " " + cmd.get_usage());
    displayer_.show_raw_text(cmd.get_full_description());
  }

  void mdb_shell::command_rbreak(const std::string& arg,
                                 iface::displayer& displayer_)
  {
    if (arg.empty())
    {
      displayer_.show_error("Argument expected");
      return;
    }
    if (!require_evaluated_metaprogram(displayer_))
    {
      return;
    }
    try
    {
      breakpoint bp{next_breakpoint_id, boost::regex(arg)};
      ++next_breakpoint_id;

      unsigned match_count = 0;
      for (metaprogram::vertex_descriptor vertex : mp->get_vertices())
      {
        if (bp.match(mp->get_vertex_property(vertex).type))
        {
          match_count += mp->get_traversal_count(vertex);
        }
      }
      if (match_count == 0)
      {
        displayer_.show_raw_text("Breakpoint \"" + arg +
                                 "\" will never stop the execution");
      }
      else
      {
        displayer_.show_raw_text(
            "Breakpoint \"" + arg + "\" will stop the execution on " +
            std::to_string(match_count) +
            (match_count > 1 ? " locations" : " location"));
        breakpoints.push_back(bp);
      }
    }
    catch (const boost::regex_error&)
    {
      displayer_.show_error("\"" + arg + "\" is not a valid regex");
    }
  }

 bool
 mdb_shell::require_evaluated_metaprogram(iface::displayer& displayer_) const
 {
   if (!mp)
   {
     displayer_.show_error("Metaprogram not evaluated yet");
     return false;
   }
   return true;
 }

 bool mdb_shell::require_empty_args(const std::string& args,
                                    iface::displayer& displayer_) const
 {
   if (!args.empty())
   {
     displayer_.show_error("This command doesn't accept arguments");
     return false;
   }
   return true;
 }

  void pragma_config_load::run(const data::command::iterator&,
                               const data::command::iterator&,
                               const data::command::iterator& args_begin_,
                               const data::command::iterator& args_end_,
                               iface::displayer& displayer_) const
  {
    const data::shell_config_name name = data::shell_config_name(
        tokens_to_string(args_begin_, args_end_).value());

    const auto& configs = _shell.get_config().shell_configs();

    const auto cfg = std::find_if(
        configs.begin(), configs.end(),
        [&name](const data::shell_config& cfg_) { return cfg_.name == name; });

    if (cfg == configs.end())
    {
      throw exception("Config " + name + " not found.");
    }
    else
    {
      const auto old_config = _shell.get_config().active_shell_config().name;
      _shell.get_config().activate(name);
      try
      {
        _shell.rebuild_environment();
        displayer_.show_comment(data::text("Switched to config " + name));
      }
      catch (const std::exception& e)
      {
        displayer_.show_error("Error loading config " + name + ": " + e.what());
        restore_config(old_config, _shell);
      }
      catch (...)
      {
        displayer_.show_error("Error loading config " + name +
                              ": unknown exception");
        restore_config(old_config, _shell);
      }
    }
  }

  void mdb_shell::command_break(const std::string& arg,
                                iface::displayer& displayer_)
  {
    // TODO there will other more kinds of arguments here but needs a proper but
    // it needs a proper command parser
    if (arg != "list")
    {
      displayer_.show_error("Call break like this: \"break list\"");
      return;
    }

    if (breakpoints.empty())
    {
      displayer_.show_raw_text("No breakpoints currently set");
      return;
    }

    for (const breakpoint& bp : breakpoints)
    {
      displayer_.show_raw_text(bp.to_string());
    }
  }

void pragma_help::run(const data::command::iterator&,
                      const data::command::iterator&,
                      const data::command::iterator& args_begin_,
                      const data::command::iterator& args_end_,
                      iface::displayer& displayer_) const
{
  using boost::algorithm::join;

  if (args_begin_ == args_end_)
  {
    display_all(displayer_, _pragma_handlers);
  }
  else
  {
    std::vector<std::string> args;
    for (auto i = args_begin_; i != args_end_; ++i)
    {
      switch (i->category())
      {
      case data::token_category::whitespace:
      case data::token_category::comment:
        // skip token
        break;
      default:
        args.push_back(i->value().value());
      }
    }

    data::text help_text;
    bool was_pragma = false;

    for (const auto& h : _pragma_handlers)
    {
      if (prefix_of(args.begin(), args.end(), h.first.begin(), h.first.end()))
      {
        if (was_pragma)
        {
          help_text.paragraphs.push_back(data::paragraph(""));
        }
        else
        {
          was_pragma = true;
        }
        const std::string p_args = h.second.arguments();
        help_text.paragraphs.push_back(
            data::paragraph("#msh " + join(h.first, " ") +
                            (p_args.empty() ? std::string() : " " + p_args)));
        help_text.paragraphs.push_back(
            data::paragraph(h.second.description(), "    "));
      }
    }
    if (was_pragma)
    {
      displayer_.show_comment(help_text);
    }
    else
    {
      displayer_.show_error("Pragma " + join(args, " ") + " not found.");
    }
  }
}

  void mdb_shell::command_evaluate(const std::string& arg_copy,
                                   iface::displayer& displayer_)
  {
    // Easier not to use spirit here (or probably not...)
    // TODO OK. after -profile, this parsing really needs some refactoring
    std::string arg = arg_copy;

    const std::string full_flag = "-full";
    const std::string profile_flag = "-profile";

    bool has_full = false;
    bool has_profile = false;

    // Intentionally left really ugly for more motivation to refactor
    while (true)
    {
      if (boost::starts_with(arg, full_flag) &&
          (arg.size() == full_flag.size() ||
           std::isspace(arg[full_flag.size()])))
      {
        has_full = true;
        arg = boost::trim_left_copy(arg.substr(full_flag.size()));
      }
      else if (boost::starts_with(arg, profile_flag) &&
               (arg.size() == profile_flag.size() ||
                std::isspace(arg[profile_flag.size()])))
      {
        has_profile = true;
        arg = boost::trim_left_copy(arg.substr(profile_flag.size()));
      }
      else
      {
        break;
      }
    }

    if (has_full && has_profile)
    {
      displayer_.show_error(
          "-full and -profile flags cannot be used together.");
      return;
    }

    boost::optional<std::string> expression = arg;
    if (expression->empty())
    {
      if (!mp)
      {
        displayer_.show_error("Nothing has been evaluated yet.");
        return;
      }
      expression = last_evaluated_expression;
    }
    else if (*expression == "-")
    {
      expression = boost::none;
    }

    next_breakpoint_id = 1;
    breakpoints.clear();

    metaprogram::mode_t mode = [&]
    {
      if (has_full)
      {
        return metaprogram::mode_t::full;
      }
      if (has_profile)
      {
        return metaprogram::mode_t::profile;
      }
      return metaprogram::mode_t::normal;
    }();

    last_evaluated_expression = expression;
    if (!run_metaprogram_with_templight(expression, mode, displayer_))
    {
      return;
    }

    displayer_.show_raw_text("Metaprogram started");

    filter_metaprogram(bool(expression));
  }