Replace ke::Vector with std::vector.

core/ChatTriggers.cpp

@@ -137,26 +137,26 @@ void ChatTriggers::OnSourceModGameInitialized()
 	};
 
 	if (ConCommand *say = FindCommand("say")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say, post_hook));
 	}
 	if (ConCommand *say_team = FindCommand("say_team")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say_team, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say_team, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say_team, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say_team, post_hook));
 	}
 
 #if SOURCE_ENGINE == SE_EPISODEONE
 	m_bIsINS = (strcmp(g_SourceMod.GetGameFolderName(), "insurgency") == 0);
 	if (m_bIsINS) {
 		if (ConCommand *say2 = FindCommand("say2")) {
-			hooks_.append(sCoreProviderImpl.AddCommandHook(say2, pre_hook));
+			hooks_.push_back(sCoreProviderImpl.AddCommandHook(say2, pre_hook));
-			hooks_.append(sCoreProviderImpl.AddPostCommandHook(say2, post_hook));
+			hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say2, post_hook));
 		}
 	}
 #elif SOURCE_ENGINE == SE_NUCLEARDAWN
 	if (ConCommand *say_squad = FindCommand("say_squad")) {
-		hooks_.append(sCoreProviderImpl.AddCommandHook(say_squad, pre_hook));
+		hooks_.push_back(sCoreProviderImpl.AddCommandHook(say_squad, pre_hook));
-		hooks_.append(sCoreProviderImpl.AddPostCommandHook(say_squad, post_hook));
+		hooks_.push_back(sCoreProviderImpl.AddPostCommandHook(say_squad, post_hook));
 	}
 #endif
 }

core/ChatTriggers.h

@@ -73,7 +73,7 @@ private:
 	bool ClientIsFlooding(int client);
 	cell_t CallOnClientSayCommand(int client);
 private:
-	ke::Vector<ke::RefPtr<CommandHook>> hooks_;
+	std::vector<ke::RefPtr<CommandHook>> hooks_;
 	std::string m_PubTrigger;
 	std::string m_PrivTrigger;
 	bool m_bWillProcessInPost;

core/GameHooks.cpp

@@ -91,7 +91,7 @@ void GameHooks::OnVSPReceived()
 
 void GameHooks::Shutdown()
 {
-	for (size_t i = 0; i < hooks_.length(); i++)
+	for (size_t i = 0; i < hooks_.size(); i++)
 		SH_REMOVE_HOOK_ID(hooks_[i]);
 	hooks_.clear();
 

core/GameHooks.h

@@ -114,11 +114,11 @@ private:
 	void SetCommandClient(int client);
 
 private:
-	class HookList : public ke::Vector<int>
+	class HookList : public std::vector<int>
 	{
 	public:
 		HookList &operator += (int hook_id) {
-			this->append(hook_id);
+			this->push_back(hook_id);
 			return *this;
 		}
 	};

core/MenuStyle_Base.cpp

@@ -628,7 +628,7 @@ Handle_t CBaseMenu::GetHandle()
 bool CBaseMenu::AppendItem(const char *info, const ItemDrawInfo &draw)
 {
 	if (m_Pagination == (unsigned)MENU_NO_PAGINATION
-		&& m_items.length() >= m_pStyle->GetMaxPageItems())
+		&& m_items.size() >= m_pStyle->GetMaxPageItems())
 	{
 		return false;
 	}
@@ -640,19 +640,19 @@ bool CBaseMenu::AppendItem(const char *info, const ItemDrawInfo &draw)
 		item.display = std::make_unique<std::string>(draw.display);
 	item.style = draw.style;
 
-	m_items.append(std::move(item));
+	m_items.push_back(std::move(item));
 	return true;
 }
 
 bool CBaseMenu::InsertItem(unsigned int position, const char *info, const ItemDrawInfo &draw)
 {
 	if (m_Pagination == (unsigned)MENU_NO_PAGINATION &&
-	    m_items.length() >= m_pStyle->GetMaxPageItems())
+	    m_items.size() >= m_pStyle->GetMaxPageItems())
 	{
 		return false;
 	}
 
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return false;
 
 	CItem item;
@@ -661,16 +661,16 @@ bool CBaseMenu::InsertItem(unsigned int position, const char *info, const ItemDr
 		item.display = std::make_unique<std::string>(draw.display);
 	item.style = draw.style;
 
-	m_items.insert(position, std::move(item));
+	ke::InsertAt(&m_items, position, std::move(item));
 	return true;
 }
 
 bool CBaseMenu::RemoveItem(unsigned int position)
 {
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return false;
 
-	m_items.remove(position);
+	ke::RemoveAt(&m_items, position);
 	return true;
 }
 
