1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
#include "inspircd.h"
#ifdef PURE_STATIC
static std::vector<AllCommandList::fn>* cmdlist = NULL;
static std::vector<AllModuleList*>* modlist = NULL;
AllCommandList::AllCommandList(fn cmd)
{
if (!cmdlist)
cmdlist = new std::vector<AllCommandList::fn>();
cmdlist->push_back(cmd);
}
AllModuleList::AllModuleList(AllModuleList::fn mod, const std::string& Name) : init(mod), name(Name)
{
if (!modlist)
modlist = new std::vector<AllModuleList*>();
modlist->push_back(this);
}
class AllModule : public Module
{
std::vector<Command*> cmds;
public:
AllModule()
{
if (!cmdlist)
return;
try
{
cmds.reserve(cmdlist->size());
for(std::vector<AllCommandList::fn>::iterator i = cmdlist->begin(); i != cmdlist->end(); ++i)
{
Command* c = (*i)(this);
cmds.push_back(c);
ServerInstance->AddCommand(c);
}
}
catch (...)
{
this->AllModule::~AllModule();
throw;
}
}
~AllModule()
{
for(std::vector<Command*>::iterator i = cmds.begin(); i != cmds.end(); ++i)
delete *i;
}
Version GetVersion()
{
return Version("All commands", VF_VENDOR|VF_CORE);
}
};
MODULE_INIT(AllModule)
bool ModuleManager::Load(const char* filename)
{
return false;
}
bool ModuleManager::CanUnload(Module* mod)
{
return false;
}
void ModuleManager::DoSafeUnload(Module* mod)
{
}
bool ModuleManager::Unload(Module* mod)
{
return false;
}
void ModuleManager::Reload(Module* mod, HandlerBase1<void, bool>* callback)
{
callback->Call(false);
}
void ModuleManager::LoadAll()
{
ModCount = 0;
for(std::vector<AllModuleList*>::iterator i = modlist->begin(); i != modlist->end(); ++i)
{
try
{
Module* c = (*(**i).init)();
c->ModuleSourceFile = (**i).name;
Modules[(**i).name] = c;
FOREACH_MOD(I_OnLoadModule,OnLoadModule(c));
}
catch (CoreException& modexcept)
{
ServerInstance->Logs->Log("MODULE", DEFAULT, "Unable to load " + (**i).name + ": " + modexcept.GetReason());
}
}
/* We give every module a chance to re-prioritize when we introduce a new one,
* not just the one thats loading, as the new module could affect the preference
* of others
*/
for(int tries = 0; tries < 20; tries++)
{
prioritizationState = tries > 0 ? PRIO_STATE_LAST : PRIO_STATE_FIRST;
for (std::map<std::string, Module*>::iterator n = Modules.begin(); n != Modules.end(); ++n)
n->second->Prioritize();
if (prioritizationState == PRIO_STATE_LAST)
break;
if (tries == 19)
ServerInstance->Logs->Log("MODULE", DEFAULT, "Hook priority dependency loop detected");
}
ServerInstance->BuildISupport();
}
void ModuleManager::UnloadAll()
{
// TODO don't really need this, who cares if we leak on exit?
}
#endif
|
