Another quick and dirty. This is for discovering functions. It has no interface, it just saves the data it captures to saved variables which you can view live using zgoo. It build a cross reference of functions, and captures calls to those function. Capturing calls might be a bit dangerous, but there doesn't seem a good reason not to include it. The general structure of that saved variable is:
Lua Code:
FunctionCapture_DB =
{
Dictionary = {},
FunctionNames = {},
FunctionAddrs = {},
FunctionTree = {},
Synonyms = {},
Fired = {},
}
All entries are cross references for functions, there is no capture at this point. FunctionNames and FunctionAddrs is simply a list of functions indexed by name or address. Addresses are in the form "function: 0F9E9A28". Synonyms is a list of function pointing to the same address grouped by address. Fired is a capture of the parms and result of the first call to function after it's hooked.
Dictionary and FunctionTree breaks apart a name by words. A word for this purpose is simply a capital letter followed by 1 or more lowercase letters. Nothing is actually thrown out so "This&That" is three words. Underscores "_" are stripped out. A special case is a prefix for a function, i.e. "prefix_function". Whatever precedes the first underscore is the first word of the function.
The general structure of Fired is:
Lua Code:
Fired =
{
GetSmithingResearchLineInfo =
{
Parms =
{
"1",
"1",
},
Result =
{
"Dagger",
"/esoui/art/icons/gear_breton_dagger_a.dds",
"8",
"328320",
},
},
}
where Parms is the parameters into the function and Result is the values returned by the function. These are only present if there are parms or return values. If there's just a single parm or return value it's collapsed into a single line rather than using a subtable.
The general structure of Dictionary is:
Lua Code:
Dictionary =
{
Drag =
{
Store =
{
ZO_Store_OnReceiveDrag = "function: 3601D638",
},
Receive =
{
ZO_Store_OnReceiveDrag = "function: 3601D638",
ZO_Trade_OnReceiveDrag = "function: 32786D78",
ZO_InventorySlot_OnReceiveDrag = "function: 2AECFDB0",
ZO_AbilitySlot_OnReceiveDrag = "function: 24E9FB60",
UnitFrame_HandleMouseReceiveDrag = "function: 49B718E0",
},
},
}
It has two levels and it's all combinations of two words used in the function. It makes for a very big dictionary, but it gets leaves down to a reasonable size. If it has no words, i.e. all lowercase, then it appears under _nowords. Note it is without regard to underscors so "this_is_a_test" is no words. That particular one would be under _nowords.this because it has a prefix. The vast majority of the saved variables is the dictionary.
The tree uses the order of the words. A bit more useful than with events. The general structure of this entry is:
Lua Code:
FunctionTree =
{
MM =
{
MM_ZrMMShown = "function: 4D79EDF8",
Hide =
{
MM_HideCheck = "function: 5AFCCC38",
MM_Hide = "function: 433EE320",
},
},
}
If the function name is in the form "prefix_function" then it appears in the root, otherwise it appears under "_noprefix". The tree is formed by the words used in the order they are used. The tree is collapsed so that the only single child nodes are the leaves.
This is a huge file, over 100k lines. Not an issue for space, just 5MB, but an issue for manually browsing the file. I would strongly urge you to use it live with zgoo. If you want to use it outside the client then I would suggest you use dofile to load the saved variables then utility functions of your own devise to retrieve what you want out of it. The two word dictionary is so you can easily browse it using zgoo. With your own function you could do the intersection of any number of words. You can use it to speed your own lookup. It cuts the number of intersections needed in half rounded up.
TODO: Some utility functions. That would be both slash commands in game and a lua script that loads the saved variables and lets you query it. Longer term an interface. I'm think that will be a separate addon, likely named CaptureViewer, that will use the variables from the addons if they are present. I provide a capture prior to that for selectively capturing function calls. I'm just real reluctant to do that across the board, i.e. every function. That would initially be through slash commands then through an gui.
05/06/14, 10:30 AM
