Home - sourcemod-central - file revision - core/smn_keyvalues.cpp@676c3b826f13 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
core/smn_keyvalues.cpp
author Matt Woodrow <pred@alliedmods.net>
Fri Aug 08 00:17:37 2008 +0000 (2008-08-08)
changeset 2224 676c3b826f13
parent 1952 b7aa2b626807
child 2289 44045ead61cd
permissions -rw-r--r--
Initial Import of beta structs extension. 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod
     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
     6  * =============================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or modify it under
     9  * the terms of the GNU General Public License, version 3.0, as published by the
    10  * Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful, but WITHOUT
    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    15  * details.
    16  *
    17  * You should have received a copy of the GNU General Public License along with
    18  * this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to link the
    21  * code of this program (as well as its derivative works) to "Half-Life 2," the
    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
    23  * by the Valve Corporation.  You must obey the GNU General Public License in
    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants
    25  * this exception to all derivative works.  AlliedModders LLC defines further
    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
    27  * or <http://www.sourcemod.net/license.php>.
    28  *
    29  * Version: $Id$
    30  */
    31 
    32 #include "sourcemod.h"
    33 #include "sourcemm_api.h"
    34 #include "sm_stringutil.h"
    35 #include "HandleSys.h"
    36 #include "HalfLife2.h"
    37 #include <KeyValues.h>
    38 #include "utlbuffer.h"
    39 
    40 HandleType_t g_KeyValueType;
    41 
    42 struct KeyValueStack 
    43 {
    44 	KeyValues *pBase;
    45 	CStack<KeyValues *> pCurRoot;
    46 };
    47 
    48 class KeyValueNatives : 
    49 	public SMGlobalClass,
    50 	public IHandleTypeDispatch
    51 {
    52 public:
    53 	void OnSourceModAllInitialized()
    54 	{
    55 		g_KeyValueType = g_HandleSys.CreateType("KeyValues", this, 0, NULL, NULL, g_pCoreIdent, NULL);
    56 	}
    57 	void OnSourceModShutdown()
    58 	{
    59 		g_HandleSys.RemoveType(g_KeyValueType, g_pCoreIdent);
    60 		g_KeyValueType = 0;
    61 	}
    62 	void OnHandleDestroy(HandleType_t type, void *object)
    63 	{
    64 		KeyValueStack *pStk = reinterpret_cast<KeyValueStack *>(object);
    65 		pStk->pBase->deleteThis();
    66 		delete pStk;
    67 	}
    68 	int CalcKVSizeR(KeyValues *pv)
    69 	{
    70 		CUtlBuffer buf;
    71 		int size;
    72 
    73 		pv->RecursiveSaveToFile(buf, 0);
    74 		size = buf.TellMaxPut();
    75 
    76 		buf.Purge();
    77 
    78 		return size;
    79 	}
    80 	bool GetHandleApproxSize(HandleType_t type, void *object, unsigned int *pSize)
    81 	{
    82 		KeyValueStack *pStk = (KeyValueStack *)object;
    83 		unsigned int size = sizeof(KeyValueStack) + (pStk->pCurRoot.size() * sizeof(KeyValues *));
    84 
    85 		/* Check how much memory the actual thing takes up */		
    86 		size += CalcKVSizeR(pStk->pBase);
    87 
    88 		*pSize = size;
    89 
    90 		return true;
    91 	}
    92 };
    93 
    94 KeyValues *SourceModBase::ReadKeyValuesHandle(Handle_t hndl, HandleError *err, bool root)
    95 {
    96 	HandleError herr;
    97 	HandleSecurity sec;
    98 	KeyValueStack *pStk;
    99 
   100 	sec.pOwner = NULL;
   101 	sec.pIdentity = g_pCoreIdent;
   102 
   103 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   104 		!= HandleError_None)
   105 	{
   106 		if (err)
   107 		{
   108 			*err = herr;
   109 		}
   110 		return NULL;
   111 	}
   112 
   113 	if (err)
   114 	{
   115 		*err = HandleError_None;
   116 	}
   117 
   118 	return (root) ? pStk->pBase : pStk->pCurRoot.front();
   119 }
   120 
   121 static cell_t smn_KvSetString(IPluginContext *pCtx, const cell_t *params)
   122 {
   123 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   124 	HandleError herr;
   125 	HandleSecurity sec;
   126 	KeyValueStack *pStk;
   127 
   128 	sec.pOwner = NULL;
   129 	sec.pIdentity = g_pCoreIdent;
   130 
   131 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   132 		!= HandleError_None)
   133 	{
   134 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   135 	}
   136 
   137 	char *key, *value;
   138 	pCtx->LocalToStringNULL(params[2], &key);
   139 	pCtx->LocalToString(params[3], &value);
   140 
   141 	pStk->pCurRoot.front()->SetString(key, value);
   142 
   143 	return 1;
   144 }
   145 
   146 static cell_t smn_KvSetNum(IPluginContext *pCtx, const cell_t *params)
   147 {
   148 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   149 	HandleError herr;
   150 	HandleSecurity sec;
   151 	KeyValueStack *pStk;
   152 
   153 	sec.pOwner = NULL;
   154 	sec.pIdentity = g_pCoreIdent;
   155 
   156 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   157 		!= HandleError_None)
   158 	{
   159 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   160 	}
   161 
   162 	char *key;
   163 	pCtx->LocalToStringNULL(params[2], &key);
   164 
   165 	pStk->pCurRoot.front()->SetInt(key, params[3]);
   166 
   167 	return 1;
   168 }
   169 
   170 static cell_t smn_KvSetUInt64(IPluginContext *pCtx, const cell_t *params)
   171 {
   172 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   173 	HandleError herr;
   174 	HandleSecurity sec;
   175 	KeyValueStack *pStk;
   176 
   177 	sec.pOwner = NULL;
   178 	sec.pIdentity = g_pCoreIdent;
   179 
   180 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   181 		!= HandleError_None)
   182 	{
   183 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   184 	}
   185 
   186 	char *key;
   187 	cell_t *addr;
   188 	uint64 value;
   189 	pCtx->LocalToStringNULL(params[2], &key);
   190 	pCtx->LocalToPhysAddr(params[3], &addr);
   191 
   192 	value = static_cast<uint64>(*addr);
   193 	pStk->pCurRoot.front()->SetUint64(key, value);
   194 
   195 	return 1;
   196 }
   197 
   198 static cell_t smn_KvSetFloat(IPluginContext *pCtx, const cell_t *params)
   199 {
   200 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   201 	HandleError herr;
   202 	HandleSecurity sec;
   203 	KeyValueStack *pStk;
   204 
   205 	sec.pOwner = NULL;
   206 	sec.pIdentity = g_pCoreIdent;
   207 
   208 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   209 		!= HandleError_None)
   210 	{
   211 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   212 	}
   213 
   214 	char *key;
   215 	pCtx->LocalToStringNULL(params[2], &key);
   216 
   217 	pStk->pCurRoot.front()->SetFloat(key, sp_ctof(params[3]));
   218 
   219 	return 1;
   220 }
   221 
   222 static cell_t smn_KvSetColor(IPluginContext *pCtx, const cell_t *params)
   223 {
   224 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   225 	HandleError herr;
   226 	HandleSecurity sec;
   227 	KeyValueStack *pStk;
   228 
   229 	sec.pOwner = NULL;
   230 	sec.pIdentity = g_pCoreIdent;
   231 
   232 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   233 		!= HandleError_None)
   234 	{
   235 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   236 	}
   237 
   238 	char *key;
   239 	pCtx->LocalToStringNULL(params[2], &key);
   240 
   241 	Color color(params[3], params[4], params[5], params[6]);
   242 	pStk->pCurRoot.front()->SetColor(key, color);
   243 
   244 	return 1;
   245 }
   246 
   247 static cell_t smn_KvSetVector(IPluginContext *pCtx, const cell_t *params)
   248 {
   249 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   250 	HandleError herr;
   251 	HandleSecurity sec;
   252 	KeyValueStack *pStk;
   253 
   254 	sec.pOwner = NULL;
   255 	sec.pIdentity = g_pCoreIdent;
   256 
   257 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   258 		!= HandleError_None)
   259 	{
   260 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   261 	}
   262 
   263 	char *key;
   264 	char buffer[64];
   265 	cell_t *vector;
   266 	pCtx->LocalToStringNULL(params[2], &key);
   267 	pCtx->LocalToPhysAddr(params[3], &vector);
   268 
   269 	UTIL_Format(buffer, sizeof(buffer), "%f %f %f", sp_ctof(vector[0]), sp_ctof(vector[1]), sp_ctof(vector[2]));
   270 
   271 	pStk->pCurRoot.front()->SetString(key, buffer);
   272 
   273 	return 1;
   274 }
   275 
   276 static cell_t smn_KvGetString(IPluginContext *pCtx, const cell_t *params)
   277 {
   278 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   279 	HandleError herr;
   280 	HandleSecurity sec;
   281 	KeyValueStack *pStk;
   282 
   283 	sec.pOwner = NULL;
   284 	sec.pIdentity = g_pCoreIdent;
   285 
   286 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   287 		!= HandleError_None)
   288 	{
   289 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   290 	}
   291 
   292 	const char *value;
   293 	char *key, *defvalue;
   294 	pCtx->LocalToStringNULL(params[2], &key);
   295 	pCtx->LocalToString(params[5], &defvalue);
   296 
   297 	value = pStk->pCurRoot.front()->GetString(key, defvalue);
   298 	pCtx->StringToLocalUTF8(params[3], params[4], value, NULL);
   299 
   300 	return 1;
   301 }
   302 
   303 static cell_t smn_KvGetNum(IPluginContext *pCtx, const cell_t *params)
   304 {
   305 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   306 	HandleError herr;
   307 	HandleSecurity sec;
   308 	KeyValueStack *pStk;
   309 
   310 	sec.pOwner = NULL;
   311 	sec.pIdentity = g_pCoreIdent;
   312 
   313 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   314 		!= HandleError_None)
   315 	{
   316 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   317 	}
   318 
   319 	int value;
   320 	char *key;
   321 	pCtx->LocalToStringNULL(params[2], &key);
   322 
   323 	value = pStk->pCurRoot.front()->GetInt(key, params[3]);
   324 
   325 	return value;
   326 }
   327 
   328 static cell_t smn_KvGetFloat(IPluginContext *pCtx, const cell_t *params)
   329 {
   330 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   331 	HandleError herr;
   332 	HandleSecurity sec;
   333 	KeyValueStack *pStk;
   334 
   335 	sec.pOwner = NULL;
   336 	sec.pIdentity = g_pCoreIdent;
   337 
   338 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   339 		!= HandleError_None)
   340 	{
   341 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   342 	}
   343 
   344 	float value;
   345 	char *key;
   346 	pCtx->LocalToStringNULL(params[2], &key);
   347 
   348 	value = pStk->pCurRoot.front()->GetFloat(key, sp_ctof(params[3]));
   349 
   350 	return sp_ftoc(value);
   351 }
   352 
   353 static cell_t smn_KvGetColor(IPluginContext *pCtx, const cell_t *params)
   354 {
   355 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   356 	HandleError herr;
   357 	HandleSecurity sec;
   358 	KeyValueStack *pStk;
   359 
   360 	sec.pOwner = NULL;
   361 	sec.pIdentity = g_pCoreIdent;
   362 
   363 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   364 		!= HandleError_None)
   365 	{
   366 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   367 	}
   368 
   369 	Color color;
   370 	char *key;
   371 	cell_t *r, *g, *b, *a;
   372 	pCtx->LocalToStringNULL(params[2], &key);
   373 	pCtx->LocalToPhysAddr(params[3], &r);
   374 	pCtx->LocalToPhysAddr(params[4], &g);
   375 	pCtx->LocalToPhysAddr(params[5], &b);
   376 	pCtx->LocalToPhysAddr(params[6], &a);
   377 
   378 	color = pStk->pCurRoot.front()->GetColor(key);
   379 	*r = color.r();
   380 	*g = color.g();
   381 	*b = color.b();
   382 	*a = color.a();
   383 
   384 	return 1;
   385 }
   386 
   387 static cell_t smn_KvGetUInt64(IPluginContext *pCtx, const cell_t *params)
   388 {
   389 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   390 	HandleError herr;
   391 	HandleSecurity sec;
   392 	KeyValueStack *pStk;
   393 
   394 	sec.pOwner = NULL;
   395 	sec.pIdentity = g_pCoreIdent;
   396 
   397 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   398 		!= HandleError_None)
   399 	{
   400 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   401 	}
   402 
   403 	char *key;
   404 	cell_t *addr, *defvalue;
   405 	uint64 value;
   406 	pCtx->LocalToStringNULL(params[2], &key);
   407 	pCtx->LocalToPhysAddr(params[3], &addr);
   408 	pCtx->LocalToPhysAddr(params[4], &defvalue);
   409 
   410 	value = pStk->pCurRoot.front()->GetUint64(key, static_cast<uint64>(*defvalue));
   411 	*reinterpret_cast<uint64 *>(addr) = value;
   412 
   413 	return 1;
   414 }
   415 
   416 static cell_t smn_KvGetVector(IPluginContext *pCtx, const cell_t *params)
   417 {
   418 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   419 	HandleError herr;
   420 	HandleSecurity sec;
   421 	KeyValueStack *pStk;
   422 
   423 	sec.pOwner = NULL;
   424 	sec.pIdentity = g_pCoreIdent;
   425 
   426 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   427 		!= HandleError_None)
   428 	{
   429 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   430 	}
   431 
   432 	char *key;
   433 	const char *value;
   434 	cell_t *defvector, *outvector;
   435 	char buffer[64];
   436 	pCtx->LocalToStringNULL(params[2], &key);
   437 	pCtx->LocalToPhysAddr(params[3], &outvector);
   438 	pCtx->LocalToPhysAddr(params[4], &defvector);
   439 
   440 	UTIL_Format(buffer, sizeof(buffer), "%f %f %f", sp_ctof(defvector[0]), sp_ctof(defvector[1]), sp_ctof(defvector[2]));
   441 
   442 	value = pStk->pCurRoot.front()->GetString(key, buffer);
   443 
   444 	float out;
   445 	int components = 0;
   446 	while (*value && components < 3)
   447 	{
   448 		while ((*value) && (*value == ' '))
   449 		{
   450 			value++;
   451 		}
   452 
   453 		out = 0.0f;
   454 		bool isnegative;
   455 		if (*value == '-')
   456 		{
   457 			isnegative = true;
   458 			value++;
   459 		}
   460 		else
   461 		{
   462 			isnegative = false;
   463 		}
   464 
   465 		for (; *value && isdigit(*value); ++value)
   466 		{
   467 			out *= 10.0f;
   468 			out += *value - '0';
   469 		}
   470 
   471 		if (*value == '.')
   472 		{
   473 			value++;
   474 			float factor = 0.1f;
   475 			for (; *value && isdigit(*value); ++value)
   476 			{
   477 				out += (*value - '0') * factor;
   478 				factor *= 0.1f;
   479 			}
   480 		}
   481 
   482 		out = (isnegative) ? -out : out;
   483 		outvector[components++] = sp_ftoc(out);
   484 	}
   485 
   486 	return 1;
   487 }
   488 
   489 static cell_t smn_CreateKeyValues(IPluginContext *pCtx, const cell_t *params)
   490 {
   491 	KeyValueStack *pStk;
   492 	char *name, *firstkey, *firstvalue;
   493 	bool is_empty;
   494 
   495 	pCtx->LocalToString(params[1], &name);
   496 	pCtx->LocalToString(params[2], &firstkey);
   497 	pCtx->LocalToString(params[3], &firstvalue);
   498 
   499 	is_empty = (firstkey[0] == '\0');
   500 	pStk = new KeyValueStack;
   501 	pStk->pBase = new KeyValues(name, is_empty ? NULL : firstkey, (is_empty||(firstvalue[0]=='\0')) ? NULL : firstvalue);
   502 	pStk->pCurRoot.push(pStk->pBase);
   503 
   504 	return g_HandleSys.CreateHandle(g_KeyValueType, pStk, pCtx->GetIdentity(), g_pCoreIdent, NULL);
   505 }
   506 
   507 static cell_t smn_KvJumpToKey(IPluginContext *pCtx, const cell_t *params)
   508 {
   509 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   510 	HandleError herr;
   511 	HandleSecurity sec;
   512 	char *name;	
   513 	KeyValueStack *pStk;
   514 
   515 	sec.pOwner = NULL;
   516 	sec.pIdentity = g_pCoreIdent;
   517 
   518 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   519 		!= HandleError_None)
   520 	{
   521 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   522 	}
   523 
   524 	pCtx->LocalToString(params[2], &name);
   525 
   526 	KeyValues *pSubKey = pStk->pCurRoot.front();
   527 	pSubKey = pSubKey->FindKey(name, (params[3]) ? true : false);
   528 	if (!pSubKey)
   529 	{
   530 		return 0;
   531 	}
   532 	pStk->pCurRoot.push(pSubKey);
   533 
   534 	return 1;
   535 }
   536 
   537 static cell_t smn_KvJumpToKeySymbol(IPluginContext *pCtx, const cell_t *params)
   538 {
   539 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   540 	HandleError herr;
   541 	HandleSecurity sec;
   542 	KeyValueStack *pStk;
   543 
   544 	sec.pOwner = NULL;
   545 	sec.pIdentity = g_pCoreIdent;
   546 
   547 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   548 		!= HandleError_None)
   549 	{
   550 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   551 	}
   552 
   553 	KeyValues *pSubKey = pStk->pCurRoot.front();
   554 	pSubKey = pSubKey->FindKey(params[2]);
   555 	if (!pSubKey)
   556 	{
   557 		return 0;
   558 	}
   559 	pStk->pCurRoot.push(pSubKey);
   560 
   561 	return 1;
   562 }
   563 
   564 static cell_t smn_KvGotoFirstSubKey(IPluginContext *pCtx, const cell_t *params)
   565 {
   566 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   567 	HandleError herr;
   568 	HandleSecurity sec;
   569 	KeyValueStack *pStk;
   570 
   571 	sec.pOwner = NULL;
   572 	sec.pIdentity = g_pCoreIdent;
   573 
   574 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   575 		!= HandleError_None)
   576 	{
   577 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   578 	}
   579 
   580 	KeyValues *pSubKey = pStk->pCurRoot.front();
   581 	KeyValues *pFirstSubKey;
   582 	if (params[2])
   583 	{
   584 		pFirstSubKey = pSubKey->GetFirstTrueSubKey();
   585 	} else {
   586 		pFirstSubKey = pSubKey->GetFirstSubKey();
   587 	}
   588 
   589 	if (!pFirstSubKey)
   590 	{
   591 		return 0;
   592 	}
   593 	pStk->pCurRoot.push(pFirstSubKey);
   594 
   595 	return 1;
   596 }
   597 
   598 static cell_t smn_KvGotoNextKey(IPluginContext *pCtx, const cell_t *params)
   599 {
   600 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   601 	HandleError herr;
   602 	HandleSecurity sec;
   603 	KeyValueStack *pStk;
   604 
   605 	sec.pOwner = NULL;
   606 	sec.pIdentity = g_pCoreIdent;
   607 
   608 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   609 		!= HandleError_None)
   610 	{
   611 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   612 	}
   613 
   614 	KeyValues *pSubKey = pStk->pCurRoot.front();
   615 	if (params[2])
   616 	{
   617 		pSubKey = pSubKey->GetNextTrueSubKey();
   618 	} else {
   619 		pSubKey = pSubKey->GetNextKey();
   620 	}
   621 	if (!pSubKey)
   622 	{
   623 		return 0;
   624 	}
   625 	pStk->pCurRoot.pop();
   626 	pStk->pCurRoot.push(pSubKey);
   627 
   628 	return 1;	
   629 }
   630 
   631 static cell_t smn_KvGoBack(IPluginContext *pCtx, const cell_t *params)
   632 {
   633 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   634 	HandleError herr;
   635 	HandleSecurity sec;
   636 	KeyValueStack *pStk;
   637 
   638 	sec.pOwner = NULL;
   639 	sec.pIdentity = g_pCoreIdent;
   640 
   641 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   642 		!= HandleError_None)
   643 	{
   644 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   645 	}
   646 
   647 	if (pStk->pCurRoot.size() == 1)
   648 	{
   649 		return 0;
   650 	}
   651 	pStk->pCurRoot.pop();
   652 
   653 	return 1;
   654 }
   655 
   656 static cell_t smn_KvRewind(IPluginContext *pCtx, const cell_t *params)
   657 {
   658 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   659 	HandleError herr;
   660 	HandleSecurity sec;
   661 	KeyValueStack *pStk;
   662 
   663 	sec.pOwner = NULL;
   664 	sec.pIdentity = g_pCoreIdent;
   665 
   666 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   667 		!= HandleError_None)
   668 	{
   669 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   670 	}
   671 
   672 	while (pStk->pCurRoot.size() > 1)
   673 	{
   674 		pStk->pCurRoot.pop();
   675 	}
   676 
   677 	return 1;
   678 }
   679 
   680 static cell_t smn_KvGetSectionName(IPluginContext *pCtx, const cell_t *params)
   681 {
   682 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   683 	HandleError herr;
   684 	HandleSecurity sec;
   685 	KeyValueStack *pStk;
   686 
   687 	sec.pOwner = NULL;
   688 	sec.pIdentity = g_pCoreIdent;
   689 
   690 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   691 		!= HandleError_None)
   692 	{
   693 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   694 	}
   695 
   696 	KeyValues *pSection = pStk->pCurRoot.front();
   697 	const char *name = pSection->GetName();
   698 	if (!name)
   699 	{
   700 		return 0;
   701 	}
   702 	pCtx->StringToLocalUTF8(params[2], params[3], name, NULL);
   703 
   704 	return 1;
   705 }
   706 
   707 static cell_t smn_KvSetSectionName(IPluginContext *pCtx, const cell_t *params)
   708 {
   709 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   710 	HandleError herr;
   711 	HandleSecurity sec;
   712 	char *name;
   713 	KeyValueStack *pStk;
   714 
   715 	sec.pOwner = NULL;
   716 	sec.pIdentity = g_pCoreIdent;
   717 
   718 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   719 		!= HandleError_None)
   720 	{
   721 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   722 	}
   723 
   724 	pCtx->LocalToString(params[2], &name);
   725 
   726 	KeyValues *pSection = pStk->pCurRoot.front();
   727 	pSection->SetName(name);
   728 
   729 	return 1;
   730 }
   731 
   732 static cell_t smn_KvGetDataType(IPluginContext *pCtx, const cell_t *params)
   733 {
   734 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   735 	HandleError herr;
   736 	HandleSecurity sec;
   737 	char *name;
   738 	KeyValueStack *pStk;
   739 
   740 	sec.pOwner = NULL;
   741 	sec.pIdentity = g_pCoreIdent;
   742 
   743 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   744 		!= HandleError_None)
   745 	{
   746 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   747 	}
   748 
   749 	pCtx->LocalToString(params[2], &name);
   750 
   751 	return pStk->pCurRoot.front()->GetDataType(name);
   752 }
   753 
   754 static cell_t smn_KeyValuesToFile(IPluginContext *pCtx, const cell_t *params)
   755 {
   756 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   757 	HandleError herr;
   758 	HandleSecurity sec;
   759 	char *path;
   760 	KeyValueStack *pStk;
   761 
   762 	sec.pOwner = NULL;
   763 	sec.pIdentity = g_pCoreIdent;
   764 
   765 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   766 		!= HandleError_None)
   767 	{
   768 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   769 	}
   770 
   771 	pCtx->LocalToString(params[2], &path);
   772 
   773 	char realpath[PLATFORM_MAX_PATH];
   774 	g_SourceMod.BuildPath(Path_Game, realpath, sizeof(realpath), "%s", path);
   775 
   776 	return pStk->pCurRoot.front()->SaveToFile(basefilesystem, realpath);
   777 }
   778 
   779 static cell_t smn_FileToKeyValues(IPluginContext *pCtx, const cell_t *params)
   780 {
   781 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   782 	HandleError herr;
   783 	HandleSecurity sec;
   784 	char *path;
   785 	KeyValueStack *pStk;
   786 	KeyValues *kv;
   787 
   788 	sec.pOwner = NULL;
   789 	sec.pIdentity = g_pCoreIdent;
   790 
   791 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   792 		!= HandleError_None)
   793 	{
   794 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   795 	}
   796 
   797 	pCtx->LocalToString(params[2], &path);
   798 
   799 	char realpath[PLATFORM_MAX_PATH];
   800 	g_SourceMod.BuildPath(Path_Game, realpath, sizeof(realpath), "%s", path);
   801 
   802 	kv = pStk->pCurRoot.front();
   803 	return g_HL2.KVLoadFromFile(kv, basefilesystem, realpath);
   804 }
   805 
   806 static cell_t smn_KvSetEscapeSequences(IPluginContext *pCtx, const cell_t *params)
   807 {
   808 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   809 	HandleError herr;
   810 	HandleSecurity sec;
   811 	KeyValueStack *pStk;
   812 
   813 	sec.pOwner = NULL;
   814 	sec.pIdentity = g_pCoreIdent;
   815 
   816 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   817 		!= HandleError_None)
   818 	{
   819 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   820 	}
   821 
   822 	pStk->pCurRoot.front()->UsesEscapeSequences(params[2] ? true : false);
   823 
   824 	return 1;
   825 }
   826 
   827 static cell_t smn_KvNodesInStack(IPluginContext *pCtx, const cell_t *params)
   828 {
   829 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   830 	HandleError herr;
   831 	HandleSecurity sec;
   832 	KeyValueStack *pStk;
   833 
   834 	sec.pOwner = NULL;
   835 	sec.pIdentity = g_pCoreIdent;
   836 
   837 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   838 		!= HandleError_None)
   839 	{
   840 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   841 	}
   842 
   843 	return pStk->pCurRoot.size() - 1;
   844 }
   845 
   846 static cell_t smn_KvDeleteThis(IPluginContext *pContext, const cell_t *params)
   847 {
   848 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   849 	HandleError herr;
   850 	HandleSecurity sec;
   851 	KeyValueStack *pStk;
   852 
   853 	sec.pOwner = NULL;
   854 	sec.pIdentity = g_pCoreIdent;
   855 
   856 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   857 		!= HandleError_None)
   858 	{
   859 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   860 	}
   861 
   862 	if (pStk->pCurRoot.size() < 2)
   863 	{
   864 		return 0;
   865 	}
   866 
   867 	KeyValues *pValues = pStk->pCurRoot.front();
   868 	pStk->pCurRoot.pop();
   869 	KeyValues *pRoot = pStk->pCurRoot.front();
   870 
   871 	/* We have to manually verify this since Valve sucks
   872 	 * :TODO: make our own KeyValues.h file and make
   873 	 * the sub stuff private so we can do this ourselves!
   874  	 */
   875 	KeyValues *sub = pRoot->GetFirstSubKey();
   876 	while (sub)
   877 	{
   878 		if (sub == pValues)
   879 		{
   880 			KeyValues *pNext = pValues->GetNextKey();
   881 			pRoot->RemoveSubKey(pValues);
   882 			pValues->deleteThis();
   883 			if (pNext)
   884 			{
   885 				pStk->pCurRoot.push(pNext);
   886 				return 1;
   887 			} else {
   888 				return -1;
   889 			}
   890 		}
   891 		sub = sub->GetNextKey();
   892 	}
   893 
   894 	/* Push this back on :( */
   895 	pStk->pCurRoot.push(pValues);
   896 
   897 	return 0;
   898 }
   899 
   900 static cell_t smn_KvDeleteKey(IPluginContext *pContext, const cell_t *params)
   901 {
   902 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   903 	HandleError herr;
   904 	HandleSecurity sec;
   905 	KeyValueStack *pStk;
   906 
   907 	sec.pOwner = NULL;
   908 	sec.pIdentity = g_pCoreIdent;
   909 
   910 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   911 		!= HandleError_None)
   912 	{
   913 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   914 	}
   915 
   916 	if (pStk->pCurRoot.size() < 2)
   917 	{
   918 		return 0;
   919 	}
   920 
   921 	char *keyName;
   922 	pContext->LocalToString(params[2], &keyName);
   923 
   924 	KeyValues *pRoot = pStk->pCurRoot.front();
   925 	KeyValues *pValues = pRoot->FindKey(keyName);
   926 	if (!pValues)
   927 	{
   928 		return 0;
   929 	}
   930 
   931 	pRoot->RemoveSubKey(pValues);
   932 	pValues->deleteThis();
   933 
   934 	return 1;
   935 }
   936 
   937 static cell_t smn_KvSavePosition(IPluginContext *pContext, const cell_t *params)
   938 {
   939 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   940 	HandleError herr;
   941 	HandleSecurity sec;
   942 	KeyValueStack *pStk;
   943 
   944 	sec.pOwner = NULL;
   945 	sec.pIdentity = g_pCoreIdent;
   946 
   947 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
   948 		!= HandleError_None)
   949 	{
   950 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
   951 	}
   952 
   953 	if (pStk->pCurRoot.size() < 2)
   954 	{
   955 		return 0;
   956 	}
   957 
   958 	KeyValues *pValues = pStk->pCurRoot.front();
   959 	pStk->pCurRoot.push(pValues);
   960 
   961 	return 1;
   962 }
   963 
   964 static cell_t smn_CopySubkeys(IPluginContext *pContext, const cell_t *params)
   965 {
   966 	Handle_t hndl_copied = static_cast<Handle_t>(params[1]);
   967 	Handle_t hndl_parent = static_cast<Handle_t>(params[2]);
   968 	HandleError herr;
   969 	HandleSecurity sec;
   970 	KeyValueStack *pStk_copied, *pStk_parent;
   971 
   972 	sec.pOwner = NULL;
   973 	sec.pIdentity = g_pCoreIdent;
   974 
   975 	if ((herr=g_HandleSys.ReadHandle(hndl_copied, g_KeyValueType, &sec, (void **)&pStk_copied))
   976 		!= HandleError_None)
   977 	{
   978 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl_copied, herr);
   979 	}
   980 	if ((herr=g_HandleSys.ReadHandle(hndl_parent, g_KeyValueType, &sec, (void **)&pStk_parent))
   981 		!= HandleError_None)
   982 	{
   983 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl_parent, herr);
   984 	}
   985 
   986 	pStk_copied->pCurRoot.front()->CopySubkeys(pStk_parent->pCurRoot.front());
   987 
   988 	return 1;
   989 }
   990 
   991 static cell_t smn_GetNameSymbol(IPluginContext *pContext, const cell_t *params)
   992 {
   993 	Handle_t hndl = static_cast<Handle_t>(params[1]);
   994 	HandleError herr;
   995 	HandleSecurity sec;
   996 	KeyValueStack *pStk;
   997 	cell_t *val;
   998 	char *key;
   999 
  1000 	sec.pOwner = NULL;
  1001 	sec.pIdentity = g_pCoreIdent;
  1002 
  1003 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
  1004 		!= HandleError_None)
  1005 	{
  1006 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
  1007 	}
  1008 
  1009 	if (pStk->pCurRoot.size() < 2)
  1010 	{
  1011 		return 0;
  1012 	}
  1013 
  1014 	pContext->LocalToString(params[2], &key);
  1015 
  1016 	KeyValues *pKv = pStk->pCurRoot.front()->FindKey(key);
  1017 	if (!pKv)
  1018 	{
  1019 		return 0;
  1020 	}
  1021 	pContext->LocalToPhysAddr(params[3], &val);
  1022 	*val = pKv->GetNameSymbol();
  1023 
  1024 	return 1;
  1025 }
  1026 
  1027 static cell_t smn_FindKeyById(IPluginContext *pContext, const cell_t *params)
  1028 {
  1029 	Handle_t hndl = static_cast<Handle_t>(params[1]);
  1030 	HandleError herr;
  1031 	HandleSecurity sec;
  1032 	KeyValueStack *pStk;
  1033 
  1034 	sec.pOwner = NULL;
  1035 	sec.pIdentity = g_pCoreIdent;
  1036 
  1037 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
  1038 		!= HandleError_None)
  1039 	{
  1040 		return pContext->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
  1041 	}
  1042 
  1043 	KeyValues *pKv = pStk->pCurRoot.front()->FindKey(params[2]);
  1044 	if (!pKv)
  1045 	{
  1046 		return 0;
  1047 	}
  1048 
  1049 	pContext->StringToLocalUTF8(params[3], params[4], pKv->GetName(), NULL);
  1050 
  1051 	return 1;
  1052 }
  1053 
  1054 static cell_t smn_KvGetSectionSymbol(IPluginContext *pCtx, const cell_t *params)
  1055 {
  1056 	Handle_t hndl = static_cast<Handle_t>(params[1]);
  1057 	HandleError herr;
  1058 	HandleSecurity sec;
  1059 	KeyValueStack *pStk;
  1060 	cell_t *val;
  1061 
  1062 	sec.pOwner = NULL;
  1063 	sec.pIdentity = g_pCoreIdent;
  1064 
  1065 	if ((herr=g_HandleSys.ReadHandle(hndl, g_KeyValueType, &sec, (void **)&pStk))
  1066 		!= HandleError_None)
  1067 	{
  1068 		return pCtx->ThrowNativeError("Invalid key value handle %x (error %d)", hndl, herr);
  1069 	}
  1070 
  1071 	KeyValues *pSection = pStk->pCurRoot.front();
  1072 
  1073 	pCtx->LocalToPhysAddr(params[2], &val);
  1074 	*val = pSection->GetNameSymbol();
  1075 
  1076 	if (!*val)
  1077 	{
  1078 		return 0;
  1079 	}
  1080 
  1081 	return 1;
  1082 }
  1083 
  1084 static KeyValueNatives s_KeyValueNatives;
  1085 
  1086 REGISTER_NATIVES(keyvaluenatives)
  1087 {
  1088 	{"KvSetString",				smn_KvSetString},
  1089 	{"KvSetNum",				smn_KvSetNum},
  1090 	{"KvSetUInt64",				smn_KvSetUInt64},
  1091 	{"KvSetFloat",				smn_KvSetFloat},
  1092 	{"KvSetColor",				smn_KvSetColor},
  1093 	{"KvGetString",				smn_KvGetString},
  1094 	{"KvGetNum",				smn_KvGetNum},
  1095 	{"KvGetFloat",				smn_KvGetFloat},
  1096 	{"KvGetColor",				smn_KvGetColor},
  1097 	{"KvGetUInt64",				smn_KvGetUInt64},
  1098 	{"CreateKeyValues",			smn_CreateKeyValues},
  1099 	{"KvJumpToKey",				smn_KvJumpToKey},
  1100 	{"KvJumpToKeySymbol",		smn_KvJumpToKeySymbol},
  1101 	{"KvGotoNextKey",			smn_KvGotoNextKey},
  1102 	{"KvGotoFirstSubKey",		smn_KvGotoFirstSubKey},
  1103 	{"KvGoBack",				smn_KvGoBack},
  1104 	{"KvRewind",				smn_KvRewind},
  1105 	{"KvGetSectionName",		smn_KvGetSectionName},
  1106 	{"KvSetSectionName",		smn_KvSetSectionName},
  1107 	{"KvGetDataType",			smn_KvGetDataType},
  1108 	{"KeyValuesToFile",			smn_KeyValuesToFile},
  1109 	{"FileToKeyValues",			smn_FileToKeyValues},
  1110 	{"KvSetEscapeSequences",	smn_KvSetEscapeSequences},
  1111 	{"KvDeleteThis",			smn_KvDeleteThis},
  1112 	{"KvDeleteKey",				smn_KvDeleteKey},
  1113 	{"KvNodesInStack",			smn_KvNodesInStack},
  1114 	{"KvSavePosition",			smn_KvSavePosition},
  1115 	{"KvCopySubkeys",			smn_CopySubkeys},
  1116 	{"KvFindKeyById",			smn_FindKeyById},
  1117 	{"KvGetNameSymbol",			smn_GetNameSymbol},
  1118 	{"KvGetSectionSymbol",		smn_KvGetSectionSymbol},
  1119 	{"KvGetVector",				smn_KvGetVector},
  1120 	{"KvSetVector",				smn_KvSetVector},
  1121 	{NULL,						NULL}
  1122 };
sourcemod-central
Feed