Removing slash commands

[Billtopia]

I was wondering how to remove a slash command once it has been added... I am making an addon that can take user supplied lua snippets and assign them to a slash command and want the option of having them be able to enable / disable the commands on the fly if they wish without needing to do a /reload

I was trying it by the following but it does not go away...

RunScript( ('SLASH_%s1 = nil'):format( cmdName ) )
RunScript( ('SlashCmdList["%s"] = nil'):format( cmdName ) )

cmdName gets made in addon by appending the addon name and the slash command (minus the slash)
the same as it is constructed during the creation of the slash command in the addon loaded event

[Nibelheim]

Originally Posted by Billtopia I was wondering how to remove a slash command once it has been added... I am making an addon that can take user supplied lua snippets and assign them to a slash command and want the option of having them be able to enable / disable the commands on the fly if they wish without needing to do a /reload I was trying it by the following but it does not go away... RunScript( ('SLASH_%s1 = nil'):format( cmdName ) ) RunScript( ('SlashCmdList["%s"] = nil'):format( cmdName ) ) cmdName gets made in addon by appending the addon name and the slash command (minus the slash) the same as it is constructed during the creation of the slash command in the addon loaded event

I don't think you want the "" around the %s

[Malsomnus]

I tried it with a specific command, and it didn't work, so I don't think the quotes are the problem. It's pretty weird though.

[Billtopia]

It needs the quotes as it will be a string indexing the SlashCmdList table
the %s gets filled in with a string value from cmdName via the format

[Nibelheim]

Edit: I'm an idiot

What you want to remove from is not SlashCmdList, but hash_SlashCmdList. SlashCmdList is a temporary storage table and doesn't actually retain any data.

[SDPhantom]

Actually, the problem is when you run a slash command, it takes all entries in SlashCmdList and moves them to its metatable. There are 3 steps that need to be done in order to unregister a slash command. Some unexpected results may occur if you don't clear all of the steps.

• Clear all SLASH_* globals.
• Clear the entry from SlashCmdList and its metatable.
• Clear the entry from hash_SlashCmdList.

The following function should accomplish this.

function RemoveSlashToken(token)
    local i=1;
    while _G["SLASH_"..token..i]~=nil do
        local slash=_G["SLASH_"..token..i];
 
        _G["SLASH_"..token..i]=nil;--   Removes SLASH_*
        hash_SlashCmdList[slash]=nil;-- Removes from hash_SlashCmdList
 
        i=i+1;
    end
 
    SlashCmdList[token]=nil;--  Removes from SlashCmdList
    getmetatable(SlashCmdList).__index[token]=nil;--    Removes from metatable
end

[Billtopia]

Thanks... hash_SlashCmdList["/MYCOMMAND"] = nil
works fine... (I had to do a /dump on it to see how it was indexed)

I found nothing on the hash table when I was looking for a way to remove the commands... now I know lol

***************************

Oh no... another post as I was replying to the previous lol
but I guess I need more info anyways...

Should I just remove my own _G["SLASH_"] tokens or all of them? will I break something if I do? or does it not matter?

[Nibelheim]

Originally Posted by SDPhantom Actually, the problem is when you run a slash command, it takes all entries in SlashCmdList and moves them to its metatable. There are 3 steps that need to be done in order to unregister a slash command. Some unexpected results may occur if you don't clear all of the steps. Clear all SLASH_* globals. Clear the entry from SlashCmdList and its metatable. Clear the entry from hash_SlashCmdList.

Neato. An interesting topic. Curiosity made me pop open ChatFrame.lua just to have a looksy at how Blizz handles slash commands.

Originally Posted by Billtopia Should I just remove my own _G["SLASH_"] tokens or all of them? will I break something if I do? or does it not matter?

Just your own. If you clear them all, any slash commands that haven't been moved to the hash table (this occurs when someone uses a slash command) will be lost.

[Billtopia]

nevermind... I see you are only clearing one, not all in the lua... so it is all of my own, not all

DOH!!!

Thanks for the help

[SDPhantom]

