fmenv->patrol_point = coord_def(0, 0);

    fmenv->patrol_point.reset();

static int _string_tag_length(const std::string& s)
{
    int taglen = 0;
    bool in_tag = false;
    int last_taglen = 0;
    for (std::string::const_iterator ci = s.begin(); ci != s.end(); ++ci)
    {
        if (in_tag)
        {
            if (*ci == '<' && last_taglen == 1)
            {
                in_tag = false;
                --taglen;
            }
            else if (*ci == '>')
            {
                in_tag = false;
                ++taglen;
            }
            else
            {
                ++last_taglen;
                ++taglen;
            }
        }
        else if (*ci == '<')
        {
            in_tag = true;
            last_taglen = 1;
            ++taglen;
        }
    }
    return (taglen);
}

         << std::setw(16 + _string_tag_length(rangestring)) << rangestring

         << std::setw(16 + tagged_string_tag_length(rangestring)) << rangestring

        std::string error_reason;
        int qv_slot = get_fire_item(&error_reason);

        int qv_slot = get_fire_item();

    std::string error_reason;
    int q = you.m_quiver->get_fire_item(&error_reason);

    int q = you.m_quiver->get_fire_item();

    if (quiver_too && item.link == you.m_quiver->get_fire_item(NULL))

    if (quiver_too && item.link == you.m_quiver->get_fire_item())

        else if (this->link == you.m_quiver->get_fire_item(NULL))

        else if (this->link == you.m_quiver->get_fire_item())

    // How many letters are only needed for formatting, but won't ever
    // be printed.
    int colour_length = 0;

        colour_length = 5;

        colour_length = (selected_from_inventory ? 11 : 3);

    formatted_message_history(msg.str()
                              .substr(0, crawl_view.msgsz.x + colour_length),

    formatted_message_history(tagged_string_substr(msg.str(),
                                                   0, crawl_view.msgsz.x),

int tagged_string_tag_length(const std::string& s);
int tagged_string_printable_length(const std::string& s);
std::string tagged_string_substr(const std::string& s, int start, int end);

// Return the actual (string) offset of character #loc to be printed,
// i.e. ignoring tags. So for instance, if s == "<tag>ab</tag>", then
// _find_string_location(s, 2) == 6.
int _find_string_location(const std::string& s, int loc)
{
    int real_offset = 0;
    bool in_tag = false;
    int last_taglen = 0;
    int offset = 0;
    for (std::string::const_iterator ci = s.begin();
         ci != s.end() && real_offset < loc;
         ++ci, ++offset)
    {
        if (in_tag)
        {
            if (*ci == '<' && last_taglen == 1)
            {
                ++real_offset;
                in_tag = false;
            }
            else if (*ci == '>')
            {
                in_tag = false;
            }
            else
            {
                ++last_taglen;
            }
        }
        else if (*ci == '<')
        {
            in_tag = true;
            last_taglen = 1;
        }
        else
        {
            ++real_offset;
        }
    }
    return (offset);
}
// Return the substring of s from character start to character end,
// where tags count as length 0.
std::string tagged_string_substr(const std::string& s, int start, int end)
{
    return (s.substr(_find_string_location(s, start),
                     _find_string_location(s, end)));
}
int tagged_string_printable_length(const std::string& s)
{
    int len = 0;
    bool in_tag = false;
    int last_taglen = 0;
    for (std::string::const_iterator ci = s.begin(); ci != s.end(); ++ci)
    {
        if (in_tag)
        {
            if (*ci == '<' && last_taglen == 1) // "<<" sequence
            {
                in_tag = false;  // this is an escape for '<'
                ++len;           // len wasn't incremented before
            }
            else if (*ci == '>') // tag close, still nothing printed
            {
                in_tag = false;
            }
            else                 // tag continues
            {
                ++last_taglen;
            }
        }
        else if (*ci == '<')     // tag starts
        {
            in_tag = true;
            last_taglen = 1;
        }
        else                     // normal, printable character
        {
            ++len;
        }
    }
    return (len);
}
// Count the length of the tags in the string.
int tagged_string_tag_length(const std::string& s)
{
    return s.size() - tagged_string_printable_length(s);
}

    std::string error_reason;
    int slot = you.m_quiver->get_fire_item(&error_reason);

    int slot = you.m_quiver->get_fire_item();