@@ -681,7 +681,7 @@ void CBaseMenu::RemoveAllItems()
 
 const char *CBaseMenu::GetItemInfo(unsigned int position, ItemDrawInfo *draw/* =NULL */)
 {
-	if (position >= m_items.length())
+	if (position >= m_items.size())
 		return NULL;
 
 	if (draw)
@@ -695,7 +695,7 @@ const char *CBaseMenu::GetItemInfo(unsigned int position, ItemDrawInfo *draw/* =
 
 unsigned int CBaseMenu::GetItemCount()
 {
-	return m_items.length();
+	return m_items.size();
 }
 
 bool CBaseMenu::SetPagination(unsigned int itemsPerPage)
@@ -825,5 +825,5 @@ IMenuHandler *CBaseMenu::GetHandler()
 
 unsigned int CBaseMenu::GetBaseMemUsage()
 {
-	return m_Title.length() + (m_items.length() * sizeof(CItem));
+	return m_Title.size() + (m_items.size() * sizeof(CItem));
 }

core/MenuStyle_Base.h

@@ -161,7 +161,7 @@ protected:
 	std::string m_Title;
 	IMenuStyle *m_pStyle;
 	unsigned int m_Pagination;
-	ke::Vector<CItem> m_items;
+	std::vector<CItem> m_items;
 	bool m_bShouldDelete;
 	bool m_bCancelling;
 	IdentityToken_t *m_pOwner;

core/logic/CDataPack.cpp

@@ -46,7 +46,7 @@ CDataPack::~CDataPack()
 	Initialize();
 }
 
-static ke::Vector<std::unique_ptr<CDataPack>> sDataPackCache;
+static std::vector<std::unique_ptr<CDataPack>> sDataPackCache;
 
 CDataPack *CDataPack::New()
 {
@@ -54,7 +54,7 @@ CDataPack *CDataPack::New()
     return new CDataPack();
 
   CDataPack *pack = sDataPackCache.back().release();
-  sDataPackCache.pop();
+  sDataPackCache.pop_back();
   pack->Initialize();
   return pack;
 }
@@ -62,7 +62,7 @@ CDataPack *CDataPack::New()
 void
 CDataPack::Free(CDataPack *pack)
 {
-  sDataPackCache.append(static_cast<CDataPack *>(pack));
+  sDataPackCache.emplace_back(pack);
 }
 
 void CDataPack::Initialize()
@@ -87,7 +87,7 @@ size_t CDataPack::CreateMemory(size_t size, void **addr)
 	val.type = CDataPackType::Raw;
 	val.pData.vval = new uint8_t[size + sizeof(size)];
 	reinterpret_cast<size_t *>(val.pData.vval)[0] = size;
-	elements.insert(position, val);
+	ke::InsertAt(&elements, position, val);
 
 	return position++;
 }
@@ -97,7 +97,7 @@ void CDataPack::PackCell(cell_t cell)
 	InternalPack val;
 	val.type = CDataPackType::Cell;
 	val.pData.cval = cell;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::PackFunction(cell_t function)
@@ -105,7 +105,7 @@ void CDataPack::PackFunction(cell_t function)
 	InternalPack val;
 	val.type = CDataPackType::Function;
 	val.pData.cval = function;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::PackFloat(float floatval)
@@ -113,7 +113,7 @@ void CDataPack::PackFloat(float floatval)
 	InternalPack val;
 	val.type = CDataPackType::Float;
 	val.pData.fval = floatval;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::PackString(const char *string)
@@ -122,7 +122,7 @@ void CDataPack::PackString(const char *string)
 	val.type = CDataPackType::String;
 	std::string *sval = new std::string(string);
 	val.pData.sval = sval;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::PackCellArray(cell_t const *vals, cell_t count)
@@ -133,7 +133,7 @@ void CDataPack::PackCellArray(cell_t const *vals, cell_t count)
 	val.pData.aval = new cell_t [count + 1];
 	memcpy(&val.pData.aval[1], vals, sizeof(cell_t) * (count + 1));
 	val.pData.aval[0] = count;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::PackFloatArray(cell_t const *vals, cell_t count)
@@ -144,7 +144,7 @@ void CDataPack::PackFloatArray(cell_t const *vals, cell_t count)
 	val.pData.aval = new cell_t [count + 1];
 	memcpy(&val.pData.aval[1], vals, sizeof(cell_t) * (count + 1));
 	val.pData.aval[0] = count;
-	elements.insert(position++, val);
+	ke::InsertAt(&elements, position++, val);
 }
 
 void CDataPack::Reset() const
@@ -159,7 +159,7 @@ size_t CDataPack::GetPosition() const
 
 bool CDataPack::SetPosition(size_t pos) const
 {
-	if (pos > elements.length())
+	if (pos > elements.size())
 		return false;
 
 	position = pos;
@@ -192,7 +192,7 @@ float CDataPack::ReadFloat() const
 
 bool CDataPack::IsReadable(size_t bytes) const
 {
-	return (position < elements.length());
+	return (position < elements.size());
 }
 
 const char *CDataPack::ReadString(size_t *len) const
@@ -207,7 +207,7 @@ const char *CDataPack::ReadString(size_t *len) const
 
 	const std::string &val = *elements[position++].pData.sval;
 	if (len)
-		*len = val.length();
+		*len = val.size();
 
 	return val.c_str();
 }
@@ -270,7 +270,7 @@ void *CDataPack::ReadMemory(size_t *size) const
 
 bool CDataPack::RemoveItem(size_t pos)
 {
-	if (!elements.length())
+	if (!elements.size())
 	{
 		return false;
 	}
@@ -280,7 +280,7 @@ bool CDataPack::RemoveItem(size_t pos)
 		pos = position;
 	}
 	
-	if (pos >= elements.length())
+	if (pos >= elements.size())
 	{
 		return false;
 	}
@@ -312,6 +312,6 @@ bool CDataPack::RemoveItem(size_t pos)
 		}
 	}
 
-	elements.remove(pos);
+	ke::RemoveAt(&elements, pos);
 	return true;
 }

core/logic/CDataPack.h

@@ -204,7 +204,7 @@ public: // Originally IDataPack
 
 public:
 	void Initialize();
-	inline size_t GetCapacity() const { return this->elements.length(); };
+	inline size_t GetCapacity() const { return this->elements.size(); };
 	inline CDataPackType GetCurrentType(void) const { return this->elements[this->position].type; };
 	bool RemoveItem(size_t pos = -1);
 
@@ -222,7 +222,7 @@ private:
 		CDataPackType type;
 	} InternalPack;
 
-	ke::Vector<InternalPack> elements;
+	std::vector<InternalPack> elements;
 	mutable size_t position;
 };
 

core/logic/Database.cpp

@@ -210,7 +210,7 @@ void DBManager::RemoveDriver(IDBDriver *pDriver)
 	}
 
 	ConfDbInfoList *list = m_Builder.GetConfigList();
-	for (size_t i = 0; i < list->length(); i++)
+	for (size_t i = 0; i < list->size(); i++)
 	{
 		ke::RefPtr<ConfDbInfo> current = list->at(i);
 		if (current->realDriver == pDriver)

core/logic/DatabaseConfBuilder.cpp

@@ -161,7 +161,7 @@ SMCResult DatabaseConfBuilder::ReadSMC_LeavingSection(const SMCStates *states)
 		
 		/* Save it.. */
 		m_ParseCurrent->AddRef();
-		m_ParseList->append(m_ParseCurrent);
+		m_ParseList->push_back(m_ParseCurrent);
 		m_ParseCurrent = nullptr;
 		
 		/* Go up one level */

core/logic/DatabaseConfBuilder.h

@@ -56,7 +56,7 @@ public:
 	DatabaseInfo info;
 };
 
-class ConfDbInfoList : public ke::Vector<ConfDbInfo *>
+class ConfDbInfoList : public std::vector<ConfDbInfo *>
 {
 	/* Allow internal usage of ConfDbInfoList */
 	friend class DBManager;
@@ -67,7 +67,7 @@ private:
 	}
 	
 	ConfDbInfo *GetDatabaseConf(const char *name) {
-		for (size_t i = 0; i < this->length(); i++)
+		for (size_t i = 0; i < this->size(); i++)
 		{
 			ConfDbInfo *current = this->at(i);
 			/* If we run into the default configuration, then we'll save it
@@ -90,7 +90,7 @@ private:
 		m_DefDriver = std::string(input);
 	}
 	void ReleaseMembers() {
-		for (size_t i = 0; i < this->length(); i++) {
+		for (size_t i = 0; i < this->size(); i++) {
 			ConfDbInfo *current = this->at(i);
 			current->Release();
 		}

core/logic/DebugReporter.cpp

@@ -194,22 +194,22 @@ void DebugReport::ReportError(const IErrorReport &report, IFrameIterator &iter)
 		g_Logger.LogError("[SM] Blaming: %s", blame);
 	}
 
-	ke::Vector<std::string> arr = GetStackTrace(&iter);
+	std::vector<std::string> arr = GetStackTrace(&iter);
-	for (size_t i = 0; i < arr.length(); i++)
+	for (size_t i = 0; i < arr.size(); i++)
 	{
 		g_Logger.LogError("%s", arr[i].c_str());
 	}
 }
 
-ke::Vector<std::string> DebugReport::GetStackTrace(IFrameIterator *iter)
+std::vector<std::string> DebugReport::GetStackTrace(IFrameIterator *iter)
 {
 	char temp[3072];
-	ke::Vector<std::string> trace;
+	std::vector<std::string> trace;
 	iter->Reset();
 	
 	if (!iter->Done())
 	{
-		trace.append("[SM] Call stack trace:");
+		trace.push_back("[SM] Call stack trace:");
 
 		for (int index = 0; !iter->Done(); iter->Next(), index++) 
 		{
@@ -221,7 +221,7 @@ ke::Vector<std::string> DebugReport::GetStackTrace(IFrameIterator *iter)
 			if (iter->IsNativeFrame()) 
 			{
 				g_pSM->Format(temp, sizeof(temp), "[SM]   [%d] %s", index, fn);
-				trace.append(temp);
+				trace.push_back(temp);
 				continue;
 			}
 			if (iter->IsScriptedFrame()) 
@@ -237,7 +237,7 @@ ke::Vector<std::string> DebugReport::GetStackTrace(IFrameIterator *iter)
 						file,
 						fn);
 				
-				trace.append(temp);
+				trace.push_back(temp);
 			}
 		}
 	}

core/logic/DebugReporter.h

@@ -50,7 +50,7 @@ public:
 	void GenerateError(IPluginContext *ctx, cell_t func_idx, int err, const char *message, ...);
 	void GenerateErrorVA(IPluginContext *ctx, cell_t func_idx, int err, const char *message, va_list ap); 
 	void GenerateCodeError(IPluginContext *ctx, uint32_t code_addr, int err, const char *message, ...);
-	ke::Vector<std::string> GetStackTrace(IFrameIterator *iter);
+	std::vector<std::string> GetStackTrace(IFrameIterator *iter);
 private:
 	int _GetPluginIndex(IPluginContext *ctx);
 };

core/logic/FrameIterator.cpp

@@ -36,7 +36,7 @@ SafeFrameIterator::SafeFrameIterator(IFrameIterator *it)
 	while (!it->Done())
 	{
 		FrameInfo info = FrameInfo(it);
-		frames.append(info);
+		frames.push_back(info);
 		it->Next(); 
 	}
 	
@@ -46,7 +46,7 @@ SafeFrameIterator::SafeFrameIterator(IFrameIterator *it)
 
 bool SafeFrameIterator::Done() const
 {
-	return current >= frames.length();
+	return current >= frames.size();
 }
 
 bool SafeFrameIterator::Next()

core/logic/FrameIterator.h

@@ -73,5 +73,5 @@ public:
 
 private:
 	size_t current;
-	ke::Vector<FrameInfo> frames;
+	std::vector<FrameInfo> frames;
 };

core/logic/NativeOwner.cpp

@@ -62,7 +62,7 @@ void CNativeOwner::AddNatives(const sp_nativeinfo_t *natives)
 	for (const sp_nativeinfo_t *native = natives; native->func && native->name; native++)
 		g_ShareSys.AddNativeToCache(this, native);
 
-	m_natives.append(natives);
+	m_natives.push_back(natives);
 }
 
 void CNativeOwner::UnbindWeakRef(const WeakNative &ref)
@@ -90,14 +90,14 @@ void CNativeOwner::DropEverything()
 	}
 
 	/* Strip all of our natives from the cache */
-	for (size_t i = 0; i < m_natives.length(); i++) {
+	for (size_t i = 0; i < m_natives.size(); i++) {
 		const sp_nativeinfo_t *natives = m_natives[i];
 		for (const sp_nativeinfo_t *native = natives; native->func && native->name; native++)
 			g_ShareSys.ClearNativeFromCache(this, native->name);
 	}
 	m_natives.clear();
 
-	for (size_t i = 0; i < m_fakes.length(); i++)
+	for (size_t i = 0; i < m_fakes.size(); i++)
 		g_ShareSys.ClearNativeFromCache(this, m_fakes[i]->name());
 	m_fakes.clear();
 }

core/logic/NativeOwner.h

@@ -80,8 +80,8 @@ protected:
 	List<CPlugin *> m_Dependents;
 	unsigned int m_nMarkSerial;
 	List<WeakNative> m_WeakRefs;
-	ke::Vector<const sp_nativeinfo_t *> m_natives;
+	std::vector<const sp_nativeinfo_t *> m_natives;
-	ke::Vector<ke::RefPtr<Native> > m_fakes;
+	std::vector<ke::RefPtr<Native> > m_fakes;
 };
 
 extern CNativeOwner g_CoreNatives;

core/logic/PluginSys.cpp

@@ -674,7 +674,7 @@ void CPlugin::DependencyDropped(CPlugin *pOwner)
 	}
 
 	unsigned int unbound = 0;
-	for (size_t i = 0; i < pOwner->m_fakes.length(); i++)
+	for (size_t i = 0; i < pOwner->m_fakes.size(); i++)
 	{
 		ke::RefPtr<Native> entry(pOwner->m_fakes[i]);
 
@@ -773,13 +773,13 @@ bool CPlugin::AddFakeNative(IPluginFunction *pFunc, const char *name, SPVM_FAKEN
 	if (!entry)
 		return false;
 
-	m_fakes.append(entry);
+	m_fakes.push_back(entry);
 	return true;
 }
 
 void CPlugin::BindFakeNativesTo(CPlugin *other)
 {
-	for (size_t i = 0; i < m_fakes.length(); i++)
+	for (size_t i = 0; i < m_fakes.size(); i++)
 		g_ShareSys.BindNativeToPlugin(other, m_fakes[i]);
 }
 

core/logic/PluginSys.h

@@ -227,7 +227,7 @@ public:
 		return m_LibraryMissing;
 	}
 	bool HasFakeNatives() const {
-		return m_fakes.length() > 0;
+		return m_fakes.size() > 0;
 	}
 
 	// True if we got far enough into the second pass to call OnPluginLoaded

core/logic/ProfileTools.cpp

@@ -52,7 +52,7 @@ ProfileToolManager::OnSourceModShutdown()
 IProfilingTool *
 ProfileToolManager::FindToolByName(const char *name)
 {
-	for (size_t i = 0; i < tools_.length(); i++) {
+	for (size_t i = 0; i < tools_.size(); i++) {
 		if (strcmp(tools_[i]->Name(), name) == 0)
 			return tools_[i];
 	}
@@ -97,7 +97,7 @@ ProfileToolManager::StartFromConsole(IProfilingTool *tool)
 void
 ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs *args)
 {
-	if (tools_.length() == 0) {
+	if (tools_.size() == 0) {
 		rootmenu->ConsolePrint("No profiling tools are enabled.");
 		return;
 	}
@@ -107,7 +107,7 @@ ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs
 
 		if (strcmp(cmdname, "list") == 0) {
 			rootmenu->ConsolePrint("Profiling tools:");
-			for (size_t i = 0; i < tools_.length(); i++) {
+			for (size_t i = 0; i < tools_.size(); i++) {
 				rootmenu->DrawGenericOption(tools_[i]->Name(), tools_[i]->Description());
 			}
 			return;
@@ -135,7 +135,7 @@ ProfileToolManager::OnRootConsoleCommand(const char *cmdname, const ICommandArgs
 			if (strcmp(cmdname, "start") == 0) {
 				if (!default_) {
 					default_ = FindToolByName("vprof");
-					if (!default_ && tools_.length() > 0)
+					if (!default_ && tools_.size() > 0)
 						default_ = tools_[0];
 					if (!default_) {
 						rootmenu->ConsolePrint("Could not find any profiler to use.");

core/logic/ProfileTools.h

@@ -51,7 +51,7 @@ public:
 	void OnRootConsoleCommand(const char *cmdname, const ICommandArgs *args) override;
 
 	void RegisterTool(IProfilingTool *tool) {
-		tools_.append(tool);
+		tools_.push_back(tool);
 	}
 
 	bool IsActive() const {
@@ -76,7 +76,7 @@ private:
 	void StartFromConsole(IProfilingTool *tool);
 
 private:
-	ke::Vector<IProfilingTool *> tools_;
+	std::vector<IProfilingTool *> tools_;
 	IProfilingTool *active_;
 	IProfilingTool *default_;
 	bool enabled_;

core/logic/frame_tasks.cpp

@@ -30,13 +30,13 @@
 
 using namespace SourceMod;
 
-ke::Vector<ke::Function<void()>> sNextTasks;
+std::vector<ke::Function<void()>> sNextTasks;
-ke::Vector<ke::Function<void()>> sWorkTasks;
+std::vector<ke::Function<void()>> sWorkTasks;
 
 void
 SourceMod::ScheduleTaskForNextFrame(ke::Function<void()>&& task)
 {
-	sNextTasks.append(std::forward<decltype(task)>(task));
+	sNextTasks.push_back(std::forward<decltype(task)>(task));
 }
 
 void
@@ -46,11 +46,11 @@ SourceMod::RunScheduledFrameTasks(bool simulating)
 		return;
 
 	// Swap.
-	ke::Vector<ke::Function<void()>> temp(std::move(sNextTasks));
+	std::vector<ke::Function<void()>> temp(std::move(sNextTasks));
 	sNextTasks = std::move(sWorkTasks);
 	sWorkTasks = std::move(temp);
 
-	for (size_t i = 0; i < sWorkTasks.length(); i++)
+	for (size_t i = 0; i < sWorkTasks.size(); i++)
 		sWorkTasks[i]();
 	sWorkTasks.clear();
 }

core/logic/smn_core.cpp

@@ -943,14 +943,14 @@ static cell_t LogStackTrace(IPluginContext *pContext, const cell_t *params)
 	g_pSM->FormatString(buffer, sizeof(buffer), pContext, params, 1);
 
 	IFrameIterator *it = pContext->CreateFrameIterator();
-	ke::Vector<std::string> arr = g_DbgReporter.GetStackTrace(it);
+	std::vector<std::string> arr = g_DbgReporter.GetStackTrace(it);
 	pContext->DestroyFrameIterator(it);
 
 	IPlugin *pPlugin = scripts->FindPluginByContext(pContext->GetContext());
 
 	g_Logger.LogError("[SM] Stack trace requested: %s", buffer);
 	g_Logger.LogError("[SM] Called from: %s", pPlugin->GetFilename());
-	for (size_t i = 0; i < arr.length(); ++i)
+	for (size_t i = 0; i < arr.size(); ++i)
 	{
 		g_Logger.LogError("%s", arr[i].c_str());
 	}

core/logic/smn_database.cpp

@@ -68,7 +68,7 @@ struct Transaction
 		cell_t data;
 	};
 
-	ke::Vector<Entry> entries;
+	std::vector<Entry> entries;
 };
 
 class DatabaseHelpers : 
@@ -1540,9 +1540,9 @@ static cell_t SQL_AddQuery(IPluginContext *pContext, const cell_t *params)
 	Transaction::Entry entry;
 	entry.query = query;
 	entry.data = params[3];
-	txn->entries.append(std::move(entry));
+	txn->entries.push_back(std::move(entry));
 
-	return cell_t(txn->entries.length() - 1);
+	return cell_t(txn->entries.size() - 1);
 }
 
 class TTransactOp : public IDBThreadOperation
@@ -1564,7 +1564,7 @@ public:
 
 	~TTransactOp()
 	{
-		for (size_t i = 0; i < results_.length(); i++)
+		for (size_t i = 0; i < results_.size(); i++)
 			results_[i]->Destroy();
 		results_.clear();
 	}
@@ -1585,7 +1585,7 @@ public:
 private:
 	bool Succeeded() const
 	{
-		return error_.length() == 0;
+		return error_.size() == 0;
 	}
 
 	void SetDbError()
@@ -1617,7 +1617,7 @@ private:
 			return;
 		}
 
-		for (size_t i = 0; i < txn_->entries.length(); i++)
+		for (size_t i = 0; i < txn_->entries.size(); i++)
 		{
 			Transaction::Entry &entry = txn_->entries[i];
 			IQuery *result = Exec(entry.query.c_str());
@@ -1626,7 +1626,7 @@ private:
 				failIndex_ = (cell_t)i;
 				return;
 			}
-			results_.append(result);
+			results_.push_back(result);
 		}
 
 		if (!db_->DoSimpleQuery("COMMIT"))
@@ -1667,11 +1667,11 @@ private:
 		// Add an extra refcount for the handle.
 		db_->AddRef();
 
-		assert(results_.length() == txn_->entries.length());
+		assert(results_.size() == txn_->entries.size());
 
-		std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(results_.length());
+		std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(results_.size());
-		std::unique_ptr<cell_t[]> handles = std::make_unique<cell_t[]>(results_.length());
+		std::unique_ptr<cell_t[]> handles = std::make_unique<cell_t[]>(results_.size());
-		for (size_t i = 0; i < results_.length(); i++)
+		for (size_t i = 0; i < results_.size(); i++)
 		{
 			CombinedQuery *obj = new CombinedQuery(results_[i], db_);
 			Handle_t rh = CreateLocalHandle(hCombinedQueryType, obj, &sec);
@@ -1682,7 +1682,7 @@ private:
 				delete obj;
 				for (size_t iter = 0; iter < i; iter++)
 					handlesys->FreeHandle(handles[iter], &sec);
-				for (size_t iter = i; iter < results_.length(); iter++)
+				for (size_t iter = i; iter < results_.size(); iter++)
 					results_[iter]->Destroy();
 				handlesys->FreeHandle(dbh, &sec);
 				results_.clear();
@@ -1698,15 +1698,15 @@ private:
 		{
 			success_->PushCell(dbh);
 			success_->PushCell(data_);
-			success_->PushCell(txn_->entries.length());
+			success_->PushCell(txn_->entries.size());
-			success_->PushArray(handles.get(), results_.length());
+			success_->PushArray(handles.get(), results_.size());
-			success_->PushArray(data.get(), results_.length());
+			success_->PushArray(data.get(), results_.size());
 			success_->Execute(NULL);
 		}
 
 		// Cleanup. Note we clear results_, since freeing their handles will
 		// call Destroy(), and we don't want to double-free in ~TTransactOp.
-		for (size_t i = 0; i < results_.length(); i++)
+		for (size_t i = 0; i < results_.size(); i++)
 			handlesys->FreeHandle(handles[i], &sec);
 		handlesys->FreeHandle(dbh, &sec);
 		results_.clear();
@@ -1730,8 +1730,8 @@ public:
 		{
 			HandleSecurity sec(ident_, g_pCoreIdent);
 
-			std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(txn_->entries.length());
+			std::unique_ptr<cell_t[]> data = std::make_unique<cell_t[]>(txn_->entries.size());
-			for (size_t i = 0; i < txn_->entries.length(); i++)
+			for (size_t i = 0; i < txn_->entries.size(); i++)
 				data[i] = txn_->entries[i].data;
 
 			Handle_t dbh = CreateLocalHandle(g_DBMan.GetDatabaseType(), db_, &sec);
@@ -1745,10 +1745,10 @@ public:
 			{
 				failure_->PushCell(dbh);
 				failure_->PushCell(data_);
-				failure_->PushCell(txn_->entries.length());
+				failure_->PushCell(txn_->entries.size());
 				failure_->PushString(error_.c_str());
 				failure_->PushCell(failIndex_);
-				failure_->PushArray(data.get(), txn_->entries.length());
+				failure_->PushArray(data.get(), txn_->entries.size());
 				failure_->Execute(NULL);
 			}
 
@@ -1765,7 +1765,7 @@ private:
 	cell_t data_;
 	AutoHandleRooter autoHandle_;
 	std::string error_;
-	ke::Vector<IQuery *> results_;
+	std::vector<IQuery *> results_;
 	cell_t failIndex_;
 };
 

core/logic_bridge.cpp

@@ -768,7 +768,7 @@ CoreProviderImpl::DefineCommand(const char *name, const char *help, const Comman
 	ke::RefPtr<CommandHook> hook = AddCommandHook(cmd, callback);
 
 	ke::RefPtr<CommandImpl> impl = new CommandImpl(cmd, hook);
-	commands_.append(impl);
+	commands_.push_back(impl);
 }
 
 void CoreProviderImpl::InitializeHooks()

core/provider.h

@@ -91,7 +91,7 @@ private:
 		ConCommand *cmd_;
 		ke::RefPtr<CommandHook> hook_;
 	};
-	ke::Vector<ke::RefPtr<CommandImpl>> commands_;
+	std::vector<ke::RefPtr<CommandImpl>> commands_;
 };
 
 extern CoreProviderImpl sCoreProviderImpl;

extensions/clientprefs/cookie.cpp

@@ -59,7 +59,7 @@ void CookieManager::Unload()
 	}
 
 	/* Find all cookies and delete them */
-	for (size_t iter = 0; iter < cookieList.length(); ++iter)
+	for (size_t iter = 0; iter < cookieList.size(); ++iter)
 		delete cookieList[iter];
 	
 	cookieList.clear();
@@ -95,7 +95,7 @@ Cookie *CookieManager::CreateCookie(const char *name, const char *description, C
 	op->m_params.cookie = pCookie;
 	
 	cookieFinder.insert(name, pCookie);
-	cookieList.append(pCookie);
+	cookieList.push_back(pCookie);
 
 	g_ClientPrefs.AddQueryToQueue(op);
 
@@ -111,7 +111,7 @@ bool CookieManager::GetCookieValue(Cookie *pCookie, int client, char **value)
 	{
 		data = new CookieData("");
 		data->parent = pCookie;
-		clientData[client].append(data);
+		clientData[client].push_back(data);
 		pCookie->data[client] = data;
 		data->changed = false;
 		data->timestamp = 0;
@@ -130,7 +130,7 @@ bool CookieManager::SetCookieValue(Cookie *pCookie, int client, const char *valu
 	{
 		data = new CookieData(value);
 		data->parent = pCookie;
-		clientData[client].append(data);
+		clientData[client].push_back(data);
 		pCookie->data[client] = data;
 	}
 	else
@@ -185,8 +185,8 @@ void CookieManager::OnClientDisconnecting(int client)
 		g_ClientPrefs.ClearQueryCache(player->GetSerial());
 	}
 
-	ke::Vector<CookieData *> &clientvec = clientData[client];
+	std::vector<CookieData *> &clientvec = clientData[client];
-	for (size_t iter = 0; iter < clientvec.length(); ++iter)
+	for (size_t iter = 0; iter < clientvec.size(); ++iter)
 	{
 		current = clientvec[iter];
 		dbId = current->parent->dbid;
@@ -263,7 +263,7 @@ void CookieManager::ClientConnectCallback(int serial, IQuery *data)
 
 		pData->parent = parent;
 		parent->data[client] = pData;
-		clientData[client].append(pData);
+		clientData[client].push_back(pData);
 	}
 
 	statsLoaded[client] = true;
@@ -317,18 +317,18 @@ bool CookieManager::AreClientCookiesPending(int client)
 
 void CookieManager::OnPluginDestroyed(IPlugin *plugin)
 {
-	ke::Vector<char *> *pList;
+	std::vector<char *> *pList;
 
 	if (plugin->GetProperty("SettingsMenuItems", (void **)&pList, true))
 	{
-		ke::Vector<char *> &menuitems = (*pList);
+		std::vector<char *> &menuitems = (*pList);
 		char *name;
 		ItemDrawInfo draw;
 		const char *info;
 		AutoMenuData * data;
 		unsigned itemcount;
 		
-		for (size_t p_iter = 0; p_iter < menuitems.length(); ++p_iter)
+		for (size_t p_iter = 0; p_iter < menuitems.size(); ++p_iter)
 		{
 			name = menuitems[p_iter];
 			itemcount = clientMenu->GetItemCount();

extensions/clientprefs/cookie.h

@@ -132,12 +132,12 @@ public:
 
 public:
 	IForward *cookieDataLoadedForward;
-	ke::Vector<Cookie *> cookieList;
+	std::vector<Cookie *> cookieList;
 	IBaseMenu *clientMenu;
 
 private:
 	NameHashSet<Cookie *> cookieFinder;
-	ke::Vector<CookieData *> clientData[SM_MAXPLAYERS+1];
+	std::vector<CookieData *> clientData[SM_MAXPLAYERS+1];
 
 	bool connected[SM_MAXPLAYERS+1];
 	bool statsLoaded[SM_MAXPLAYERS+1];

extensions/clientprefs/extension.cpp

@@ -313,7 +313,7 @@ bool ClientPrefs::AddQueryToQueue(TQueryOp *query)
 		std::lock_guard<std::mutex> lock(queryLock);
 		if (!Database)
 		{
-			cachedQueries.append(query);
+			cachedQueries.push_back(query);
 			return false;
 		}
 		
@@ -331,7 +331,7 @@ void ClientPrefs::ProcessQueryCache()
 	if (!Database)
 		return;
 
-	for (size_t iter = 0; iter < cachedQueries.length(); ++iter)
+	for (size_t iter = 0; iter < cachedQueries.size(); ++iter)
 	{
 		TQueryOp *op = cachedQueries[iter];
 		op->SetDatabase(Database);
@@ -373,13 +373,13 @@ void ClientPrefs::ClearQueryCache(int serial)
 {
 	std::lock_guard<std::mutex> lock(queryLock);
 
-	for (size_t iter = 0; iter < cachedQueries.length(); ++iter)
+	for (size_t iter = 0; iter < cachedQueries.size(); ++iter)
 	{
 		TQueryOp *op = cachedQueries[iter];
 		if (op && op->PullQueryType() == Query_SelectData && op->PullQuerySerial() == serial)
  		{
 			op->Destroy();
-			cachedQueries.remove(iter--);
+			ke::RemoveAt(&cachedQueries, iter--);
 		}
  	}
 }

extensions/clientprefs/extension.h

@@ -158,7 +158,7 @@ public:
 	bool databaseLoading;
 
 private:
-	ke::Vector<TQueryOp *> cachedQueries;
+	std::vector<TQueryOp *> cachedQueries;
 	std::mutex queryLock;
 	IdentityToken_t *identity;
 };

extensions/clientprefs/natives.cpp

@@ -299,7 +299,7 @@ static cell_t ReadCookieIterator(IPluginContext *pContext, const cell_t *params)
 		return pContext->ThrowNativeError("Invalid Cookie iterator handle %x (error %d)", hndl, err);
 	}
 
-	if (*iter >= g_CookieManager.cookieList.length())
+	if (*iter >= g_CookieManager.cookieList.size())
 	{
 		return 0;
 	}
@@ -356,18 +356,18 @@ cell_t AddSettingsMenuItem(IPluginContext *pContext, const cell_t *params)
 	/* Track this in case the plugin unloads */
 
 	IPlugin *pPlugin = plsys->FindPluginByContext(pContext->GetContext());
-	ke::Vector<char *> *pList = NULL;
+	std::vector<char *> *pList = NULL;
 
 	if (!pPlugin->GetProperty("SettingsMenuItems", (void **)&pList, false) || !pList)
 	{
-		pList = new ke::Vector<char *>;
+		pList = new std::vector<char *>;
 		pPlugin->SetProperty("SettingsMenuItems", pList);
 	}
 
 	char *copyarray = new char[strlen(display)+1];
 	g_pSM->Format(copyarray, strlen(display)+1, "%s", display);
 
-	pList->append(copyarray);
+	pList->push_back(copyarray);
 
 	return 0;
 }
@@ -426,18 +426,18 @@ cell_t AddSettingsPrefabMenuItem(IPluginContext *pContext, const cell_t *params)
 	/* Track this in case the plugin unloads */
 
 	IPlugin *pPlugin = plsys->FindPluginByContext(pContext->GetContext());
-	ke::Vector<char *> *pList = NULL;
+	std::vector<char *> *pList = NULL;
 
 	if (!pPlugin->GetProperty("SettingsMenuItems", (void **)&pList, false) || !pList)
 	{
-		pList = new ke::Vector<char *>;
+		pList = new std::vector<char *>;
 		pPlugin->SetProperty("SettingsMenuItems", pList);
 	}
 
 	char *copyarray = new char[strlen(display)+1];
 	g_pSM->Format(copyarray, strlen(display)+1, "%s", display);
 
-	pList->append(copyarray);
+	pList->push_back(copyarray);
 
 	return 0;
 }

extensions/cstrike/RegNatives.cpp

@@ -36,12 +36,12 @@ RegNatives g_RegNatives;
 
 void RegNatives::Register(ICallWrapper *pWrapper)
 {
-	m_Natives.append(pWrapper);
+	m_Natives.push_back(pWrapper);
 }
 
 void RegNatives::UnregisterAll()
 {
-	for (size_t iter = 0; iter < m_Natives.length(); ++iter)
+	for (size_t iter = 0; iter < m_Natives.size(); ++iter)
 	{
 		m_Natives[iter]->Destroy();
 	}

extensions/cstrike/RegNatives.h

@@ -40,7 +40,7 @@ public:
 	void Register(ICallWrapper *pWrapper);
 	void UnregisterAll();
 private:
-	ke::Vector<ICallWrapper *> m_Natives;
+	std::vector<ICallWrapper *> m_Natives;
 };
 
 extern RegNatives g_RegNatives;

extensions/sdkhooks/extension.cpp

@@ -101,7 +101,7 @@ SDKHooks g_Interface;
 SMEXT_LINK(&g_Interface);
 
 CGlobalVars *gpGlobals;
-ke::Vector<CVTableList *> g_HookList[SDKHook_MAXHOOKS];
+std::vector<CVTableList *> g_HookList[SDKHook_MAXHOOKS];
 
 IBinTools *g_pBinTools = NULL;
 ICvar *icvar = NULL;
@@ -454,17 +454,17 @@ FeatureStatus SDKHooks::GetFeatureStatus(FeatureType type, const char *name)
  * Functions
  */
 
-static void PopulateCallbackList(const ke::Vector<HookList> &source, ke::Vector<IPluginFunction *> &destination, int entity)
+static void PopulateCallbackList(const std::vector<HookList> &source, std::vector<IPluginFunction *> &destination, int entity)
 {
-	destination.ensure(8); /* Skip trivial allocations as AMTL uses length<<1. */
+	destination.reserve(8);
-	for (size_t iter = 0; iter < source.length(); ++iter)
+	for (size_t iter = 0; iter < source.size(); ++iter)
 	{
 		if (source[iter].entity != entity)
 		{
 			continue;
 		}
 
-		destination.append(source[iter].callback);
+		destination.push_back(source[iter].callback);
 	}
 }
 
@@ -483,8 +483,8 @@ cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, CBaseEntity *pOther)
 	cell_t ret = Pl_Continue;
 
 	CVTableHook vhook(pEnt);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[type];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -494,9 +494,9 @@ cell_t SDKHooks::Call(CBaseEntity *pEnt, SDKHookType type, CBaseEntity *pOther)
 		int entity = gamehelpers->EntityToBCompatRef(pEnt);
 		int other = gamehelpers->EntityToBCompatRef(pOther);
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -584,8 +584,8 @@ HookReturn SDKHooks::Hook(int entity, SDKHookType type, IPluginFunction *callbac
 
 	size_t entry;
 	CVTableHook vhook(pEnt);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[type];
-	for (entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook == vtablehooklist[entry]->vtablehook)
 		{
@@ -593,7 +593,7 @@ HookReturn SDKHooks::Hook(int entity, SDKHookType type, IPluginFunction *callbac
 		}
 	}
 
-	if (entry == vtablehooklist.length())
+	if (entry == vtablehooklist.size())
 	{
 		int hookid = 0;
 		switch(type)
@@ -738,14 +738,14 @@ HookReturn SDKHooks::Hook(int entity, SDKHookType type, IPluginFunction *callbac
 
 		CVTableList *vtablelist = new CVTableList;
 		vtablelist->vtablehook = new CVTableHook(vhook);
-		vtablehooklist.append(vtablelist);
+		vtablehooklist.push_back(vtablelist);
 	}
 	
 	// Add hook to hook list
 	HookList hook;
 	hook.entity = gamehelpers->EntityToBCompatRef(pEnt);
 	hook.callback = callback;
-	vtablehooklist[entry]->hooks.append(hook);
+	vtablehooklist[entry]->hooks.push_back(hook);
 
 	return HookRet_Successful;
 }
@@ -760,24 +760,24 @@ void SDKHooks::Unhook(CBaseEntity *pEntity)
 	int entity = gamehelpers->EntityToBCompatRef(pEntity);
 	for (size_t type = 0; type < SDKHook_MAXHOOKS; ++type)
 	{
-		ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];
+		std::vector<CVTableList *> &vtablehooklist = g_HookList[type];
-		for (size_t listentry = 0; listentry < vtablehooklist.length(); ++listentry)
+		for (size_t listentry = 0; listentry < vtablehooklist.size(); ++listentry)
 		{
-			ke::Vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
+			std::vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
-			for (size_t entry = 0; entry < pawnhooks.length(); ++entry)
+			for (size_t entry = 0; entry < pawnhooks.size(); ++entry)
 			{
 				if (entity != pawnhooks[entry].entity)
 				{
 					continue;
 				}
 
-				pawnhooks.remove(entry--);
+				ke::RemoveAt(&pawnhooks, entry--);
 			}
 
-			if (pawnhooks.length() == 0)
+			if (pawnhooks.size() == 0)
 			{
 				delete vtablehooklist[listentry];
-				vtablehooklist.remove(listentry--);
+				ke::RemoveAt(&vtablehooklist, listentry--);
 			}
 		}
 	}
@@ -787,24 +787,24 @@ void SDKHooks::Unhook(IPluginContext *pContext)
 {
 	for (size_t type = 0; type < SDKHook_MAXHOOKS; ++type)
 	{
-		ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];
+		std::vector<CVTableList *> &vtablehooklist = g_HookList[type];
-		for (size_t listentry = 0; listentry < vtablehooklist.length(); ++listentry)
+		for (size_t listentry = 0; listentry < vtablehooklist.size(); ++listentry)
 		{
-			ke::Vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
+			std::vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
-			for (size_t entry = 0; entry < pawnhooks.length(); ++entry)
+			for (size_t entry = 0; entry < pawnhooks.size(); ++entry)
 			{
 				if (pContext != NULL && pContext != pawnhooks[entry].callback->GetParentRuntime()->GetDefaultContext())
 				{
 					continue;
 				}
 
-				pawnhooks.remove(entry--);
+				ke::RemoveAt(&pawnhooks, entry--);
 			}
 
-			if (pawnhooks.length() == 0)
+			if (pawnhooks.size() == 0)
 			{
 				delete vtablehooklist[listentry];
-				vtablehooklist.remove(listentry--);
+				ke::RemoveAt(&vtablehooklist, listentry--);
 			}
 		}
 	}
@@ -819,8 +819,8 @@ void SDKHooks::Unhook(int entity, SDKHookType type, IPluginFunction *pCallback)
 	}
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[type];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[type];
-	for (size_t listentry = 0; listentry < vtablehooklist.length(); ++listentry)
+	for (size_t listentry = 0; listentry < vtablehooklist.size(); ++listentry)
 	{
 		if (vhook != vtablehooklist[listentry]->vtablehook)
 		{
@@ -829,8 +829,8 @@ void SDKHooks::Unhook(int entity, SDKHookType type, IPluginFunction *pCallback)
 
 		entity = gamehelpers->EntityToBCompatRef(pEntity);
 
-		ke::Vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
+		std::vector<HookList> &pawnhooks = vtablehooklist[listentry]->hooks;
-		for (size_t entry = 0; entry < pawnhooks.length(); ++entry)
+		for (size_t entry = 0; entry < pawnhooks.size(); ++entry)
 		{
 			HookList &hookentry = pawnhooks[entry];
 			if (entity != hookentry.entity || pCallback != hookentry.callback)
@@ -838,13 +838,13 @@ void SDKHooks::Unhook(int entity, SDKHookType type, IPluginFunction *pCallback)
 				continue;
 			}
 
-			pawnhooks.remove(entry--);
+			ke::RemoveAt(&pawnhooks, entry--);
 		}
 
-		if (pawnhooks.length() == 0)
+		if (pawnhooks.size() == 0)
 		{
 			delete vtablehooklist[listentry];
-			vtablehooklist.remove(listentry);
+			ke::RemoveAt(&vtablehooklist, listentry);
 		}
 
 		break;
@@ -932,8 +932,8 @@ bool SDKHooks::Hook_CanBeAutobalanced()
 	CBaseEntity *pPlayer = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pPlayer);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_CanBeAutobalanced];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_CanBeAutobalanced];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -945,9 +945,9 @@ bool SDKHooks::Hook_CanBeAutobalanced()
 		bool origRet = SH_MCALL(pPlayer, CanBeAutobalanced)();
 		bool newRet = origRet;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			cell_t res = origRet;
 			IPluginFunction *callback = callbackList[entry];
@@ -1000,8 +1000,8 @@ void SDKHooks::Hook_FireBulletsPost(const FireBulletsInfo_t &info)
 		RETURN_META(MRES_IGNORED);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_FireBulletsPost];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_FireBulletsPost];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1010,9 +1010,9 @@ void SDKHooks::Hook_FireBulletsPost(const FireBulletsInfo_t &info)
 
 		const char *weapon = pInfo->GetWeaponName();
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1034,8 +1034,8 @@ int SDKHooks::Hook_GetMaxHealth()
 	int original_max = SH_MCALL(pEntity, GetMaxHealth)();
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_GetMaxHealth];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_GetMaxHealth];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1048,9 +1048,9 @@ int SDKHooks::Hook_GetMaxHealth()
 
 		cell_t res = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1078,8 +1078,8 @@ int SDKHooks::HandleOnTakeDamageHook(CTakeDamageInfoHack &info, SDKHookType hook
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[hookType];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[hookType];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1101,9 +1101,9 @@ int SDKHooks::HandleOnTakeDamageHook(CTakeDamageInfoHack &info, SDKHookType hook
 
 		cell_t res, ret = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1169,8 +1169,8 @@ int SDKHooks::HandleOnTakeDamageHookPost(CTakeDamageInfoHack &info, SDKHookType
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[hookType];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[hookType];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1179,9 +1179,9 @@ int SDKHooks::HandleOnTakeDamageHookPost(CTakeDamageInfoHack &info, SDKHookType
 
 		int entity = gamehelpers->EntityToBCompatRef(pEntity);
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1257,8 +1257,8 @@ bool SDKHooks::Hook_Reload()
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Reload];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Reload];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1268,9 +1268,9 @@ bool SDKHooks::Hook_Reload()
 		int entity = gamehelpers->EntityToBCompatRef(pEntity);
 		cell_t res = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1291,8 +1291,8 @@ bool SDKHooks::Hook_ReloadPost()
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_ReloadPost];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_ReloadPost];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1302,9 +1302,9 @@ bool SDKHooks::Hook_ReloadPost()
 		int entity = gamehelpers->EntityToBCompatRef(pEntity);
 		cell_t origreturn = META_RESULT_ORIG_RET(bool) ? 1 : 0;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1333,8 +1333,8 @@ bool SDKHooks::Hook_ShouldCollide(int collisionGroup, int contentsMask)
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_ShouldCollide];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_ShouldCollide];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1345,9 +1345,9 @@ bool SDKHooks::Hook_ShouldCollide(int collisionGroup, int contentsMask)
 		cell_t origRet = ((META_RESULT_STATUS >= MRES_OVERRIDE)?(META_RESULT_OVERRIDE_RET(bool)):(META_RESULT_ORIG_RET(bool))) ? 1 : 0;
 		cell_t res = 0;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1374,8 +1374,8 @@ void SDKHooks::Hook_Spawn()
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Spawn];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Spawn];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1385,9 +1385,9 @@ void SDKHooks::Hook_Spawn()
 		int entity = gamehelpers->EntityToBCompatRef(pEntity);
 		cell_t res = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1460,8 +1460,8 @@ void SDKHooks::Hook_TraceAttack(CTakeDamageInfoHack &info, const Vector &vecDir,
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_TraceAttack];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_TraceAttack];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1476,9 +1476,9 @@ void SDKHooks::Hook_TraceAttack(CTakeDamageInfoHack &info, const Vector &vecDir,
 		int ammotype = info.GetAmmoType();
 		cell_t res, ret = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1541,8 +1541,8 @@ void SDKHooks::Hook_TraceAttackPost(CTakeDamageInfoHack &info, const Vector &vec
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_TraceAttackPost];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_TraceAttackPost];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1551,9 +1551,9 @@ void SDKHooks::Hook_TraceAttackPost(CTakeDamageInfoHack &info, const Vector &vec
 
 		int entity = gamehelpers->EntityToBCompatRef(pEntity);
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1578,8 +1578,8 @@ void SDKHooks::Hook_Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Use];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_Use];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1591,9 +1591,9 @@ void SDKHooks::Hook_Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
 		int caller = gamehelpers->EntityToBCompatRef(pCaller);
 		cell_t ret = Pl_Continue;
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);
@@ -1618,8 +1618,8 @@ void SDKHooks::Hook_UsePost(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
 	CBaseEntity *pEntity = META_IFACEPTR(CBaseEntity);
 
 	CVTableHook vhook(pEntity);
-	ke::Vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_UsePost];
+	std::vector<CVTableList *> &vtablehooklist = g_HookList[SDKHook_UsePost];
-	for (size_t entry = 0; entry < vtablehooklist.length(); ++entry)
+	for (size_t entry = 0; entry < vtablehooklist.size(); ++entry)
 	{
 		if (vhook != vtablehooklist[entry]->vtablehook)
 		{
@@ -1630,9 +1630,9 @@ void SDKHooks::Hook_UsePost(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
 		int activator = gamehelpers->EntityToBCompatRef(pActivator);
 		int caller = gamehelpers->EntityToBCompatRef(pCaller);
 
-		ke::Vector<IPluginFunction *> callbackList;
+		std::vector<IPluginFunction *> callbackList;
 		PopulateCallbackList(vtablehooklist[entry]->hooks, callbackList, entity);
-		for (entry = 0; entry < callbackList.length(); ++entry)
+		for (entry = 0; entry < callbackList.size(); ++entry)
 		{
 			IPluginFunction *callback = callbackList[entry];
 			callback->PushCell(entity);

extensions/sdkhooks/extension.h

@@ -127,7 +127,7 @@ public:
 	};
 public:
 	CVTableHook *vtablehook;
-	ke::Vector<HookList> hooks;
+	std::vector<HookList> hooks;
 };
 
 class IEntityListener
@@ -344,7 +344,7 @@ private:
 };
 
 extern CGlobalVars *gpGlobals;
-extern ke::Vector<CVTableList *> g_HookList[SDKHook_MAXHOOKS];
+extern std::vector<CVTableList *> g_HookList[SDKHook_MAXHOOKS];
 
 extern ICvar *icvar;
 

extensions/sdktools/hooks.cpp

@@ -169,9 +169,9 @@ void CHookManager::PlayerRunCmdHook(int client, bool post)
 		return;
 	}
 
