fiddlerwoaroof/crawl - Change BWAQ3FHBBM6G3K3KYP75CRTR343RDQZJRYX5ZGYUEXYBAC3APDLAC

sort_menus now allows the user to choose what menus to sort, and how to

sort items, at the cost of obfuscating the sort_menus option massively.

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1494 c06c8d41-db1a-0410-9941-cceddc491573

Created by dshaligram on May 31, 2007

BWAQ3FHBBM6G3K3KYP75CRTR343RDQZJRYX5ZGYUEXYBAC3APDLAC

Dependencies

In channels

main

Change contents

Replacement in crawl-ref/source/stash.cc at line 364 [10.147324]

B:BD[10.156195] → [11.116682:116748]

    StashMenu() : InvMenu(MF_SINGLESELECT), can_travel(false) { }

[10.156195]

[12.22]

    StashMenu() : InvMenu(MF_SINGLESELECT), can_travel(false)
    {
        set_type(MT_PICKUP);
    }

Replacement in crawl-ref/source/spl-book.cc at line 962 [13.397614]

B:BD[13.421617] → [11.137841:137919]

    book = prompt_invent_item("Memorise from which spellbook?", MT_INVSELECT,

[13.421617]

[11.137919]

    book = prompt_invent_item("Memorise from which spellbook?", MT_INVLIST,

Replacement in crawl-ref/source/spells4.cc at line 1881 [13.436250]

B:BD[11.143555] → [11.143555:143635]

        prompt_invent_item( "Throw which potion?", MT_INVSELECT, OBJ_POTIONS );

[11.143555]

[13.488268]

        prompt_invent_item( "Throw which potion?", MT_INVLIST, OBJ_POTIONS );

Replacement in crawl-ref/source/spells1.cc at line 371 [13.616635]

B:BD[13.622714] → [11.158100:158178]

        item_slot = prompt_invent_item( "Identify which item?", MT_INVSELECT,

[13.622714]

[4.155]

        item_slot = prompt_invent_item( "Identify which item?", MT_INVLIST,

Insertion in crawl-ref/source/libutil.h at line 33 [13.2493627]

[9.3477]

[14.965]

std::string pluralise(const std::string &name, 
                      const char *no_of[] = NULL);

Insertion in crawl-ref/source/libutil.cc at line 213 [13.2494093]

[9.4081]

}
// Pluralises a monster or item name. This'll need to be updated for
// correctness whenever new monsters/items are added.
std::string pluralise(const std::string &name, 
                      const char *no_of[])
{
    std::string::size_type pos;
    // Pluralise first word of names like 'eye of draining' or
    // 'scrolls labeled FOOBAR', but only if the whole name is not
    // suffixed by a supplied modifier, such as 'zombie' or 'skeleton'
    if ( (pos = name.find(" of ")) != std::string::npos 
            && !ends_with(name, no_of) )
        return pluralise(name.substr(0, pos)) + name.substr(pos);
    else if ( (pos = name.find(" labeled ")) != std::string::npos
              && !ends_with(name, no_of) )
        return pluralise(name.substr(0, pos)) + name.substr(pos);
    else if (ends_with(name, "us"))
        // Fungus, ufetubus, for instance.
        return name.substr(0, name.length() - 2) + "i";
    else if (ends_with(name, "larva") || ends_with(name, "amoeba"))
        // Giant amoebae sounds a little weird, to tell the truth.
        return name + "e";
    else if (ends_with(name, "ex"))
        // Vortex; vortexes is legal, but the classic plural is cooler.
        return name.substr(0, name.length() - 2) + "ices";
    else if (ends_with(name, "cyclops"))
        return name.substr(0, name.length() - 1) + "es";
    else if (ends_with(name, "y"))
        return name.substr(0, name.length() - 1) + "ies";
    else if (ends_with(name, "elf") || ends_with(name, "olf"))
        // Elf, wolf. Dwarfs can stay dwarfs, if there were dwarfs.
        return name.substr(0, name.length() - 1) + "ves";
    else if (ends_with(name, "mage"))
        // mage -> magi
        return name.substr(0, name.length() - 1) + "i";
    else if ( ends_with(name, "sheep") || ends_with(name, "manes")
            || ends_with(name, "fish") )
        // Maybe we should generalise 'manes' to ends_with("es")?
        return name;
    else if (ends_with(name, "ch") || ends_with(name, "sh") 
            || ends_with(name, "x"))
        // To handle cockroaches, fish and sphinxes. Fish will be netted by
        // the previous check anyway.
        return name + "es";
    else if (ends_with(name, "um"))
        // simulacrum -> simulacra
        return name.substr(0, name.length() - 2) + "a";
    else if (ends_with(name, "efreet"))
        // efreet -> efreeti. Not sure this is correct.
        return name + "i";
    return name + "s";

Replacement in crawl-ref/source/itemname.cc at line 91 [13.2667494]

B:BD[13.2677104] → [15.793:855]

    const std::string auxname = this->name_aux(terse, ident);

[13.2677104]

[15.855]

    const std::string auxname = this->name_aux(descrip, terse, ident);

Replacement in crawl-ref/source/itemname.cc at line 157 [13.2667494]

B:BD[13.2679134] → [15.1397:1436]

        buff << this->quantity << " ";

[13.2679134]

[13.2679267]

        if (descrip != DESC_BASENAME && descrip != DESC_QUALNAME)
            buff << this->quantity << " ";

Replacement in crawl-ref/source/itemname.cc at line 908 [13.2667494]

B:BD[13.2682307] → [15.25910:25973]

std::string item_def::name_aux( bool terse, bool ident ) const

[13.2682307]

[13.2682418]

std::string item_def::name_aux( description_level_type desc,
                                bool terse, bool ident ) const

Replacement in crawl-ref/source/itemname.cc at line 916 [13.2667494]

B:BD[13.2682617] → [16.5197:5272]

    const bool know_curse = ident || item_ident(*this, ISFLAG_KNOW_CURSE);

[13.2682617]

[16.5272]

    const bool basename = desc == DESC_BASENAME;
    const bool qualname = desc == DESC_QUALNAME;
    
    const bool know_curse =
        !basename && !qualname
        && (ident || item_ident(*this, ISFLAG_KNOW_CURSE));

Replacement in crawl-ref/source/itemname.cc at line 924 [13.2667494]

B:BD[16.5332] → [16.5332:5409]

    const bool know_pluses = ident || item_ident(*this, ISFLAG_KNOW_PLUSES);

[16.5332]

[16.5409]

    const bool know_pluses =
        !basename && !qualname
        && (ident || item_ident(*this, ISFLAG_KNOW_PLUSES));

Replacement in crawl-ref/source/itemname.cc at line 978 [13.2667494]
B:BD[13.2687926] → [16.5538:5574]
```
        if (!know_pluses && !terse)
```
[13.2687926]
[13.2687992]
```
        if (!know_pluses && !terse && !basename)
```

Replacement in crawl-ref/source/itemname.cc at line 991 [13.2667494]

B:BD[13.2688312] → [13.2688312:2688375]

B:BD[13.2688375] → [15.26588:26645]

        // always give racial type (it does have game effects)
        buff << racial_description_string(*this, terse);

[13.2688312]

[13.2688375]

        if (!basename)
        {
            // always give racial type (it does have game effects)
            buff << racial_description_string(*this, terse);

Replacement in crawl-ref/source/itemname.cc at line 996 [13.2667494]

B:BD[13.2688376] → [5.3845:3973]

        if (know_type && !terse &&
            (get_weapon_brand(*this) == SPWPN_VAMPIRICISM))
            buff << "vampiric ";

[13.2688376]

[13.2688844]

            if (know_type && !terse &&
                (get_weapon_brand(*this) == SPWPN_VAMPIRICISM))
                buff << "vampiric ";

Replacement in crawl-ref/source/itemname.cc at line 1000 [13.2667494]

B:BD[13.2689062] → [15.26684:26723]

B:BD[15.26723] → [5.3974:4052]

        buff << item_base_name(*this);
        if ( know_type )
            buff << weapon_brand_name(*this, terse);

[13.2688845]

[13.2689162]

            buff << item_base_name(*this);
            if ( know_type )
                buff << weapon_brand_name(*this, terse);

Replacement in crawl-ref/source/itemname.cc at line 1004 [13.2667494]

B:BD[13.2692484] → [16.5633:5688]

B:BD[16.5688] → [15.28402:28434]

        if (know_curse && item_cursed(*this) && terse)
            buff << " (curse)";

[13.2689163]

[13.2692619]

            if (know_curse && item_cursed(*this) && terse)
                buff << " (curse)";
        }

Deletion in crawl-ref/source/itemname.cc at line 1010 [13.2667494]
B:BD[13.2692658] → [5.4053:4082]
```
        need_plural = false;
```

Replacement in crawl-ref/source/itemname.cc at line 1012 [13.2667494]

B:BD[13.2692701] → [17.193:230]

B:BD[17.230] → [15.28477:28534]

        if (brand == SPMSL_POISONED)
            buff << ((terse) ? "poison " : "poisoned ");

[13.2692701]

[11.711769]

        if (!basename)
        {
            if (brand == SPMSL_POISONED)
                buff << ((terse) ? "poison " : "poisoned ");

Replacement in crawl-ref/source/itemname.cc at line 1017 [13.2667494]

B:BD[11.711778] → [11.711778:711813]

B:BD[11.711813] → [15.28535:28597]

        if (brand == SPMSL_CURARE)
            buff << ((terse) ? "curare " : "curare-tipped ");

[11.711778]

[13.2692867]

            if (brand == SPMSL_CURARE)
                buff << ((terse) ? "curare " : "curare-tipped ");
        }

Deletion in crawl-ref/source/itemname.cc at line 1039 [13.2667494]
B:BD[13.2694073] → [13.2694073:2694074]
B:BD[13.2694074] → [18.15485:15517]
B:BD[18.15517] → [15.29146:29171]
```
        if (this->quantity > 1)
            buff << "s";
```
Replacement in crawl-ref/source/itemname.cc at line 1040 [13.2667494]
B:BD[13.2694149] → [16.5715:5738]
```
        if (know_type)
```
[13.2694149]
[13.2694199]
```
        if (know_type && !basename)
```

Replacement in crawl-ref/source/itemname.cc at line 1078 [13.2667494]

B:BD[13.2695478] → [18.15779:15820]

        if (is_random_artefact( *this ))

[13.2695478]

[13.2695518]

        // When asking for the base item name, randartism is ignored.
        if (is_random_artefact( *this ) && !basename)

Replacement in crawl-ref/source/itemname.cc at line 1088 [13.2667494]
B:BD[13.2695798] → [16.5838:5874]
```
        if (!know_pluses && !terse)
```
[13.2695798]
[13.2695864]
```
        if (!know_pluses && !terse & !basename)
```

Replacement in crawl-ref/source/itemname.cc at line 1115 [13.2667494]

B:BD[13.2696702] → [13.2696702:2696763]

B:BD[13.2696763] → [15.30069:30126]

        // always give racial description (has game effects)
        buff << racial_description_string(*this, terse);

[13.2696702]

[13.2697329]

        if (!basename)
        {
            // always give racial description (has game effects)
            buff << racial_description_string(*this, terse);
        }

Insertion in crawl-ref/source/itemname.cc at line 1123 [13.2667494]
[13.2697376]
[13.2697451]
```
        if (!basename)
```

Replacement in crawl-ref/source/itemname.cc at line 1135 [13.2667494]

B:BD[13.2700376] → [16.5924:5979]

        if (know_curse && item_cursed(*this) && terse)

[13.2700376]

[15.30419]

        if (know_curse && item_cursed(*this) && terse && !basename)

Deletion in crawl-ref/source/itemname.cc at line 1156 [13.2667494]
B:BD[13.2704455] → [5.4083:4112]
```
        need_plural = false;
```

Replacement in crawl-ref/source/itemname.cc at line 1158 [13.2667494]

B:BD[13.2704578] → [15.30710:30865]

            buff << "potion";
            if ( this->quantity > 1 )
                buff << "s";
            buff << " of " << potion_type_name(item_typ);

[13.2704578]

[13.2706354]

            buff << "potion of " << potion_type_name(item_typ);

Deletion in crawl-ref/source/itemname.cc at line 1190 [13.2667494]
∅:D[15.31028] → [13.2708062:2708063]
∅:D[11.713804] → [13.2708062:2708063]
B:BD[13.2708062] → [13.2708062:2708063]
B:BD[13.2708063] → [18.16809:16845]
B:BD[18.16845] → [15.31029:31058]
```
            if (this->quantity > 1)
                buff << "s";
```

Replacement in crawl-ref/source/itemname.cc at line 1202 [13.2667494]

B:BD[5.4439] → [5.4439:4499]

        case FOOD_ROYAL_JELLY: buff << "royal jell"; break;

[5.4439]

[5.4499]

        case FOOD_ROYAL_JELLY: buff << "royal jelly"; break;

Replacement in crawl-ref/source/itemname.cc at line 1208 [13.2667494]

B:BD[5.4773] → [5.4773:4831]

        case FOOD_STRAWBERRY: buff << "strawberr"; break;

[5.4773]

[5.4831]

        case FOOD_STRAWBERRY: buff << "strawberry"; break;

Replacement in crawl-ref/source/itemname.cc at line 1214 [13.2667494]

B:BD[5.5088] → [5.5088:5146]

        case FOOD_BEEF_JERKY: buff << "beef jerk"; break;

[5.5088]

[5.5146]

        case FOOD_BEEF_JERKY: buff << "beef jerky"; break;

Deletion in crawl-ref/source/itemname.cc at line 1218 [13.2667494]
B:BD[13.2710661] → [15.31746:31756]
B:BD[15.31756] → [5.5251:5285]
```
        {
            need_plural = false;
```
Deletion in crawl-ref/source/itemname.cc at line 1220 [13.2667494]
∅:D[15.31793] → [13.2710816:2710817]
B:BD[13.2710816] → [13.2710816:2710817]
B:BD[13.2710817] → [15.31794:31823]
∅:D[15.31823] → [13.2710869:2710870]
B:BD[13.2710869] → [13.2710869:2710870]
B:BD[13.2710870] → [18.16884:16920]
B:BD[18.16920] → [15.31824:31853]
```
            buff << "chunk";
            if (this->quantity > 1)
                buff << "s";
```

Replacement in crawl-ref/source/itemname.cc at line 1221 [13.2667494]

B:BD[13.2711130] → [8.10020:10099]

            buff << " of " << mons_type_name(it_plus, DESC_PLAIN) << " flesh";

[13.2711130]

[15.32026]

            buff << "chunk of "
                 << mons_type_name(it_plus, DESC_PLAIN)
                 << " flesh";

Deletion in crawl-ref/source/itemname.cc at line 1226 [13.2667494]
∅:D[15.32055] → [13.2711130:2711140]
B:BD[13.2711130] → [13.2711130:2711140]
```
        }
```

Deletion in crawl-ref/source/itemname.cc at line 1227 [13.2667494]

B:BD[13.2711141] → [13.2711141:2711257]

B:BD[13.2711257] → [15.32056:32114]

        if (item_typ == FOOD_ROYAL_JELLY || item_typ == FOOD_STRAWBERRY
            || item_typ == FOOD_BEEF_JERKY)
            buff << ((this->quantity > 1) ? "ie" : "y");

Replacement in crawl-ref/source/itemname.cc at line 1230 [13.2667494]

B:BD[13.2711403] → [5.5286:5315]

∅:D[5.5315] → [15.32160:32266]

B:BD[13.2711403] → [15.32160:32266]

        need_plural = false;
        buff << "scroll";
        if ( this->quantity > 1 )
            buff << "s";
        buff << " ";

[13.2711403]

[13.2711520]

        buff << "scroll ";

Replacement in crawl-ref/source/itemname.cc at line 1268 [13.2667494]
B:BD[13.2714511] → [18.17474:17515]
```
        if (is_random_artefact( *this ))
```
[13.2714511]
[13.2714551]
```
        if (is_random_artefact( *this ) && !basename)
```

Replacement in crawl-ref/source/itemname.cc at line 1276 [13.2667494]

B:BD[13.2714783] → [15.32749:32804]

            if (know_pluses && ring_has_pluses(*this))

[13.2714783]

[13.2715097]

            if (know_pluses && ring_has_pluses(*this) && !basename && !qualname)

Deletion in crawl-ref/source/itemname.cc at line 1308 [13.2667494]
B:BD[13.2727066] → [5.5316:5345]
```
        need_plural = false;
```
Deletion in crawl-ref/source/itemname.cc at line 1311 [13.2667494]
∅:D[15.33596] → [13.2728475:2728476]
B:BD[13.2728475] → [13.2728475:2728476]
B:BD[13.2728576] → [18.18204:18240]
B:BD[18.18240] → [15.33597:33626]
```
            if (this->quantity > 1)
                buff << "s";
```

Insertion in crawl-ref/source/itemname.cc at line 1402 [13.2667494]

[15.35209]

[10.360262]


    // One plural to rule them all.
    if (need_plural && this->quantity > 1 && !basename && !qualname)
        buff.str( pluralise(buff.str()) );

Replacement in crawl-ref/source/itemname.cc at line 1408 [13.2667494]
B:BD[10.360285] → [16.6844:6873]
```
    if (!terse && know_type)
```
[10.360285]
[10.360339]
```
    if (!terse && !basename && know_type)
```
Deletion in crawl-ref/source/itemname.cc at line 1462 [13.2667494]
B:BD[13.2745164] → [13.2745164:2745165]
B:BD[13.2745165] → [5.5346:5389]
∅:D[5.5389] → [15.35841:35862]
B:BD[13.2745423] → [15.35841:35862]
```
    if (need_plural && this->quantity > 1)
        buff << "s";
```

Replacement in crawl-ref/source/item_use.cc at line 212 [13.2781507]

∅:D[2.210] → [11.731531:731586]

B:BD[11.731531] → [11.731531:731586]

                            MT_INVSELECT, OSEL_WIELD,

[2.210]

[11.731586]

                            MT_INVLIST, OSEL_WIELD,

Replacement in crawl-ref/source/item_use.cc at line 653 [13.2781507]

B:BD[13.2796991] → [11.734257:734332]

        slot = prompt_invent_item( mesg.c_str(), MT_INVSELECT, OBJ_ARMOUR,

[13.2796991]

[19.80464]

        slot = prompt_invent_item( mesg.c_str(), MT_INVLIST, OBJ_ARMOUR,

Replacement in crawl-ref/source/item_use.cc at line 1072 [13.2781507]

B:BD[2.285] → [2.285:336]

                                     MT_INVSELECT,

[2.285]

[11.737880]

                                     MT_INVLIST,

Replacement in crawl-ref/source/item_use.cc at line 2289 [13.2781507]

B:BD[10.367601] → [11.756526:756581]

                        MT_INVSELECT, OBJ_JEWELLERY );

[10.367601]

[10.367654]

                        MT_INVLIST, OBJ_JEWELLERY );

Replacement in crawl-ref/source/item_use.cc at line 2429 [13.2781507]

B:BD[10.368012] → [11.758669:758727]

                                            MT_INVSELECT,

[10.368012]

[19.80683]

                                            MT_INVLIST,

Replacement in crawl-ref/source/item_use.cc at line 2521 [13.2781507]

B:BD[11.759580] → [11.759580:759630]

                                    MT_INVSELECT,

[11.759580]

[11.759630]

                                    MT_INVLIST,

Replacement in crawl-ref/source/item_use.cc at line 2690 [13.2781507]
B:BD[11.760912] → [11.760912:760947]
```
                    MT_INVSELECT, 
```
[11.760912]
[11.760947]
```
                    MT_INVLIST, 
```

Replacement in crawl-ref/source/item_use.cc at line 2734 [13.2781507]

B:BD[11.761306] → [11.761306:761369]

                                    MT_INVSELECT, OBJ_POTIONS,

[11.761306]

[19.81522]

                                    MT_INVLIST, OBJ_POTIONS,

Replacement in crawl-ref/source/item_use.cc at line 3230 [13.2781507]
B:BD[11.762151] → [11.762151:762190]
```
                        MT_INVSELECT, 
```
[11.762151]
[11.762190]
```
                        MT_INVLIST, 
```

Replacement in crawl-ref/source/item_use.cc at line 3588 [13.2781507]

B:BD[11.763139] → [11.763139:763197]

                                        MT_INVSELECT, -1,

[11.763139]

[19.81873]

                                        MT_INVLIST, -1,

Insertion in crawl-ref/source/invent.h at line 59 [13.2919073]

[11.768211]

    mutable std::string basename;
    mutable std::string qualname;

Insertion in crawl-ref/source/invent.h at line 69 [13.2919073]

[11.768348]


    const std::string &get_basename() const;
    const std::string &get_qualname() const;
    const std::string &get_fullname() const;
    const bool        is_item_cursed() const;

Replacement in crawl-ref/source/invent.h at line 90 [13.2919073]

B:BD[11.768584] → [11.768584:768646]

        : Menu(mflags), type(MT_INVSELECT), pre_select(NULL),

[11.768584]

[11.768646]

        : Menu(mflags), type(MT_INVLIST), pre_select(NULL),

Insertion in crawl-ref/source/invent.h at line 130 [13.2919073]

[11.770201]

    void sort_menu(std::vector<InvEntry*> &items,
                   const menu_sort_condition *cond);
    const menu_sort_condition *find_menu_sort_condition() const;

Replacement in crawl-ref/source/invent.h at line 154 [13.2919073]

B:BD[11.770660] → [11.770660:770728]

                        const char *title, bool noselect = false );

[11.770660]

[13.2919755]

                        const char *title, bool noselect = false,
                        menu_type mtype = MT_PICKUP );

Insertion in crawl-ref/source/invent.h at line 201 [13.2919073]

[7.1329]

[10.370196]


void init_item_sort_comparators(item_sort_comparators &list,
                                const std::string &set);

Insertion in crawl-ref/source/invent.cc at line 85 [13.2920632]

[11.772927]

const std::string &InvEntry::get_basename() const
{
    if (basename.empty())
        basename = item->name(DESC_BASENAME);
    return (basename);
}
const std::string &InvEntry::get_qualname() const
{
    if (qualname.empty())
        qualname = item->name(DESC_QUALNAME);
    return (qualname);
}
const std::string &InvEntry::get_fullname() const
{
    return (text);
}
const bool InvEntry::is_item_cursed() const
{
    return (item_ident(*item, ISFLAG_KNOW_CURSE) && item_cursed(*item));
}

Insertion in crawl-ref/source/invent.cc at line 284 [13.2920632]

[11.776734]

}
template <std::string (*proc)(const InvEntry *a)>
int compare_item_str(const InvEntry *a, const InvEntry *b)
{
    return (proc(a).compare(proc(b)));
}
template <typename T, T (*proc)(const InvEntry *a)>
int compare_item(const InvEntry *a, const InvEntry *b)
{
    return (int(proc(a)) - int(proc(b)));

Replacement in crawl-ref/source/invent.cc at line 298 [13.2920632]

B:BD[13.2922288] → [11.776737:776810]

static bool compare_menu_entries(const MenuEntry* a, const MenuEntry* b)

[13.2922288]

[11.776810]

// C++ needs anonymous subs already!
std::string sort_item_basename(const InvEntry *a)
{
    return a->get_basename();
}
std::string sort_item_qualname(const InvEntry *a)

Replacement in crawl-ref/source/invent.cc at line 305 [13.2920632]

B:BD[11.776812] → [11.776812:776834]

    return (*a < *b);

[11.776812]

[11.776834]

    return a->get_qualname();
}
std::string sort_item_fullname(const InvEntry *a)
{
    return a->get_fullname();
}
int sort_item_qty(const InvEntry *a)
{
    return a->quantity;
}
int sort_item_slot(const InvEntry *a)
{
    return a->item->link;
}
bool sort_item_curse(const InvEntry *a)
{
    return a->is_item_cursed();
}
static bool compare_invmenu_items(const InvEntry *a, const InvEntry *b,
                                  const item_sort_comparators *cmps)
{
    for (item_sort_comparators::const_iterator i = cmps->begin();
         i != cmps->end();
         ++i)
    {
        const int cmp = i->compare(a, b);
        if (cmp)
            return (cmp < 0);
    }
    return (false);
}
struct menu_entry_comparator
{
    const menu_sort_condition *cond;
    
    menu_entry_comparator(const menu_sort_condition *c)
        : cond(c)
    {
    }
    bool operator () (const MenuEntry* a, const MenuEntry* b) const
    {
        const InvEntry *ia = dynamic_cast<const InvEntry *>(a);
        const InvEntry *ib = dynamic_cast<const InvEntry *>(b);
        return compare_invmenu_items(ia, ib, &cond->cmp);
    }
};
void init_item_sort_comparators(item_sort_comparators &list,
                                const std::string &set)
{
    static struct
    {
        const std::string cname;
        item_sort_fn cmp;
    } cmp_map[]  =
      {
          { "basename", compare_item_str<sort_item_basename> },
          { "qualname", compare_item_str<sort_item_qualname> },
          { "fullname", compare_item_str<sort_item_fullname> },
          { "curse",    compare_item<bool, sort_item_curse> },
          { "qty",      compare_item<int, sort_item_qty> },
          { "slot",     compare_item<int, sort_item_slot> },
      };
    
    list.clear();
    std::vector<std::string> cmps = split_string(",", set);
    for (int i = 0, size = cmps.size(); i < size; ++i)
    {
        std::string s = cmps[i];
        if (s.empty())
            continue;
        
        const bool negated = s[0] == '>';
        if (s[0] == '<' || s[0] == '>')
            s = s.substr(1);
        for (unsigned ci = 0; ci < ARRAYSIZE(cmp_map); ++ci)
            if (cmp_map[ci].cname == s)
            {
                list.push_back( item_comparator( cmp_map[ci].cmp, negated ) );
                break;
            }
    }
    if (list.empty())
        list.push_back(
            item_comparator(compare_item_str<sort_item_fullname>));
}
const menu_sort_condition *InvMenu::find_menu_sort_condition() const
{
    for (int i = 0, size = Options.sort_menus.size(); i < size; ++i)
        if (Options.sort_menus[i].matches(type))
            return &Options.sort_menus[i];
    return (NULL);
}
void InvMenu::sort_menu(std::vector<InvEntry*> &invitems,
                        const menu_sort_condition *cond)
{
    if (!cond || cond->sort == -1 || (int) invitems.size() < cond->sort)
        return;
    
    std::sort( invitems.begin(), invitems.end(), menu_entry_comparator(cond) );

Insertion in crawl-ref/source/invent.cc at line 423 [13.2920632]
[11.777196]
[11.777196]
```
    const menu_sort_condition *cond = find_menu_sort_condition();
```

Replacement in crawl-ref/source/invent.cc at line 439 [13.2920632]

B:BD[11.777593] → [20.139:241]

∅:D[20.241] → [11.777625:777741]

B:BD[11.777625] → [11.777625:777741]

        if (Options.sort_menus != -1 &&
            (int)items_in_class.size() >= Options.sort_menus)
            std::sort( items_in_class.begin(), items_in_class.end(),
                       compare_menu_entries );

[11.777593]

[11.777741]

        sort_menu(items_in_class, cond);

Replacement in crawl-ref/source/invent.cc at line 581 [13.2920632]

B:BD[11.779700] → [11.779700:779770]

                                   const char *title, bool noselect )

[11.779700]

[10.377834]

                                   const char *title, bool noselect,
                                   menu_type mtype )

