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

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

游戏引擎

开发平台：

C++ Builder

lscript_alloc.cpp：源码内容
  1. /** 
  2.  * @file lscript_alloc.cpp
  3.  * @brief general heap management for scripting system
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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. // #define at top of file accelerates gcc compiles
  34. // Under gcc 2.9, the manual is unclear if comments can appear above #ifndef
  35. // Under gcc 3, the manual explicitly states comments can appear above the #ifndef
  37. #include "linden_common.h"
  38. #include "lscript_alloc.h"
  39. #include "llrand.h"
  41. // supported data types
  43. // basic types
  44. // integer 4 bytes of integer data
  45. // float 4 bytes of float data
  46. // string data null terminated 1 byte string
  47. // key data null terminated 1 byte string
  48. // vector data 12 bytes of 3 floats
  49. // quaternion data 16 bytes of 4 floats
  51. // list type
  52. // list data 4 bytes of number of entries followed by pointer
  54. // string pointer 4 bytes of address of string data on the heap (only used in list data)
  55. //  key pointer 4 bytes of address of key data on the heap (only used in list data)
  57. // heap format
  58. // 
  59. // 4 byte offset to next block (in bytes)
  60. // 1 byte of type of variable or empty
  61. // 2 bytes of reference count
  62. // nn bytes of data
  64. void reset_hp_to_safe_spot(const U8 *buffer)
  65. {
  66. set_register((U8 *)buffer, LREG_HP, TOP_OF_MEMORY);
  67. }
  69. // create a heap from the HR to TM
  70. BOOL lsa_create_heap(U8 *heap_start, S32 size)
  71. {
  72. LLScriptAllocEntry entry(size, LST_NULL);
  74. S32 position = 0;
  76. alloc_entry2bytestream(heap_start, position, entry);
  78. return TRUE;
  79. }
  81. S32 lsa_heap_top(U8 *heap_start, S32 maxtop)
  82. {
  83. S32 offset = 0;
  84. LLScriptAllocEntry entry;
  85. bytestream2alloc_entry(entry, heap_start, offset);
  87. while (offset + entry.mSize < maxtop)
  88. {
  89. offset += entry.mSize;
  90. bytestream2alloc_entry(entry, heap_start, offset);
  91. }
  92. return offset + entry.mSize;
  93. }
  96. // adding to heap
  97. // if block is empty
  98. // if block is at least block size + 4 larger than data
  99. // split block
  100. // insert data into first part
  101. // return address
  102. // else
  103. // insert data into block
  104. // return address
  105. // else
  106. // if next block is >= SP 
  107. // set Stack-Heap collision
  108. // return NULL
  109. // if next block is empty
  110. // merge next block with current block
  111. // go to start of algorithm
  112. // else
  113. // move to next block
  114. // go to start of algorithm
  116. S32 lsa_heap_add_data(U8 *buffer, LLScriptLibData *data, S32 heapsize, BOOL b_delete)
  117. {
  118. if (get_register(buffer, LREG_FR))
  119. return 1;
  120. LLScriptAllocEntry entry, nextentry;
  121. S32 hr = get_register(buffer, LREG_HR);
  122. S32 hp = get_register(buffer, LREG_HP);
  123. S32 current_offset, next_offset, offset = hr;
  124. S32 size = 0;
  126. switch(data->mType)
  127. {
  128. case LST_INTEGER:
  129. size = 4;
  130. break;
  131. case LST_FLOATINGPOINT:
  132. size = 4;
  133. break;
  134. case LST_KEY:
  135.         // NOTE: babbage: defensive as some library calls set data to NULL
  136.         size = data->mKey ? (S32)strlen(data->mKey) + 1 : 1; /*Flawfinder: ignore*/
  137. break;
  138. case LST_STRING:
  139.                 // NOTE: babbage: defensive as some library calls set data to NULL
  140.              size = data->mString ? (S32)strlen(data->mString) + 1 : 1; /*Flawfinder: ignore*/
  141. break;
  142. case LST_LIST:
  143. // list data 4 bytes of number of entries followed by number of pointer
  144. size = 4 + 4*data->getListLength();
  145. if (data->checkForMultipleLists())
  146. {
  147. set_fault(buffer, LSRF_NESTING_LISTS);
  148. }
  149. break;
  150. case LST_VECTOR:
  151. size = 12;
  152. break;
  153. case LST_QUATERNION:
  154. size = 16;
  155. break;
  156. default:
  157. break;
  158. }
  160. current_offset = offset;
  161. bytestream2alloc_entry(entry, buffer, offset);
  163. do
  164. {
  165. hp = get_register(buffer, LREG_HP);
  166. if (!entry.mType)
  167. {
  168. if (entry.mSize >= size + SIZEOF_SCRIPT_ALLOC_ENTRY + 4)
  169. {
  170. offset = current_offset;
  171. lsa_split_block(buffer, offset, size, entry);
  172. entry.mType = data->mType;
  173. entry.mSize = size;
  174. entry.mReferenceCount = 1;
  175. offset = current_offset;
  176. alloc_entry2bytestream(buffer, offset, entry);
  177. lsa_insert_data(buffer, offset, data, entry, heapsize);
  178. hp = get_register(buffer, LREG_HP);
  179. S32 new_hp = current_offset + size + 2*SIZEOF_SCRIPT_ALLOC_ENTRY;
  180. if (new_hp >= hr + heapsize)
  181. {
  182. break;
  183. }
  184. if (new_hp > hp)
  185. {
  186. set_register(buffer, LREG_HP, new_hp);
  187. hp = get_register(buffer, LREG_HP);
  188. }
  189. if (b_delete)
  190. delete data;
  191. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  192. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  193. if (current_offset <= hp)
  194. return current_offset - hr + 1;
  195. else
  196. return hp - hr + 1;
  197. }
  198. else if (entry.mSize >= size)
  199. {
  200. entry.mType = data->mType;
  201. entry.mReferenceCount = 1;
  202. offset = current_offset;
  203. alloc_entry2bytestream(buffer, offset, entry);
  204. lsa_insert_data(buffer, offset, data, entry, heapsize);
  205. hp = get_register(buffer, LREG_HP);
  206. if (b_delete)
  207. delete data;
  208. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  209. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  210. return current_offset - hr + 1;
  211. }
  212. }
  213. offset += entry.mSize;
  214. if (offset < hr + heapsize)
  215. {
  216. next_offset = offset;
  217. bytestream2alloc_entry(nextentry, buffer, offset);
  218. if (!nextentry.mType && !entry.mType)
  219. {
  220. entry.mSize += nextentry.mSize + SIZEOF_SCRIPT_ALLOC_ENTRY;
  221. offset = current_offset;
  222. alloc_entry2bytestream(buffer, offset, entry);
  223. }
  224. else
  225. {
  226. current_offset = next_offset;
  227. entry = nextentry;
  228. }
  230. // this works whether we are bumping out or coming in
  231. S32 new_hp = current_offset + size + 2*SIZEOF_SCRIPT_ALLOC_ENTRY;
  233. // make sure we aren't about to be stupid
  234. if (new_hp >= hr + heapsize)
  235. {
  236. break;
  237. }
  238. if (new_hp > hp)
  239. {
  240. set_register(buffer, LREG_HP, new_hp);
  241. hp = get_register(buffer, LREG_HP);
  242. }
  243. }
  244. else
  245. {
  246. break;
  247. }
  248. } while (1);
  249. set_fault(buffer, LSRF_STACK_HEAP_COLLISION);
  250. reset_hp_to_safe_spot(buffer);
  251. if (b_delete)
  252. delete data;
  253. return 0;
  254. }
  256. // split block
  257. // set offset to point to new block
  258. // set offset of new block to point to original offset - block size - data size
  259. // set new block to empty
  260. // set new block reference count to 0
  261. void lsa_split_block(U8 *buffer, S32 &offset, S32 size, LLScriptAllocEntry &entry)
  262. {
  263. if (get_register(buffer, LREG_FR))
  264. return;
  265. LLScriptAllocEntry newentry;
  267. newentry.mSize = entry.mSize - SIZEOF_SCRIPT_ALLOC_ENTRY - size;
  268. entry.mSize -= newentry.mSize + SIZEOF_SCRIPT_ALLOC_ENTRY;
  270. alloc_entry2bytestream(buffer, offset, entry);
  271. S32 orig_offset = offset + size;
  272. alloc_entry2bytestream(buffer, orig_offset, newentry);
  273. }
  275. // insert data
  276. // if data is non-list type
  277. // set type to basic type, set reference count to 1, copy data, return address
  278. // else
  279. // set type to list data type, set reference count to 1
  280. // save length of list
  281. // for each list entry
  282. // insert data
  283. // return address
  285. void lsa_insert_data(U8 *buffer, S32 &offset, LLScriptLibData *data, LLScriptAllocEntry &entry, S32 heapsize)
  286. {
  287. if (get_register(buffer, LREG_FR))
  288. return;
  289. if (data->mType != LST_LIST)
  290. {
  291. switch(data->mType)
  292. {
  293. case LST_INTEGER:
  294. integer2bytestream(buffer, offset, data->mInteger);
  295. break;
  296. case LST_FLOATINGPOINT:
  297. float2bytestream(buffer, offset, data->mFP);
  298. break;
  299. case LST_KEY:
  300.         char2bytestream(buffer, offset, data->mKey ? data->mKey : "");
  301. break;
  302. case LST_STRING:
  303.         char2bytestream(buffer, offset, data->mString ? data->mString : "");
  304. break;
  305. case LST_VECTOR:
  306. vector2bytestream(buffer, offset, data->mVec);
  307. break;
  308. case LST_QUATERNION:
  309. quaternion2bytestream(buffer, offset, data->mQuat);
  310. break;
  311. default:
  312. break;
  313. }
  314. }
  315. else
  316. {
  317. // store length of list
  318. integer2bytestream(buffer, offset, data->getListLength());
  319. data = data->mListp;
  320. while(data)
  321. {
  322. // store entry and then store address if valid
  323. S32 address = lsa_heap_add_data(buffer, data, heapsize, FALSE);
  324. integer2bytestream(buffer, offset, address);
  325. data = data->mListp;
  326. }
  327. }
  328. }
  330. S32 lsa_create_data_block(U8 **buffer, LLScriptLibData *data, S32 base_offset)
  331. {
  332. S32 offset = 0;
  333. S32 size = 0;
  335. LLScriptAllocEntry entry;
  337. if (!data)
  338. {
  339. entry.mType = LST_NULL;
  340. entry.mReferenceCount = 0;
  341. entry.mSize = MAX_HEAP_SIZE;
  342. size = SIZEOF_SCRIPT_ALLOC_ENTRY;
  343. *buffer = new U8[size];
  344. alloc_entry2bytestream(*buffer, offset, entry);
  345. return size;
  346. }
  348. entry.mType = data->mType;
  349. entry.mReferenceCount = 1;
  351. if (data->mType != LST_LIST)
  352. {
  353. if (  (data->mType != LST_STRING)
  354. &&(data->mType != LST_KEY))
  355. {
  356. size = LSCRIPTDataSize[data->mType];
  357. }
  358. else
  359. {
  360. if (data->mType == LST_STRING)
  361. {
  362. if (data->mString)
  363. {
  364. size = (S32)strlen(data->mString) + 1; /*Flawfinder: ignore*/
  365. }
  366. else
  367. {
  368. size = 1;
  369. }
  370. }
  371. if (data->mType == LST_KEY)
  372. {
  373. if (data->mKey)
  374. {
  375. size = (S32)strlen(data->mKey) + 1; /*Flawfinder: ignore*/
  376. }
  377. else
  378. {
  379. size = 1;
  380. }
  381. }
  382. }
  383. entry.mSize = size;
  384. size += SIZEOF_SCRIPT_ALLOC_ENTRY;
  385. *buffer = new U8[size];
  386. alloc_entry2bytestream(*buffer, offset, entry);
  388. switch(data->mType)
  389. {
  390. case LST_INTEGER:
  391. integer2bytestream(*buffer, offset, data->mInteger);
  392. break;
  393. case LST_FLOATINGPOINT:
  394. float2bytestream(*buffer, offset, data->mFP);
  395. break;
  396. case LST_KEY:
  397. if (data->mKey)
  398. char2bytestream(*buffer, offset, data->mKey);
  399. else
  400. byte2bytestream(*buffer, offset, 0);
  401. break;
  402. case LST_STRING:
  403. if (data->mString)
  404. char2bytestream(*buffer, offset, data->mString);
  405. else
  406. byte2bytestream(*buffer, offset, 0);
  407. break;
  408. case LST_VECTOR:
  409. vector2bytestream(*buffer, offset, data->mVec);
  410. break;
  411. case LST_QUATERNION:
  412. quaternion2bytestream(*buffer, offset, data->mQuat);
  413. break;
  414. default:
  415. break;
  416. }
  417. }
  418. else
  419. {
  420. U8 *listbuf;
  421. S32 length = data->getListLength();
  422. size = 4 * length + 4;
  423. entry.mSize = size;
  425. size += SIZEOF_SCRIPT_ALLOC_ENTRY;
  426. *buffer = new U8[size];
  428. alloc_entry2bytestream(*buffer, offset, entry);
  429. // store length of list
  430. integer2bytestream(*buffer, offset, length);
  431. data = data->mListp;
  432. while(data)
  433. {
  434. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  435. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  436. integer2bytestream(*buffer, offset, size + base_offset + 1);
  438. S32 listsize = lsa_create_data_block(&listbuf, data, base_offset + size);
  439. if (listsize)
  440. {
  441. U8 *tbuff = new U8[size + listsize];
  442. if (tbuff == NULL)
  443. {
  444. llerrs << "Memory Allocation Failed" << llendl;
  445. }
  446. memcpy(tbuff, *buffer, size); /*Flawfinder: ignore*/
  447. memcpy(tbuff + size, listbuf, listsize); /*Flawfinder: ignore*/
  448. size += listsize;
  449. delete [] *buffer;
  450. delete [] listbuf;
  451. *buffer = tbuff;
  452. }
  453. data = data->mListp;
  454. }
  455. }
  456. return size;
  457. }
  459. // increase reference count
  460. // increase reference count by 1
  462. void lsa_increase_ref_count(U8 *buffer, S32 offset)
  463. {
  464. if (get_register(buffer, LREG_FR))
  465. return;
  466. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  467. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  468. offset += get_register(buffer, LREG_HR) - 1;
  469. if (  (offset < get_register(buffer, LREG_HR))
  470. ||(offset >= get_register(buffer, LREG_HP)))
  471. {
  472. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  473. return;
  474. }
  475. S32 orig_offset = offset;
  476. LLScriptAllocEntry entry;
  477. bytestream2alloc_entry(entry, buffer, offset);
  479. entry.mReferenceCount++;
  481. alloc_entry2bytestream(buffer, orig_offset, entry);
  482. }
  484. // decrease reference count
  485. // decrease reference count by 1
  486. // if reference count == 0
  487. // set type to empty
  489. void lsa_decrease_ref_count(U8 *buffer, S32 offset)
  490. {
  491. if (get_register(buffer, LREG_FR))
  492. return;
  493. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  494. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  495. offset += get_register(buffer, LREG_HR) - 1;
  496. if (  (offset < get_register(buffer, LREG_HR))
  497. ||(offset >= get_register(buffer, LREG_HP)))
  498. {
  499. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  500. return;
  501. }
  502. S32 orig_offset = offset;
  503. LLScriptAllocEntry entry;
  504. bytestream2alloc_entry(entry, buffer, offset);
  506. entry.mReferenceCount--;
  508. if (entry.mReferenceCount < 0)
  509. {
  510. entry.mReferenceCount = 0;
  511. set_fault(buffer, LSRF_HEAP_ERROR);
  512. }
  513. else if (!entry.mReferenceCount)
  514. {
  515. if (entry.mType == LST_LIST)
  516. {
  517. S32 i, num = bytestream2integer(buffer, offset);
  518. for (i = 0; i < num; i++)
  519. {
  520. S32 list_offset = bytestream2integer(buffer, offset);
  521. lsa_decrease_ref_count(buffer, list_offset);
  522. }
  523. }
  524. entry.mType = LST_NULL;
  525. }
  527. alloc_entry2bytestream(buffer, orig_offset, entry);
  528. }
  530. char gLSAStringRead[TOP_OF_MEMORY]; /*Flawfinder: ignore*/
  533. LLScriptLibData *lsa_get_data(U8 *buffer, S32 &offset, BOOL b_dec_ref)
  534. {
  535. if (get_register(buffer, LREG_FR))
  536. return (new LLScriptLibData);
  537. S32 orig_offset = offset;
  538. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  539. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  540. offset += get_register(buffer, LREG_HR) - 1;
  541. if (  (offset < get_register(buffer, LREG_HR))
  542. ||(offset >= get_register(buffer, LREG_HP)))
  543. {
  544. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  545. return (new LLScriptLibData);
  546. }
  547. LLScriptAllocEntry entry;
  548. bytestream2alloc_entry(entry, buffer, offset);
  550. LLScriptLibData *retval = new LLScriptLibData;
  552. if (!entry.mType)
  553. {
  554. set_fault(buffer, LSRF_HEAP_ERROR);
  555. return retval;
  556. }
  558. retval->mType = (LSCRIPTType)entry.mType;
  559. if (entry.mType != LST_LIST)
  560. {
  561. switch(entry.mType)
  562. {
  563. case LST_INTEGER:
  564. retval->mInteger = bytestream2integer(buffer, offset);
  565. break;
  566. case LST_FLOATINGPOINT:
  567. retval->mFP = bytestream2float(buffer, offset);
  568. break;
  569. case LST_KEY:
  570. bytestream2char(gLSAStringRead, buffer, offset, sizeof(gLSAStringRead)); // global sring buffer? for real? :(
  571. retval->mKey = new char[strlen(gLSAStringRead) + 1]; /*Flawfinder: ignore*/
  572. strcpy(retval->mKey, gLSAStringRead); /*Flawfinder: ignore*/
  573. break;
  574. case LST_STRING:
  575. bytestream2char(gLSAStringRead, buffer, offset, sizeof(gLSAStringRead));
  576. retval->mString = new char[strlen(gLSAStringRead) + 1]; /*Flawfinder: ignore*/
  577. strcpy(retval->mString, gLSAStringRead); /*Flawfinder: ignore*/
  578. break;
  579. case LST_VECTOR:
  580. bytestream2vector(retval->mVec, buffer, offset);
  581. break;
  582. case LST_QUATERNION:
  583. bytestream2quaternion(retval->mQuat, buffer, offset);
  584. break;
  585. default:
  586. break;
  587. }
  588. }
  589. else
  590. {
  591. // get length of list
  592. S32 i, length = bytestream2integer(buffer, offset);
  593. LLScriptLibData *tip = retval;
  595. for (i = 0; i < length; i++)
  596. {
  597. S32 address = bytestream2integer(buffer, offset);
  598. tip->mListp = lsa_get_data(buffer, address, FALSE);
  599. tip = tip->mListp;
  600. }
  601. }
  602. if (retval->checkForMultipleLists())
  603. {
  604. set_fault(buffer, LSRF_NESTING_LISTS);
  605. }
  606. if (b_dec_ref)
  607. {
  608. lsa_decrease_ref_count(buffer, orig_offset);
  609. }
  610. return retval;
  611. }
  613. LLScriptLibData *lsa_get_list_ptr(U8 *buffer, S32 &offset, BOOL b_dec_ref)
  614. {
  615. if (get_register(buffer, LREG_FR))
  616. return (new LLScriptLibData);
  617. S32 orig_offset = offset;
  618. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  619. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  620. offset += get_register(buffer, LREG_HR) - 1;
  621. if (  (offset < get_register(buffer, LREG_HR))
  622. ||(offset >= get_register(buffer, LREG_HP)))
  623. {
  624. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  625. return (new LLScriptLibData);
  626. }
  627. LLScriptAllocEntry entry;
  628. bytestream2alloc_entry(entry, buffer, offset);
  630. if (!entry.mType)
  631. {
  632. set_fault(buffer, LSRF_HEAP_ERROR);
  633. return NULL;
  634. }
  636. LLScriptLibData base, *tip = &base;
  638. if (entry.mType != LST_LIST)
  639. {
  640. return NULL;
  641. }
  642. else
  643. {
  644. // get length of list
  645. S32 i, length = bytestream2integer(buffer, offset);
  647. for (i = 0; i < length; i++)
  648. {
  649. S32 address = bytestream2integer(buffer, offset);
  650. tip->mListp = lsa_get_data(buffer, address, FALSE);
  651. tip = tip->mListp;
  652. }
  653. }
  654. if (b_dec_ref)
  655. {
  656. lsa_decrease_ref_count(buffer, orig_offset);
  657. }
  658. tip = base.mListp;
  659. base.mListp = NULL;
  660. return tip;
  661. }
  663. S32 lsa_cat_strings(U8 *buffer, S32 offset1, S32 offset2, S32 heapsize)
  664. {
  665. if (get_register(buffer, LREG_FR))
  666. return 0;
  667. LLScriptLibData *string1;
  668. LLScriptLibData *string2;
  669. if (offset1 != offset2)
  670. {
  671. string1 = lsa_get_data(buffer, offset1, TRUE);
  672. string2 = lsa_get_data(buffer, offset2, TRUE);
  673. }
  674. else
  675. {
  676. string1 = lsa_get_data(buffer, offset1, TRUE);
  677. string2 = lsa_get_data(buffer, offset2, TRUE);
  678. }
  680. if (  (!string1)
  681. ||(!string2))
  682. {
  683. set_fault(buffer, LSRF_HEAP_ERROR);
  684. delete string1;
  685. delete string2;
  686. return 0;
  687. }
  689. char *test1 = NULL, *test2 = NULL;
  691. if (string1->mType == LST_STRING)
  692. {
  693. test1 = string1->mString;
  694. }
  695. else if (string1->mType == LST_KEY)
  696. {
  697. test1 = string1->mKey;
  698. }
  699. if (string2->mType == LST_STRING)
  700. {
  701. test2 = string2->mString;
  702. }
  703. else if (string2->mType == LST_KEY)
  704. {
  705. test2 = string2->mKey;
  706. }
  708. if (  (!test1)
  709. ||(!test2))
  710. {
  711. set_fault(buffer, LSRF_HEAP_ERROR);
  712. delete string1;
  713. delete string2;
  714. return 0;
  715. }
  717. S32 size = (S32)strlen(test1) + (S32)strlen(test2) + 1; /*Flawfinder: ignore*/
  719. LLScriptLibData *string3 = new LLScriptLibData;
  720. string3->mType = LST_STRING;
  721. string3->mString = new char[size];
  722. strcpy(string3->mString, test1); /*Flawfinder: ignore*/
  723. strcat(string3->mString, test2); /*Flawfinder: ignore*/
  725. delete string1;
  726. delete string2;
  728. return lsa_heap_add_data(buffer, string3, heapsize, TRUE);
  729. }
  731. S32 lsa_cmp_strings(U8 *buffer, S32 offset1, S32 offset2)
  732. {
  733. if (get_register(buffer, LREG_FR))
  734. return 0;
  735. LLScriptLibData *string1;
  736. LLScriptLibData *string2;
  738. string1 = lsa_get_data(buffer, offset1, TRUE);
  739. string2 = lsa_get_data(buffer, offset2, TRUE);
  741. if (  (!string1)
  742. ||(!string2))
  743. {
  744. set_fault(buffer, LSRF_HEAP_ERROR);
  745. delete string1;
  746. delete string2;
  747. return 0;
  748. }
  750. char *test1 = NULL, *test2 = NULL;
  752. if (string1->mType == LST_STRING)
  753. {
  754. test1 = string1->mString;
  755. }
  756. else if (string1->mType == LST_KEY)
  757. {
  758. test1 = string1->mKey;
  759. }
  760. if (string2->mType == LST_STRING)
  761. {
  762. test2 = string2->mString;
  763. }
  764. else if (string2->mType == LST_KEY)
  765. {
  766. test2 = string2->mKey;
  767. }
  769. if (  (!test1)
  770. ||(!test2))
  771. {
  772. set_fault(buffer, LSRF_HEAP_ERROR);
  773. delete string1;
  774. delete string2;
  775. return 0;
  776. }
  777. S32 retval = strcmp(test1, test2);
  779. delete string1;
  780. delete string2;
  782. return retval;
  783. }
  785. void lsa_print_heap(U8 *buffer)
  786. {
  787. S32 offset = get_register(buffer, LREG_HR);
  788. S32 readoffset;
  789. S32 ivalue;
  790. F32 fpvalue;
  791. LLVector3 vvalue;
  792. LLQuaternion qvalue;
  793. char string[4096]; /*Flawfinder: ignore*/
  795. LLScriptAllocEntry entry;
  797. bytestream2alloc_entry(entry, buffer, offset);
  799. printf("HP: [0x%X]n", get_register(buffer, LREG_HP));
  800. printf("==========n");
  802. while (offset + entry.mSize < MAX_HEAP_SIZE)
  803. {
  804. printf("[0x%X] ", offset);
  805. printf("%s ", LSCRIPTTypeNames[entry.mType]);
  806. printf("Ref Count: %d ", entry.mReferenceCount);
  807. printf("Size: %d = ", entry.mSize);
  809. readoffset = offset;
  811. switch(entry.mType)
  812. {
  813. case LST_INTEGER:
  814. ivalue = bytestream2integer(buffer, readoffset);
  815. printf("%dn", ivalue);
  816. break;
  817. case LST_FLOATINGPOINT:
  818. fpvalue = bytestream2float(buffer, readoffset);
  819. printf("%fn", fpvalue);
  820. break;
  821. case LST_STRING:
  822. bytestream2char(string, buffer, readoffset, sizeof(string));
  823. printf("%sn", string);
  824. break;
  825. case LST_KEY:
  826. bytestream2char(string, buffer, readoffset, sizeof(string));
  827. printf("%sn", string);
  828. break;
  829. case LST_VECTOR:
  830. bytestream2vector(vvalue, buffer, readoffset);
  831. printf("< %f, %f, %f >n", vvalue.mV[VX], vvalue.mV[VY], vvalue.mV[VZ]);
  832. break;
  833. case LST_QUATERNION:
  834. bytestream2quaternion(qvalue, buffer, readoffset);
  835. printf("< %f, %f, %f, %f >n", qvalue.mQ[VX], qvalue.mQ[VY], qvalue.mQ[VZ], qvalue.mQ[VS]);
  836. break;
  837. case LST_LIST:
  838. ivalue = bytestream2integer(buffer, readoffset);
  839. printf("%dn", ivalue);
  840. break;
  841. default:
  842. printf("n");
  843. break;
  844. }
  845. offset += entry.mSize;
  846. bytestream2alloc_entry(entry, buffer, offset);
  847. }
  848. printf("[0x%X] ", offset);
  849. printf("%s ", LSCRIPTTypeNames[entry.mType]);
  850. printf("Ref Count: %d ", entry.mReferenceCount);
  851. printf("Size: %dn", entry.mSize);
  852. printf("==========n");
  853. }
  855. void lsa_fprint_heap(U8 *buffer, LLFILE *fp)
  856. {
  857. S32 offset = get_register(buffer, LREG_HR);
  858. S32 readoffset;
  859. S32 ivalue;
  860. F32 fpvalue;
  861. LLVector3 vvalue;
  862. LLQuaternion qvalue;
  863. char string[4096]; /*Flawfinder: ignore*/
  865. LLScriptAllocEntry entry;
  867. bytestream2alloc_entry(entry, buffer, offset);
  869. while (offset + entry.mSize < MAX_HEAP_SIZE)
  870. {
  871. fprintf(fp, "[0x%X] ", offset);
  872. fprintf(fp, "%s ", LSCRIPTTypeNames[entry.mType]);
  873. fprintf(fp, "Ref Count: %d ", entry.mReferenceCount);
  874. fprintf(fp, "Size: %d = ", entry.mSize);
  876. readoffset = offset;
  878. switch(entry.mType)
  879. {
  880. case LST_INTEGER:
  881. ivalue = bytestream2integer(buffer, readoffset);
  882. fprintf(fp, "%dn", ivalue);
  883. break;
  884. case LST_FLOATINGPOINT:
  885. fpvalue = bytestream2float(buffer, readoffset);
  886. fprintf(fp, "%fn", fpvalue);
  887. break;
  888. case LST_STRING:
  889. bytestream2char(string, buffer, readoffset, sizeof(string));
  890. fprintf(fp, "%sn", string);
  891. break;
  892. case LST_KEY:
  893. bytestream2char(string, buffer, readoffset, sizeof(string));
  894. fprintf(fp, "%sn", string);
  895. break;
  896. case LST_VECTOR:
  897. bytestream2vector(vvalue, buffer, readoffset);
  898. fprintf(fp, "< %f, %f, %f >n", vvalue.mV[VX], vvalue.mV[VY], vvalue.mV[VZ]);
  899. break;
  900. case LST_QUATERNION:
  901. bytestream2quaternion(qvalue, buffer, readoffset);
  902. fprintf(fp, "< %f, %f, %f, %f >n", qvalue.mQ[VX], qvalue.mQ[VY], qvalue.mQ[VZ], qvalue.mQ[VS]);
  903. break;
  904. case LST_LIST:
  905. ivalue = bytestream2integer(buffer, readoffset);
  906. fprintf(fp, "%dn", ivalue);
  907. break;
  908. default:
  909. fprintf(fp, "n");
  910. break;
  911. }
  912. offset += entry.mSize;
  913. bytestream2alloc_entry(entry, buffer, offset);
  914. }
  915. fprintf(fp, "[0x%X] ", offset);
  916. fprintf(fp, "%s ", LSCRIPTTypeNames[entry.mType]);
  917. fprintf(fp, "Ref Count: %d ", entry.mReferenceCount);
  918. fprintf(fp, "Size: %d", entry.mSize);
  919. fprintf(fp, "n");
  920. }
  922. S32 lsa_cat_lists(U8 *buffer, S32 offset1, S32 offset2, S32 heapsize)
  923. {
  924. if (get_register(buffer, LREG_FR))
  925. return 0;
  926. LLScriptLibData *list1;
  927. LLScriptLibData *list2;
  928. if (offset1 != offset2)
  929. {
  930. list1 = lsa_get_data(buffer, offset1, TRUE);
  931. list2 = lsa_get_data(buffer, offset2, TRUE);
  932. }
  933. else
  934. {
  935. list1 = lsa_get_data(buffer, offset1, TRUE);
  936. list2 = lsa_get_data(buffer, offset2, TRUE);
  937. }
  939. if (  (!list1)
  940. ||(!list2))
  941. {
  942. set_fault(buffer, LSRF_HEAP_ERROR);
  943. delete list1;
  944. delete list2;
  945. return 0;
  946. }
  948. if (  (list1->mType != LST_LIST)
  949. ||(list2->mType != LST_LIST))
  950. {
  951. set_fault(buffer, LSRF_HEAP_ERROR);
  952. delete list1;
  953. delete list2;
  954. return 0;
  955. }
  957. LLScriptLibData *runner = list1;
  959. while (runner->mListp)
  960. {
  961. runner = runner->mListp;
  962. }
  964. runner->mListp = list2->mListp;
  966. list2->mListp = NULL;
  968. delete list2;
  970. return lsa_heap_add_data(buffer, list1, heapsize, TRUE);
  971. }
  974. S32 lsa_cmp_lists(U8 *buffer, S32 offset1, S32 offset2)
  975. {
  976. if (get_register(buffer, LREG_FR))
  977. return 0;
  978. LLScriptLibData *list1;
  979. LLScriptLibData *list2;
  980. if (offset1 != offset2)
  981. {
  982. list1 = lsa_get_data(buffer, offset1, TRUE);
  983. list2 = lsa_get_data(buffer, offset2, TRUE);
  984. }
  985. else
  986. {
  987. list1 = lsa_get_data(buffer, offset1, FALSE);
  988. list2 = lsa_get_data(buffer, offset2, TRUE);
  989. }
  991. if (  (!list1)
  992. ||(!list2))
  993. {
  994. set_fault(buffer, LSRF_HEAP_ERROR);
  995. delete list1;
  996. delete list2;
  997. return 0;
  998. }
  1000. if (  (list1->mType != LST_LIST)
  1001. ||(list2->mType != LST_LIST))
  1002. {
  1003. set_fault(buffer, LSRF_HEAP_ERROR);
  1004. delete list1;
  1005. delete list2;
  1006. return 0;
  1007. }
  1009. S32 length1 = list1->getListLength();
  1010. S32 length2 = list2->getListLength();
  1011. delete list1;
  1012. delete list2;
  1013. return length1 - length2;
  1014. }
  1017. S32 lsa_preadd_lists(U8 *buffer, LLScriptLibData *data, S32 offset2, S32 heapsize)
  1018. {
  1019. if (get_register(buffer, LREG_FR))
  1020. return 0;
  1021. LLScriptLibData *list2 = lsa_get_data(buffer, offset2, TRUE);
  1023. if (!list2)
  1024. {
  1025. set_fault(buffer, LSRF_HEAP_ERROR);
  1026. delete list2;
  1027. return 0;
  1028. }
  1030. if (list2->mType != LST_LIST)
  1031. {
  1032. set_fault(buffer, LSRF_HEAP_ERROR);
  1033. delete list2;
  1034. return 0;
  1035. }
  1037. LLScriptLibData *runner = data->mListp;
  1039. while (runner->mListp)
  1040. {
  1041. runner = runner->mListp;
  1042. }
  1045. runner->mListp = list2->mListp;
  1046. list2->mListp = data->mListp;
  1048. return lsa_heap_add_data(buffer, list2, heapsize, TRUE);
  1049. }
  1052. S32 lsa_postadd_lists(U8 *buffer, S32 offset1, LLScriptLibData *data, S32 heapsize)
  1053. {
  1054. if (get_register(buffer, LREG_FR))
  1055. return 0;
  1056. LLScriptLibData *list1 = lsa_get_data(buffer, offset1, TRUE);
  1058. if (!list1)
  1059. {
  1060. set_fault(buffer, LSRF_HEAP_ERROR);
  1061. delete list1;
  1062. return 0;
  1063. }
  1065. if (list1->mType != LST_LIST)
  1066. {
  1067. set_fault(buffer, LSRF_HEAP_ERROR);
  1068. delete list1;
  1069. return 0;
  1070. }
  1072. LLScriptLibData *runner = list1;
  1074. while (runner->mListp)
  1075. {
  1076. runner = runner->mListp;
  1077. }
  1079. runner->mListp = data->mListp;
  1081. return lsa_heap_add_data(buffer, list1, heapsize, TRUE);
  1082. }
  1085. LLScriptLibData* lsa_randomize(LLScriptLibData* src, S32 stride)
  1086. {
  1087. S32 number = src->getListLength();
  1088. if (number <= 0)
  1089. {
  1090. return NULL;
  1091. }
  1092. if (stride <= 0)
  1093. {
  1094. stride = 1;
  1095. }
  1096. if(number % stride)
  1097. {
  1098. LLScriptLibData* retval = src->mListp;
  1099. src->mListp = NULL;
  1100. return retval;
  1101. }
  1102. S32 buckets = number / stride;
  1104. // Copy everything into a special vector for sorting;
  1105. std::vector<LLScriptLibData*> sort_array;
  1106. sort_array.reserve(number);
  1107. LLScriptLibData* temp = src->mListp;
  1108. while(temp)
  1109. {
  1110. sort_array.push_back(temp);
  1111. temp = temp->mListp;
  1112. }
  1114. // We cannot simply call random_shuffle or similar algorithm since
  1115. // we need to obey the stride. So, we iterate over what we have
  1116. // and swap each with a random other segment.
  1117. S32 index = 0;
  1118. S32 ii = 0;
  1119. for(; ii < number; ii += stride)
  1120. {
  1121. index = ll_rand(buckets) * stride;
  1122. for(S32 jj = 0; jj < stride; ++jj)
  1123. {
  1124. std::swap(sort_array[ii + jj], sort_array[index + jj]);
  1125. }
  1126. }
  1128. // copy the pointers back out
  1129. ii = 1;
  1130. temp = sort_array[0];
  1131. while (ii < number)
  1132. {
  1133. temp->mListp = sort_array[ii++];
  1134. temp = temp->mListp;
  1135. }
  1136. temp->mListp = NULL;
  1138. src->mListp = NULL;
  1140. LLScriptLibData* ret_value = sort_array[0];
  1141. return ret_value;
  1142. }