-	ke::Vector<CVTableHook *> &runUserCmdHookVec = post ? m_runUserCmdPostHooks : m_runUserCmdHooks;
+	std::vector<CVTableHook *> &runUserCmdHookVec = post ? m_runUserCmdPostHooks : m_runUserCmdHooks;
 	CVTableHook hook(pEntity);
-	for (size_t i = 0; i < runUserCmdHookVec.length(); ++i)
+	for (size_t i = 0; i < runUserCmdHookVec.size(); ++i)
 	{
 		if (hook == runUserCmdHookVec[i])
 		{
@@ -186,7 +186,7 @@ void CHookManager::PlayerRunCmdHook(int client, bool post)
 		hookid = SH_ADD_MANUALVPHOOK(PlayerRunCmdHook, pEntity, SH_MEMBER(this, &CHookManager::PlayerRunCmd), false);
 
 	hook.SetHookID(hookid);
-	runUserCmdHookVec.append(new CVTableHook(hook));
+	runUserCmdHookVec.push_back(new CVTableHook(hook));
 }
 
 void CHookManager::PlayerRunCmd(CUserCmd *ucmd, IMoveHelper *moveHelper)
@@ -332,16 +332,16 @@ void CHookManager::NetChannelHook(int client)
 		}
 		else
 #endif