Insertion in crawl-ref/source/invent.cc at line 588 [13.2920632]
[11.779818]
[11.779818]
```
        menu.set_type(mtype);
```
Insertion in crawl-ref/source/initfile.cc at line 31 [13.2957258]
[13.2957817]
[10.391028]
```
#include "invent.h"
```

Replacement in crawl-ref/source/initfile.cc at line 623 [13.2957258]

B:BD[11.793164] → [21.217:286]

    // Don't sort menus by default.
    sort_menus             = -1;

[11.793164]

[11.793200]

    // Sort only pickup menus by default.
    sort_menus.clear();
    set_menu_sort("pickup: true");

Insertion in crawl-ref/source/initfile.cc at line 1308 [13.2957258]

[22.3112]

[11.798376]

// Option syntax is:
// sort_menu = [menu_type:]yes|no|auto:n[:sort_conditions]
void game_options::set_menu_sort(std::string field)
{
    if (field.empty())
        return;
    
    menu_sort_condition cond(field);
    sort_menus.push_back(cond);
}

Replacement in crawl-ref/source/initfile.cc at line 2058 [13.2957258]

B:BD[11.807993] → [20.910:980]

        sort_menus = read_bool_or_number(field, sort_menus, "auto:");

[11.807993]

[10.417926]

        std::vector<std::string> frags = split_string(";", field);
        for (int i = 0, size = frags.size(); i < size; ++i)
        {
            if (frags[i].empty())
                continue;
            set_menu_sort(frags[i]);
        }

