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

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

游戏引擎

开发平台：

C++ Builder

lscript_byteconvert.h：源码内容
  1. /** 
  2.  * @file lscript_byteconvert.h
  3.  * @brief Shared code for compiler and assembler for LSL
  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. // data shared between compiler/assembler
  34. // used to convert data between byte stream and outside data types
  36. #ifndef LL_LSCRIPT_BYTECONVERT_H
  37. #define LL_LSCRIPT_BYTECONVERT_H
  39. #include "stdtypes.h"
  40. #include "v3math.h"
  41. #include "llquaternion.h"
  42. #include "lscript_byteformat.h"
  43. #include "lluuid.h"
  45. void reset_hp_to_safe_spot(const U8 *buffer);
  47. // remember that LScript byte stream is BigEndian
  48. void set_fault(const U8 *stream, LSCRIPTRunTimeFaults fault);
  50. inline S32 bytestream2integer(const U8 *stream, S32 &offset)
  51. {
  52. stream += offset;
  53. offset += 4;
  54. return (*stream<<24) | (*(stream + 1)<<16) | (*(stream + 2)<<8) | *(stream + 3);
  55. }
  57. inline U32 bytestream2unsigned_integer(const U8 *stream, S32 &offset)
  58. {
  59. stream += offset;
  60. offset += 4;
  61. return (*stream<<24) | (*(stream + 1)<<16) | (*(stream + 2)<<8) | *(stream + 3);
  62. }
  64. inline U64 bytestream2u64(const U8 *stream, S32 &offset)
  65. {
  66. stream += offset;
  67. offset += 8;
  68. return ((U64)(*stream)<<56)| ((U64)(*(stream + 1))<<48) | ((U64)(*(stream + 2))<<40) | ((U64)(*(stream + 3))<<32) | 
  69.    ((U64)(*(stream + 4))<<24) | ((U64)(*(stream + 5))<<16) | ((U64)(*(stream + 6))<<8) | (U64)(*(stream + 7));
  70. }
  72. inline void integer2bytestream(U8 *stream, S32 &offset, S32 integer)
  73. {
  74. stream += offset;
  75. offset += 4;
  76. *(stream) = (integer >> 24);
  77. *(stream + 1) = (integer >> 16) & 0xff;
  78. *(stream + 2) = (integer >> 8) & 0xff;
  79. *(stream + 3) = (integer) & 0xff;
  80. }
  82. inline void unsigned_integer2bytestream(U8 *stream, S32 &offset, U32 integer)
  83. {
  84. stream += offset;
  85. offset += 4;
  86. *(stream) = (integer >> 24);
  87. *(stream + 1) = (integer >> 16) & 0xff;
  88. *(stream + 2) = (integer >> 8) & 0xff;
  89. *(stream + 3) = (integer) & 0xff;
  90. }
  91. inline void u642bytestream(U8 *stream, S32 &offset, U64 integer)
  92. {
  93. stream += offset;
  94. offset += 8;
  95. *(stream) = (U8)(integer >> 56);
  96. *(stream + 1) = (U8)((integer >> 48) & 0xff);
  97. *(stream + 2) = (U8)((integer >> 40) & 0xff);
  98. *(stream + 3) = (U8)((integer >> 32) & 0xff);
  99. *(stream + 4) = (U8)((integer >> 24) & 0xff);
  100. *(stream + 5) = (U8)((integer >> 16) & 0xff);
  101. *(stream + 6) = (U8)((integer >> 8) & 0xff);
  102. *(stream + 7) = (U8)((integer) & 0xff);
  103. }
  105. inline S16 bytestream2s16(const U8 *stream, S32 &offset)
  106. {
  107. stream += offset;
  108. offset += 2;
  109. return (*stream<<8) | *(stream + 1);
  110. }
  112. inline void s162bytestream(U8 *stream, S32 &offset, S16 integer)
  113. {
  114. stream += offset;
  115. offset += 2;
  116. *(stream) = (integer >> 8);
  117. *(stream + 1) = (integer) & 0xff;
  118. }
  120. inline U16 bytestream2u16(const U8 *stream, S32 &offset)
  121. {
  122. stream += offset;
  123. offset += 2;
  124. return (*stream<<8) | *(stream + 1);
  125. }
  127. inline void u162bytestream(U8 *stream, S32 &offset, U16 integer)
  128. {
  129. stream += offset;
  130. offset += 2;
  131. *(stream) = (integer >> 8);
  132. *(stream + 1) = (integer) & 0xff;
  133. }
  135. inline F32 bytestream2float(const U8 *stream, S32 &offset)
  136. {
  137. S32 value = bytestream2integer(stream, offset);
  138. F32 fpvalue = *(F32 *)&value;
  139. if (!llfinite(fpvalue))
  140. {
  141. fpvalue = 0;
  142. set_fault(stream, LSRF_MATH);
  143. }
  144. return fpvalue;
  145. }
  147. inline void float2bytestream(U8 *stream, S32 &offset, F32 floatingpoint)
  148. {
  149. S32 value = *(S32 *)&floatingpoint;
  150. integer2bytestream(stream, offset, value);
  151. }
  153. inline void bytestream_int2float(U8 *stream, S32 &offset)
  154. {
  155. S32 value = bytestream2integer(stream, offset);
  156. offset -= 4;
  157. F32 fpvalue = (F32)value;
  158. if (!llfinite(fpvalue))
  159. {
  160. fpvalue = 0;
  161. set_fault(stream, LSRF_MATH);
  162. }
  163. float2bytestream(stream, offset, fpvalue);
  164. }
  166. // Returns true on success, return false and clip copy on buffer overflow
  167. inline bool bytestream2char(char *buffer, const U8 *stream, S32 &offset, S32 buffsize)
  168. {
  169. S32 source_len = strlen( (const char *)stream+offset );
  170. S32 copy_len = buffsize - 1;
  171. if( copy_len > source_len )
  172. {
  173. copy_len = source_len;
  174. }
  176. // strncpy without  padding overhead
  177. memcpy( buffer, stream+offset, copy_len );
  178. buffer[copy_len] = 0;
  180. offset += source_len + 1; // advance past source string, include terminating ''
  182. return source_len < buffsize;
  183. }
  185. inline void char2bytestream(U8 *stream, S32 &offset, const char *buffer)
  186. {
  187. while ((*(stream + offset++) = *buffer++))
  188. ;
  189. }
  191. inline U8 bytestream2byte(const U8 *stream, S32 &offset)
  192. {
  193. return *(stream + offset++);
  194. }
  196. inline void byte2bytestream(U8 *stream, S32 &offset, U8 byte)
  197. {
  198. *(stream + offset++) = byte;
  199. }
  201. inline void bytestream2bytestream(U8 *dest, S32 &dest_offset, const U8 *src, S32 &src_offset, S32 count)
  202. {
  203. while (count)
  204. {
  205. (*(dest + dest_offset++)) = (*(src + src_offset++));
  206. count--;
  207. }
  208. }
  210. inline void uuid2bytestream(U8 *stream, S32 &offset, const LLUUID &uuid)
  211. {
  212. S32 i;
  213. for (i = 0; i < UUID_BYTES; i++)
  214. {
  215. *(stream + offset++) = uuid.mData[i];
  216. }
  217. }
  219. inline void bytestream2uuid(U8 *stream, S32 &offset, LLUUID &uuid)
  220. {
  221. S32 i;
  222. for (i = 0; i < UUID_BYTES; i++)
  223. {
  224. uuid.mData[i] = *(stream + offset++);
  225. }
  226. }
  228. // vectors and quaternions and encoded in backwards order to match the way in which they are stored on the stack
  229. inline void bytestream2vector(LLVector3 &vector, const U8 *stream, S32 &offset)
  230. {
  231. S32 value = bytestream2integer(stream, offset);
  232. vector.mV[VZ] = *(F32 *)&value;
  233. if (!llfinite(vector.mV[VZ]))
  234. {
  235. vector.mV[VZ] = 0;
  236. set_fault(stream, LSRF_MATH);
  237. }
  238. value = bytestream2integer(stream, offset);
  239. vector.mV[VY] = *(F32 *)&value;
  240. if (!llfinite(vector.mV[VY]))
  241. {
  242. vector.mV[VY] = 0;
  243. set_fault(stream, LSRF_MATH);
  244. }
  245. value = bytestream2integer(stream, offset);
  246. vector.mV[VX] = *(F32 *)&value;
  247. if (!llfinite(vector.mV[VX]))
  248. {
  249. vector.mV[VX] = 0;
  250. set_fault(stream, LSRF_MATH);
  251. }
  252. }
  254. inline void vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &vector)
  255. {
  256. S32 value = *(S32 *)&vector.mV[VZ];
  257. integer2bytestream(stream, offset, value);
  258. value = *(S32 *)&vector.mV[VY];
  259. integer2bytestream(stream, offset, value);
  260. value = *(S32 *)&vector.mV[VX];
  261. integer2bytestream(stream, offset, value);
  262. }
  264. inline void bytestream2quaternion(LLQuaternion &quat, const U8 *stream, S32 &offset)
  265. {
  266. S32 value = bytestream2integer(stream, offset);
  267. quat.mQ[VS] = *(F32 *)&value;
  268. if (!llfinite(quat.mQ[VS]))
  269. {
  270. quat.mQ[VS] = 0;
  271. set_fault(stream, LSRF_MATH);
  272. }
  273. value = bytestream2integer(stream, offset);
  274. quat.mQ[VZ] = *(F32 *)&value;
  275. if (!llfinite(quat.mQ[VZ]))
  276. {
  277. quat.mQ[VZ] = 0;
  278. set_fault(stream, LSRF_MATH);
  279. }
  280. value = bytestream2integer(stream, offset);
  281. quat.mQ[VY] = *(F32 *)&value;
  282. if (!llfinite(quat.mQ[VY]))
  283. {
  284. quat.mQ[VY] = 0;
  285. set_fault(stream, LSRF_MATH);
  286. }
  287. value = bytestream2integer(stream, offset);
  288. quat.mQ[VX] = *(F32 *)&value;
  289. if (!llfinite(quat.mQ[VX]))
  290. {
  291. quat.mQ[VX] = 0;
  292. set_fault(stream, LSRF_MATH);
  293. }
  294. }
  296. inline void quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &quat)
  297. {
  298. S32 value = *(S32 *)&quat.mQ[VS];
  299. integer2bytestream(stream, offset, value);
  300. value = *(S32 *)&quat.mQ[VZ];
  301. integer2bytestream(stream, offset, value);
  302. value = *(S32 *)&quat.mQ[VY];
  303. integer2bytestream(stream, offset, value);
  304. value = *(S32 *)&quat.mQ[VX];
  305. integer2bytestream(stream, offset, value);
  306. }
  308. inline S32 get_register(const U8 *stream, LSCRIPTRegisters reg)
  309. {
  310. S32 offset = gLSCRIPTRegisterAddresses[reg];
  311. return bytestream2integer(stream, offset);
  312. }
  314. inline F32 get_register_fp(U8 *stream, LSCRIPTRegisters reg)
  315. {
  316. S32 offset = gLSCRIPTRegisterAddresses[reg];
  317. F32 value = bytestream2float(stream, offset);
  318. if (!llfinite(value))
  319. {
  320. value = 0;
  321. set_fault(stream, LSRF_MATH);
  322. }
  323. return value;
  324. }
  325. inline U64 get_register_u64(U8 *stream, LSCRIPTRegisters reg)
  326. {
  327. S32 offset = gLSCRIPTRegisterAddresses[reg];
  328. return bytestream2u64(stream, offset);
  329. }
  331. inline U64 get_event_register(U8 *stream, LSCRIPTRegisters reg, S32 major_version)
  332. {
  333. if (major_version == 1)
  334. {
  335. S32 offset = gLSCRIPTRegisterAddresses[reg];
  336. return (U64)bytestream2integer(stream, offset);
  337. }
  338. else if (major_version == 2)
  339. {
  340. S32 offset = gLSCRIPTRegisterAddresses[reg + (LREG_NCE - LREG_CE)];
  341. return bytestream2u64(stream, offset);
  342. }
  343. else
  344. {
  345. S32 offset = gLSCRIPTRegisterAddresses[reg];
  346. return (U64)bytestream2integer(stream, offset);
  347. }
  348. }
  350. inline void set_register(U8 *stream, LSCRIPTRegisters reg, S32 value)
  351. {
  352. S32 offset = gLSCRIPTRegisterAddresses[reg];
  353. integer2bytestream(stream, offset, value);
  354. }
  356. inline void set_register_fp(U8 *stream, LSCRIPTRegisters reg, F32 value)
  357. {
  358. S32 offset = gLSCRIPTRegisterAddresses[reg];
  359. float2bytestream(stream, offset, value);
  360. }
  362. inline void set_register_u64(U8 *stream, LSCRIPTRegisters reg, U64 value)
  363. {
  364. S32 offset = gLSCRIPTRegisterAddresses[reg];
  365. u642bytestream(stream, offset, value);
  366. }
  368. inline void set_event_register(U8 *stream, LSCRIPTRegisters reg, U64 value, S32 major_version)
  369. {
  370. if (major_version == 1)
  371. {
  372. S32 offset = gLSCRIPTRegisterAddresses[reg];
  373. integer2bytestream(stream, offset, (S32)value);
  374. }
  375. else if (major_version == 2)
  376. {
  377. S32 offset = gLSCRIPTRegisterAddresses[reg + (LREG_NCE - LREG_CE)];
  378. u642bytestream(stream, offset, value);
  379. }
  380. else
  381. {
  382. S32 offset = gLSCRIPTRegisterAddresses[reg];
  383. integer2bytestream(stream, offset, (S32)value);
  384. }
  385. }
  388. inline F32 add_register_fp(U8 *stream, LSCRIPTRegisters reg, F32 value)
  389. {
  390. S32 offset = gLSCRIPTRegisterAddresses[reg];
  391. F32 newvalue = bytestream2float(stream, offset);
  392. newvalue += value;
  393. if (!llfinite(newvalue))
  394. {
  395. newvalue = 0;
  396. set_fault(stream, LSRF_MATH);
  397. }
  398. offset = gLSCRIPTRegisterAddresses[reg];
  399. float2bytestream(stream, offset, newvalue);
  400. return newvalue;
  401. }
  403. void lsa_print_heap(U8 *buffer);
  406. inline void set_fault(const U8 *stream, LSCRIPTRunTimeFaults fault)
  407. {
  408.    S32 fr = get_register(stream, LREG_FR);
  409.    // record the first error
  410.    if (!fr)
  411.    {
  412.    if (  (fault == LSRF_HEAP_ERROR)
  413.    ||(fault == LSRF_STACK_HEAP_COLLISION)
  414.    ||(fault == LSRF_BOUND_CHECK_ERROR))
  415.    {
  416. reset_hp_to_safe_spot(stream);
  417. //     lsa_print_heap((U8 *)stream);
  418.    }
  419.        fr = fault;
  420.        set_register((U8 *)stream, LREG_FR, fr);
  421.    }
  422. }
  424. inline BOOL set_ip(U8 *stream, S32 ip)
  425. {
  426. // Verify that the Instruction Pointer is in a valid
  427. // code area (between the Global Function Register
  428. // and Heap Register).
  429. S32 gfr = get_register(stream, LREG_GFR);
  430. if (ip == 0)
  431. {
  432. set_register(stream, LREG_IP, ip);
  433. return TRUE;
  434. }
  435. if (ip < gfr)
  436. {
  437. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  438. return FALSE;
  439. }
  440. S32 hr = get_register(stream, LREG_HR);
  441. if (ip >= hr)
  442. {
  443. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  444. return FALSE;
  445. }
  446. set_register(stream, LREG_IP, ip);
  447. return TRUE;
  448. }
  450. inline BOOL set_bp(U8 *stream, S32 bp)
  451. {
  452. // Verify that the Base Pointer is in a valid
  453. // data area (between the Heap Pointer and
  454. // the Top of Memory, and below the
  455. // Stack Pointer).
  456. S32 hp = get_register(stream, LREG_HP);
  457. if (bp <= hp)
  458. {
  459. set_fault(stream, LSRF_STACK_HEAP_COLLISION);
  460. return FALSE;
  461. }
  462. S32 tm = get_register(stream, LREG_TM);
  463. if (bp >= tm)
  464. {
  465. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  466. return FALSE;
  467. }
  468. S32 sp = get_register(stream, LREG_SP);
  469. if (bp < sp)
  470. {
  471. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  472. return FALSE;
  473. }
  474. set_register(stream, LREG_BP, bp);
  475. return TRUE;
  476. }
  478. inline BOOL set_sp(U8 *stream, S32 sp)
  479. {
  480. // Verify that the Stack Pointer is in a valid
  481. // data area (between the Heap Pointer and
  482. // the Top of Memory).
  483. S32 hp = get_register(stream, LREG_HP);
  484. if (sp <= hp)
  485. {
  486. set_fault(stream, LSRF_STACK_HEAP_COLLISION);
  487. return FALSE;
  488. }
  489. S32 tm = get_register(stream, LREG_TM);
  490. if (sp >= tm)
  491. {
  492. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  493. return FALSE;
  494. }
  495. set_register(stream, LREG_SP, sp);
  496. return TRUE;
  497. }
  499. inline void lscript_push(U8 *stream, U8 value)
  500. {
  501. S32 sp = get_register(stream, LREG_SP);
  502. sp -= 1;
  504. if (set_sp(stream, sp))
  505. {
  506. *(stream + sp) = value;
  507. }
  508. }
  510. inline void lscript_push(U8 *stream, S32 value)
  511. {
  512. S32 sp = get_register(stream, LREG_SP);
  513. sp -= LSCRIPTDataSize[LST_INTEGER];
  515. if (set_sp(stream, sp))
  516. {
  517. integer2bytestream(stream, sp, value);
  518. }
  519. }
  521. inline void lscript_push(U8 *stream, F32 value)
  522. {
  523. S32 sp = get_register(stream, LREG_SP);
  524. sp -= LSCRIPTDataSize[LST_FLOATINGPOINT];
  526. if (set_sp(stream, sp))
  527. {
  528. float2bytestream(stream, sp, value);
  529. }
  530. }
  532. inline void lscript_push(U8 *stream, const LLVector3 &value)
  533. {
  534. S32 sp = get_register(stream, LREG_SP);
  535. sp -= LSCRIPTDataSize[LST_VECTOR];
  537. if (set_sp(stream, sp))
  538. {
  539. vector2bytestream(stream, sp, value);
  540. }
  541. }
  543. inline void lscript_push(U8 *stream, const LLQuaternion &value)
  544. {
  545. S32 sp = get_register(stream, LREG_SP);
  546. sp -= LSCRIPTDataSize[LST_QUATERNION];
  548. if (set_sp(stream, sp))
  549. {
  550. quaternion2bytestream(stream, sp, value);
  551. }
  552. }
  554. inline void lscript_pusharg(U8 *stream, S32 arg)
  555. {
  556. S32 sp = get_register(stream, LREG_SP);
  557. sp -= arg;
  559. set_sp(stream, sp);
  560. }
  562. inline void lscript_poparg(U8 *stream, S32 arg)
  563. {
  564. S32 sp = get_register(stream, LREG_SP);
  565. sp += arg;
  567. set_sp(stream, sp);
  568. }
  570. inline U8 lscript_pop_char(U8 *stream)
  571. {
  572. S32 sp = get_register(stream, LREG_SP);
  573. U8 value = *(stream + sp++);
  574. set_sp(stream, sp);
  575. return value;
  576. }
  578. inline S32 lscript_pop_int(U8 *stream)
  579. {
  580. S32 sp = get_register(stream, LREG_SP);
  581. S32 value = bytestream2integer(stream, sp);
  582. set_sp(stream, sp);
  583. return value;
  584. }
  586. inline F32 lscript_pop_float(U8 *stream)
  587. {
  588. S32 sp = get_register(stream, LREG_SP);
  589. F32 value = bytestream2float(stream, sp);
  590. if (!llfinite(value))
  591. {
  592. value = 0;
  593. set_fault(stream, LSRF_MATH);
  594. }
  595. set_sp(stream, sp);
  596. return value;
  597. }
  599. inline void lscript_pop_vector(U8 *stream, LLVector3 &value)
  600. {
  601. S32 sp = get_register(stream, LREG_SP);
  602. bytestream2vector(value, stream, sp);
  603. set_sp(stream, sp);
  604. }
  606. inline void lscript_pop_quaternion(U8 *stream, LLQuaternion &value)
  607. {
  608. S32 sp = get_register(stream, LREG_SP);
  609. bytestream2quaternion(value, stream, sp);
  610. set_sp(stream, sp);
  611. }
  613. inline void lscript_pusharge(U8 *stream, S32 value)
  614. {
  615. S32 sp = get_register(stream, LREG_SP);
  616. sp -= value;
  617. if (set_sp(stream, sp))
  618. {
  619. S32 i;
  620. for (i = 0; i < value; i++)
  621. {
  622. *(stream + sp++) = 0;
  623. }
  624. }
  625. }
  627. inline BOOL lscript_check_local(U8 *stream, S32 &address, S32 size)
  628. {
  629. S32 sp = get_register(stream, LREG_SP);
  630. S32 bp = get_register(stream, LREG_BP);
  632. address += size;
  633. address = bp - address;
  635. if (address < sp - size)
  636. {
  637. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  638. return FALSE;
  639. }
  640. S32 tm = get_register(stream, LREG_TM);
  641. if (address + size > tm)
  642. {
  643. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  644. return FALSE;
  645. }
  646. return TRUE;
  647. }
  649. inline BOOL lscript_check_global(U8 *stream, S32 &address, S32 size)
  650. {
  651. S32 gvr = get_register(stream, LREG_GVR);
  653. // Possibility of overwriting registers?  -- DK 09/07/04
  654. if (address < 0)
  655. {
  656. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  657. return FALSE;
  658. }
  660. address += gvr;
  661. S32 gfr = get_register(stream, LREG_GFR);
  663. if (address + size > gfr)
  664. {
  665. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  666. return FALSE;
  667. }
  668. return TRUE;
  669. }
  671. inline void lscript_local_store(U8 *stream, S32 address, S32 value)
  672. {
  673. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_INTEGER]))
  674. integer2bytestream(stream, address, value);
  675. }
  677. inline void lscript_local_store(U8 *stream, S32 address, F32 value)
  678. {
  679. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_FLOATINGPOINT]))
  680. float2bytestream(stream, address, value);
  681. }
  683. inline void lscript_local_store(U8 *stream, S32 address, const LLVector3 value)
  684. {
  685. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_VECTOR]))
  686. vector2bytestream(stream, address, value);
  687. }
  689. inline void lscript_local_store(U8 *stream, S32 address, const LLQuaternion value)
  690. {
  691. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
  692. quaternion2bytestream(stream, address, value);
  693. }
  695. inline void lscript_global_store(U8 *stream, S32 address, S32 value)
  696. {
  697. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_INTEGER]))
  698. integer2bytestream(stream, address, value);
  699. }
  701. inline void lscript_global_store(U8 *stream, S32 address, F32 value)
  702. {
  703. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_FLOATINGPOINT]))
  704. float2bytestream(stream, address, value);
  705. }
  707. inline void lscript_global_store(U8 *stream, S32 address, const LLVector3 value)
  708. {
  709. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_VECTOR]))
  710. vector2bytestream(stream, address, value);
  711. }
  713. inline void lscript_global_store(U8 *stream, S32 address, const LLQuaternion value)
  714. {
  715. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
  716. quaternion2bytestream(stream, address, value);
  717. }
  719. inline S32 lscript_local_get(U8 *stream, S32 address)
  720. {
  721. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_INTEGER]))
  722. return bytestream2integer(stream, address);
  723. return 0;
  724. }
  726. inline void lscript_local_get(U8 *stream, S32 address, F32 &value)
  727. {
  728. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_FLOATINGPOINT]))
  729. value = bytestream2float(stream, address);
  730. if (!llfinite(value))
  731. {
  732. value = 0;
  733. set_fault(stream, LSRF_MATH);
  734. }
  735. }
  737. inline void lscript_local_get(U8 *stream, S32 address, LLVector3 &value)
  738. {
  739. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_VECTOR]))
  740. bytestream2vector(value, stream, address);
  741. }
  743. inline void lscript_local_get(U8 *stream, S32 address, LLQuaternion &value)
  744. {
  745. if (lscript_check_local(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
  746. bytestream2quaternion(value, stream, address);
  747. }
  749. inline S32 lscript_global_get(U8 *stream, S32 address)
  750. {
  751. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_INTEGER]))
  752. return bytestream2integer(stream, address);
  753. return 0;
  754. }
  756. inline void lscript_global_get(U8 *stream, S32 address, F32 &value)
  757. {
  758. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_FLOATINGPOINT]))
  759. value = bytestream2float(stream, address);
  760. if (!llfinite(value))
  761. {
  762. value = 0;
  763. set_fault(stream, LSRF_MATH);
  764. }
  765. }
  767. inline void lscript_global_get(U8 *stream, S32 address, LLVector3 &value)
  768. {
  769. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_VECTOR]))
  770. bytestream2vector(value, stream, address);
  771. }
  773. inline void lscript_global_get(U8 *stream, S32 address, LLQuaternion &value)
  774. {
  775. if (lscript_check_global(stream, address, LSCRIPTDataSize[LST_QUATERNION]))
  776. bytestream2quaternion(value, stream, address);
  777. }
  781. inline S32 get_state_event_opcoode_start(U8 *stream, S32 state, LSCRIPTStateEventType event)
  782. {
  783. // get the start of the state table
  784. S32 sr = get_register(stream, LREG_SR);
  786. // get the position of the jump to the desired state
  787. S32 value = get_register(stream, LREG_VN);
  789. S32 state_offset_offset = 0;
  790. S32 major_version = 0;
  791. if (value == LSL2_VERSION1_END_NUMBER)
  792. {
  793. major_version = LSL2_MAJOR_VERSION_ONE;
  794. state_offset_offset = sr + LSCRIPTDataSize[LST_INTEGER] + LSCRIPTDataSize[LST_INTEGER]*2*state;
  795. }
  796. else if (value == LSL2_VERSION_NUMBER)
  797. {
  798. major_version = LSL2_MAJOR_VERSION_TWO;
  799. state_offset_offset = sr + LSCRIPTDataSize[LST_INTEGER] + LSCRIPTDataSize[LST_INTEGER]*3*state;
  800. }
  801. if ( state_offset_offset < 0 || state_offset_offset > TOP_OF_MEMORY )
  802. {
  803. return -1;
  804. }
  806. // get the actual position in memory of the desired state
  807. S32 state_offset = sr + bytestream2integer(stream, state_offset_offset);
  808. if ( state_offset < 0 || state_offset > TOP_OF_MEMORY )
  809. {
  810. return -1;
  811. }
  813. // save that value
  814. S32 state_offset_base = state_offset;
  816. // jump past the state name
  817. S32 event_jump_offset = state_offset_base + bytestream2integer(stream, state_offset);
  819. // get the location of the event offset
  820. S32 event_offset = event_jump_offset + LSCRIPTDataSize[LST_INTEGER]*2*get_event_handler_jump_position(get_event_register(stream, LREG_ER, major_version), event);
  821. if ( event_offset < 0 || event_offset > TOP_OF_MEMORY )
  822. {
  823. return -1;
  824. }
  826. // now, jump to the event
  827. S32 event_start = bytestream2integer(stream, event_offset);
  828. if ( event_start < 0 || event_start > TOP_OF_MEMORY )
  829. {
  830. return -1;
  831. }
  832. event_start += event_jump_offset;
  834. S32 event_start_original = event_start;
  836. // now skip past the parameters
  837. S32 opcode_offset = bytestream2integer(stream, event_start);
  838. if ( opcode_offset < 0 || opcode_offset > TOP_OF_MEMORY )
  839. {
  840. return -1;
  841. }
  843. return opcode_offset + event_start_original;
  844. }
  847. inline U64 get_handled_events(U8 *stream, S32 state)
  848. {
  849. U64 retvalue = 0;
  850. // get the start of the state table
  851. S32 sr = get_register(stream, LREG_SR);
  853. // get the position of the jump to the desired state
  854. S32 value = get_register(stream, LREG_VN);
  855. S32 state_handled_offset = 0;
  856. if (value == LSL2_VERSION1_END_NUMBER)
  857. {
  858. state_handled_offset = sr + LSCRIPTDataSize[LST_INTEGER]*2*state + 2*LSCRIPTDataSize[LST_INTEGER];
  859. retvalue = bytestream2integer(stream, state_handled_offset);
  860. }
  861. else if (value == LSL2_VERSION_NUMBER)
  862. {
  863. state_handled_offset = sr + LSCRIPTDataSize[LST_INTEGER]*3*state + 2*LSCRIPTDataSize[LST_INTEGER];
  864. retvalue = bytestream2u64(stream, state_handled_offset);
  865. }
  867. // get the handled events
  868. return retvalue;
  869. }
  871. // Returns -1 on error
  872. inline S32 get_event_stack_size(U8 *stream, S32 state, LSCRIPTStateEventType event)
  873. {
  874. // get the start of the state table
  875. S32 sr = get_register(stream, LREG_SR);
  877. // get state offset
  878. S32 value = get_register(stream, LREG_VN);
  879. S32 state_offset_offset = 0;
  880. S32 major_version = 0;
  881. if (value == LSL2_VERSION1_END_NUMBER)
  882. {
  883. major_version = LSL2_MAJOR_VERSION_ONE;
  884. state_offset_offset = sr + LSCRIPTDataSize[LST_INTEGER] + LSCRIPTDataSize[LST_INTEGER]*2*state;
  885. }
  886. else if (value == LSL2_VERSION_NUMBER)
  887. {
  888. major_version = LSL2_MAJOR_VERSION_TWO;
  889. state_offset_offset = sr + LSCRIPTDataSize[LST_INTEGER] + LSCRIPTDataSize[LST_INTEGER]*3*state;
  890. }
  892. if ( state_offset_offset < 0 || state_offset_offset > TOP_OF_MEMORY )
  893. {
  894. return -1;
  895. }
  897. S32 state_offset = bytestream2integer(stream, state_offset_offset);
  898. state_offset += sr;
  900. state_offset_offset = state_offset;
  901. if ( state_offset_offset < 0 || state_offset_offset > TOP_OF_MEMORY )
  902. {
  903. return -1;
  904. }
  906. // skip to jump table
  907. S32 jump_table = bytestream2integer(stream, state_offset_offset);
  909. jump_table += state_offset;
  910. if ( jump_table < 0 || jump_table > TOP_OF_MEMORY )
  911. {
  912. return -1;
  913. }
  915. // get the position of the jump to the desired state
  916. S32 stack_size_offset = jump_table + LSCRIPTDataSize[LST_INTEGER]*2*get_event_handler_jump_position(get_event_register(stream, LREG_ER, major_version), event) + LSCRIPTDataSize[LST_INTEGER];
  918. // get the handled events
  919. S32 stack_size = bytestream2integer(stream, stack_size_offset);
  920. if ( stack_size < 0 || stack_size > TOP_OF_MEMORY )
  921. {
  922. return -1;
  923. }
  925. return stack_size;
  926. }
  928. inline LSCRIPTStateEventType return_first_event(S32 event)
  929. {
  930. S32 count = 1;
  931. while (count < LSTT_EOF)
  932. {
  933. if (event & 0x1)
  934. {
  935. return (LSCRIPTStateEventType) count;
  936. }
  937. else
  938. {
  939. event >>= 1;
  940. count++;
  941. }
  942. }
  943. return LSTT_NULL;
  944. }
  947. // the safe instruction versions of these commands will only work if offset is between
  948. // GFR and HR, meaning that it is an instruction (more or less) in global functions or event handlers
  950. inline BOOL safe_instruction_check_address(U8 *stream, S32 offset, S32 size)
  951. {
  952. S32 gfr = get_register(stream, LREG_GFR);
  953. if (offset < gfr)
  954. {
  955. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  956. return FALSE;
  957. }
  958. else
  959. {
  960. S32 hr = get_register(stream, LREG_HR);
  961. if (offset + size > hr)
  962. {
  963. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  964. return FALSE;
  965. }
  966. else
  967. {
  968. return TRUE;
  969. }
  970. }
  971. }
  973. inline BOOL safe_heap_check_address(U8 *stream, S32 offset, S32 size)
  974. {
  975. S32 hr = get_register(stream, LREG_HR);
  976. if (offset < hr)
  977. {
  978. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  979. return FALSE;
  980. }
  981. else
  982. {
  983. S32 hp = get_register(stream, LREG_HP);
  984. if (offset + size > hp)
  985. {
  986. set_fault(stream, LSRF_BOUND_CHECK_ERROR);
  987. return FALSE;
  988. }
  989. else
  990. {
  991. return TRUE;
  992. }
  993. }
  994. }
  996. inline U8 safe_instruction_bytestream2byte(U8 *stream, S32 &offset)
  997. {
  998. if (safe_instruction_check_address(stream, offset, 1))
  999. {
  1000. return *(stream + offset++);
  1001. }
  1002. else
  1003. {
  1004. return 0;
  1005. }
  1006. }
  1008. inline void safe_instruction_byte2bytestream(U8 *stream, S32 &offset, U8 byte)
  1009. {
  1010. if (safe_instruction_check_address(stream, offset, 1))
  1011. {
  1012. *(stream + offset++) = byte;
  1013. }
  1014. }
  1016. inline S32 safe_instruction_bytestream2integer(U8 *stream, S32 &offset)
  1017. {
  1018. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_INTEGER]))
  1019. {
  1020. return (bytestream2integer(stream, offset));
  1021. }
  1022. else
  1023. {
  1024. return 0;
  1025. }
  1026. }
  1028. inline void safe_instruction_integer2bytestream(U8 *stream, S32 &offset, S32 value)
  1029. {
  1030. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_INTEGER]))
  1031. {
  1032. integer2bytestream(stream, offset, value);
  1033. }
  1034. }
  1036. inline U16 safe_instruction_bytestream2u16(U8 *stream, S32 &offset)
  1037. {
  1038. if (safe_instruction_check_address(stream, offset, 2))
  1039. {
  1040. return (bytestream2u16(stream, offset));
  1041. }
  1042. else
  1043. {
  1044. return 0;
  1045. }
  1046. }
  1048. inline void safe_instruction_u162bytestream(U8 *stream, S32 &offset, U16 value)
  1049. {
  1050. if (safe_instruction_check_address(stream, offset, 2))
  1051. {
  1052. u162bytestream(stream, offset, value);
  1053. }
  1054. }
  1056. inline F32 safe_instruction_bytestream2float(U8 *stream, S32 &offset)
  1057. {
  1058. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_INTEGER]))
  1059. {
  1060. F32 value = bytestream2float(stream, offset);
  1061. if (!llfinite(value))
  1062. {
  1063. value = 0;
  1064. set_fault(stream, LSRF_MATH);
  1065. }
  1066. return value;
  1067. }
  1068. else
  1069. {
  1070. return 0;
  1071. }
  1072. }
  1074. inline void safe_instruction_float2bytestream(U8 *stream, S32 &offset, F32 value)
  1075. {
  1076. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_FLOATINGPOINT]))
  1077. {
  1078. float2bytestream(stream, offset, value);
  1079. }
  1080. }
  1082. inline void safe_instruction_bytestream2char(char *buffer, U8 *stream, S32 &offset, S32 buffsize)
  1083. {
  1084. // This varies from the old method. Previously, we would copy up until we got an error,
  1085. // then halt the script via safe_isntruction_check_address. Now we don't bother
  1086. // copying a thing if there's an error.
  1088. if( safe_instruction_check_address(stream, offset, strlen( (const char *)stream + offset ) + 1 ) )
  1089. {
  1090. // Takes the same parms as this function. Won't overread, per above check.
  1091. bytestream2char( buffer, stream, offset, buffsize );
  1092. }
  1093. else
  1094. {
  1095. // Truncate - no point in copying
  1096. *buffer = 0;
  1097. }
  1098. }
  1100. inline void safe_instruction_bytestream_count_char(U8 *stream, S32 &offset)
  1101. {
  1102. while (  (safe_instruction_check_address(stream, offset, 1))
  1103.    &&(*(stream + offset++)))
  1104. ;
  1105. }
  1107. inline void safe_heap_bytestream_count_char(U8 *stream, S32 &offset)
  1108. {
  1109. while (  (safe_heap_check_address(stream, offset, 1))
  1110.    &&(*(stream + offset++)))
  1111. ;
  1112. }
  1114. inline void safe_instruction_char2bytestream(U8 *stream, S32 &offset, const char* buffer)
  1115. {
  1116. while (  (safe_instruction_check_address(stream, offset, 1))
  1117.    &&(*(stream + offset++) = *buffer++))
  1118. ;
  1119. }
  1121. inline void safe_instruction_bytestream2vector(LLVector3 &value, U8 *stream, S32 &offset)
  1122. {
  1123. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_VECTOR]))
  1124. {
  1125. bytestream2vector(value, stream, offset);
  1126. }
  1127. }
  1129. inline void safe_instruction_vector2bytestream(U8 *stream, S32 &offset, const LLVector3 &value)
  1130. {
  1131. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_VECTOR]))
  1132. {
  1133. vector2bytestream(stream, offset, value);
  1134. }
  1135. }
  1137. inline void safe_instruction_bytestream2quaternion(LLQuaternion &value, U8 *stream, S32 &offset)
  1138. {
  1139. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_QUATERNION]))
  1140. {
  1141. bytestream2quaternion(value, stream, offset);
  1142. }
  1143. }
  1145. inline void safe_instruction_quaternion2bytestream(U8 *stream, S32 &offset, const LLQuaternion &value)
  1146. {
  1147. if (safe_instruction_check_address(stream, offset, LSCRIPTDataSize[LST_QUATERNION]))
  1148. {
  1149. quaternion2bytestream(stream, offset, value);
  1150. }
  1151. }
  1153. static inline LSCRIPTType char2type(char type)
  1154. {
  1155. switch(type)
  1156. {
  1157. case 'i':
  1158. return LST_INTEGER;
  1159. case 'f':
  1160. return LST_FLOATINGPOINT;
  1161. case 's':
  1162. return LST_STRING;
  1163. case 'k':
  1164. return LST_KEY;
  1165. case 'v':
  1166. return LST_VECTOR;
  1167. case 'q':
  1168. return LST_QUATERNION;
  1169. case 'l':
  1170. return LST_LIST;
  1171. default:
  1172. return LST_NULL;
  1173. }
  1174. }
  1176. #endif