-		if (!m_netChannelHooks.length())
+		if (!m_netChannelHooks.size())
 		{
 			CVTableHook filehook(basefilesystem);
 
 			int hookid = SH_ADD_VPHOOK(IBaseFileSystem, FileExists, basefilesystem, SH_MEMBER(this, &CHookManager::FileExists), false);
 			filehook.SetHookID(hookid);
-			m_netChannelHooks.append(new CVTableHook(filehook));
+			m_netChannelHooks.push_back(new CVTableHook(filehook));
 		}
 
-		for (iter = 0; iter < m_netChannelHooks.length(); ++iter)
+		for (iter = 0; iter < m_netChannelHooks.size(); ++iter)
 		{
 			if (nethook == m_netChannelHooks[iter])
 			{
@@ -349,19 +349,19 @@ void CHookManager::NetChannelHook(int client)
 			}
 		}
 
-		if (iter == m_netChannelHooks.length())
+		if (iter == m_netChannelHooks.size())
 		{
 			int hookid = SH_ADD_VPHOOK(INetChannel, SendFile, pNetChannel, SH_MEMBER(this, &CHookManager::SendFile), false);
 			nethook.SetHookID(hookid);
-			m_netChannelHooks.append(new CVTableHook(nethook));
+			m_netChannelHooks.push_back(new CVTableHook(nethook));
 			
 			hookid = SH_ADD_VPHOOK(INetChannel, ProcessPacket, pNetChannel, SH_MEMBER(this, &CHookManager::ProcessPacket), false);
 			nethook.SetHookID(hookid);
-			m_netChannelHooks.append(new CVTableHook(nethook));
+			m_netChannelHooks.push_back(new CVTableHook(nethook));
 			
 			hookid = SH_ADD_VPHOOK(INetChannel, ProcessPacket, pNetChannel, SH_MEMBER(this, &CHookManager::ProcessPacket_Post), true);
 			nethook.SetHookID(hookid);
-			m_netChannelHooks.append(new CVTableHook(nethook));
+			m_netChannelHooks.push_back(new CVTableHook(nethook));
 		}
 	}
 }