Insertion in crawl-ref/source/initfile.cc at line 2722 [13.2957258]

[11.813600]


///////////////////////////////////////////////////////////////////////
// menu_sort_condition
menu_sort_condition::menu_sort_condition(menu_type _mt, int _sort)
    : mtype(_mt), sort(_sort), cmp()
{
}
menu_sort_condition::menu_sort_condition(const std::string &s)
    : mtype(MT_ANY), sort(-1), cmp()
{
    std::string cp = s;
    set_menu_type(cp);
    set_sort(cp);
    set_comparators(cp);
}
bool menu_sort_condition::matches(menu_type mt) const
{
    return (mtype == MT_ANY || mtype == mt);
}
void menu_sort_condition::set_menu_type(std::string &s)
{
    static struct
    {
        const std::string mname;
        menu_type mtype;
    } menu_type_map[] =
      {
          { "any:",    MT_ANY       },
          { "inv:",    MT_INVLIST   },
          { "drop:",   MT_DROP      },
          { "pickup:", MT_PICKUP    }
      };
    for (unsigned mi = 0; mi < ARRAYSIZE(menu_type_map); ++mi)
    {
        const std::string &name = menu_type_map[mi].mname;
        if (s.find(name) == 0)
        {
            s = s.substr(name.length());
            mtype = menu_type_map[mi].mtype;
            break;
        }
    }
}
void menu_sort_condition::set_sort(std::string &s)
{
    // Strip off the optional sort clauses and get the primary sort condition.
    std::string::size_type trail_pos = s.find(':');
    if (s.find("auto:") == 0)
        trail_pos = s.find(':', trail_pos + 1);
    std::string sort_cond =
        trail_pos == std::string::npos? s : s.substr(0, trail_pos);
    trim_string(sort_cond);
    sort = read_bool_or_number(sort_cond, sort, "auto:");
    if (trail_pos != std::string::npos)
        s = s.substr(trail_pos + 1);
    else
        s.clear();
}
void menu_sort_condition::set_comparators(std::string &s)
{
    init_item_sort_comparators(
        cmp,
        s.empty()? "basename, qualname, curse, qty" : s);
}