Originally Posted by Nibelheim Neato. An interesting topic. Curiosity made me pop open ChatFrame.lua just to have a looksy at how Blizz handles slash commands.

They changed it in Cata 4.3, which broke SlashHelp at the time. Figures one change they make that doesn't offer any benefit breaks something useful.

[pelf]

Not sure if this helps, but I found a few functions in the SlashCmdList, while browsing through the source, that never got bound to a slash command. I wanted to change that, so I wrote this:

local errorsOff = "UI_ERRORS_OFF"

rawset(SlashCmdList, errorsOff, SlashCmdList[errorsOff])

_G["SLASH_"..errorsOff.."1"] = "/suppresserrors"
_G["SLASH_"..errorsOff.."2"] = "/se"

local errorsOn = "UI_ERRORS_ON"

rawset(SlashCmdList, errorsOn, SlashCmdList[errorsOn])

_G["SLASH_"..errorsOn.."1"] = "/restoreerrors"
_G["SLASH_"..errorsOn.."2"] = "/re"

ChatFrame_ImportAllListsToHash()

Using rawset lets me set the value directly without triggering the stuff that would prevent this from working as it looks like it should. Then, the call to ChatFrame_ImportAllListsToHash processes all the entries in SlashCmdList that aren't migrated into the hash_ version using the proper sequence of events to activate the slash commands.

[SDPhantom]

Originally Posted by pelf Using rawset lets me set the value directly without triggering the stuff that would prevent this from working as it looks like it should.

Not exactly a solid explanation. You're talking of avoiding the __newindex metamethod in which if one exists, it would need to allow writing to the table or else break the slash command system. What's happening in the code is you're copying the function from the metatable and inserting it back into the table itself. This lets ChatFrame_ImportAllListsToHash() see the function and reprocess it. In the long run, rawset() isn't necessary as the following deceptively works fine as-is without the overhead of calling a global function.

SlashCmdList.UI_ERRORS_OFF=SlashCmdList.UI_ERRORS_OFF;
SlashCmdList.UI_ERRORS_ON=SlashCmdList.UI_ERRORS_ON;

Note since the indices don't exist, it pulls the functions from the metatable and creates the entry in the base table, not back into the metatable.





If you really wanted to bypass setting all the globals, you could just inject the function directly into hash.

hash_SlashCmdList["/ERROROFF"]=SlashCmdList.UI_ERRORS_OFF;
hash_SlashCmdList["/ERROFF"]=SlashCmdList.UI_ERRORS_OFF;

hash_SlashCmdList["/ERRORON"]=SlashCmdList.UI_ERRORS_ON;
hash_SlashCmdList["/ERRON"]=SlashCmdList.UI_ERRORS_ON;

Note the indices need to be in uppercase as all entered slash commands are checked this way.

[pelf]

I knew someone wouldn't be able to resist giving a better explanation . I spent a while that night sifting through UI code to figure out how it expects slash commands to be added and I will admit that a good bit of it is a blur.

Thanks for expounding.

[SDPhantom]

The previous version of the command system scanned SlashCmdList for command tokens in which to check the specific globals for a matching command. There was an included feature when it found a command, it loaded the command with a pointer to the command token's handler function into a cache table, hash_SlashCmdList. Further uses of that specific command would run the function from cache instead of running the scanner again.

The current version runs exclusively off of the mappings in hash_SlashCmdList and queries SlashCmdList for new entries using its metatable system for backwards compatibility when a slash command is executed. Note all slash commands are converted to uppercase before being inserted into hash_SlashCmdList. This helps with the case insensitivity of the command system. Using an index that is not all uppercase will not be recognized.

The scanner of the new command system is based off the fact when an entry is moved into the __index section of a metatable, it can still be accessed if referenced directly. Therefore command calls like SlashCmdList["Command_Token"]() will sill function as they always had. However, when the base table is iterated through with a for ... end loop, the entry will not be seen by the loop. This allows backwards compatibility as well as letting the new system see if any new commands had been added since the last time scanner had been run.