9c62e94239
Original patch written by David Anderson (original r from Fyren). - Updated to function with the current JIT compiler. - Took in clean-ups from later-dated patches.
496 lines
12 KiB
C++
496 lines
12 KiB
C++
/**
|
|
* vim: set ts=4 sw=4 tw=99 noet :
|
|
* =============================================================================
|
|
* SourceMod
|
|
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
|
|
* =============================================================================
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under
|
|
* the terms of the GNU General Public License, version 3.0, as published by the
|
|
* Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* As a special exception, AlliedModders LLC gives you permission to link the
|
|
* code of this program (as well as its derivative works) to "Half-Life 2," the
|
|
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
|
|
* by the Valve Corporation. You must obey the GNU General Public License in
|
|
* all respects for all other code used. Additionally, AlliedModders LLC grants
|
|
* this exception to all derivative works. AlliedModders LLC defines further
|
|
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
|
|
* or <http://www.sourcemod.net/license.php>.
|
|
*
|
|
* Version: $Id$
|
|
*/
|
|
|
|
#include "ShareSys.h"
|
|
#include "ExtensionSys.h"
|
|
#include <ILibrarySys.h>
|
|
#include "common_logic.h"
|
|
#include "PluginSys.h"
|
|
#include "HandleSys.h"
|
|
#include <assert.h>
|
|
|
|
using namespace ke;
|
|
|
|
ShareSystem g_ShareSys;
|
|
static unsigned int g_mark_serial = 0;
|
|
|
|
ShareSystem::ShareSystem()
|
|
{
|
|
m_IdentRoot.ident = 0;
|
|
m_TypeRoot = 0;
|
|
m_IfaceType = 0;
|
|
m_CoreType = 0;
|
|
}
|
|
|
|
IdentityToken_t *ShareSystem::CreateCoreIdentity()
|
|
{
|
|
if (!m_CoreType)
|
|
{
|
|
m_CoreType = CreateIdentType("CORE");
|
|
}
|
|
|
|
return CreateIdentity(m_CoreType, this);
|
|
}
|
|
|
|
void ShareSystem::Initialize()
|
|
{
|
|
TypeAccess sec;
|
|
|
|
handlesys->InitAccessDefaults(&sec, NULL);
|
|
sec.ident = GetIdentRoot();
|
|
|
|
m_TypeRoot = handlesys->CreateType("Identity", this, 0, &sec, NULL, NULL, NULL);
|
|
m_IfaceType = handlesys->CreateType("Interface", this, 0, NULL, NULL, GetIdentRoot(), NULL);
|
|
|
|
/* Initialize our static identity handle */
|
|
m_IdentRoot.ident = handlesys->CreateHandle(m_TypeRoot, NULL, NULL, GetIdentRoot(), NULL);
|
|
|
|
/* Add the Handle System and others... they are too innocent and pure to do it themselves */
|
|
AddInterface(NULL, handlesys);
|
|
AddInterface(NULL, libsys);
|
|
}
|
|
|
|
void ShareSystem::OnSourceModShutdown()
|
|
{
|
|
if (m_CoreType)
|
|
{
|
|
handlesys->RemoveType(m_CoreType, GetIdentRoot());
|
|
}
|
|
|
|
handlesys->RemoveType(m_IfaceType, GetIdentRoot());
|
|
handlesys->RemoveType(m_TypeRoot, GetIdentRoot());
|
|
}
|
|
|
|
IdentityType_t ShareSystem::FindIdentType(const char *name)
|
|
{
|
|
HandleType_t type;
|
|
|
|
if (handlesys->FindHandleType(name, &type))
|
|
{
|
|
if (g_HandleSys.TypeCheck(type, m_TypeRoot))
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
IdentityType_t ShareSystem::CreateIdentType(const char *name)
|
|
{
|
|
if (!m_TypeRoot)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return handlesys->CreateType(name, this, m_TypeRoot, NULL, NULL, GetIdentRoot(), NULL);
|
|
}
|
|
|
|
void ShareSystem::OnHandleDestroy(HandleType_t type, void *object)
|
|
{
|
|
/* THIS WILL NEVER BE CALLED FOR ANYTHING WITH THE IDENTITY TYPE */
|
|
}
|
|
|
|
IdentityToken_t *ShareSystem::CreateIdentity(IdentityType_t type, void *ptr)
|
|
{
|
|
if (!m_TypeRoot)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* :TODO: Cache? */
|
|
IdentityToken_t *pToken = new IdentityToken_t;
|
|
|
|
HandleSecurity sec;
|
|
sec.pOwner = sec.pIdentity = GetIdentRoot();
|
|
|
|
pToken->ident = g_HandleSys.CreateHandleInt(type, NULL, &sec, NULL, NULL, true);
|
|
pToken->ptr = ptr;
|
|
pToken->type = type;
|
|
|
|
return pToken;
|
|
}
|
|
|
|
bool ShareSystem::AddInterface(IExtension *myself, SMInterface *iface)
|
|
{
|
|
if (!iface)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
IfaceInfo info;
|
|
|
|
info.owner = myself;
|
|
info.iface = iface;
|
|
|
|
m_Interfaces.push_back(info);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ShareSystem::RequestInterface(const char *iface_name,
|
|
unsigned int iface_vers,
|
|
IExtension *myself,
|
|
SMInterface **pIface)
|
|
{
|
|
/* See if the interface exists */
|
|
List<IfaceInfo>::iterator iter;
|
|
SMInterface *iface;
|
|
IExtension *iface_owner;
|
|
bool found = false;
|
|
for (iter=m_Interfaces.begin(); iter!=m_Interfaces.end(); iter++)
|
|
{
|
|
IfaceInfo &info = (*iter);
|
|
iface = info.iface;
|
|
if (strcmp(iface->GetInterfaceName(), iface_name) == 0)
|
|
{
|
|
if (iface->GetInterfaceVersion() == iface_vers
|
|
|| iface->IsVersionCompatible(iface_vers))
|
|
{
|
|
iface_owner = info.owner;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/* Add a dependency node */
|
|
if (iface_owner)
|
|
{
|
|
IfaceInfo info;
|
|
info.iface = iface;
|
|
info.owner = iface_owner;
|
|
g_Extensions.BindDependency(myself, &info);
|
|
}
|
|
|
|
if (pIface)
|
|
{
|
|
*pIface = iface;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void ShareSystem::AddNatives(IExtension *myself, const sp_nativeinfo_t *natives)
|
|
{
|
|
CNativeOwner *pOwner;
|
|
|
|
pOwner = g_Extensions.GetNativeOwner(myself);
|
|
|
|
pOwner->AddNatives(natives);
|
|
}
|
|
|
|
void ShareSystem::DestroyIdentity(IdentityToken_t *identity)
|
|
{
|
|
HandleSecurity sec;
|
|
|
|
sec.pOwner = GetIdentRoot();
|
|
sec.pIdentity = GetIdentRoot();
|
|
|
|
handlesys->FreeHandle(identity->ident, &sec);
|
|
delete identity;
|
|
}
|
|
|
|
void ShareSystem::DestroyIdentType(IdentityType_t type)
|
|
{
|
|
handlesys->RemoveType(type, GetIdentRoot());
|
|
}
|
|
|
|
void ShareSystem::RemoveInterfaces(IExtension *pExtension)
|
|
{
|
|
List<IfaceInfo>::iterator iter = m_Interfaces.begin();
|
|
|
|
while (iter != m_Interfaces.end())
|
|
{
|
|
if ((*iter).owner == pExtension)
|
|
{
|
|
iter = m_Interfaces.erase(iter);
|
|
}
|
|
else
|
|
{
|
|
iter++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ShareSystem::AddDependency(IExtension *myself, const char *filename, bool require, bool autoload)
|
|
{
|
|
g_Extensions.AddDependency(myself, filename, require, autoload);
|
|
}
|
|
|
|
void ShareSystem::RegisterLibrary(IExtension *myself, const char *name)
|
|
{
|
|
g_Extensions.AddLibrary(myself, name);
|
|
}
|
|
|
|
void ShareSystem::OverrideNatives(IExtension *myself, const sp_nativeinfo_t *natives)
|
|
{
|
|
assert(false);
|
|
}
|
|
|
|
PassRef<Native> ShareSystem::FindNative(const char *name)
|
|
{
|
|
NativeCache::Result r = m_NtvCache.find(name);
|
|
if (!r.found())
|
|
return NULL;
|
|
return *r;
|
|
}
|
|
|
|
void ShareSystem::BindNativesToPlugin(CPlugin *pPlugin, bool bCoreOnly)
|
|
{
|
|
sp_native_t *native;
|
|
uint32_t i, native_count;
|
|
IPluginContext *pContext;
|
|
|
|
pContext = pPlugin->GetBaseContext();
|
|
|
|
/* Generate a new serial ID, mark our dependencies with it. */
|
|
g_mark_serial++;
|
|
pPlugin->PropagateMarkSerial(g_mark_serial);
|
|
|
|
native_count = pContext->GetNativesNum();
|
|
for (i = 0; i < native_count; i++)
|
|
{
|
|
if (pContext->GetNativeByIndex(i, &native) != SP_ERROR_NONE)
|
|
continue;
|
|
|
|
// If we're already bound, no need to do anything else.
|
|
if (native->status == SP_NATIVE_BOUND)
|
|
continue;
|
|
|
|
/* Otherwise, the native must be in our cache. */
|
|
Ref<Native> pEntry = FindNative(native->name);
|
|
if (!pEntry)
|
|
continue;
|
|
|
|
if (bCoreOnly && pEntry->owner != &g_CoreNatives)
|
|
continue;
|
|
|
|
BindNativeToPlugin(pPlugin, native, i, pEntry);
|
|
}
|
|
}
|
|
|
|
void ShareSystem::BindNativeToPlugin(CPlugin *pPlugin, const Ref<Native> &entry)
|
|
{
|
|
if (!entry->owner)
|
|
return;
|
|
|
|
IPluginContext *pContext = pPlugin->GetBaseContext();
|
|
|
|
uint32_t i;
|
|
if (pContext->FindNativeByName(entry->name(), &i) != SP_ERROR_NONE)
|
|
return;
|
|
|
|
sp_native_t *native;
|
|
if (pContext->GetNativeByIndex(i, &native) != SP_ERROR_NONE)
|
|
return;
|
|
|
|
if (native->status == SP_NATIVE_BOUND)
|
|
return;
|
|
|
|
BindNativeToPlugin(pPlugin, native, i, entry);
|
|
}
|
|
|
|
void ShareSystem::BindNativeToPlugin(CPlugin *pPlugin, sp_native_t *native, uint32_t index,
|
|
const Ref<Native> &pEntry)
|
|
{
|
|
/* Mark as bound... we do the rest next. */
|
|
native->status = SP_NATIVE_BOUND;
|
|
native->pfn = pEntry->func();
|
|
|
|
if (pEntry->fake)
|
|
{
|
|
/* This native is not necessarily optional, but we don't guarantee
|
|
* that its address is long-lived. */
|
|
native->flags |= SP_NTVFLAG_EPHEMERAL;
|
|
}
|
|
|
|
/* We don't bother with dependency crap if the owner is Core. */
|
|
if (pEntry->owner != &g_CoreNatives)
|
|
{
|
|
/* The native is optional, this is a special case */
|
|
if ((native->flags & SP_NTVFLAG_OPTIONAL) == SP_NTVFLAG_OPTIONAL)
|
|
{
|
|
/* Only add if there is a valid owner. */
|
|
if (pEntry->owner)
|
|
pEntry->owner->AddWeakRef(WeakNative(pPlugin, index));
|
|
else
|
|
native->status = SP_NATIVE_UNBOUND;
|
|
}
|
|
/* Otherwise, we're a strong dependent and not a weak one */
|
|
else
|
|
{
|
|
/* See if this has already been marked as a dependent.
|
|
* If it has, it means this relationship has already occurred,
|
|
* and there is no reason to do it again.
|
|
*/
|
|
if (pEntry->owner != pPlugin->ToNativeOwner()
|
|
&& pEntry->owner->GetMarkSerial() != g_mark_serial)
|
|
{
|
|
/* This has not been marked as a dependency yet */
|
|
//pPlugin->AddDependency(pEntry->owner);
|
|
pEntry->owner->AddDependent(pPlugin);
|
|
pEntry->owner->SetMarkSerial(g_mark_serial);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
PassRef<Native> ShareSystem::AddNativeToCache(CNativeOwner *pOwner, const sp_nativeinfo_t *ntv)
|
|
{
|
|
NativeCache::Insert i = m_NtvCache.findForAdd(ntv->name);
|
|
if (i.found())
|
|
return NULL;
|
|
|
|
Ref<Native> entry = Newborn<Native>(new Native(pOwner, ntv));
|
|
m_NtvCache.insert(ntv->name, entry);
|
|
return entry;
|
|
}
|
|
|
|
FakeNative::~FakeNative()
|
|
{
|
|
g_pSourcePawn2->DestroyFakeNative(gate);
|
|
}
|
|
|
|
void ShareSystem::ClearNativeFromCache(CNativeOwner *pOwner, const char *name)
|
|
{
|
|
NativeCache::Result r = m_NtvCache.find(name);
|
|
if (!r.found())
|
|
return;
|
|
|
|
Ref<Native> entry(*r);
|
|
if (entry->owner != pOwner)
|
|
return;
|
|
|
|
// Clear out the owner bit as a sanity measure.
|
|
entry->owner = NULL;
|
|
|
|
m_NtvCache.remove(r);
|
|
}
|
|
|
|
PassRef<Native> ShareSystem::AddFakeNative(IPluginFunction *pFunc, const char *name, SPVM_FAKENATIVE_FUNC func)
|
|
{
|
|
Ref<Native> entry(FindNative(name));
|
|
if (entry)
|
|
return NULL;
|
|
|
|
AutoPtr<FakeNative> fake(new FakeNative(name, pFunc));
|
|
|
|
fake->gate = g_pSourcePawn2->CreateFakeNative(func, fake);
|
|
if (!fake->gate)
|
|
return NULL;
|
|
|
|
CNativeOwner *owner = g_PluginSys.GetPluginByCtx(fake->ctx->GetContext());
|
|
|
|
entry = Newborn<Native>(new Native(owner, fake.take()));
|
|
m_NtvCache.insert(name, entry);
|
|
|
|
return entry;
|
|
}
|
|
|
|
void ShareSystem::AddCapabilityProvider(IExtension *myself, IFeatureProvider *provider,
|
|
const char *name)
|
|
{
|
|
if (m_caps.contains(name))
|
|
return;
|
|
|
|
Capability cap;
|
|
cap.ext = myself;
|
|
cap.provider = provider;
|
|
|
|
m_caps.insert(name, cap);
|
|
}
|
|
|
|
void ShareSystem::DropCapabilityProvider(IExtension *myself, IFeatureProvider *provider,
|
|
const char *name)
|
|
{
|
|
StringHashMap<Capability>::Result r = m_caps.find(name);
|
|
if (!r.found())
|
|
return;
|
|
if (r->value.ext != myself || r->value.provider != provider)
|
|
return;
|
|
|
|
m_caps.remove(r);
|
|
}
|
|
|
|
FeatureStatus ShareSystem::TestFeature(IPluginRuntime *pRuntime, FeatureType feature,
|
|
const char *name)
|
|
{
|
|
switch (feature)
|
|
{
|
|
case FeatureType_Native:
|
|
return TestNative(pRuntime, name);
|
|
case FeatureType_Capability:
|
|
return TestCap(name);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return FeatureStatus_Unknown;
|
|
}
|
|
|
|
FeatureStatus ShareSystem::TestNative(IPluginRuntime *pRuntime, const char *name)
|
|
{
|
|
uint32_t index;
|
|
|
|
if (pRuntime->FindNativeByName(name, &index) == SP_ERROR_NONE)
|
|
{
|
|
sp_native_t *native;
|
|
if (pRuntime->GetNativeByIndex(index, &native) == SP_ERROR_NONE)
|
|
{
|
|
if (native->status == SP_NATIVE_BOUND)
|
|
return FeatureStatus_Available;
|
|
else
|
|
return FeatureStatus_Unknown;
|
|
}
|
|
}
|
|
|
|
Ref<Native> entry = FindNative(name);
|
|
if (!entry)
|
|
return FeatureStatus_Unknown;
|
|
|
|
return FeatureStatus_Unavailable;
|
|
}
|
|
|
|
FeatureStatus ShareSystem::TestCap(const char *name)
|
|
{
|
|
StringHashMap<Capability>::Result r = m_caps.find(name);
|
|
if (!r.found())
|
|
return FeatureStatus_Unknown;
|
|
|
|
return r->value.provider->GetFeatureStatus(FeatureType_Capability, name);
|
|
}
|