Replacement in crawl-ref/source/food.cc at line 401 [13.3043806]
B:BD[11.853673] → [11.853673:853707]
```
                    MT_INVSELECT,
```
[11.853673]
[11.853707]
```
                    MT_INVLIST,
```

Replacement in crawl-ref/source/externs.h at line 445 [13.3270163]

B:BD[18.27409] → [15.35964:36022]

    std::string name_aux( bool terse, bool ident ) const;

[18.27409]

[13.3275464]

    std::string name_aux( description_level_type desc,
                          bool terse, bool ident ) const;

Insertion in crawl-ref/source/externs.h at line 1243 [13.3270163]

[23.3906]

[10.442371]

};
class InvEntry;
typedef int (*item_sort_fn)(const InvEntry *a, const InvEntry *b);
struct item_comparator
{
    item_sort_fn cmpfn;
    bool negated;
    item_comparator(item_sort_fn cfn, bool neg = false)
        : cmpfn(cfn), negated(neg)
    {
    }
    int compare(const InvEntry *a, const InvEntry *b) const
    {
        return (negated? -cmpfn(a, b) : cmpfn(a, b));
    }
};
typedef std::vector<item_comparator> item_sort_comparators;
struct menu_sort_condition
{
public:
    menu_type mtype;
    int       sort;
    item_sort_comparators cmp;
public:
    menu_sort_condition(menu_type mt = MT_INVLIST, int sort = 0);
    menu_sort_condition(const std::string &s);
    bool matches(menu_type mt) const;
private:
    void set_menu_type(std::string &s);
    void set_sort(std::string &s);
    void set_comparators(std::string &s);

Replacement in crawl-ref/source/externs.h at line 1435 [13.3270163]

B:BD[11.900343] → [20.990:1115]

