开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
llnamevalue.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：21k
源码类别：

游戏引擎

开发平台：

C++ Builder

llnamevalue.cpp：源码内容
  1. /** 
  2.  * @file llnamevalue.cpp
  3.  * @brief class for defining name value pairs.
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. // Examples:
  34. // AvatarCharacter STRING RW DSV male1
  36. #include "linden_common.h"
  38. #include "llnamevalue.h"
  40. #include "u64.h"
  41. #include "llstring.h"
  42. #include "string_table.h"
  44. // Anonymous enumeration to provide constants in this file.
  45. // *NOTE: These values may be used in sscanf statements below as their
  46. // value-1, so search for '2047' if you cange NV_BUFFER_LEN or '63' if
  47. // you change U64_BUFFER_LEN.
  48. enum
  49. {
  50. NV_BUFFER_LEN = 2048,
  51. U64_BUFFER_LEN = 64
  52. };
  54. LLStringTable gNVNameTable(256);
  56. char NameValueTypeStrings[NVT_EOF][NAME_VALUE_TYPE_STRING_LENGTH] = /*Flawfinder: Ignore*/
  57. {
  58. "NULL",
  59. "STRING",
  60. "F32",
  61. "S32",
  62. "VEC3",
  63. "U32",
  64. "CAMERA", // Deprecated, but leaving in case removing completely would cause problems
  65. "ASSET",
  66. "U64"
  67. };
  69. char NameValueClassStrings[NVC_EOF][NAME_VALUE_CLASS_STRING_LENGTH] = /*Flawfinder: Ignore*/
  70. {
  71. "NULL",
  72. "R", // read only
  73. "RW" // read write
  74. };
  76. char NameValueSendtoStrings[NVS_EOF][NAME_VALUE_SENDTO_STRING_LENGTH] = /*Flawfinder: Ignore*/
  77. {
  78. "NULL",
  79. "S", // "Sim", formerly SIM
  80. "DS", // "Data Sim" formerly SIM_SPACE
  81. "SV", // "Sim Viewer" formerly SIM_VIEWER
  82. "DSV" // "Data Sim Viewer", formerly SIM_SPACE_VIEWER
  83. }; /*Flawfinder: Ignore*/
  86. //
  87. // Class
  88. //
  90. LLNameValue::LLNameValue()
  91. {
  92. baseInit();
  93. }
  95. void LLNameValue::baseInit()
  96. {
  97. mNVNameTable = &gNVNameTable;
  99. mName = NULL;
  100. mNameValueReference.string = NULL;
  102. mType = NVT_NULL;
  103. mStringType = NameValueTypeStrings[NVT_NULL];
  105. mClass = NVC_NULL;
  106. mStringClass = NameValueClassStrings[NVC_NULL];
  108. mSendto = NVS_NULL;
  109. mStringSendto = NameValueSendtoStrings[NVS_NULL];
  110. }
  112. void LLNameValue::init(const char *name, const char *data, const char *type, const char *nvclass, const char *nvsendto)
  113. {
  114. mNVNameTable = &gNVNameTable;
  116. mName = mNVNameTable->addString(name);
  118. // Nota Bene: Whatever global structure manages this should have these in the name table already!
  119. mStringType = mNVNameTable->addString(type);
  120. if (!strcmp(mStringType, "STRING"))
  121. {
  122. S32 string_length = (S32)strlen(data); /*Flawfinder: Ignore*/
  123. mType = NVT_STRING;
  125. delete[] mNameValueReference.string;
  127. // two options here. . .  data can either look like foo or "foo"
  128. // WRONG! - this is a poorly implemented and incomplete escape
  129. // mechanism. For example, using this scheme, there is no way
  130. // to tell an intentional double quotes from a zero length
  131. // string. This needs to excised. Phoenix
  132. //if (strchr(data, '"'))
  133. //{
  134. // string_length -= 2;
  135. // mNameValueReference.string = new char[string_length + 1];;
  136. // strncpy(mNameValueReference.string, data + 1, string_length);
  137. //}
  138. //else
  139. //{
  140. mNameValueReference.string = new char[string_length + 1];;
  141. strncpy(mNameValueReference.string, data, string_length); /*Flawfinder: Ignore*/
  142. //}
  143. mNameValueReference.string[string_length] = 0;
  144. }
  145. else if (!strcmp(mStringType, "F32"))
  146. {
  147. mType = NVT_F32;
  148. mNameValueReference.f32 = new F32((F32)atof(data));
  149. }
  150. else if (!strcmp(mStringType, "S32"))
  151. {
  152. mType = NVT_S32;
  153. mNameValueReference.s32 = new S32(atoi(data));
  154. }
  155. else if (!strcmp(mStringType, "U64"))
  156. {
  157. mType = NVT_U64;
  158. mNameValueReference.u64 = new U64(str_to_U64(ll_safe_string(data)));
  159. }
  160. else if (!strcmp(mStringType, "VEC3"))
  161. {
  162. mType = NVT_VEC3;
  163. F32 t1, t2, t3;
  165. // two options here. . .  data can either look like 0, 1, 2 or <0, 1, 2>
  167. if (strchr(data, '<'))
  168. {
  169. sscanf(data, "<%f, %f, %f>", &t1, &t2, &t3);
  170. }
  171. else
  172. {
  173. sscanf(data, "%f, %f, %f", &t1, &t2, &t3);
  174. }
  176. // finite checks
  177. if (!llfinite(t1) || !llfinite(t2) || !llfinite(t3))
  178. {
  179. t1 = 0.f;
  180. t2 = 0.f;
  181. t3 = 0.f;
  182. }
  184. mNameValueReference.vec3 = new LLVector3(t1, t2, t3);
  185. }
  186. else if (!strcmp(mStringType, "U32"))
  187. {
  188. mType = NVT_U32;
  189. mNameValueReference.u32 = new U32(atoi(data));
  190. }
  191. else if(!strcmp(mStringType, (const char*)NameValueTypeStrings[NVT_ASSET]))
  192. {
  193. // assets are treated like strings, except that the name has
  194. // meaning to an LLAssetInfo object
  195. S32 string_length = (S32)strlen(data); /*Flawfinder: Ignore*/
  196. mType = NVT_ASSET;
  198. // two options here. . .  data can either look like foo or "foo"
  199. // WRONG! - this is a poorly implemented and incomplete escape
  200. // mechanism. For example, using this scheme, there is no way
  201. // to tell an intentional double quotes from a zero length
  202. // string. This needs to excised. Phoenix
  203. //if (strchr(data, '"'))
  204. //{
  205. // string_length -= 2;
  206. // mNameValueReference.string = new char[string_length + 1];;
  207. // strncpy(mNameValueReference.string, data + 1, string_length);
  208. //}
  209. //else
  210. //{
  211. mNameValueReference.string = new char[string_length + 1];;
  212. strncpy(mNameValueReference.string, data, string_length); /*Flawfinder: Ignore*/
  213. //}
  214. mNameValueReference.string[string_length] = 0;
  215. }
  216. else
  217. {
  218. llwarns << "Unknown name value type string " << mStringType << " for " << mName << llendl;
  219. mType = NVT_NULL;
  220. }
  223. // Nota Bene: Whatever global structure manages this should have these in the name table already!
  224. if (!strcmp(nvclass, "R") ||
  225. !strcmp(nvclass, "READ_ONLY")) // legacy
  226. {
  227. mClass = NVC_READ_ONLY;
  228. mStringClass = mNVNameTable->addString("R");
  229. }
  230. else if (!strcmp(nvclass, "RW") ||
  231. !strcmp(nvclass, "READ_WRITE")) // legacy
  232. {
  233. mClass = NVC_READ_WRITE;
  234. mStringClass = mNVNameTable->addString("RW");
  235. }
  236. else
  237. {
  238. // assume it's bad
  239. mClass = NVC_NULL;
  240. mStringClass = mNVNameTable->addString(nvclass);
  241. }
  243. // Initialize the sendto variable
  244. if (!strcmp(nvsendto, "S") ||
  245. !strcmp(nvsendto, "SIM")) // legacy
  246. {
  247. mSendto = NVS_SIM;
  248. mStringSendto = mNVNameTable->addString("S");
  249. }
  250. else if (!strcmp(nvsendto, "DS") ||
  251. !strcmp(nvsendto, "SIM_SPACE")) // legacy
  252. {
  253. mSendto = NVS_DATA_SIM;
  254. mStringSendto = mNVNameTable->addString("DS");
  255. }
  256. else if (!strcmp(nvsendto, "SV") ||
  257. !strcmp(nvsendto, "SIM_VIEWER")) // legacy
  258. {
  259. mSendto = NVS_SIM_VIEWER;
  260. mStringSendto = mNVNameTable->addString("SV");
  261. }
  262. else if (!strcmp(nvsendto, "DSV") ||
  263. !strcmp(nvsendto, "SIM_SPACE_VIEWER")) // legacy
  264. {
  265. mSendto = NVS_DATA_SIM_VIEWER;
  266. mStringSendto = mNVNameTable->addString("DSV");
  267. }
  268. else
  269. {
  270. llwarns << "LLNameValue::init() - unknown sendto field " 
  271. << nvsendto << " for NV " << mName << llendl;
  272. mSendto = NVS_NULL;
  273. mStringSendto = mNVNameTable->addString("S");
  274. }
  276. }
  279. LLNameValue::LLNameValue(const char *name, const char *data, const char *type, const char *nvclass)
  280. {
  281. baseInit();
  282. // if not specified, send to simulator only
  283. init(name, data, type, nvclass, "SIM");
  284. }
  287. LLNameValue::LLNameValue(const char *name, const char *data, const char *type, const char *nvclass, const char *nvsendto)
  288. {
  289. baseInit();
  290. init(name, data, type, nvclass, nvsendto);
  291. }
  295. // Initialize without any initial data.
  296. LLNameValue::LLNameValue(const char *name, const char *type, const char *nvclass)
  297. {
  298. baseInit();
  299. mName = mNVNameTable->addString(name);
  301. // Nota Bene: Whatever global structure manages this should have these in the name table already!
  302. mStringType = mNVNameTable->addString(type);
  303. if (!strcmp(mStringType, "STRING"))
  304. {
  305. mType = NVT_STRING;
  306. mNameValueReference.string = NULL;
  307. }
  308. else if (!strcmp(mStringType, "F32"))
  309. {
  310. mType = NVT_F32;
  311. mNameValueReference.f32 = NULL;
  312. }
  313. else if (!strcmp(mStringType, "S32"))
  314. {
  315. mType = NVT_S32;
  316. mNameValueReference.s32 = NULL;
  317. }
  318. else if (!strcmp(mStringType, "VEC3"))
  319. {
  320. mType = NVT_VEC3;
  321. mNameValueReference.vec3 = NULL;
  322. }
  323. else if (!strcmp(mStringType, "U32"))
  324. {
  325. mType = NVT_U32;
  326. mNameValueReference.u32 = NULL;
  327. }
  328. else if (!strcmp(mStringType, "U64"))
  329. {
  330. mType = NVT_U64;
  331. mNameValueReference.u64 = NULL;
  332. }
  333. else if(!strcmp(mStringType, (const char*)NameValueTypeStrings[NVT_ASSET]))
  334. {
  335. mType = NVT_ASSET;
  336. mNameValueReference.string = NULL;
  337. }
  338. else
  339. {
  340. mType = NVT_NULL;
  341. llinfos << "Unknown name-value type " << mStringType << llendl;
  342. }
  344. // Nota Bene: Whatever global structure manages this should have these in the name table already!
  345. mStringClass = mNVNameTable->addString(nvclass);
  346. if (!strcmp(mStringClass, "READ_ONLY"))
  347. {
  348. mClass = NVC_READ_ONLY;
  349. }
  350. else if (!strcmp(mStringClass, "READ_WRITE"))
  351. {
  352. mClass = NVC_READ_WRITE;
  353. }
  354. else
  355. {
  356. mClass = NVC_NULL;
  357. }
  359. // Initialize the sendto variable
  360. mStringSendto = mNVNameTable->addString("SIM");
  361. mSendto = NVS_SIM;
  362. }
  365. // data is in the format:
  366. // "NameValueName Type Class Data"
  367. LLNameValue::LLNameValue(const char *data)
  368. {
  369. baseInit();
  370. static char name[NV_BUFFER_LEN]; /*Flawfinder: ignore*/
  371. static char type[NV_BUFFER_LEN]; /*Flawfinder: ignore*/
  372. static char nvclass[NV_BUFFER_LEN]; /*Flawfinder: ignore*/
  373. static char nvsendto[NV_BUFFER_LEN]; /*Flawfinder: ignore*/
  374. static char nvdata[NV_BUFFER_LEN]; /*Flawfinder: ignore*/
  376. S32 i;
  378. S32 character_count = 0;
  379. S32 length = 0;
  381. // go to first non-whitespace character
  382. while (1)
  383. {
  384. if (  (*(data + character_count) == ' ')
  385. ||(*(data + character_count) == 'n')
  386. ||(*(data + character_count) == 't')
  387. ||(*(data + character_count) == 'r'))
  388. {
  389. character_count++;
  390. }
  391. else
  392. {
  393. break;
  394. }
  395. }
  397. // read in the name
  398. sscanf((data + character_count), "%2047s", name); /*Flawfinder: ignore*/
  400. // bump past it and add null terminator
  401. length = (S32)strlen(name); /* Flawfinder: ignore */
  402. name[length] = 0;
  403. character_count += length;
  405. // go to the next non-whitespace character
  406. while (1)
  407. {
  408. if (  (*(data + character_count) == ' ')
  409. ||(*(data + character_count) == 'n')
  410. ||(*(data + character_count) == 't')
  411. ||(*(data + character_count) == 'r'))
  412. {
  413. character_count++;
  414. }
  415. else
  416. {
  417. break;
  418. }
  419. }
  421. // read in the type
  422. sscanf((data + character_count), "%2047s", type); /*Flawfinder: ignore*/
  424. // bump past it and add null terminator
  425. length = (S32)strlen(type); /* Flawfinder: ignore */
  426. type[length] = 0;
  427. character_count += length;
  429. // go to the next non-whitespace character
  430. while (1)
  431. {
  432. if (  (*(data + character_count) == ' ')
  433. ||(*(data + character_count) == 'n')
  434. ||(*(data + character_count) == 't')
  435. ||(*(data + character_count) == 'r'))
  436. {
  437. character_count++;
  438. }
  439. else
  440. {
  441. break;
  442. }
  443. }
  445. // do we have a type argument?
  446. for (i = NVC_READ_ONLY; i < NVC_EOF; i++)
  447. {
  448. if (!strncmp(NameValueClassStrings[i], data + character_count, strlen(NameValueClassStrings[i]))) /* Flawfinder: ignore */
  449. {
  450. break;
  451. }
  452. }
  454. if (i != NVC_EOF)
  455. {
  456. // yes we do!
  457. // read in the class
  458. sscanf((data + character_count), "%2047s", nvclass); /*Flawfinder: ignore*/
  460. // bump past it and add null terminator
  461. length = (S32)strlen(nvclass); /* Flawfinder: ignore */
  462. nvclass[length] = 0;
  463. character_count += length;
  465. // go to the next non-whitespace character
  466. while (1)
  467. {
  468. if (  (*(data + character_count) == ' ')
  469. ||(*(data + character_count) == 'n')
  470. ||(*(data + character_count) == 't')
  471. ||(*(data + character_count) == 'r'))
  472. {
  473. character_count++;
  474. }
  475. else
  476. {
  477. break;
  478. }
  479. }
  480. }
  481. else
  482. {
  483. // no type argument given, default to read-write
  484. strncpy(nvclass, "READ_WRITE", sizeof(nvclass) -1); /* Flawfinder: ignore */
  485. nvclass[sizeof(nvclass) -1] = '';
  486. }
  488. // Do we have a sendto argument?
  489. for (i = NVS_SIM; i < NVS_EOF; i++)
  490. {
  491. if (!strncmp(NameValueSendtoStrings[i], data + character_count, strlen(NameValueSendtoStrings[i]))) /* Flawfinder: ignore */
  492. {
  493. break;
  494. }
  495. }
  497. if (i != NVS_EOF)
  498. {
  499. // found a sendto argument
  500. sscanf((data + character_count), "%2047s", nvsendto); /*Flawfinder: ignore*/
  502. // add null terminator
  503. length = (S32)strlen(nvsendto); /* Flawfinder: ignore */
  504. nvsendto[length] = 0;
  505. character_count += length;
  507. // seek to next non-whitespace characer
  508. while (1)
  509. {
  510. if (  (*(data + character_count) == ' ')
  511. ||(*(data + character_count) == 'n')
  512. ||(*(data + character_count) == 't')
  513. ||(*(data + character_count) == 'r'))
  514. {
  515. character_count++;
  516. }
  517. else
  518. {
  519. break;
  520. }
  521. }
  522. }
  523. else
  524. {
  525. // no sendto argument given, default to sim only
  526. strncpy(nvsendto, "SIM", sizeof(nvsendto) -1); /* Flawfinder: ignore */
  527. nvsendto[sizeof(nvsendto) -1] ='';
  528. }
  531. // copy the rest character by character into data
  532. length = 0;
  534. while ( (*(nvdata + length++) = *(data + character_count++)) )
  535. ;
  537. init(name, nvdata, type, nvclass, nvsendto);
  538. }
  541. LLNameValue::~LLNameValue()
  542. {
  543. mNVNameTable->removeString(mName);
  544. mName = NULL;
  546. switch(mType)
  547. {
  548. case NVT_STRING:
  549. case NVT_ASSET:
  550. delete [] mNameValueReference.string;
  551. mNameValueReference.string = NULL;
  552. break;
  553. case NVT_F32:
  554. delete mNameValueReference.f32;
  555. mNameValueReference.string = NULL;
  556. break;
  557. case NVT_S32:
  558. delete mNameValueReference.s32;
  559. mNameValueReference.string = NULL;
  560. break;
  561. case NVT_VEC3:
  562. delete mNameValueReference.vec3;
  563. mNameValueReference.string = NULL;
  564. break;
  565. case NVT_U32:
  566. delete mNameValueReference.u32;
  567. mNameValueReference.u32 = NULL;
  568. break;
  569. case NVT_U64:
  570. delete mNameValueReference.u64;
  571. mNameValueReference.u64 = NULL;
  572. break;
  573. default:
  574. break;
  575. }
  577. delete[] mNameValueReference.string;
  578. mNameValueReference.string = NULL;
  579. }
  581. char *LLNameValue::getString()
  582. {
  583. if (mType == NVT_STRING)
  584. {
  585. return mNameValueReference.string;
  586. }
  587. else
  588. {
  589. llerrs << mName << " not a string!" << llendl;
  590. return NULL;
  591. }
  592. }
  594. const char *LLNameValue::getAsset() const
  595. {
  596. if (mType == NVT_ASSET)
  597. {
  598. return mNameValueReference.string;
  599. }
  600. else
  601. {
  602. llerrs << mName << " not an asset!" << llendl;
  603. return NULL;
  604. }
  605. }
  607. F32 *LLNameValue::getF32()
  608. {
  609. if (mType == NVT_F32)
  610. {
  611. return mNameValueReference.f32;
  612. }
  613. else
  614. {
  615. llerrs << mName << " not a F32!" << llendl;
  616. return NULL;
  617. }
  618. }
  620. S32 *LLNameValue::getS32()
  621. {
  622. if (mType == NVT_S32)
  623. {
  624. return mNameValueReference.s32;
  625. }
  626. else
  627. {
  628. llerrs << mName << " not a S32!" << llendl;
  629. return NULL;
  630. }
  631. }
  633. U32 *LLNameValue::getU32()
  634. {
  635. if (mType == NVT_U32)
  636. {
  637. return mNameValueReference.u32;
  638. }
  639. else
  640. {
  641. llerrs << mName << " not a U32!" << llendl;
  642. return NULL;
  643. }
  644. }
  646. U64 *LLNameValue::getU64()
  647. {
  648. if (mType == NVT_U64)
  649. {
  650. return mNameValueReference.u64;
  651. }
  652. else
  653. {
  654. llerrs << mName << " not a U64!" << llendl;
  655. return NULL;
  656. }
  657. }
  659. void LLNameValue::getVec3(LLVector3 &vec)
  660. {
  661. if (mType == NVT_VEC3)
  662. {
  663. vec = *mNameValueReference.vec3;
  664. }
  665. else
  666. {
  667. llerrs << mName << " not a Vec3!" << llendl;
  668. }
  669. }
  671. LLVector3 *LLNameValue::getVec3()
  672. {
  673. if (mType == NVT_VEC3)
  674. {
  675.  return (mNameValueReference.vec3);
  676. }
  677. else
  678. {
  679. llerrs << mName << " not a Vec3!" << llendl;
  680. return NULL;
  681. }
  682. }
  685. BOOL LLNameValue::sendToData() const
  686. {
  687. return (mSendto == NVS_DATA_SIM || mSendto == NVS_DATA_SIM_VIEWER);
  688. }
  691. BOOL LLNameValue::sendToViewer() const
  692. {
  693. return (mSendto == NVS_SIM_VIEWER || mSendto == NVS_DATA_SIM_VIEWER);
  694. }
  697. LLNameValue &LLNameValue::operator=(const LLNameValue &a)
  698. {
  699. if (mType != a.mType)
  700. {
  701. return *this;
  702. }
  703. if (mClass == NVC_READ_ONLY)
  704. return *this;
  706. switch(a.mType)
  707. {
  708. case NVT_STRING:
  709. case NVT_ASSET:
  710. if (mNameValueReference.string)
  711. delete [] mNameValueReference.string;
  713. mNameValueReference.string = new char [strlen(a.mNameValueReference.string) + 1]; /* Flawfinder: ignore */
  714. if(mNameValueReference.string != NULL)
  715. {
  716. strcpy(mNameValueReference.string, a.mNameValueReference.string); /* Flawfinder: ignore */
  717. }
  718. break;
  719. case NVT_F32:
  720. *mNameValueReference.f32 = *a.mNameValueReference.f32;
  721. break;
  722. case NVT_S32:
  723. *mNameValueReference.s32 = *a.mNameValueReference.s32;
  724. break;
  725. case NVT_VEC3:
  726. *mNameValueReference.vec3 = *a.mNameValueReference.vec3;
  727. break;
  728. case NVT_U32:
  729. *mNameValueReference.u32 = *a.mNameValueReference.u32;
  730. break;
  731. case NVT_U64:
  732. *mNameValueReference.u64 = *a.mNameValueReference.u64;
  733. break;
  734. default:
  735. llerrs << "Unknown Name value type " << (U32)a.mType << llendl;
  736. break;
  737. }
  739. return *this;
  740. }
  742. void LLNameValue::setString(const char *a)
  743. {
  744. if (mClass == NVC_READ_ONLY)
  745. return;
  747. switch(mType)
  748. {
  749. case NVT_STRING:
  750. if (a)
  751. {
  752. if (mNameValueReference.string)
  753. {
  754. delete [] mNameValueReference.string;
  755. }
  757. mNameValueReference.string = new char [strlen(a) + 1]; /* Flawfinder: ignore */
  758. if(mNameValueReference.string != NULL)
  759. {
  760. strcpy(mNameValueReference.string,  a); /* Flawfinder: ignore */
  761. }
  762. }
  763. else
  764. {
  765. if (mNameValueReference.string)
  766. delete [] mNameValueReference.string;
  768. mNameValueReference.string = new char [1];
  769. mNameValueReference.string[0] = 0;
  770. }
  771. break;
  772. default:
  773. break;
  774. }
  776. return;
  777. }
  780. void LLNameValue::setAsset(const char *a)
  781. {
  782. if (mClass == NVC_READ_ONLY)
  783. return;
  785. switch(mType)
  786. {
  787. case NVT_ASSET:
  788. if (a)
  789. {
  790. if (mNameValueReference.string)
  791. {
  792. delete [] mNameValueReference.string;
  793. }
  794. mNameValueReference.string = new char [strlen(a) + 1]; /* Flawfinder: ignore */
  795. if(mNameValueReference.string != NULL)
  796. {
  797. strcpy(mNameValueReference.string,  a); /* Flawfinder: ignore */
  798. }
  799. }
  800. else
  801. {
  802. if (mNameValueReference.string)
  803. delete [] mNameValueReference.string;
  805. mNameValueReference.string = new char [1];
  806. mNameValueReference.string[0] = 0;
  807. }
  808. break;
  809. default:
  810. break;
  811. }
  812. }
  815. void LLNameValue::setF32(const F32 a)
  816. {
  817. if (mClass == NVC_READ_ONLY)
  818. return;
  820. switch(mType)
  821. {
  822. case NVT_F32:
  823. *mNameValueReference.f32 = a;
  824. break;
  825. default:
  826. break;
  827. }
  829. return;
  830. }
  833. void LLNameValue::setS32(const S32 a)
  834. {
  835. if (mClass == NVC_READ_ONLY)
  836. return;
  838. switch(mType)
  839. {
  840. case NVT_S32:
  841. *mNameValueReference.s32 = a;
  842. break;
  843. case NVT_U32:
  844. *mNameValueReference.u32 = a;
  845. break;
  846. case NVT_F32:
  847. *mNameValueReference.f32 = (F32)a;
  848. break;
  849. default:
  850. break;
  851. }
  853. return;
  854. }
  857. void LLNameValue::setU32(const U32 a)
  858. {
  859. if (mClass == NVC_READ_ONLY)
  860. return;
  862. switch(mType)
  863. {
  864. case NVT_S32:
  865. *mNameValueReference.s32 = a;
  866. break;
  867. case NVT_U32:
  868. *mNameValueReference.u32 = a;
  869. break;
  870. case NVT_F32:
  871. *mNameValueReference.f32 = (F32)a;
  872. break;
  873. default:
  874. llerrs << "NameValue: Trying to set U32 into a " << mStringType << ", unknown conversion" << llendl;
  875. break;
  876. }
  877. return;
  878. }
  881. void LLNameValue::setVec3(const LLVector3 &a)
  882. {
  883. if (mClass == NVC_READ_ONLY)
  884. return;
  886. switch(mType)
  887. {
  888. case NVT_VEC3:
  889. *mNameValueReference.vec3 = a;
  890. break;
  891. default:
  892. llerrs << "NameValue: Trying to set LLVector3 into a " << mStringType << ", unknown conversion" << llendl;
  893. break;
  894. }
  895. return;
  896. }
  899. std::string LLNameValue::printNameValue() const
  900. {
  901. std::string buffer;
  902. buffer = llformat("%s %s %s %s ", mName, mStringType, mStringClass, mStringSendto);
  903. buffer += printData();
  904. // llinfos << "Name Value Length: " << buffer.size() + 1 << llendl;
  905. return buffer;
  906. }
  908. std::string LLNameValue::printData() const
  909. {
  910. std::string buffer;
  911. switch(mType)
  912. {
  913. case NVT_STRING:
  914. case NVT_ASSET:
  915. buffer = mNameValueReference.string;
  916. break;
  917. case NVT_F32:
  918. buffer = llformat("%f", *mNameValueReference.f32);
  919. break;
  920. case NVT_S32:
  921. buffer = llformat("%d", *mNameValueReference.s32);
  922. break;
  923. case NVT_U32:
  924.    buffer = llformat("%u", *mNameValueReference.u32);
  925. break;
  926. case NVT_U64:
  927. {
  928. char u64_string[U64_BUFFER_LEN]; /* Flawfinder: ignore */
  929. U64_to_str(*mNameValueReference.u64, u64_string, sizeof(u64_string));
  930. buffer = u64_string;
  931. }
  932. break;
  933. case NVT_VEC3:
  934.    buffer = llformat( "%f, %f, %f", mNameValueReference.vec3->mV[VX], mNameValueReference.vec3->mV[VY], mNameValueReference.vec3->mV[VZ]);
  935. break;
  936. default:
  937. llerrs << "Trying to print unknown NameValue type " << mStringType << llendl;
  938. break;
  939. }
  940. return buffer;
  941. }
  943. std::ostream& operator<<(std::ostream& s, const LLNameValue &a)
  944. {
  945. switch(a.mType)
  946. {
  947. case NVT_STRING:
  948. case NVT_ASSET:
  949. s << a.mNameValueReference.string;
  950. break;
  951. case NVT_F32:
  952. s << (*a.mNameValueReference.f32);
  953. break;
  954. case NVT_S32:
  955. s << *(a.mNameValueReference.s32);
  956. break;
  957. case NVT_U32:
  958. s << *(a.mNameValueReference.u32);
  959. break;
  960. case NVT_U64:
  961. {
  962. char u64_string[U64_BUFFER_LEN]; /* Flawfinder: ignore */
  963. U64_to_str(*a.mNameValueReference.u64, u64_string, sizeof(u64_string));
  964. s << u64_string;
  965. }
  966. break;
  967. case NVT_VEC3:
  968. s << *(a.mNameValueReference.vec3);
  969. break;
  970. default:
  971. llerrs << "Trying to print unknown NameValue type " << a.mStringType << llendl;
  972. break;
  973. }
  974. return s;
  975. }