sourcemod-central: core/systems/PluginSys.cpp@e5342c8a0cf4 (annotated)

dvander@173	1	#include <stdio.h>
dvander@173	2	#include "PluginSys.h"
dvander@229	3	#include "ShareSys.h"
dvander@190	4	#include "LibrarySys.h"
dvander@220	5	#include "HandleSys.h"
dvander@197	6	#include "sourcemm_api.h"
dvander@209	7	#include "sourcemod.h"
dvander@203	8	#include "CTextParsers.h"
dvander@282	9	#include "CLogger.h"
dvander@298	10	#include "ExtensionSys.h"
dvander@309	11	#include "sm_srvcmds.h"
dvander@309	12	#include "sm_stringutil.h"
dvander@173	13
dvander@211	14	CPluginManager g_PluginSys;
dvander@220	15	HandleType_t g_PluginType = 0;
dvander@229	16	IdentityType_t g_PluginIdent = 0;
dvander@173	17
dvander@209	18	CPlugin::CPlugin(const char *file)
dvander@209	19	{
dvander@209	20	static int MySerial = 0;
dvander@209	21
dvander@209	22	m_type = PluginType_Private;
dvander@209	23	m_status = Plugin_Uncompiled;
dvander@209	24	m_serial = ++MySerial;
dvander@209	25	m_plugin = NULL;
dvander@209	26	m_funcsnum = 0;
dvander@209	27	m_priv_funcs = NULL;
dvander@209	28	m_pub_funcs = NULL;
dvander@209	29	m_errormsg[256] = '\0';
dvander@209	30	snprintf(m_filename, sizeof(m_filename), "%s", file);
dvander@229	31	m_handle = 0;
dvander@229	32	m_ident = NULL;
dvander@209	33	}
dvander@209	34
dvander@209	35	CPlugin::~CPlugin()
dvander@173	36	{
dvander@298	37	if (m_handle)
dvander@298	38	{
dvander@298	39	HandleSecurity sec;
dvander@298	40	sec.pOwner = g_PluginSys.GetIdentity();
dvander@298	41	sec.pIdentity = sec.pOwner;
dvander@298	42
dvander@298	43	g_HandleSys.FreeHandle(m_handle, &sec);
dvander@298	44	g_ShareSys.DestroyIdentity(m_ident);
dvander@298	45	}
dvander@298	46
dvander@209	47	if (m_ctx.base)
dvander@209	48	{
dvander@262	49	delete m_ctx.base;
dvander@209	50	m_ctx.base = NULL;
dvander@209	51	}
dvander@209	52	if (m_ctx.ctx)
dvander@209	53	{
dvander@209	54	m_ctx.vm->FreeContext(m_ctx.ctx);
dvander@209	55	m_ctx.ctx = NULL;
dvander@209	56	}
dvander@209	57	if (m_ctx.co)
dvander@209	58	{
dvander@209	59	m_ctx.vm->AbortCompilation(m_ctx.co);
dvander@209	60	m_ctx.co = NULL;
dvander@209	61	}
dvander@209	62
dvander@209	63	if (m_pub_funcs)
dvander@209	64	{
dvander@209	65	for (uint32_t i=0; i<m_plugin->info.publics_num; i++)
dvander@209	66	{
dvander@211	67	g_PluginSys.ReleaseFunctionToPool(m_pub_funcs[i]);
dvander@209	68	}
dvander@209	69	delete [] m_pub_funcs;
dvander@209	70	m_pub_funcs = NULL;
dvander@209	71	}
dvander@209	72
dvander@209	73	if (m_priv_funcs)
dvander@209	74	{
dvander@209	75	for (unsigned int i=0; i<m_funcsnum; i++)
dvander@209	76	{
dvander@211	77	g_PluginSys.ReleaseFunctionToPool(m_priv_funcs[i]);
dvander@209	78	}
dvander@209	79	delete [] m_priv_funcs;
dvander@209	80	m_priv_funcs = NULL;
dvander@209	81	}
dvander@222	82
dvander@222	83	if (m_plugin)
dvander@222	84	{
dvander@222	85	g_pSourcePawn->FreeFromMemory(m_plugin);
dvander@222	86	m_plugin = NULL;
dvander@222	87	}
dvander@229	88	}
dvander@229	89
dvander@229	90	void CPlugin::InitIdentity()
dvander@229	91	{
dvander@229	92	if (!m_handle)
dvander@229	93	{
dvander@229	94	m_ident = g_ShareSys.CreateIdentity(g_PluginIdent);
dvander@262	95	m_handle = g_HandleSys.CreateHandle(g_PluginType, this, g_PluginSys.GetIdentity(), g_PluginSys.GetIdentity(), NULL);
dvander@262	96	m_ctx.base->SetIdentity(m_ident);
dvander@229	97	}
dvander@209	98	}
dvander@209	99
dvander@209	100	CPlugin CPlugin::CreatePlugin(const char file, char *error, size_t maxlength)
dvander@209	101	{
dvander@209	102	char fullpath[PLATFORM_MAX_PATH+1];
dvander@317	103	g_SourceMod.BuildPath(Path_SM, fullpath, sizeof(fullpath), "plugins/%s", file);
dvander@209	104	FILE *fp = fopen(fullpath, "rb");
dvander@173	105
dvander@298	106	CPlugin *pPlugin = new CPlugin(file);
dvander@298	107
dvander@173	108	if (!fp)
dvander@173	109	{
dvander@209	110	if (error)
dvander@209	111	{
dvander@209	112	snprintf(error, maxlength, "Unable to open file");
dvander@209	113	}
dvander@298	114	pPlugin->m_status = Plugin_BadLoad;
dvander@298	115	return pPlugin;
dvander@173	116	}
dvander@173	117
dvander@173	118	int err;
dvander@173	119	sp_plugin_t *pl = g_pSourcePawn->LoadFromFilePointer(fp, &err);
dvander@173	120	if (pl == NULL)
dvander@173	121	{
dvander@209	122	fclose(fp);
dvander@209	123	if (error)
dvander@209	124	{
dvander@209	125	snprintf(error, maxlength, "Error %d while parsing plugin", err);
dvander@209	126	}
dvander@298	127	pPlugin->m_status = Plugin_BadLoad;
dvander@298	128	return pPlugin;
dvander@173	129	}
dvander@173	130
dvander@173	131	fclose(fp);
dvander@173	132
dvander@209	133	pPlugin->m_plugin = pl;
dvander@298	134
dvander@209	135	return pPlugin;
dvander@209	136	}
dvander@209	137
dvander@209	138	ICompilation CPlugin::StartMyCompile(IVirtualMachine vm)
dvander@209	139	{
dvander@209	140	if (!m_plugin)
dvander@173	141	{
dvander@209	142	return NULL;
dvander@173	143	}
dvander@173	144
dvander@209	145	/* :NOTICE: We will eventually need to change these natives
dvander@209	146	* for swapping in new contexts
dvander@209	147	*/
dvander@209	148	if (m_ctx.co \|\| m_ctx.ctx)
dvander@173	149	{
dvander@173	150	return NULL;
dvander@173	151	}
dvander@173	152
dvander@209	153	m_status = Plugin_Uncompiled;
dvander@173	154
dvander@209	155	m_ctx.vm = vm;
dvander@209	156	m_ctx.co = vm->StartCompilation(m_plugin);
dvander@209	157
dvander@209	158	return m_ctx.co;
dvander@209	159	}
dvander@173	160
dvander@209	161	void CPlugin::CancelMyCompile()
dvander@209	162	{
dvander@209	163	if (!m_ctx.co)
dvander@209	164	{
dvander@209	165	return;
dvander@209	166	}
dvander@176	167
dvander@209	168	m_ctx.vm->AbortCompilation(m_ctx.co);
dvander@209	169	m_ctx.co = NULL;
dvander@209	170	m_ctx.vm = NULL;
dvander@209	171	}
dvander@209	172
dvander@209	173	bool CPlugin::FinishMyCompile(char *error, size_t maxlength)
dvander@209	174	{
dvander@209	175	if (!m_ctx.co)
dvander@176	176	{
dvander@209	177	return false;
dvander@176	178	}
dvander@176	179
dvander@209	180	int err;
dvander@209	181	m_ctx.ctx = m_ctx.vm->CompileToContext(m_ctx.co, &err);
dvander@209	182	if (!m_ctx.ctx)
dvander@176	183	{
dvander@209	184	memset(&m_ctx, 0, sizeof(m_ctx));
dvander@298	185	if (error)
dvander@209	186	{
dvander@209	187	snprintf(error, maxlength, "Failed to compile (error %d)", err);
dvander@209	188	}
dvander@209	189	return false;
dvander@176	190	}
dvander@176	191
dvander@262	192	m_ctx.base = new BaseContext(m_ctx.ctx);
dvander@209	193	m_ctx.ctx->user[SM_CONTEXTVAR_MYSELF] = (void *)this;
dvander@209	194
dvander@209	195	m_funcsnum = m_ctx.vm->FunctionCount(m_ctx.ctx);
dvander@209	196
dvander@209	197	/**
dvander@209	198	* Note: Since the m_plugin member will never change,
dvander@209	199	* it is safe to assume the function count will never change
dvander@209	200	*/
dvander@209	201	if (m_funcsnum && m_priv_funcs == NULL)
dvander@209	202	{
dvander@209	203	m_priv_funcs = new CFunction *[m_funcsnum];
dvander@209	204	memset(m_priv_funcs, 0, sizeof(CFunction ) m_funcsnum);
dvander@209	205	} else {
dvander@209	206	m_priv_funcs = NULL;
dvander@209	207	}
dvander@209	208
dvander@209	209	if (m_plugin->info.publics_num && m_pub_funcs == NULL)
dvander@209	210	{
dvander@209	211	m_pub_funcs = new CFunction *[m_plugin->info.publics_num];
dvander@209	212	memset(m_pub_funcs, 0, sizeof(CFunction ) m_plugin->info.publics_num);
dvander@209	213	} else {
dvander@209	214	m_pub_funcs = NULL;
dvander@209	215	}
dvander@209	216
dvander@211	217	m_status = Plugin_Created;
faluco@216	218	m_ctx.co = NULL;
dvander@211	219
dvander@209	220	UpdateInfo();
dvander@209	221
dvander@209	222	return true;
dvander@209	223	}
dvander@209	224
dvander@209	225	void CPlugin::SetErrorState(PluginStatus status, const char *error_fmt, ...)
dvander@209	226	{
dvander@209	227	m_status = status;
dvander@209	228
dvander@209	229	va_list ap;
dvander@209	230	va_start(ap, error_fmt);
dvander@209	231	vsnprintf(m_errormsg, sizeof(m_errormsg), error_fmt, ap);
dvander@209	232	va_end(ap);
dvander@173	233	}
dvander@173	234
dvander@176	235	IPluginFunction *CPlugin::GetFunctionById(funcid_t func_id)
dvander@176	236	{
dvander@176	237	CFunction *pFunc = NULL;
dvander@176	238	funcid_t save = func_id;
dvander@176	239
dvander@176	240	if (func_id & 1)
dvander@176	241	{
dvander@176	242	func_id >>= 1;
dvander@176	243	if (func_id >= m_plugin->info.publics_num)
dvander@176	244	{
dvander@176	245	return NULL;
dvander@176	246	}
dvander@176	247	pFunc = m_pub_funcs[func_id];
dvander@176	248	if (!pFunc)
dvander@176	249	{
dvander@211	250	pFunc = g_PluginSys.GetFunctionFromPool(save, this);
dvander@176	251	m_pub_funcs[func_id] = pFunc;
dvander@176	252	}
dvander@176	253	} else {
dvander@176	254	func_id >>= 1;
dvander@176	255	unsigned int index;
dvander@209	256	if (!g_pVM->FunctionLookup(m_ctx.ctx, func_id, &index))
dvander@176	257	{
dvander@176	258	return NULL;
dvander@176	259	}
dvander@176	260	pFunc = m_priv_funcs[func_id];
dvander@176	261	if (!pFunc)
dvander@176	262	{
dvander@211	263	pFunc = g_PluginSys.GetFunctionFromPool(save, this);
dvander@176	264	m_priv_funcs[func_id] = pFunc;
dvander@176	265	}
dvander@176	266	}
dvander@176	267
dvander@176	268	return pFunc;
dvander@176	269	}
dvander@176	270
dvander@176	271	IPluginFunction CPlugin::GetFunctionByName(const char public_name)
dvander@176	272	{
dvander@176	273	uint32_t index;
dvander@209	274	IPluginContext *base = m_ctx.base;
dvander@176	275
dvander@176	276	if (base->FindPublicByName(public_name, &index) != SP_ERROR_NONE)
dvander@176	277	{
dvander@176	278	return NULL;
dvander@176	279	}
dvander@176	280
dvander@176	281	CFunction *pFunc = m_pub_funcs[index];
dvander@176	282	if (!pFunc)
dvander@176	283	{
dvander@176	284	sp_public_t *pub = NULL;
dvander@176	285	base->GetPublicByIndex(index, &pub);
dvander@176	286	if (pub)
dvander@176	287	{
dvander@211	288	pFunc = g_PluginSys.GetFunctionFromPool(pub->funcid, this);
dvander@176	289	m_pub_funcs[index] = pFunc;
dvander@176	290	}
dvander@176	291	}
dvander@176	292
dvander@176	293	return pFunc;
dvander@176	294	}
dvander@176	295
dvander@173	296	void CPlugin::UpdateInfo()
dvander@173	297	{
dvander@173	298	/* Now grab the info */
dvander@173	299	uint32_t idx;
dvander@173	300	IPluginContext *base = GetBaseContext();
dvander@173	301	int err = base->FindPubvarByName("myinfo", &idx);
dvander@173	302
dvander@173	303	if (err == SP_ERROR_NONE)
dvander@173	304	{
dvander@173	305	struct sm_plugininfo_c_t
dvander@173	306	{
dvander@173	307	cell_t name;
dvander@173	308	cell_t description;
dvander@173	309	cell_t author;
dvander@173	310	cell_t version;
dvander@173	311	cell_t url;
dvander@173	312	};
dvander@173	313	sm_plugininfo_c_t *cinfo;
dvander@173	314	cell_t local_addr;
dvander@173	315
dvander@173	316	base->GetPubvarAddrs(idx, &local_addr, (cell_t **)&cinfo);
dvander@173	317	base->LocalToString(cinfo->name, (char **)&m_info.name);
dvander@173	318	base->LocalToString(cinfo->description, (char **)&m_info.description);
dvander@173	319	base->LocalToString(cinfo->author, (char **)&m_info.author);
dvander@173	320	base->LocalToString(cinfo->url, (char **)&m_info.url);
dvander@173	321	base->LocalToString(cinfo->version, (char **)&m_info.version);
dvander@173	322	}
dvander@173	323
dvander@173	324	m_info.author = m_info.author ? m_info.author : "";
dvander@173	325	m_info.description = m_info.description ? m_info.description : "";
dvander@173	326	m_info.name = m_info.name ? m_info.name : "";
dvander@173	327	m_info.url = m_info.url ? m_info.url : "";
dvander@173	328	m_info.version = m_info.version ? m_info.version : "";
dvander@173	329	}
dvander@173	330
dvander@211	331	void CPlugin::Call_OnPluginInit()
dvander@211	332	{
dvander@211	333	if (m_status != Plugin_Loaded)
dvander@211	334	{
dvander@211	335	return;
dvander@211	336	}
dvander@211	337
dvander@211	338	m_status = Plugin_Running;
dvander@211	339
dvander@211	340	cell_t result;
dvander@211	341	IPluginFunction *pFunction = GetFunctionByName("OnPluginInit");
dvander@211	342	if (!pFunction)
dvander@211	343	{
dvander@211	344	return;
dvander@211	345	}
dvander@211	346
dvander@222	347	pFunction->PushCell(m_handle);
dvander@282	348	pFunction->Execute(&result);
dvander@282	349	}
dvander@282	350
dvander@282	351	void CPlugin::Call_OnPluginUnload()
dvander@282	352	{
dvander@282	353	if (m_status < Plugin_Paused)
dvander@211	354	{
dvander@282	355	return;
dvander@211	356	}
dvander@282	357
dvander@282	358	cell_t result;
dvander@282	359	IPluginFunction *pFunction = GetFunctionByName("OnPluginUnload");
dvander@282	360	if (!pFunction)
dvander@282	361	{
dvander@282	362	return;
dvander@282	363	}
dvander@282	364
dvander@282	365	pFunction->Execute(&result);
dvander@211	366	}
dvander@211	367
dvander@211	368	bool CPlugin::Call_AskPluginLoad(char *error, size_t maxlength)
dvander@211	369	{
dvander@211	370	if (m_status != Plugin_Created)
dvander@211	371	{
dvander@211	372	return false;
dvander@211	373	}
dvander@211	374
faluco@216	375	m_status = Plugin_Loaded;
faluco@216	376
dvander@211	377	int err;
dvander@211	378	cell_t result;
dvander@211	379	IPluginFunction *pFunction = GetFunctionByName("AskPluginLoad");
dvander@211	380
dvander@211	381	if (!pFunction)
dvander@211	382	{
dvander@211	383	return true;
dvander@211	384	}
dvander@211	385
dvander@222	386	pFunction->PushCell(m_handle);
dvander@211	387	pFunction->PushCell(g_PluginSys.IsLateLoadTime() ? 1 : 0);
dvander@211	388	pFunction->PushStringEx(error, maxlength, 0, SM_PARAM_COPYBACK);
dvander@211	389	pFunction->PushCell(maxlength);
dvander@211	390	if ((err=pFunction->Execute(&result)) != SP_ERROR_NONE)
dvander@211	391	{
dvander@282	392	m_status = Plugin_Failed;
dvander@211	393	return false;
dvander@211	394	}
dvander@211	395
dvander@282	396	if (!result \|\| m_status != Plugin_Loaded)
dvander@211	397	{
dvander@282	398	m_status = Plugin_Failed;
dvander@211	399	return false;
dvander@211	400	}
dvander@211	401
dvander@211	402	return true;
dvander@211	403	}
dvander@211	404
dvander@173	405	const sp_plugin_t *CPlugin::GetPluginStructure() const
dvander@173	406	{
dvander@173	407	return m_plugin;
dvander@173	408	}
dvander@173	409
dvander@173	410	IPluginContext *CPlugin::GetBaseContext() const
dvander@173	411	{
dvander@209	412	return m_ctx.base;
dvander@173	413	}
dvander@173	414
dvander@173	415	sp_context_t *CPlugin::GetContext() const
dvander@173	416	{
dvander@209	417	return m_ctx.ctx;
dvander@173	418	}
dvander@173	419
dvander@173	420	const char *CPlugin::GetFilename() const
dvander@173	421	{
dvander@173	422	return m_filename;
dvander@173	423	}
dvander@173	424
dvander@174	425	PluginType CPlugin::GetType() const
dvander@173	426	{
dvander@174	427	return m_type;
dvander@173	428	}
dvander@173	429
dvander@173	430	const sm_plugininfo_t *CPlugin::GetPublicInfo() const
dvander@173	431	{
dvander@173	432	return &m_info;
dvander@173	433	}
dvander@173	434
dvander@173	435	unsigned int CPlugin::GetSerial() const
dvander@173	436	{
dvander@173	437	return m_serial;
dvander@173	438	}
dvander@173	439
dvander@173	440	PluginStatus CPlugin::GetStatus() const
dvander@173	441	{
dvander@173	442	return m_status;
dvander@173	443	}
dvander@173	444
dvander@173	445	bool CPlugin::IsDebugging() const
dvander@173	446	{
dvander@209	447	if (!m_ctx.ctx)
dvander@209	448	{
dvander@209	449	return false;
dvander@209	450	}
dvander@209	451
dvander@209	452	return ((m_ctx.ctx->flags & SP_FLAG_DEBUG) == SP_FLAG_DEBUG);
dvander@173	453	}
dvander@173	454
dvander@173	455	bool CPlugin::SetPauseState(bool paused)
dvander@173	456	{
dvander@173	457	if (paused && GetStatus() != Plugin_Paused)
dvander@173	458	{
dvander@173	459	return false;
dvander@173	460	} else if (!paused && GetStatus() != Plugin_Running) {
dvander@173	461	return false;
dvander@173	462	}
dvander@282	463
faluco@288	464	m_status = (paused) ? Plugin_Paused : Plugin_Running;
faluco@288	465
dvander@282	466	IPluginFunction *pFunction = GetFunctionByName("OnPluginPauseChange");
dvander@282	467	if (pFunction)
dvander@282	468	{
dvander@282	469	cell_t result;
dvander@282	470	pFunction->PushCell(paused ? 1 : 0);
dvander@282	471	pFunction->Execute(&result);
dvander@282	472	}
dvander@173	473
dvander@173	474	return true;
dvander@173	475	}
dvander@174	476
faluco@290	477	IdentityToken_t *CPlugin::GetIdentity() const
dvander@220	478	{
dvander@229	479	return m_ident;
dvander@220	480	}
dvander@220	481
dvander@309	482	bool CPlugin::ToggleDebugMode(bool debug, char *error, size_t maxlength)
faluco@290	483	{
faluco@290	484	int err;
faluco@290	485
faluco@290	486	if (!IsRunnable())
faluco@290	487	{
dvander@309	488	if (error)
dvander@309	489	{
dvander@309	490	snprintf(error, maxlength, "Plugin is not runnable.");
dvander@309	491	}
faluco@290	492	return false;
faluco@290	493	}
faluco@290	494
dvander@309	495	if (debug && IsDebugging())
faluco@290	496	{
dvander@309	497	if (error)
dvander@309	498	{
dvander@309	499	snprintf(error, maxlength, "Plugin is already in debug mode.");
dvander@309	500	}
dvander@309	501	return false;
dvander@309	502	} else if (!debug && !IsDebugging()) {
dvander@309	503	if (error)
dvander@309	504	{
dvander@309	505	snprintf(error, maxlength, "Plugins is already in production mode.");
dvander@309	506	}
faluco@290	507	return false;
faluco@290	508	}
dvander@309	509
faluco@290	510	ICompilation *co = g_pVM->StartCompilation(m_ctx.ctx->plugin);
faluco@290	511	if (!g_pVM->SetCompilationOption(co, "debug", (debug) ? "1" : "0"))
faluco@290	512	{
dvander@309	513	if (error)
dvander@309	514	{
dvander@309	515	snprintf(error, maxlength, "Failed to change plugin mode (JIT failure).");
dvander@309	516	}
faluco@290	517	return false;
faluco@290	518	}
dvander@309	519
faluco@290	520	sp_context_t *new_ctx = g_pVM->CompileToContext(co, &err);
faluco@290	521
dvander@309	522	if (new_ctx)
dvander@309	523	{
dvander@309	524	memcpy(new_ctx->memory, m_ctx.ctx->memory, m_ctx.ctx->mem_size);
dvander@309	525	new_ctx->hp = m_ctx.ctx->hp;
dvander@309	526	new_ctx->sp = m_ctx.ctx->sp;
dvander@309	527	new_ctx->frm = m_ctx.ctx->frm;
dvander@309	528	new_ctx->dbreak = m_ctx.ctx->dbreak;
dvander@309	529	new_ctx->context = m_ctx.ctx->context;
dvander@309	530	memcpy(new_ctx->user, m_ctx.ctx->user, sizeof(m_ctx.ctx->user));
faluco@290	531
dvander@309	532	g_pVM->FreeContext(m_ctx.ctx);
dvander@309	533	m_ctx.ctx = new_ctx;
dvander@309	534	m_ctx.base->SetContext(new_ctx);
faluco@290	535
dvander@309	536	UpdateInfo();
dvander@309	537	} else {
dvander@309	538	if (error)
dvander@309	539	{
dvander@309	540	snprintf(error, maxlength, "Failed to recompile plugin (JIT error %d).", err);
dvander@309	541	}
dvander@309	542	return false;
dvander@309	543	}
faluco@290	544
faluco@290	545	return true;
faluco@290	546	}
faluco@290	547
faluco@290	548	bool CPlugin::IsRunnable() const
faluco@290	549	{
faluco@290	550	return (m_status <= Plugin_Paused) ? true : false;
faluco@290	551	}
faluco@290	552
dvander@174	553	/*******************
dvander@174	554	* PLUGIN ITERATOR *
dvander@174	555	*******************/
dvander@190	556
dvander@213	557	CPluginManager::CPluginIterator::CPluginIterator(List<CPlugin > _mylist)
dvander@174	558	{
dvander@174	559	mylist = _mylist;
faluco@216	560	Reset();
dvander@174	561	}
dvander@174	562
dvander@174	563	IPlugin *CPluginManager::CPluginIterator::GetPlugin()
dvander@174	564	{
dvander@174	565	return (*current);
dvander@174	566	}
dvander@174	567
dvander@174	568	bool CPluginManager::CPluginIterator::MorePlugins()
dvander@174	569	{
dvander@174	570	return (current != mylist->end());
dvander@174	571	}
dvander@174	572
dvander@174	573	void CPluginManager::CPluginIterator::NextPlugin()
dvander@174	574	{
dvander@174	575	current++;
dvander@174	576	}
dvander@174	577
dvander@174	578	void CPluginManager::CPluginIterator::Release()
dvander@174	579	{
dvander@211	580	g_PluginSys.ReleaseIterator(this);
dvander@174	581	}
dvander@174	582
dvander@174	583	CPluginManager::CPluginIterator::~CPluginIterator()
dvander@174	584	{
dvander@174	585	}
dvander@174	586
dvander@174	587	void CPluginManager::CPluginIterator::Reset()
dvander@174	588	{
dvander@174	589	current = mylist->begin();
dvander@174	590	}
dvander@174	591
dvander@174	592	/******************
dvander@174	593	* PLUGIN MANAGER *
dvander@174	594	******************/
dvander@174	595
dvander@211	596	CPluginManager::CPluginManager()
dvander@211	597	{
dvander@211	598	m_LoadLookup = sm_trie_create();
dvander@211	599	m_AllPluginsLoaded = false;
dvander@229	600	m_MyIdent = NULL;
dvander@211	601	}
dvander@211	602
dvander@211	603	CPluginManager::~CPluginManager()
dvander@211	604	{
dvander@282	605	/* :NOTICE:
dvander@282	606	* Ignore the fact that there might be plugins in the cache.
dvander@282	607	* This usually means that Core is not being unloaded properly, and everything
dvander@282	608	* will crash anyway. YAY
dvander@282	609	*/
dvander@211	610	sm_trie_destroy(m_LoadLookup);
dvander@211	611	}
dvander@211	612
dvander@211	613
dvander@213	614	void CPluginManager::LoadAll_FirstPass(const char config, const char basedir)
dvander@190	615	{
dvander@203	616	/* First read in the database of plugin settings */
dvander@203	617	SMCParseError err;
dvander@203	618	unsigned int line, col;
faluco@216	619	m_AllPluginsLoaded = false;
dvander@273	620	if ((err=g_TextParser.ParseFile_SMC(config, &m_PluginInfo, &line, &col)) != SMCParse_Okay)
dvander@203	621	{
dvander@305	622	g_Logger.LogError("[SM] Encountered fatal error parsing file \"%s\"", config);
dvander@282	623	const char *err_msg = g_TextParser.GetSMCErrorString(err);
dvander@282	624	if (err_msg)
dvander@282	625	{
dvander@305	626	g_Logger.LogError("[SM] Parse error encountered: \"%s\"", err_msg);
dvander@282	627	}
dvander@203	628	}
dvander@203	629
dvander@209	630	LoadPluginsFromDir(basedir, NULL);
dvander@209	631	}
dvander@203	632
dvander@209	633	void CPluginManager::LoadPluginsFromDir(const char basedir, const char localpath)
dvander@209	634	{
dvander@209	635	char base_path[PLATFORM_MAX_PATH+1];
dvander@209	636
dvander@209	637	/* Form the current path to start reading from */
dvander@209	638	if (localpath == NULL)
dvander@209	639	{
dvander@209	640	g_LibSys.PathFormat(base_path, sizeof(base_path), "%s", basedir);
dvander@209	641	} else {
dvander@209	642	g_LibSys.PathFormat(base_path, sizeof(base_path), "%s/%s", basedir, localpath);
dvander@209	643	}
dvander@209	644
dvander@209	645	IDirectory *dir = g_LibSys.OpenDirectory(base_path);
dvander@209	646
dvander@209	647	if (!dir)
dvander@209	648	{
dvander@282	649	char error[256];
dvander@282	650	g_LibSys.GetPlatformError(error, sizeof(error));
dvander@305	651	g_Logger.LogError("[SM] Failure reading from plugins path: %s", localpath);
dvander@305	652	g_Logger.LogError("[SM] Platform returned error: %s", error);
dvander@209	653	return;
dvander@209	654	}
dvander@209	655
dvander@190	656	while (dir->MoreFiles())
dvander@190	657	{
dvander@209	658	if (dir->IsEntryDirectory()
dvander@209	659	&& (strcmp(dir->GetEntryName(), ".") != 0)
dvander@209	660	&& (strcmp(dir->GetEntryName(), "..") != 0)
dvander@209	661	&& (strcmp(dir->GetEntryName(), "disabled") != 0)
dvander@209	662	&& (strcmp(dir->GetEntryName(), "optional") != 0))
dvander@190	663	{
dvander@209	664	char new_local[PLATFORM_MAX_PATH+1];
dvander@209	665	if (localpath == NULL)
dvander@209	666	{
dvander@209	667	/* If no path yet, don't add a former slash */
dvander@209	668	snprintf(new_local, sizeof(new_local), "%s", dir->GetEntryName());
dvander@209	669	} else {
dvander@209	670	g_LibSys.PathFormat(new_local, sizeof(new_local), "%s/%s", localpath, dir->GetEntryName());
dvander@209	671	}
dvander@209	672	LoadPluginsFromDir(basedir, new_local);
dvander@209	673	} else if (dir->IsEntryFile()) {
dvander@209	674	const char *name = dir->GetEntryName();
dvander@209	675	size_t len = strlen(name);
dvander@211	676	if (len >= 4
dvander@211	677	&& strcmp(&name[len-4], ".smx") == 0)
dvander@209	678	{
dvander@211	679	/* If the filename matches, load the plugin */
dvander@211	680	char plugin[PLATFORM_MAX_PATH+1];
dvander@211	681	if (localpath == NULL)
dvander@211	682	{
dvander@211	683	snprintf(plugin, sizeof(plugin), "%s", name);
dvander@211	684	} else {
dvander@211	685	g_LibSys.PathFormat(plugin, sizeof(plugin), "%s/%s", localpath, name);
dvander@211	686	}
dvander@211	687	LoadAutoPlugin(plugin);
dvander@209	688	}
dvander@209	689	}
dvander@209	690	dir->NextEntry();
dvander@209	691	}
dvander@209	692	g_LibSys.CloseDirectory(dir);
dvander@209	693	}
dvander@209	694
dvander@211	695	//well i have discovered that gabe newell is very fat, so i wrote this comment now
dvander@298	696	bool CPluginManager::_LoadPlugin(CPlugin *_plugin, const char path, bool debug, PluginType type, char error[], size_t err_max)
dvander@209	697	{
dvander@211	698	/**
dvander@211	699	* Does this plugin already exist?
dvander@211	700	*/
dvander@211	701	CPlugin *pPlugin;
dvander@298	702	if (sm_trie_retrieve(m_LoadLookup, path, (void **)&pPlugin))
dvander@211	703	{
dvander@211	704	/* First check the type */
dvander@211	705	PluginType type = pPlugin->GetType();
dvander@211	706	if (type == PluginType_Private
dvander@211	707	\|\| type == PluginType_Global)
dvander@211	708	{
dvander@298	709	return true;
dvander@211	710	}
dvander@211	711	/* Check to see if we should try reloading it */
dvander@211	712	if (pPlugin->GetStatus() == Plugin_BadLoad
dvander@282	713	\|\| pPlugin->GetStatus() == Plugin_Error
dvander@282	714	\|\| pPlugin->GetStatus() == Plugin_Failed)
dvander@211	715	{
dvander@211	716	UnloadPlugin(pPlugin);
dvander@211	717	}
dvander@211	718	}
dvander@211	719
dvander@298	720	pPlugin = CPlugin::CreatePlugin(path, error, err_max);
dvander@209	721
dvander@209	722	assert(pPlugin != NULL);
dvander@209	723
dvander@209	724	pPlugin->m_type = PluginType_MapUpdated;
dvander@209	725
dvander@209	726	ICompilation *co = NULL;
dvander@209	727
dvander@209	728	if (pPlugin->m_status == Plugin_Uncompiled)
dvander@209	729	{
dvander@209	730	co = pPlugin->StartMyCompile(g_pVM);
dvander@209	731	}
dvander@209	732
dvander@209	733	PluginSettings *pset;
dvander@209	734	unsigned int setcount = m_PluginInfo.GetSettingsNum();
dvander@209	735	for (unsigned int i=0; i<setcount; i++)
dvander@209	736	{
dvander@298	737	if ((pset=m_PluginInfo.GetSettingsIfMatch(i, path)) == NULL)
dvander@209	738	{
dvander@209	739	continue;
dvander@209	740	}
dvander@209	741	pPlugin->m_type = pset->type_val;
dvander@209	742	if (co)
dvander@209	743	{
dvander@209	744	for (unsigned int j=0; j<pset->opts_num; j++)
dvander@209	745	{
dvander@209	746	const char key, val;
dvander@209	747	m_PluginInfo.GetOptionsForPlugin(pset, j, &key, &val);
dvander@209	748	if (!key \|\| !val)
dvander@209	749	{
dvander@209	750	continue;
dvander@209	751	}
dvander@209	752	if (!g_pVM->SetCompilationOption(co, key, val))
dvander@209	753	{
dvander@298	754	if (error)
dvander@298	755	{
dvander@298	756	snprintf(error, err_max, "Unable to set JIT option (key \"%s\") (value \"%s\")", key, val);
dvander@298	757	}
dvander@209	758	pPlugin->CancelMyCompile();
dvander@298	759	pPlugin->m_status = Plugin_Failed;
dvander@209	760	co = NULL;
dvander@209	761	break;
dvander@209	762	}
dvander@209	763	}
dvander@190	764	}
dvander@190	765	}
dvander@209	766
dvander@298	767	/* Do the actual compiling */
dvander@209	768	if (co)
dvander@209	769	{
dvander@209	770	pPlugin->FinishMyCompile(NULL, 0);
dvander@209	771	co = NULL;
dvander@209	772	}
dvander@209	773
dvander@298	774	/* Get the status */
dvander@211	775	if (pPlugin->GetStatus() == Plugin_Created)
dvander@211	776	{
dvander@211	777	AddCoreNativesToPlugin(pPlugin);
dvander@229	778	pPlugin->InitIdentity();
dvander@315	779	if (pPlugin->Call_AskPluginLoad(error, err_max))
dvander@315	780	{
dvander@315	781	/* Autoload any modules */
dvander@315	782	LoadOrRequireExtensions(pPlugin, 1, error, err_max);
dvander@315	783	}
dvander@211	784	}
dvander@211	785
dvander@298	786	if (_plugin)
dvander@298	787	{
dvander@298	788	*_plugin = pPlugin;
dvander@298	789	}
dvander@298	790
dvander@298	791	return (pPlugin->GetStatus() == Plugin_Loaded);
dvander@190	792	}
dvander@190	793
dvander@174	794	IPlugin CPluginManager::LoadPlugin(const char path, bool debug, PluginType type, char error[], size_t err_max)
dvander@174	795	{
dvander@298	796	CPlugin *pl;
dvander@211	797
dvander@298	798	if (!_LoadPlugin(&pl, path, debug, type, error, err_max))
dvander@211	799	{
dvander@298	800	delete pl;
dvander@174	801	return NULL;
dvander@174	802	}
dvander@174	803
dvander@298	804	AddPlugin(pl);
dvander@298	805
dvander@315	806	/* Run second pass if we need to */
dvander@315	807	if (IsLateLoadTime() && pl->GetStatus() == Plugin_Loaded)
dvander@315	808	{
dvander@315	809	if (!RunSecondPass(pl, error, err_max))
dvander@315	810	{
dvander@315	811	UnloadPlugin(pl);
dvander@315	812	return NULL;
dvander@315	813	}
dvander@315	814	}
dvander@315	815
dvander@298	816	return pl;
dvander@298	817	}
dvander@298	818
dvander@298	819	void CPluginManager::LoadAutoPlugin(const char *plugin)
dvander@298	820	{
dvander@298	821	CPlugin *pl;
dvander@298	822	char error[255] = "Unknown error";
dvander@298	823
dvander@298	824	if (!_LoadPlugin(&pl, plugin, false, PluginType_MapUpdated, error, sizeof(error)))
dvander@209	825	{
dvander@305	826	g_Logger.LogError("[SM] Failed to load plugin \"%s\": %s", plugin, error);
dvander@298	827	pl->SetErrorState(Plugin_Failed, "%s", error);
dvander@209	828	}
dvander@209	829
dvander@298	830	AddPlugin(pl);
dvander@209	831	}
dvander@209	832
dvander@211	833	void CPluginManager::AddPlugin(CPlugin *pPlugin)
dvander@209	834	{
dvander@174	835	List<IPluginsListener *>::iterator iter;
dvander@174	836	IPluginsListener *pListener;
dvander@298	837
dvander@174	838	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)
dvander@174	839	{
dvander@174	840	pListener = (*iter);
dvander@174	841	pListener->OnPluginCreated(pPlugin);
dvander@174	842	}
dvander@174	843
dvander@298	844	m_plugins.push_back(pPlugin);
dvander@298	845	sm_trie_insert(m_LoadLookup, pPlugin->m_filename, pPlugin);
dvander@211	846	}
dvander@211	847
dvander@213	848	void CPluginManager::LoadAll_SecondPass()
dvander@213	849	{
dvander@213	850	List<CPlugin *>::iterator iter;
dvander@213	851	CPlugin *pPlugin;
dvander@213	852
dvander@315	853	char error[256];
dvander@213	854	for (iter=m_plugins.begin(); iter!=m_plugins.end(); iter++)
dvander@213	855	{
dvander@213	856	pPlugin = (*iter);
dvander@213	857	if (pPlugin->GetStatus() == Plugin_Loaded)
dvander@213	858	{
dvander@315	859	error[0] = '\0';
dvander@315	860	if (!RunSecondPass(pPlugin, error, sizeof(error)))
dvander@315	861	{
dvander@315	862	g_Logger.LogError("[SM] Unable to load plugin \"%s\": %s", pPlugin->GetFilename(), error);
dvander@315	863	pPlugin->SetErrorState(Plugin_Failed, "%s", error);
dvander@315	864	}
dvander@213	865	}
dvander@213	866	}
dvander@298	867
faluco@216	868	m_AllPluginsLoaded = true;
dvander@213	869	}
dvander@213	870
dvander@315	871	bool CPluginManager::LoadOrRequireExtensions(CPlugin pPlugin, unsigned int pass, char error, size_t maxlength)
dvander@211	872	{
dvander@298	873	/* Find any extensions this plugin needs */
dvander@298	874	struct _ext
dvander@298	875	{
dvander@298	876	cell_t name;
dvander@298	877	cell_t file;
dvander@298	878	cell_t autoload;
dvander@298	879	cell_t required;
dvander@298	880	} *ext;
dvander@298	881
dvander@298	882	IPluginContext *pBase = pPlugin->GetBaseContext();
dvander@298	883	uint32_t num = pBase->GetPubVarsNum();
dvander@298	884	sp_pubvar_t *pubvar;
dvander@298	885	IExtension *pExt;
dvander@298	886	char path[PLATFORM_MAX_PATH+1];
dvander@298	887	char file, name;
dvander@298	888	for (uint32_t i=0; i<num; i++)
dvander@298	889	{
dvander@298	890	if (pBase->GetPubvarByIndex(i, &pubvar) != SP_ERROR_NONE)
dvander@298	891	{
dvander@298	892	continue;
dvander@298	893	}
dvander@298	894	if (strncmp(pubvar->name, "__ext_", 6) == 0)
dvander@298	895	{
dvander@298	896	ext = (_ext *)pubvar->offs;
dvander@298	897	if (!ext->required && !ext->autoload)
dvander@298	898	{
dvander@298	899	continue;
dvander@298	900	}
dvander@298	901	if (pBase->LocalToString(ext->file, &file) != SP_ERROR_NONE)
dvander@298	902	{
dvander@298	903	continue;
dvander@298	904	}
dvander@298	905	if (pBase->LocalToString(ext->name, &name) != SP_ERROR_NONE)
dvander@298	906	{
dvander@298	907	continue;
dvander@298	908	}
dvander@315	909	if (pass == 1)
dvander@298	910	{
dvander@315	911	/* Attempt to auto-load if necessary */
dvander@315	912	if (ext->autoload)
dvander@315	913	{
dvander@315	914	g_LibSys.PathFormat(path, PLATFORM_MAX_PATH, "%s", file);
dvander@315	915	g_Extensions.LoadAutoExtension(path);
dvander@315	916	}
dvander@315	917	} else if (pass == 2) {
dvander@315	918	/* Is this required? */
dvander@315	919	if (ext->required)
dvander@298	920	{
dvander@315	921	g_LibSys.PathFormat(path, PLATFORM_MAX_PATH, "%s", file);
dvander@315	922	if ((pExt = g_Extensions.FindExtensionByFile(path)) == NULL)
dvander@315	923	{
dvander@315	924	pExt = g_Extensions.FindExtensionByName(name);
dvander@315	925	}
dvander@315	926	/* :TODO: should we bind to unloaded extensions?
dvander@315	927	* Currently the extension manager will ignore this.
dvander@315	928	*/
dvander@315	929	if (!pExt \|\| !pExt->IsRunning(NULL, 0))
dvander@315	930	{
dvander@315	931	if (error)
dvander@315	932	{
dvander@315	933	snprintf(error, maxlength, "Required extension \"%s\" file(\"%s\") not running", name, file);
dvander@315	934	}
dvander@315	935	pPlugin->m_status = Plugin_Failed;
dvander@315	936	return false;
dvander@315	937	} else {
dvander@315	938	g_Extensions.BindChildPlugin(pExt, pPlugin);
dvander@315	939	}
dvander@298	940	}
dvander@298	941	}
dvander@315	942	}
dvander@315	943	}
dvander@315	944
dvander@315	945	return true;
dvander@315	946	}
dvander@315	947
dvander@315	948	bool CPluginManager::RunSecondPass(CPlugin pPlugin, char error, size_t maxlength)
dvander@315	949	{
dvander@315	950	/* Second pass for extension requirements */
dvander@315	951	if (!LoadOrRequireExtensions(pPlugin, 2, error, maxlength))
dvander@315	952	{
dvander@315	953	return false;
dvander@315	954	}
dvander@315	955
dvander@315	956	/* Bind all extra natives */
dvander@315	957	g_Extensions.BindAllNativesToPlugin(pPlugin);
dvander@315	958
dvander@315	959	/* Find any unbound natives
dvander@315	960	* Right now, these are not allowed
dvander@315	961	*/
dvander@315	962	IPluginContext *pContext = pPlugin->GetBaseContext();
dvander@315	963	uint32_t num = pContext->GetNativesNum();
dvander@315	964	sp_native_t *native;
dvander@315	965	for (unsigned int i=0; i<num; i++)
dvander@315	966	{
dvander@315	967	if (pContext->GetNativeByIndex(i, &native) != SP_ERROR_NONE)
dvander@315	968	{
dvander@315	969	break;
dvander@315	970	}
dvander@315	971	if (native->status == SP_NATIVE_UNBOUND)
dvander@315	972	{
dvander@315	973	if (error)
dvander@298	974	{
dvander@315	975	snprintf(error, maxlength, "Native \"%s\" was not found.", native->name);
dvander@298	976	}
dvander@315	977	return false;
dvander@298	978	}
dvander@298	979	}
dvander@211	980
dvander@211	981	/* Finish by telling all listeners */
dvander@211	982	List<IPluginsListener *>::iterator iter;
dvander@211	983	IPluginsListener *pListener;
dvander@211	984	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)
dvander@211	985	{
dvander@211	986	pListener = (*iter);
dvander@211	987	pListener->OnPluginLoaded(pPlugin);
dvander@211	988	}
dvander@298	989
dvander@298	990	/* Tell this plugin to finish initializing itself */
dvander@298	991	pPlugin->Call_OnPluginInit();
dvander@298	992
dvander@298	993	return true;
dvander@211	994	}
dvander@211	995
dvander@211	996	void CPluginManager::AddCoreNativesToPlugin(CPlugin *pPlugin)
dvander@211	997	{
dvander@211	998	List<sp_nativeinfo_t *>::iterator iter;
dvander@211	999
dvander@211	1000	for (iter=m_natives.begin(); iter!=m_natives.end(); iter++)
dvander@211	1001	{
dvander@211	1002	sp_nativeinfo_t natives = (iter);
dvander@211	1003	IPluginContext *ctx = pPlugin->GetBaseContext();
dvander@211	1004	unsigned int i=0;
dvander@211	1005	/* Attempt to bind every native! */
dvander@211	1006	while (natives[i].func != NULL)
dvander@211	1007	{
dvander@211	1008	ctx->BindNative(&natives[i++]);
dvander@211	1009	}
dvander@211	1010	}
dvander@174	1011	}
dvander@174	1012
dvander@174	1013	bool CPluginManager::UnloadPlugin(IPlugin *plugin)
dvander@174	1014	{
dvander@174	1015	CPlugin pPlugin = (CPlugin )plugin;
dvander@298	1016
dvander@298	1017	/* This prevents removal during insertion or anything else weird */
dvander@298	1018	if (m_plugins.find(pPlugin) == m_plugins.end())
dvander@298	1019	{
dvander@298	1020	return false;
dvander@298	1021	}
dvander@298	1022
dvander@174	1023	List<IPluginsListener *>::iterator iter;
dvander@174	1024	IPluginsListener *pListener;
dvander@282	1025
dvander@311	1026	if (pPlugin->GetStatus() <= Plugin_Error)
dvander@282	1027	{
dvander@282	1028	/* Notify listeners of unloading */
dvander@282	1029	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)
dvander@282	1030	{
dvander@282	1031	pListener = (*iter);
dvander@282	1032	pListener->OnPluginUnloaded(pPlugin);
dvander@282	1033	}
dvander@282	1034	/* Notify plugin */
dvander@282	1035	pPlugin->Call_OnPluginUnload();
dvander@282	1036	}
dvander@282	1037
dvander@174	1038	for (iter=m_listeners.begin(); iter!=m_listeners.end(); iter++)
dvander@174	1039	{
dvander@282	1040	/* Notify listeners of destruction */
dvander@174	1041	pListener = (*iter);
dvander@174	1042	pListener->OnPluginDestroyed(pPlugin);
dvander@174	1043	}
dvander@211	1044
dvander@282	1045	/* Remove us from the lookup table and linked list */
dvander@213	1046	m_plugins.remove(pPlugin);
dvander@211	1047	sm_trie_delete(m_LoadLookup, pPlugin->m_filename);
dvander@176	1048
dvander@282	1049	/* Tell the plugin to delete itself */
dvander@174	1050	delete pPlugin;
dvander@174	1051
dvander@174	1052	return true;
dvander@174	1053	}
dvander@174	1054
dvander@174	1055	IPlugin CPluginManager::FindPluginByContext(const sp_context_t ctx)
dvander@174	1056	{
dvander@174	1057	IPlugin pl = (IPlugin )ctx->user[SM_CONTEXTVAR_MYSELF];
dvander@174	1058	return pl;
dvander@174	1059	}
dvander@174	1060
dvander@174	1061	unsigned int CPluginManager::GetPluginCount()
dvander@174	1062	{
dvander@174	1063	return m_plugins.size();
dvander@174	1064	}
dvander@174	1065
dvander@174	1066	void CPluginManager::AddPluginsListener(IPluginsListener *listener)
dvander@174	1067	{
dvander@174	1068	m_listeners.push_back(listener);
dvander@174	1069	}
dvander@174	1070
dvander@174	1071	void CPluginManager::RemovePluginsListener(IPluginsListener *listener)
dvander@174	1072	{
dvander@174	1073	m_listeners.remove(listener);
dvander@174	1074	}
dvander@174	1075
dvander@174	1076	IPluginIterator *CPluginManager::GetPluginIterator()
dvander@174	1077	{
dvander@174	1078	if (m_iters.empty())
dvander@174	1079	{
dvander@174	1080	return new CPluginIterator(&m_plugins);
dvander@174	1081	} else {
dvander@174	1082	CPluginIterator *iter = m_iters.front();
dvander@174	1083	m_iters.pop();
faluco@216	1084	iter->Reset();
dvander@174	1085	return iter;
dvander@174	1086	}
dvander@174	1087	}
dvander@174	1088
dvander@174	1089	void CPluginManager::ReleaseIterator(CPluginIterator *iter)
dvander@174	1090	{
dvander@174	1091	m_iters.push(iter);
dvander@174	1092	}
dvander@176	1093
dvander@176	1094	void CPluginManager::ReleaseFunctionToPool(CFunction *func)
dvander@176	1095	{
dvander@177	1096	if (!func)
dvander@177	1097	{
dvander@177	1098	return;
dvander@177	1099	}
dvander@177	1100	func->Cancel();
dvander@176	1101	m_funcpool.push(func);
dvander@176	1102	}
dvander@176	1103
dvander@176	1104	CFunction CPluginManager::GetFunctionFromPool(funcid_t f, CPlugin plugin)
dvander@176	1105	{
dvander@176	1106	if (m_funcpool.empty())
dvander@176	1107	{
dvander@176	1108	return new CFunction(f, plugin);
dvander@176	1109	} else {
dvander@176	1110	CFunction *func = m_funcpool.front();
dvander@176	1111	m_funcpool.pop();
dvander@176	1112	func->Set(f, plugin);
dvander@176	1113	return func;
dvander@176	1114	}
dvander@176	1115	}
dvander@176	1116
dvander@203	1117	bool CPluginManager::TestAliasMatch(const char alias, const char localpath)
dvander@203	1118	{
dvander@203	1119	/* As an optimization, we do not call strlen, but compute the length in the first pass */
dvander@203	1120	size_t alias_len = 0;
dvander@203	1121	size_t local_len = 0;
dvander@203	1122
dvander@203	1123	const char *ptr = alias;
dvander@203	1124	unsigned int alias_explicit_paths = 0;
dvander@203	1125	unsigned int alias_path_end = 0;
dvander@203	1126	while (*ptr != '\0')
dvander@203	1127	{
dvander@203	1128	if (ptr == '\\' \|\| ptr == '/')
dvander@203	1129	{
dvander@203	1130	alias_explicit_paths++;
dvander@203	1131	alias_path_end = alias_len;
dvander@203	1132	}
dvander@203	1133	alias_len++;
dvander@203	1134	ptr++;
dvander@203	1135	}
dvander@203	1136
dvander@209	1137	if (alias_explicit_paths && alias_path_end == alias_len - 1)
dvander@203	1138	{
dvander@203	1139	/* Trailing slash is totally invalid here */
dvander@203	1140	return false;
dvander@203	1141	}
dvander@203	1142
dvander@203	1143	ptr = localpath;
dvander@203	1144	unsigned int local_explicit_paths = 0;
dvander@203	1145	unsigned int local_path_end = 0;
dvander@203	1146	while (*ptr != '\0')
dvander@203	1147	{
dvander@203	1148	if (ptr == '\\' \|\| ptr == '/')
dvander@203	1149	{
dvander@203	1150	local_explicit_paths++;
dvander@203	1151	local_path_end = local_len;
dvander@203	1152	}
dvander@203	1153	local_len++;
dvander@203	1154	ptr++;
dvander@203	1155	}
dvander@203	1156
dvander@203	1157	/* If the alias has more explicit paths than the real path,
dvander@203	1158	* no match will be possible.
dvander@203	1159	*/
dvander@203	1160	if (alias_explicit_paths > local_explicit_paths)
dvander@203	1161	{
dvander@203	1162	return false;
dvander@203	1163	}
dvander@203	1164
dvander@203	1165	if (alias_explicit_paths)
dvander@203	1166	{
dvander@203	1167	/* We need to find if the paths match now. For example, these should all match:
dvander@203	1168	* csdm csdm
dvander@203	1169	* csdm optional/csdm
dvander@203	1170	* csdm/ban optional/crab/csdm/ban
dvander@203	1171	*/
dvander@203	1172	const char *aliasptr = alias;
dvander@203	1173	const char *localptr = localpath;
dvander@203	1174	bool match = true;
dvander@203	1175	do
dvander@203	1176	{
dvander@203	1177	if (aliasptr != localptr)
dvander@203	1178	{
dvander@203	1179	/* We have to knock one path off */
dvander@203	1180	local_explicit_paths--;
dvander@203	1181	if (alias_explicit_paths > local_explicit_paths)
dvander@203	1182	{
dvander@203	1183	/* Skip out if we're gonna have an impossible match */
dvander@203	1184	return false;
dvander@203	1185	}
dvander@203	1186	/* Eat up localptr tokens until we get a result */
dvander@203	1187	while (((localptr - localpath) < (int)local_path_end)
dvander@203	1188	&& *localptr != '/'
dvander@203	1189	&& *localptr != '\\')
dvander@203	1190	{
dvander@203	1191	localptr++;
dvander@203	1192	}
dvander@203	1193	/* Check if we hit the end of our searchable area.
dvander@203	1194	* This probably isn't possible because of the path
dvander@203	1195	* count check, but it's a good idea anyway.
dvander@203	1196	*/
dvander@203	1197	if ((localptr - localpath) >= (int)local_path_end)
dvander@203	1198	{
dvander@203	1199	return false;
dvander@203	1200	} else {
dvander@203	1201	/* Consume the slash token */
dvander@203	1202	localptr++;
dvander@203	1203	}
dvander@203	1204	/* Reset the alias pointer so we can continue consuming */
dvander@203	1205	aliasptr = alias;
dvander@203	1206	match = false;
dvander@203	1207	continue;
dvander@203	1208	}
dvander@203	1209	/* Note:
dvander@203	1210	* This is safe because if localptr terminates early, aliasptr will too
dvander@203	1211	*/
dvander@203	1212	do
dvander@203	1213	{
dvander@203	1214	/* We should never reach the end of the string because of this check. */
dvander@203	1215	bool aliasend = (aliasptr - alias) > (int)alias_path_end;
dvander@203	1216	bool localend = (localptr - localpath) > (int)local_path_end;
dvander@203	1217	if (aliasend \|\| localend)
dvander@203	1218	{
dvander@203	1219	if (aliasend && localend)
dvander@203	1220	{
dvander@203	1221	/* we matched, and we can break out now */
dvander@203	1222	match = true;
dvander@203	1223	break;
dvander@203	1224	}
dvander@203	1225	/* Otherwise, we've hit the end somehow and rest won't match up. Break out. */
dvander@203	1226	match = false;
dvander@203	1227	break;
dvander@203	1228	}
dvander@203	1229
dvander@203	1230	/* If we got here, it's safe to compare the next two tokens */
dvander@203	1231	if (localptr != aliasptr)
dvander@203	1232	{
dvander@203	1233	match = false;
dvander@203	1234	break;
dvander@203	1235	}
dvander@203	1236	localptr++;
dvander@203	1237	aliasptr++;
dvander@203	1238	} while (true);
dvander@203	1239	} while (!match);
dvander@203	1240	}
dvander@203	1241
dvander@203	1242	/* If we got here, it's time to compare filenames */
dvander@203	1243	const char *aliasptr = alias;
dvander@203	1244	const char *localptr = localpath;
dvander@203	1245
dvander@203	1246	if (alias_explicit_paths)
dvander@203	1247	{
dvander@203	1248	aliasptr = &alias[alias_path_end + 1];
dvander@203	1249	}
dvander@203	1250
dvander@203	1251	if (local_explicit_paths)
dvander@203	1252	{
dvander@203	1253	localptr = &localpath[local_path_end + 1];
dvander@203	1254	}
dvander@203	1255
dvander@203	1256	while (true)
dvander@203	1257	{
dvander@203	1258	if (aliasptr == '')
dvander@203	1259	{
dvander@203	1260	/* First, see if this is the last character */
dvander@203	1261	if (aliasptr - alias == alias_len - 1)
dvander@203	1262	{
dvander@203	1263	/* If so, there's no need to match anything else */
dvander@203	1264	return true;
dvander@203	1265	}
dvander@203	1266	/* Otherwise, we need to search for an appropriate matching sequence in local.
dvander@203	1267	* Note that we only need to search up to the next asterisk.
dvander@203	1268	*/
dvander@203	1269	aliasptr++;
dvander@203	1270	bool match = true;
dvander@203	1271	const char *local_orig = localptr;
dvander@203	1272	do
dvander@203	1273	{
dvander@203	1274	match = true;
dvander@203	1275	while (aliasptr != '\0' && aliasptr != '*')
dvander@203	1276	{
dvander@203	1277	/* Since aliasptr is never '\0', localptr hitting the end will fail */
dvander@203	1278	if (aliasptr != localptr)
dvander@203	1279	{
dvander@203	1280	match = false;
dvander@203	1281	break;
dvander@203	1282	}
dvander@203	1283	aliasptr++;
dvander@203	1284	localptr++;
dvander@203	1285	}
dvander@203	1286	if (!match)
dvander@203	1287	{
dvander@203	1288	/* If we didn't get a match, we need to advance the search stream.
dvander@203	1289	* This will let us skip tokens while still searching for another match.
dvander@203	1290	*/
dvander@203	1291	localptr = ++local_orig;
dvander@203	1292	/* Make sure we don't go out of bounds */
dvander@203	1293	if (*localptr == '\0')
dvander@203	1294	{
dvander@203	1295	break;
dvander@203	1296	}
dvander@203	1297	}
dvander@203	1298	} while (!match);
dvander@203	1299
dvander@203	1300	if (!match)
dvander@203	1301	{
dvander@203	1302	return false;
dvander@203	1303	} else {
dvander@203	1304	/* If we got a match, move on to the next token */
dvander@203	1305	continue;
dvander@203	1306	}
dvander@203	1307	} else if (*aliasptr == '\0') {
dvander@203	1308	if (*localptr == '\0'
dvander@203	1309	\|\|
dvander@203	1310	strcmp(localptr, ".smx") == 0)
dvander@203	1311	{
dvander@203	1312	return true;
dvander@203	1313	} else {
dvander@203	1314	return false;
dvander@203	1315	}
dvander@203	1316	} else if (aliasptr != localptr) {
dvander@203	1317	return false;
dvander@203	1318	}
dvander@203	1319	aliasptr++;
dvander@203	1320	localptr++;
dvander@203	1321	}
dvander@203	1322
dvander@203	1323	return true;
dvander@203	1324	}
dvander@203	1325
faluco@290	1326	bool CPluginManager::IsLateLoadTime() const
dvander@176	1327	{
dvander@315	1328	return (m_AllPluginsLoaded \|\| !g_SourceMod.IsMapLoading());
dvander@176	1329	}
dvander@220	1330
dvander@220	1331	void CPluginManager::OnSourceModAllInitialized()
dvander@220	1332	{
dvander@229	1333	m_MyIdent = g_ShareSys.CreateCoreIdentity();
dvander@229	1334
dvander@262	1335	HandleAccess sec;
dvander@262	1336	g_HandleSys.InitAccessDefaults(NULL, &sec);
dvander@220	1337
dvander@262	1338	sec.access[HandleAccess_Delete] = HANDLE_RESTRICT_IDENTITY;
dvander@262	1339	sec.access[HandleAccess_Clone] = HANDLE_RESTRICT_IDENTITY;
dvander@262	1340
dvander@262	1341	g_PluginType = g_HandleSys.CreateType("Plugin", this, 0, NULL, &sec, m_MyIdent, NULL);
dvander@229	1342	g_PluginIdent = g_ShareSys.CreateIdentType("PLUGIN");
dvander@309	1343
dvander@309	1344	g_RootMenu.AddRootConsoleCommand("plugins", "Manage Plugins", this);
dvander@220	1345	}
dvander@220	1346
dvander@220	1347	void CPluginManager::OnSourceModShutdown()
dvander@220	1348	{
dvander@309	1349	g_RootMenu.RemoveRootConsoleCommand("plugins", this);
dvander@309	1350
dvander@298	1351	List<CPlugin *>::iterator iter;
dvander@298	1352	while ( (iter = m_plugins.begin()) != m_plugins.end() )
dvander@298	1353	{
dvander@298	1354	UnloadPlugin((*iter));
dvander@298	1355	}
dvander@298	1356
dvander@229	1357	g_HandleSys.RemoveType(g_PluginType, m_MyIdent);
dvander@229	1358	g_ShareSys.DestroyIdentType(g_PluginIdent);
dvander@229	1359	g_ShareSys.DestroyIdentity(m_MyIdent);
dvander@220	1360	}
dvander@220	1361
dvander@220	1362	void CPluginManager::OnHandleDestroy(HandleType_t type, void *object)
dvander@220	1363	{
dvander@220	1364	/* We don't care about the internal object, actually */
dvander@220	1365	}
dvander@233	1366
dvander@233	1367	void CPluginManager::RegisterNativesFromCore(sp_nativeinfo_t *natives)
dvander@233	1368	{
dvander@233	1369	m_natives.push_back(natives);
dvander@233	1370	}
dvander@247	1371
dvander@247	1372	IPlugin CPluginManager::PluginFromHandle(Handle_t handle, HandleError err)
dvander@247	1373	{
dvander@247	1374	IPlugin *pPlugin;
dvander@247	1375	HandleError _err;
dvander@247	1376
dvander@262	1377	HandleSecurity sec;
dvander@262	1378
dvander@262	1379	sec.pOwner = NULL;
dvander@262	1380	sec.pIdentity = m_MyIdent;
dvander@262	1381
dvander@262	1382	if ((_err=g_HandleSys.ReadHandle(handle, g_PluginType, &sec, (void **)&pPlugin)) != HandleError_None)
dvander@247	1383	{
dvander@247	1384	pPlugin = NULL;
dvander@247	1385	}
dvander@247	1386
dvander@247	1387	if (err)
dvander@247	1388	{
dvander@247	1389	*err = _err;
dvander@247	1390	}
dvander@247	1391
dvander@247	1392	return pPlugin;
dvander@247	1393	}
faluco@290	1394
faluco@290	1395	CPlugin *CPluginManager::GetPluginByOrder(int num)
faluco@290	1396	{
faluco@290	1397	if (num < 1 \|\| num > (int)GetPluginCount())
faluco@290	1398	{
faluco@290	1399	return NULL;
faluco@290	1400	}
faluco@290	1401
faluco@290	1402	CPlugin *pl;
faluco@290	1403	int id = 1;
faluco@290	1404
faluco@290	1405	IPluginIterator *iter = GetPluginIterator();
faluco@290	1406	for (; iter->MorePlugins() && id<num; iter->NextPlugin(), id++) {}
faluco@290	1407
faluco@290	1408	pl = (CPlugin *)(iter->GetPlugin());
faluco@290	1409	iter->Release();
faluco@290	1410
faluco@290	1411	return pl;
dvander@298	1412	}
dvander@309	1413
dvander@309	1414	const char *CPluginManager::GetStatusText(PluginStatus st)
dvander@309	1415	{
dvander@309	1416	switch (st)
dvander@309	1417	{
dvander@309	1418	case Plugin_Running:
dvander@309	1419	return "Running";
dvander@309	1420	case Plugin_Paused:
dvander@309	1421	return "Paused";
dvander@309	1422	case Plugin_Error:
dvander@309	1423	return "Error";
dvander@309	1424	case Plugin_Uncompiled:
dvander@309	1425	return "Uncompiled";
dvander@309	1426	case Plugin_BadLoad:
dvander@309	1427	return "Bad Load";
dvander@309	1428	case Plugin_Failed:
dvander@309	1429	return "Failed";
dvander@309	1430	default:
dvander@309	1431	assert(false);
dvander@309	1432	return "-";
dvander@309	1433	}
dvander@309	1434	}
dvander@309	1435
dvander@309	1436	#define IS_STR_FILLED(var) (var[0] != '\0')
dvander@309	1437	void CPluginManager::OnRootConsoleCommand(const char *command, unsigned int argcount)
dvander@309	1438	{
dvander@309	1439	if (argcount >= 3)
dvander@309	1440	{
dvander@309	1441	const char *cmd = g_RootMenu.GetArgument(2);
dvander@309	1442	if (strcmp(cmd, "list") == 0)
dvander@309	1443	{
dvander@309	1444	char buffer[256];
dvander@309	1445	unsigned int id = 1;
dvander@309	1446	int plnum = GetPluginCount();
dvander@309	1447
dvander@309	1448	if (!plnum)
dvander@309	1449	{
dvander@309	1450	g_RootMenu.ConsolePrint("[SM] No plugins loaded");
dvander@309	1451	return;
dvander@309	1452	} else {
dvander@309	1453	g_RootMenu.ConsolePrint("[SM] Displaying %d plugin%s:", GetPluginCount(), (plnum > 1) ? "s" : "");
dvander@309	1454	}
dvander@309	1455
dvander@309	1456	IPluginIterator *iter = GetPluginIterator();
dvander@309	1457	for (; iter->MorePlugins(); iter->NextPlugin(), id++)
dvander@309	1458	{
dvander@309	1459	IPlugin *pl = iter->GetPlugin();
dvander@309	1460	assert(pl->GetStatus() != Plugin_Created);
dvander@309	1461	int len = 0;
dvander@309	1462	const sm_plugininfo_t *info = pl->GetPublicInfo();
dvander@309	1463
dvander@309	1464	len += UTIL_Format(buffer, sizeof(buffer), " %02d <%s>", id, GetStatusText(pl->GetStatus()));
dvander@309	1465	len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " \"%s\"", (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());
dvander@309	1466	if (IS_STR_FILLED(info->version))
dvander@309	1467	{
dvander@309	1468	len += UTIL_Format(&buffer[len], sizeof(buffer)-len, " (%s)", info->version);
dvander@309	1469	}
dvander@309	1470	if (IS_STR_FILLED(info->author))
dvander@309	1471	{
dvander@309	1472	UTIL_Format(&buffer[len], sizeof(buffer)-len, " by %s", info->author);
dvander@309	1473	}
dvander@309	1474	g_RootMenu.ConsolePrint("%s", buffer);
dvander@309	1475	}
dvander@309	1476
dvander@309	1477	iter->Release();
dvander@309	1478	return;
dvander@309	1479	} else if (strcmp(cmd, "load") == 0) {
dvander@309	1480	if (argcount < 4)
dvander@309	1481	{
dvander@310	1482	g_RootMenu.ConsolePrint("[SM] Usage: sm plugins load <file>");
dvander@309	1483	return;
dvander@309	1484	}
dvander@309	1485
dvander@309	1486	char error[128];
dvander@309	1487	const char *filename = g_RootMenu.GetArgument(3);
dvander@309	1488	IPlugin *pl = LoadPlugin(filename, false, PluginType_MapUpdated, error, sizeof(error));
dvander@309	1489
dvander@309	1490	if (pl)
dvander@309	1491	{
dvander@309	1492	g_RootMenu.ConsolePrint("[SM] Loaded plugin %s successfully.", filename);
dvander@309	1493	} else {
dvander@309	1494	g_RootMenu.ConsolePrint("[SM] Plugin %s failed to load: %s.", filename, error);
dvander@309	1495	}
dvander@309	1496
dvander@309	1497	return;
dvander@309	1498	} else if (strcmp(cmd, "unload") == 0) {
dvander@309	1499	if (argcount < 4)
dvander@309	1500	{
dvander@310	1501	g_RootMenu.ConsolePrint("[SM] Usage: sm plugins unload <#>");
dvander@309	1502	return;
dvander@309	1503	}
dvander@309	1504
dvander@309	1505	int id = 1;
dvander@309	1506	int num = atoi(g_RootMenu.GetArgument(3));
dvander@309	1507	if (num < 1 \|\| num > (int)GetPluginCount())
dvander@309	1508	{
dvander@310	1509	g_RootMenu.ConsolePrint("[SM] Plugin index %d not found.", num);
dvander@309	1510	return;
dvander@309	1511	}
dvander@309	1512
dvander@309	1513	IPluginIterator *iter = GetPluginIterator();
dvander@309	1514	for (; iter->MorePlugins() && id<num; iter->NextPlugin(), id++)
dvander@309	1515	;
dvander@309	1516	IPlugin *pl = iter->GetPlugin();
dvander@309	1517
dvander@309	1518	char name[PLATFORM_MAX_PATH+1];
dvander@309	1519	const sm_plugininfo_t *info = pl->GetPublicInfo();
dvander@309	1520	strcpy(name, (IS_STR_FILLED(info->name)) ? info->name : pl->GetFilename());
dvander@309	1521
dvander@309	1522	if (UnloadPlugin(pl))
dvander@309	1523	{
dvander@310	1524	g_RootMenu.ConsolePrint("[SM] Plugin %s unloaded successfully.", name);
dvander@309	1525	} else {
dvander@310	1526	g_RootMenu.ConsolePrint("[SM] Failed to unload plugin %s.", name);
dvander@309	1527	}
dvander@309	1528
dvander@309	1529	iter->Release();
dvander@309	1530	return;
dvander@309	1531	} else if (strcmp(cmd, "info") == 0) {
dvander@309	1532	if (argcount < 4)
dvander@309	1533	{
dvander@310	1534	g_RootMenu.ConsolePrint("[SM] Usage: sm plugins info <#>");
dvander@309	1535	return;
dvander@309	1536	}
dvander@309	1537
dvander@309	1538	int id = 1;
dvander@309	1539	int num = atoi(g_RootMenu.GetArgument(3));
dvander@309	1540	if (num < 1 \|\| num > (int)GetPluginCount())
dvander@309	1541	{
dvander@310	1542	g_RootMenu.ConsolePrint("[SM] Plugin index not found.");
dvander@309	1543	return;
dvander@309	1544	}
dvander@309	1545
dvander@315	1546	CPlugin *pl = GetPluginByOrder(num);
dvander@309	1547	const sm_plugininfo_t *info = pl->GetPublicInfo();
dvander@309	1548
dvander@309	1549	g_RootMenu.ConsolePrint(" Filename: %s", pl->GetFilename());
dvander@315	1550	if (pl->GetStatus() <= Plugin_Error)
dvander@309	1551	{
dvander@315	1552	if (IS_STR_FILLED(info->name))
dvander@315	1553	{
dvander@315	1554	g_RootMenu.ConsolePrint(" Title: %s", info->name);
dvander@315	1555	}
dvander@315	1556	if (IS_STR_FILLED(info->version))
dvander@315	1557	{
dvander@315	1558	g_RootMenu.ConsolePrint(" Version: %s", info->version);
dvander@315	1559	}
dvander@315	1560	if (IS_STR_FILLED(info->url))
dvander@315	1561	{
dvander@315	1562	g_RootMenu.ConsolePrint(" URL: %s", info->url);
dvander@315	1563	}
dvander@315	1564	if (IS_STR_FILLED(info->author))
dvander@315	1565	{
dvander@315	1566	g_RootMenu.ConsolePrint(" Author: %s", info->author);
dvander@315	1567	}
dvander@315	1568	if (IS_STR_FILLED(info->version))
dvander@315	1569	{
dvander@315	1570	g_RootMenu.ConsolePrint(" Version: %s", info->version);
dvander@315	1571	}
dvander@315	1572	if (IS_STR_FILLED(info->description))
dvander@315	1573	{
dvander@315	1574	g_RootMenu.ConsolePrint(" Description: %s", info->description);
dvander@315	1575	}
dvander@315	1576	g_RootMenu.ConsolePrint(" Debugging: %s", pl->IsDebugging() ? "yes" : "no");
dvander@315	1577	g_RootMenu.ConsolePrint(" Paused: %s", pl->GetStatus() == Plugin_Running ? "yes" : "no");
dvander@315	1578	} else {
dvander@315	1579	g_RootMenu.ConsolePrint(" Load error: %s", pl->m_errormsg);
dvander@315	1580	g_RootMenu.ConsolePrint(" File info: (title \"%s\") (version \"%s\")",
dvander@315	1581	info->name ? info->name : "<none>",
dvander@315	1582	info->version ? info->version : "<none>");
dvander@315	1583	if (IS_STR_FILLED(info->url))
dvander@315	1584	{
dvander@315	1585	g_RootMenu.ConsolePrint(" File URL: %s", info->url);
dvander@315	1586	}
dvander@309	1587	}
dvander@309	1588
dvander@309	1589	return;
dvander@309	1590	} else if (strcmp(cmd, "debug") == 0) {
dvander@309	1591	if (argcount < 5)
dvander@309	1592	{
dvander@310	1593	g_RootMenu.ConsolePrint("[SM] Usage: sm plugins debug <#> [on\|off]");
dvander@309	1594	return;
dvander@309	1595	}
dvander@309	1596
dvander@309	1597	int num = atoi(g_RootMenu.GetArgument(3));
dvander@309	1598	if (num < 1 \|\| num > (int)GetPluginCount())
dvander@309	1599	{
dvander@310	1600	g_RootMenu.ConsolePrint("[SM] Plugin index not found.");
dvander@309	1601	return;
dvander@309	1602	}
dvander@309	1603
dvander@309	1604	int res;
dvander@309	1605	const char *mode = g_RootMenu.GetArgument(4);
dvander@309	1606	if ((res=strcmp("on", mode)) && strcmp("off", mode))
dvander@309	1607	{
dvander@310	1608	g_RootMenu.ConsolePrint("[SM] The only possible options are \"on\" and \"off.\"");
dvander@309	1609	return;
dvander@309	1610	}
dvander@309	1611
dvander@309	1612	bool debug;
dvander@309	1613	if (!res)
dvander@309	1614	{
dvander@309	1615	debug = true;
dvander@309	1616	} else {
dvander@309	1617	debug = false;
dvander@309	1618	}
dvander@309	1619
dvander@309	1620	CPlugin *pl = GetPluginByOrder(num);
dvander@309	1621	if (debug && pl->IsDebugging())
dvander@309	1622	{
dvander@309	1623	g_RootMenu.ConsolePrint("[SM] This plugin is already in debug mode.");
dvander@309	1624	return;
dvander@309	1625	} else if (!debug && !pl->IsDebugging()) {
dvander@309	1626	g_RootMenu.ConsolePrint("[SM] Debug mode is already disabled in this plugin.");
dvander@309	1627	return;
dvander@309	1628	}
dvander@309	1629
dvander@309	1630	char error[256];
dvander@309	1631	if (pl->ToggleDebugMode(debug, error, sizeof(error)))
dvander@309	1632	{
dvander@310	1633	g_RootMenu.ConsolePrint("[SM] Successfully toggled debug mode on plugin %s.", pl->GetFilename());
dvander@309	1634	return;
dvander@309	1635	} else {
dvander@309	1636	g_RootMenu.ConsolePrint("[SM] Could not toggle debug mode on plugin %s.", pl->GetFilename());
dvander@309	1637	g_RootMenu.ConsolePrint("[SM] Plugin returned error: %s", error);
dvander@309	1638	return;
dvander@309	1639	}
dvander@309	1640	}
dvander@309	1641	}
dvander@309	1642
dvander@309	1643	/* Draw the main menu */
dvander@309	1644	g_RootMenu.ConsolePrint("SourceMod Plugins Menu:");
dvander@309	1645	g_RootMenu.DrawGenericOption("list", "Show loaded plugins");
dvander@309	1646	g_RootMenu.DrawGenericOption("load", "Load a plugin");
dvander@309	1647	g_RootMenu.DrawGenericOption("unload", "Unload a plugin");
dvander@309	1648	g_RootMenu.DrawGenericOption("info", "Information about a plugin");
dvander@309	1649	g_RootMenu.DrawGenericOption("debug", "Toggle debug mode on a plugin");
dvander@309	1650	}

author	David Anderson <dvander@alliedmods.net>
	Fri Jan 19 02:14:50 2007 +0000 (2007-01-19)
changeset 317	e5342c8a0cf4
parent 315	5f48300aa103
child 327	e244337a9b38
permissions	-rw-r--r--