    int        sort_menus;        // 0 = always, -1 = never, number = beyond
                                  // that size.

[11.900343]

[10.445195]

    std::vector<menu_sort_condition> sort_menus;

Insertion in crawl-ref/source/externs.h at line 1562 [13.3270163]
[24.1394]
[25.10807]
```
    void set_menu_sort(std::string field);
```

Replacement in crawl-ref/source/enum.h at line 907 [13.3287960]

B:BD[26.89799] → [26.89799:89843]

    DESC_INVENTORY                     // 9

[26.89799]

[13.3307232]

    DESC_INVENTORY,                    // 9
    // Partial item names.
    DESC_BASENAME,                     // Base name of item subtype
    DESC_QUALNAME                      // Name without articles, quantities,
                                       // enchantments.

Replacement in crawl-ref/source/enum.h at line 1730 [13.3287960]
B:BD[11.917787] → [11.917787:917858]
```
    MT_INVSELECT,                      // General - select single item
```
[11.917787]
[11.917858]
```
    MT_ANY = -1,
    
```
Replacement in crawl-ref/source/enum.h at line 1733 [13.3287960]
B:BD[11.917915] → [11.917915:917927]
```
    MT_DROP
```
[11.917915]
[11.917927]
```
    MT_DROP,
    MT_PICKUP
```

Replacement in crawl-ref/source/debug.cc at line 794 [13.4016436]

B:BD[13.4042374] → [11.1025512:1025587]