@@ -508,7 +508,7 @@ void CHookManager::OnPluginUnloaded(IPlugin *plugin)
 {
 	if (PRCH_used && !m_usercmdsFwd->GetFunctionCount())
 	{
-		for (size_t i = 0; i < m_runUserCmdHooks.length(); ++i)
+		for (size_t i = 0; i < m_runUserCmdHooks.size(); ++i)
 		{
 			delete m_runUserCmdHooks[i];
 		}
@@ -519,7 +519,7 @@ void CHookManager::OnPluginUnloaded(IPlugin *plugin)
 
 	if (PRCHPost_used && !m_usercmdsPostFwd->GetFunctionCount())
 	{
-		for (size_t i = 0; i < m_runUserCmdPostHooks.length(); ++i)
+		for (size_t i = 0; i < m_runUserCmdPostHooks.size(); ++i)
 		{
 			delete m_runUserCmdPostHooks[i];
 		}
@@ -530,7 +530,7 @@ void CHookManager::OnPluginUnloaded(IPlugin *plugin)
 
 	if (FILE_used && !m_netFileSendFwd->GetFunctionCount() && !m_netFileReceiveFwd->GetFunctionCount())
 	{
-		for (size_t i = 0; i < m_netChannelHooks.length(); ++i)
+		for (size_t i = 0; i < m_netChannelHooks.size(); ++i)
 		{
 			delete m_netChannelHooks[i];
 		}

extensions/sdktools/hooks.h

@@ -75,9 +75,9 @@ private:
 	IForward *m_usercmdsPostFwd;
 	IForward *m_netFileSendFwd;
 	IForward *m_netFileReceiveFwd;
-	ke::Vector<CVTableHook *> m_runUserCmdHooks;
+	std::vector<CVTableHook *> m_runUserCmdHooks;
-	ke::Vector<CVTableHook *> m_runUserCmdPostHooks;
+	std::vector<CVTableHook *> m_runUserCmdPostHooks;
-	ke::Vector<CVTableHook *> m_netChannelHooks;
+	std::vector<CVTableHook *> m_netChannelHooks;
 	INetChannel *m_pActiveNetChannel;
 	bool m_bFSTranHookWarned = false;
 	bool m_bReplayEnabled = false;

extensions/tf2/RegNatives.cpp

@@ -36,12 +36,12 @@ RegNatives g_RegNatives;
 
 void RegNatives::Register(ICallWrapper *pWrapper)
 {
-	m_Natives.append(pWrapper);
+	m_Natives.push_back(pWrapper);
 }
 
 void RegNatives::UnregisterAll()
 {
-	for (size_t iter = 0; iter < m_Natives.length(); ++iter)
+	for (size_t iter = 0; iter < m_Natives.size(); ++iter)
 	{
 		m_Natives[iter]->Destroy();
 	}

extensions/tf2/RegNatives.h

@@ -40,7 +40,7 @@ public:
 	void Register(ICallWrapper *pWrapper);
 	void UnregisterAll();
 private:
-	ke::Vector<ICallWrapper *> m_Natives;
+	std::vector<ICallWrapper *> m_Natives;
 };
 
 extern RegNatives g_RegNatives;

public/amtl

@@ -1 +1 @@
-Subproject commit 0d11efc79bcfcb9640e73d5c9e6516314218372a
+Subproject commit abb3b74a1a58803fcf43f24936c3f595c2faf081

sourcepawn

@@ -1 +1 @@
-Subproject commit 71016c40cfee83ff3f7e9c2b5c10e2e5a77952b9
+Subproject commit 7db5de576c3e7cbadc854a6d34b40ac659216e6b