    int item = prompt_invent_item("Tweak which item? ", MT_INVSELECT, -1);

[13.4042374]

[13.4042437]

    int item = prompt_invent_item("Tweak which item? ", MT_INVLIST, -1);

Replacement in crawl-ref/source/command.cc at line 146 [13.4082507]

B:BD[13.4084333] → [11.1186120:1186198]

    from_slot = prompt_invent_item( "Adjust which item?", MT_INVSELECT, -1 );

[13.4084333]

[13.4084398]

    from_slot = prompt_invent_item( "Adjust which item?", MT_INVLIST, -1 );

Replacement in crawl-ref/source/command.cc at line 157 [13.4082507]
B:BD[11.1186281] → [11.1186281:1186316]
```
                    MT_INVSELECT, 
```
[11.1186281]
[11.1186316]
```
                    MT_INVLIST, 
```

Replacement in crawl-ref/source/acr.cc at line 425 [13.4397395]

B:BD[13.4409445] → [11.1256450:1256526]

        i = prompt_invent_item( "Value of which item?", MT_INVSELECT, -1 );

[13.4409445]

[13.4409507]

        i = prompt_invent_item( "Value of which item?", MT_INVLIST, -1 );

Replacement in crawl-ref/source/acr.cc at line 439 [13.4397395]

B:BD[11.1256559] → [11.1256559:1256634]

                "Make an artefact out of which item?", MT_INVSELECT, -1 );

[11.1256559]

[13.4409903]

                "Make an artefact out of which item?", MT_INVLIST, -1 );

Deletion in crawl-ref/source/Kills.h at line 15 [10.553491]
B:BD[10.553734] → [27.5010:5058]
∅:D[27.5058] → [26.92000:92051]
B:BD[26.92000] → [26.92000:92051]
```
std::string pluralise(const std::string &name, 
                      const char *no_of[] = NULL);
```

Deletion in crawl-ref/source/Kills.cc at line 354 [10.558235]

B:BD[10.570059] → [10.570059:570060]

B:BD[10.570060] → [27.5407:5480]

∅:D[27.5480] → [10.570133:570169]

B:BD[10.570133] → [10.570133:570169]

B:BD[10.570169] → [27.5481:5529]

∅:D[27.5529] → [26.92102:92145]

B:BD[26.92102] → [26.92102:92145]

∅:D[26.92145] → [10.570281:570316]

B:BD[10.570281] → [10.570281:570316]

B:BD[10.570316] → [27.5530:5607]

∅:D[27.5607] → [10.570393:570571]

B:BD[10.570393] → [10.570393:570571]

B:BD[10.570571] → [27.5608:5674]

∅:D[27.5674] → [10.570657:571312]

B:BD[10.570657] → [10.570657:571312]

B:BD[10.571312] → [28.979:1042]

∅:D[28.1042] → [10.571348:572277]

B:BD[10.571348] → [10.571348:572277]


// Pluralises a monster name. This'll need to be updated for correctness
// whenever new monsters are added.
std::string pluralise(const std::string &name, 
                      const char *no_of[])
{
    std::string::size_type pos;
    // Pluralise first word of names like 'eye of draining', but only if the
    // whole name is not suffixed by a modifier, such as 'zombie' or 'skeleton'
    if ( (pos = name.find(" of ")) != std::string::npos 
            && !ends_with(name, no_of) )
        return pluralise(name.substr(0, pos)) + name.substr(pos);
    else if (ends_with(name, "us"))
        // Fungus, ufetubus, for instance.
        return name.substr(0, name.length() - 2) + "i";
    else if (ends_with(name, "larva") || ends_with(name, "amoeba"))
        // Giant amoebae sounds a little weird, to tell the truth.
        return name + "e";
    else if (ends_with(name, "ex"))
        // Vortex; vortexes is legal, but the classic plural is cooler.
        return name.substr(0, name.length() - 2) + "ices";
    else if (ends_with(name, "cyclops"))
        return name.substr(0, name.length() - 1) + "es";
    else if (ends_with(name, "y"))
        return name.substr(0, name.length() - 1) + "ies";
    else if (ends_with(name, "elf") || ends_with(name, "olf"))
        // Elf, wolf. Dwarfs can stay dwarfs, if there were dwarfs.
        return name.substr(0, name.length() - 1) + "ves";
    else if (ends_with(name, "mage"))
        // mage -> magi
        return name.substr(0, name.length() - 1) + "i";
    else if ( ends_with(name, "sheep") || ends_with(name, "manes")
            || ends_with(name, "fish") )
        // Maybe we should generalise 'manes' to ends_with("es")?
        return name;
    else if (ends_with(name, "ch") || ends_with(name, "sh") 
            || ends_with(name, "x"))
        // To handle cockroaches, fish and sphinxes. Fish will be netted by
        // the previous check anyway.
        return name + "es";
    else if (ends_with(name, "um"))
        // simulacrum -> simulacra
        return name.substr(0, name.length() - 2) + "a";
    else if (ends_with(name, "efreet"))
        // efreet -> efreeti. Not sure this is correct.
        return name + "i";

Deletion in crawl-ref/source/Kills.cc at line 355 [10.558235]
B:BD[10.572278] → [10.572278:572304]
```
    return name + "s";
}
```
Replacement in crawl-ref/init.txt at line 153 [13.4830895]
B:BD[29.4349] → [30.1074:1113]
```
# sort_menus = (auto:5 | true | false)
```
[29.4349]
[13.4835203]
```
# sort_menus = pickup: true : basename, qualname, curse, qty
```

Insertion in crawl-ref/docs/crawl_options.txt at line 654 [29.63392]

[3.406]

[30.28118]


sort_menus = [menu:](true | false | auto:X)[:sort_order]
        Controls if and how items are sorted in inventory and pickup
        menus.

Replacement in crawl-ref/docs/crawl_options.txt at line 659 [29.63392]

B:BD[30.28119] → [30.28119:28231]

B:BD[30.28231] → [21.49034:49135]

∅:D[21.49135] → [31.19578:19637]

B:BD[30.28310] → [31.19578:19637]

B:BD[31.19637] → [21.49136:49165]

B:BD[21.49165] → [6.2308:2388]

∅:D[6.2388] → [21.49166:49239]

B:BD[30.28487] → [21.49166:49239]

∅:D[21.49239] → [30.28565:28631]

B:BD[30.28565] → [30.28565:28631]

sort_menus = (true | false | auto:X)
        When set to true, items are sorted by description in inventory and
        pickup menus. When set to false (the default), items are ordered by
        equipment slot. 
        When set to a number - using a syntax of the form 
         sort_menus = auto:5
        - items are sorted by their description if the total number of items in
        that category is at least that number; in the example, having 4 
        kinds of potions would not sort them, but having 5 would.

[30.28119]

[31.19638]

        When sort_menus = false (the default), items are not sorted,
        and will be ordered by inventory letter (or in the order
        they're stacked for items on the floor).
        When sort_menus = true, items are sorted by base name,
        qualified name, curse status and quantity.
        If sort_menus = auto:X, items are sorted if there are at least
        X items in the same category. For instance:
            sort_menus = auto:5
        will sort item classes that have at least 5 items. For
        instance, having 4 kinds of potions would not sort them, but
        having 5 would.
        You can explicitly specify sort criteria in the sort_menus
        option as:
            sort_menus = true : basename, qualname, curse, qty
        The available sort criteria are:
        
        * basename:
          This is the name of the item type. The basename for all of
          "a +0 robe", "an embroidered robe" and "the cursed +2 robe
          of Ponies" is just "robe".
        * qualname:
          The name of the item without articles (a/an/the),
          quantities, enchantments, or curse-status. The qualified
          names for the robes described above are "robe", "embroidered
          robe" and "robe of Ponies", respectively.
        * fullname:
          This is the name of the item as displayed in menus
          (including quantities, curse-status, etc.)
        * curse:
          Curse-status of the item (if known). Uncursed items show up
          first.
        * qty:
          The quantity for stackable items (such as scrolls, potions,
          etc.)
        * slot:
          The inventory letter for items in inventory; irrelevant for
          items on the floor.
        The default sort criteria are: "basename, qualname, curse, qty".
        You can ask for a descending order sort by prefixing one or
        more sort criteria with > as:
            sort_menus = true : basename, >qty
        You can also request sorting only for specific menus:
            sort_menus = pickup: true
        or
            sort_menus = inv: true
        (Menu types must be specified as name:, with no space between
        name and colon.)
        The menu selectors available are:
        pickup: All pickup menus, stash-search menus, etc. for items not
                in your inventory.
        drop:   The item drop menu.
        inv:    Inventory listings for any command (but not for dropping
                items).
        any:    All menus; this is the default when unspecified.