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

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

游戏引擎

开发平台：

C++ Builder

lscript_execute.cpp：源码内容
  1. /**
  2.  * @file lscript_execute.cpp
  3.  * @brief classes to execute bytecode
  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. #include "linden_common.h"
  35. #include <algorithm>
  36. #include <sstream>
  38. #include "lscript_execute.h"
  39. #include "lltimer.h"
  40. #include "lscript_readlso.h"
  41. #include "lscript_library.h"
  42. #include "lscript_heapruntime.h"
  43. #include "lscript_alloc.h"
  44. #include "llstat.h"
  47. // Static
  48. const S32 DEFAULT_SCRIPT_TIMER_CHECK_SKIP = 4;
  49. S32 LLScriptExecute::sTimerCheckSkip = DEFAULT_SCRIPT_TIMER_CHECK_SKIP;
  51. void (*binary_operations[LST_EOF][LST_EOF])(U8 *buffer, LSCRIPTOpCodesEnum opcode);
  52. void (*unary_operations[LST_EOF])(U8 *buffer, LSCRIPTOpCodesEnum opcode);
  54. const char* LSCRIPTRunTimeFaultStrings[LSRF_EOF] = /*Flawfinder: ignore*/
  55. {
  56. "Invalid", // LSRF_INVALID,
  57. "Math Error", // LSRF_MATH,
  58. "Stack-Heap Collision", // LSRF_STACK_HEAP_COLLISION,
  59. "Bounds Check Error", // LSRF_BOUND_CHECK_ERROR,
  60. "Heap Error", // LSRF_HEAP_ERROR,
  61. "Version Mismatch", // LSRF_VERSION_MISMATCH,
  62. "Missing Inventory", // LSRF_MISSING_INVENTORY,
  63. "Hit Sandbox Limit", // LSRF_SANDBOX,
  64. "Chat Overrun", // LSRF_CHAT_OVERRUN,
  65. "Too Many Listens",   // LSRF_TOO_MANY_LISTENS,
  66. "Lists may not contain lists", // LSRF_NESTING_LISTS,
  67. "CLI Exception" // LSRF_CLI
  68. };
  70. void LLScriptExecuteLSL2::startRunning() {}
  71. void LLScriptExecuteLSL2::stopRunning() {}
  73. const char* URL_REQUEST_GRANTED = "URL_REQUEST_GRANTED";
  74. const char* URL_REQUEST_DENIED = "URL_REQUEST_DENIED";
  76. // HTTP Requests to LSL scripts will time out after 25 seconds.
  77. const U64 LSL_HTTP_REQUEST_TIMEOUT_USEC = 25 * USEC_PER_SEC; 
  79. LLScriptExecuteLSL2::LLScriptExecuteLSL2(LLFILE *fp)
  80. {
  81. U8  sizearray[4];
  82. size_t filesize;
  83. S32 pos = 0;
  84. if (fread(&sizearray, 1, 4, fp) != 4)
  85. {
  86. llwarns << "Short read" << llendl;
  87. filesize = 0;
  88. } else {
  89. filesize = bytestream2integer(sizearray, pos);
  90. }
  91. mBuffer = new U8[filesize];
  92. fseek(fp, 0, SEEK_SET);
  93. if (fread(mBuffer, 1, filesize, fp) != filesize)
  94. {
  95. llwarns << "Short read" << llendl;
  96. }
  97. fclose(fp);
  99. init();
  100. }
  102. LLScriptExecuteLSL2::LLScriptExecuteLSL2(const U8* bytecode, U32 bytecode_size)
  103. {
  104. mBuffer = new U8[TOP_OF_MEMORY];
  105. memset(mBuffer + bytecode_size, 0, TOP_OF_MEMORY - bytecode_size);
  106. S32 src_offset = 0;
  107. S32 dest_offset = 0;
  108. bytestream2bytestream(mBuffer, dest_offset, bytecode, src_offset, bytecode_size);
  109. mBytecodeSize = bytecode_size;
  110. mBytecode = new U8[mBytecodeSize];
  111. memcpy(mBytecode, bytecode, mBytecodeSize);
  112. init();
  113. }
  115. LLScriptExecute::~LLScriptExecute() {}
  116. LLScriptExecuteLSL2::~LLScriptExecuteLSL2()
  117. {
  118. delete[] mBuffer;
  119. delete[] mBytecode;
  120. }
  122. void LLScriptExecuteLSL2::init()
  123. {
  124. S32 i, j;
  126. mInstructionCount = 0;
  128. for (i = 0; i < 256; i++)
  129. {
  130. mExecuteFuncs[i] = run_noop;
  131. }
  132. mExecuteFuncs[LSCRIPTOpCodes[LOPC_NOOP]] = run_noop;
  134. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POP]] = run_pop;
  135. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPS]] = run_pops;
  136. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPL]] = run_popl;
  137. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPV]] = run_popv;
  138. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPQ]] = run_popq;
  139. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPARG]] = run_poparg;
  140. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPIP]] = run_popip;
  141. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPBP]] = run_popbp;
  142. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPSP]] = run_popsp;
  143. mExecuteFuncs[LSCRIPTOpCodes[LOPC_POPSLR]] = run_popslr;
  145. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUP]] = run_dup;
  146. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPS]] = run_dups;
  147. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPL]] = run_dupl;
  148. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPV]] = run_dupv;
  149. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DUPQ]] = run_dupq;
  151. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STORE]] = run_store;
  152. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STORES]] = run_stores;
  153. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREL]] = run_storel;
  154. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREV]] = run_storev;
  155. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREQ]] = run_storeq;
  156. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREG]] = run_storeg;
  157. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGL]] = run_storegl;
  158. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGS]] = run_storegs;
  159. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGV]] = run_storegv;
  160. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STOREGQ]] = run_storegq;
  161. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADP]] = run_loadp;
  162. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADSP]] = run_loadsp;
  163. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADLP]] = run_loadlp;
  164. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADVP]] = run_loadvp;
  165. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADQP]] = run_loadqp;
  166. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGP]] = run_loadgp;
  167. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGSP]] = run_loadgsp;
  168. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGLP]] = run_loadglp;
  169. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGVP]] = run_loadgvp;
  170. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LOADGQP]] = run_loadgqp;
  172. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSH]] = run_push;
  173. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHS]] = run_pushs;
  174. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHL]] = run_pushl;
  175. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHV]] = run_pushv;
  176. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHQ]] = run_pushq;
  177. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHG]] = run_pushg;
  178. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGS]] = run_pushgs;
  179. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGL]] = run_pushgl;
  180. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGV]] = run_pushgv;
  181. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHGQ]] = run_pushgq;
  182. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHIP]] = run_puship;
  183. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHSP]] = run_pushsp;
  184. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHBP]] = run_pushbp;
  185. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGB]] = run_pushargb;
  186. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGI]] = run_pushargi;
  187. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGF]] = run_pushargf;
  188. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGS]] = run_pushargs;
  189. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGV]] = run_pushargv;
  190. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGQ]] = run_pushargq;
  191. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHE]] = run_pushe;
  192. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHEV]] = run_pushev;
  193. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHEQ]] = run_pusheq;
  194. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PUSHARGE]] = run_pusharge;
  196. mExecuteFuncs[LSCRIPTOpCodes[LOPC_ADD]] = run_add;
  197. mExecuteFuncs[LSCRIPTOpCodes[LOPC_SUB]] = run_sub;
  198. mExecuteFuncs[LSCRIPTOpCodes[LOPC_MUL]] = run_mul;
  199. mExecuteFuncs[LSCRIPTOpCodes[LOPC_DIV]] = run_div;
  200. mExecuteFuncs[LSCRIPTOpCodes[LOPC_MOD]] = run_mod;
  202. mExecuteFuncs[LSCRIPTOpCodes[LOPC_EQ]] = run_eq;
  203. mExecuteFuncs[LSCRIPTOpCodes[LOPC_NEQ]] = run_neq;
  204. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LEQ]] = run_leq;
  205. mExecuteFuncs[LSCRIPTOpCodes[LOPC_GEQ]] = run_geq;
  206. mExecuteFuncs[LSCRIPTOpCodes[LOPC_LESS]] = run_less;
  207. mExecuteFuncs[LSCRIPTOpCodes[LOPC_GREATER]] = run_greater;
  209. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITAND]] = run_bitand;
  210. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITOR]] = run_bitor;
  211. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITXOR]] = run_bitxor;
  213. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLAND]] = run_booland;
  214. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLOR]] = run_boolor;
  216. mExecuteFuncs[LSCRIPTOpCodes[LOPC_SHL]] = run_shl;
  217. mExecuteFuncs[LSCRIPTOpCodes[LOPC_SHR]] = run_shr;
  219. mExecuteFuncs[LSCRIPTOpCodes[LOPC_NEG]] = run_neg;
  220. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BITNOT]] = run_bitnot;
  221. mExecuteFuncs[LSCRIPTOpCodes[LOPC_BOOLNOT]] = run_boolnot;
  223. mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMP]] = run_jump;
  224. mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMPIF]] = run_jumpif;
  225. mExecuteFuncs[LSCRIPTOpCodes[LOPC_JUMPNIF]] = run_jumpnif;
  227. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STATE]] = run_state;
  228. mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALL]] = run_call;
  229. mExecuteFuncs[LSCRIPTOpCodes[LOPC_RETURN]] = run_return;
  230. mExecuteFuncs[LSCRIPTOpCodes[LOPC_CAST]] = run_cast;
  231. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STACKTOS]] = run_stacktos;
  232. mExecuteFuncs[LSCRIPTOpCodes[LOPC_STACKTOL]] = run_stacktol;
  234. mExecuteFuncs[LSCRIPTOpCodes[LOPC_PRINT]] = run_print;
  236. mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALLLIB]] = run_calllib;
  237. mExecuteFuncs[LSCRIPTOpCodes[LOPC_CALLLIB_TWO_BYTE]] = run_calllib_two_byte;
  239. for (i = 0; i < LST_EOF; i++)
  240. {
  241. for (j = 0; j < LST_EOF; j++)
  242. {
  243. binary_operations[i][j] = unknown_operation;
  244. }
  245. }
  247. binary_operations[LST_INTEGER][LST_INTEGER] = integer_integer_operation;
  248. binary_operations[LST_INTEGER][LST_FLOATINGPOINT] = integer_float_operation;
  249. binary_operations[LST_INTEGER][LST_VECTOR] = integer_vector_operation;
  251. binary_operations[LST_FLOATINGPOINT][LST_INTEGER] = float_integer_operation;
  252. binary_operations[LST_FLOATINGPOINT][LST_FLOATINGPOINT] = float_float_operation;
  253. binary_operations[LST_FLOATINGPOINT][LST_VECTOR] = float_vector_operation;
  255. binary_operations[LST_STRING][LST_STRING] = string_string_operation;
  256. binary_operations[LST_STRING][LST_KEY] = string_key_operation;
  258. binary_operations[LST_KEY][LST_STRING] = key_string_operation;
  259. binary_operations[LST_KEY][LST_KEY] = key_key_operation;
  261. binary_operations[LST_VECTOR][LST_INTEGER] = vector_integer_operation;
  262. binary_operations[LST_VECTOR][LST_FLOATINGPOINT] = vector_float_operation;
  263. binary_operations[LST_VECTOR][LST_VECTOR] = vector_vector_operation;
  264. binary_operations[LST_VECTOR][LST_QUATERNION] = vector_quaternion_operation;
  266. binary_operations[LST_QUATERNION][LST_QUATERNION] = quaternion_quaternion_operation;
  268. binary_operations[LST_INTEGER][LST_LIST] = integer_list_operation;
  269. binary_operations[LST_FLOATINGPOINT][LST_LIST] = float_list_operation;
  270. binary_operations[LST_STRING][LST_LIST] = string_list_operation;
  271. binary_operations[LST_KEY][LST_LIST] = key_list_operation;
  272. binary_operations[LST_VECTOR][LST_LIST] = vector_list_operation;
  273. binary_operations[LST_QUATERNION][LST_LIST] = quaternion_list_operation;
  274. binary_operations[LST_LIST][LST_INTEGER] = list_integer_operation;
  275. binary_operations[LST_LIST][LST_FLOATINGPOINT] = list_float_operation;
  276. binary_operations[LST_LIST][LST_STRING] = list_string_operation;
  277. binary_operations[LST_LIST][LST_KEY] = list_key_operation;
  278. binary_operations[LST_LIST][LST_VECTOR] = list_vector_operation;
  279. binary_operations[LST_LIST][LST_QUATERNION] = list_quaternion_operation;
  280. binary_operations[LST_LIST][LST_LIST] = list_list_operation;
  282. for (i = 0; i < LST_EOF; i++)
  283. {
  284. unary_operations[i] = unknown_operation;
  285. }
  287. unary_operations[LST_INTEGER] = integer_operation;
  288. unary_operations[LST_FLOATINGPOINT] = float_operation;
  289. unary_operations[LST_VECTOR] = vector_operation;
  290. unary_operations[LST_QUATERNION] = quaternion_operation;
  292. }
  295. // Utility routine for when there's a boundary error parsing bytecode
  296. void LLScriptExecuteLSL2::recordBoundaryError( const LLUUID &id )
  297. {
  298. set_fault(mBuffer, LSRF_BOUND_CHECK_ERROR);
  299. llwarns << "Script boundary error for ID " << id << llendl;
  300. }
  303. // set IP to the event handler with some error checking
  304. void LLScriptExecuteLSL2::setStateEventOpcoodeStartSafely( S32 state, LSCRIPTStateEventType event, const LLUUID &id )
  305. {
  306. S32 opcode_start = get_state_event_opcoode_start( mBuffer, state, event );
  307. if ( opcode_start == -1 )
  308. {
  309. recordBoundaryError( id );
  310. }
  311. else
  312. {
  313. set_ip( mBuffer, opcode_start );
  314. }
  315. }
  320. S32 lscript_push_variable(LLScriptLibData *data, U8 *buffer);
  322. void LLScriptExecuteLSL2::resumeEventHandler(BOOL b_print, const LLUUID &id, F32 time_slice)
  323. {
  324. // call opcode run function pointer with buffer and IP
  325. mInstructionCount++;
  326. S32 value = get_register(mBuffer, LREG_IP);
  327. S32 tvalue = value;
  328. S32 opcode = safe_instruction_bytestream2byte(mBuffer, tvalue);
  329. mExecuteFuncs[opcode](mBuffer, value, b_print, id);
  330. set_ip(mBuffer, value);
  331. add_register_fp(mBuffer, LREG_ESR, -0.1f);
  332. // lsa_print_heap(mBuffer);
  334. if (b_print)
  335. {
  336. lsa_print_heap(mBuffer);
  337. printf("ip: 0x%Xn", get_register(mBuffer, LREG_IP));
  338. printf("sp: 0x%Xn", get_register(mBuffer, LREG_SP));
  339. printf("bp: 0x%Xn", get_register(mBuffer, LREG_BP));
  340. printf("hr: 0x%Xn", get_register(mBuffer, LREG_HR));
  341. printf("hp: 0x%Xn", get_register(mBuffer, LREG_HP));
  342. }
  344. // NOTE: Babbage: all mExecuteFuncs return false.
  345. }
  347. void LLScriptExecuteLSL2::callEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice)
  348. {
  349. S32 major_version = getMajorVersion();
  350. // push a zero to be popped
  351. lscript_push(mBuffer, 0);
  352. // push sp as current bp
  353. S32 sp = get_register(mBuffer, LREG_SP);
  354. lscript_push(mBuffer, sp);
  356. // Update current handler and current events registers.
  357. set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
  358. U64 current_events = get_event_register(mBuffer, LREG_CE, major_version);
  359. current_events &= ~LSCRIPTStateBitField[event];
  360. set_event_register(mBuffer, LREG_CE, current_events, major_version);
  362. // now, push any additional stack space
  363. U32 current_state = get_register(mBuffer, LREG_CS);
  364. S32 additional_size = get_event_stack_size(mBuffer, current_state, event);
  365. lscript_pusharge(mBuffer, additional_size);
  367. // now set the bp correctly
  368. sp = get_register(mBuffer, LREG_SP);
  369. sp += additional_size;
  370. set_bp(mBuffer, sp);
  372. // set IP to the function
  373. S32 opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
  374. set_ip(mBuffer, opcode_start);
  375. }
  377. //void callStateExitHandler()
  378. //{
  379. // // push a zero to be popped
  380. // lscript_push(mBuffer, 0);
  381. // // push sp as current bp
  382. // S32 sp = get_register(mBuffer, LREG_SP);
  383. // lscript_push(mBuffer, sp);
  384. //
  385. // // now, push any additional stack space
  386. // S32 additional_size = get_event_stack_size(mBuffer, current_state, LSTT_STATE_EXIT);
  387. // lscript_pusharge(mBuffer, additional_size);
  388. //
  389. // sp = get_register(mBuffer, LREG_SP);
  390. // sp += additional_size;
  391. // set_bp(mBuffer, sp);
  392. //
  393. // // set IP to the event handler
  394. // S32 opcode_start = get_state_event_opcoode_start(mBuffer, current_state, LSTT_STATE_EXIT);
  395. // set_ip(mBuffer, opcode_start);
  396. //}
  397. //
  398. //void callStateEntryHandler()
  399. //{
  400. // // push a zero to be popped
  401. // lscript_push(mBuffer, 0);
  402. // // push sp as current bp
  403. // S32 sp = get_register(mBuffer, LREG_SP);
  404. // lscript_push(mBuffer, sp);
  405. //
  406. // event = return_first_event((S32)LSCRIPTStateBitField[LSTT_STATE_ENTRY]);
  407. // set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
  408. // current_events &= ~LSCRIPTStateBitField[event];
  409. // set_event_register(mBuffer, LREG_CE, current_events, major_version);
  410. //
  411. // // now, push any additional stack space
  412. // S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
  413. // lscript_pusharge(mBuffer, additional_size);
  414. //
  415. // // now set the bp correctly
  416. // sp = get_register(mBuffer, LREG_SP);
  417. // sp += additional_size + size;
  418. // set_bp(mBuffer, sp);
  419. // // set IP to the function
  420. // S32 opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
  421. // set_ip(mBuffer, opcode_start);
  422. //}
  424. void LLScriptExecuteLSL2::callQueuedEventHandler(LSCRIPTStateEventType event, const LLUUID &id, F32 time_slice)
  425. {
  426. S32 major_version = getMajorVersion();
  427. LLScriptDataCollection* eventdata;
  429. for (eventdata = mEventData.mEventDataList.getFirstData(); eventdata; eventdata = mEventData.mEventDataList.getNextData())
  430. {
  431. if (eventdata->mType == event)
  432. {
  433. // push a zero to be popped
  434. lscript_push(mBuffer, 0);
  435. // push sp as current bp
  436. S32 sp = get_register(mBuffer, LREG_SP);
  437. lscript_push(mBuffer, sp);
  439. // Update current handler and current events registers.
  440. set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
  441. U64 current_events = get_event_register(mBuffer, LREG_CE, major_version);
  442. current_events &= ~LSCRIPTStateBitField[event];
  443. set_event_register(mBuffer, LREG_CE, current_events, major_version);
  445. // push any arguments that need to be pushed onto the stack
  446. // last piece of data will be type LST_NULL
  447. LLScriptLibData *data = eventdata->mData;
  448. U32 size = 0;
  449. while (data->mType)
  450. {
  451. size += lscript_push_variable(data, mBuffer);
  452. data++;
  453. }
  454. // now, push any additional stack space
  455. U32 current_state = get_register(mBuffer, LREG_CS);
  456. S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
  457. lscript_pusharge(mBuffer, additional_size);
  459. // now set the bp correctly
  460. sp = get_register(mBuffer, LREG_SP);
  461. sp += additional_size + size;
  462. set_bp(mBuffer, sp);
  464. // set IP to the function
  465. S32 opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
  466. set_ip(mBuffer, opcode_start);
  468. mEventData.mEventDataList.deleteCurrentData();
  469. break;
  470. }
  471. }
  472. }
  474. void LLScriptExecuteLSL2::callNextQueuedEventHandler(U64 event_register, const LLUUID &id, F32 time_slice)
  475. {
  476. S32 major_version = getMajorVersion();
  477. LLScriptDataCollection* eventdata = mEventData.getNextEvent();
  478. if (eventdata)
  479. {
  480. LSCRIPTStateEventType event = eventdata->mType;
  482. // make sure that we can actually handle this one
  483. if (LSCRIPTStateBitField[event] & event_register)
  484. {
  485. // push a zero to be popped
  486. lscript_push(mBuffer, 0);
  487. // push sp as current bp
  488. S32 sp = get_register(mBuffer, LREG_SP);
  489. lscript_push(mBuffer, sp);
  491. // Update current handler and current events registers.
  492. set_event_register(mBuffer, LREG_IE, LSCRIPTStateBitField[event], major_version);
  493. U64 current_events = get_event_register(mBuffer, LREG_CE, major_version);
  494. current_events &= ~LSCRIPTStateBitField[event];
  495. set_event_register(mBuffer, LREG_CE, current_events, major_version);
  497. // push any arguments that need to be pushed onto the stack
  498. // last piece of data will be type LST_NULL
  499. LLScriptLibData *data = eventdata->mData;
  500. U32 size = 0;
  501. while (data->mType)
  502. {
  503. size += lscript_push_variable(data, mBuffer);
  504. data++;
  505. }
  507. // now, push any additional stack space
  508. U32 current_state = get_register(mBuffer, LREG_CS);
  509. S32 additional_size = get_event_stack_size(mBuffer, current_state, event) - size;
  510. lscript_pusharge(mBuffer, additional_size);
  512. // now set the bp correctly
  513. sp = get_register(mBuffer, LREG_SP);
  514. sp += additional_size + size;
  515. set_bp(mBuffer, sp);
  517. // set IP to the function
  518. S32 opcode_start = get_state_event_opcoode_start(mBuffer, current_state, event);
  519. set_ip(mBuffer, opcode_start);
  520. }
  521. else
  522. {
  523. llwarns << "Shit, somehow got an event that we're not registered for!" << llendl;
  524. }
  525. delete eventdata;
  526. }
  527. }
  529. U64 LLScriptExecuteLSL2::nextState()
  530. {
  531. // copy NS to CS
  532. S32 next_state = get_register(mBuffer, LREG_NS);
  533. set_register(mBuffer, LREG_CS, next_state);
  535. // copy new state's handled events into ER (SR + CS*4 + 4)
  536. return get_handled_events(mBuffer, next_state);
  537. }
  539. //virtual 
  540. void LLScriptExecuteLSL2::addEvent(LLScriptDataCollection* event)
  541. {
  542. mEventData.addEventData(event);
  543. }
  545. //virtual 
  546. void LLScriptExecuteLSL2::removeEventType(LSCRIPTStateEventType event_type)
  547. {
  548. mEventData.removeEventType(event_type);
  549. }
  551. //virtual 
  552. F32 LLScriptExecuteLSL2::getSleep() const
  553. {
  554. return get_register_fp(mBuffer, LREG_SLR);
  555. }
  557. //virtual 
  558. void LLScriptExecuteLSL2::setSleep(F32 value)
  559. {
  560. set_register_fp(mBuffer, LREG_SLR, value);
  561. }
  563. //virtual 
  564. U64 LLScriptExecuteLSL2::getCurrentHandler()
  565. {
  566. return get_event_register(mBuffer, LREG_IE, getMajorVersion());
  567. }
  569. //virtual 
  570. F32 LLScriptExecuteLSL2::getEnergy() const
  571. {
  572. return get_register_fp(mBuffer, LREG_ESR);
  573. }
  575. //virtual 
  576. void LLScriptExecuteLSL2::setEnergy(F32 value)
  577. {
  578. set_register_fp(mBuffer, LREG_ESR, value);
  579. }
  581. //virtual 
  582. U32 LLScriptExecuteLSL2::getFreeMemory()
  583. {
  584. return get_register(mBuffer, LREG_SP) - get_register(mBuffer, LREG_HP);
  585. }
  587. //virtual 
  588. S32 LLScriptExecuteLSL2::getParameter()
  589. {
  590. return get_register(mBuffer, LREG_PR);
  591. }
  593. //virtual 
  594. void LLScriptExecuteLSL2::setParameter(S32 value)
  595. {
  596. set_register(mBuffer, LREG_PR, value);
  597. }
  600. S32 LLScriptExecuteLSL2::writeState(U8 **dest, U32 header_size, U32 footer_size)
  601. {
  602. // data format:
  603. // 4 bytes of size of Registers, Name and Description, and Global Variables
  604. // Registers, Name and Description, and Global Variables data
  605. // 4 bytes of size of Heap
  606. // Heap data
  607. // 4 bytes of stack size
  608. // Stack data
  610. S32 registers_size = get_register(mBuffer, LREG_GFR);
  612. if (get_register(mBuffer, LREG_HP) > TOP_OF_MEMORY)
  613. reset_hp_to_safe_spot(mBuffer);
  615. S32 heap_size = get_register(mBuffer, LREG_HP) - get_register(mBuffer, LREG_HR);
  616. S32 stack_size = get_register(mBuffer, LREG_TM) - get_register(mBuffer, LREG_SP);
  617. S32 total_size = registers_size + LSCRIPTDataSize[LST_INTEGER] + 
  618. heap_size + LSCRIPTDataSize[LST_INTEGER] + 
  619. stack_size + LSCRIPTDataSize[LST_INTEGER];
  621. // actually allocate data
  622. delete[] *dest;
  623. *dest = new U8[header_size + total_size + footer_size];
  624. memset(*dest, 0, header_size + total_size + footer_size);
  625. S32 dest_offset = header_size;
  626. S32 src_offset = 0;
  628. // registers
  629. integer2bytestream(*dest, dest_offset, registers_size);
  631. // llinfos << "Writing CE: " << getCurrentEvents() << llendl;
  632. bytestream2bytestream(*dest, dest_offset, mBuffer, src_offset, registers_size);
  634. // heap
  635. integer2bytestream(*dest, dest_offset, heap_size);
  637. src_offset = get_register(mBuffer, LREG_HR);
  638. bytestream2bytestream(*dest, dest_offset, mBuffer, src_offset, heap_size);
  640. // stack
  641. integer2bytestream(*dest, dest_offset, stack_size);
  643. src_offset = get_register(mBuffer, LREG_SP);
  644. bytestream2bytestream(*dest, dest_offset, mBuffer, src_offset, stack_size);
  646. return total_size;
  647. }
  649. S32 LLScriptExecuteLSL2::writeBytecode(U8 **dest)
  650. {
  651. // data format:
  652. // registers through top of heap
  653. // Heap data
  654. S32 total_size = get_register(mBuffer, LREG_HP);
  656. // actually allocate data
  657. delete [] *dest;
  658. *dest = new U8[total_size];
  659. S32 dest_offset = 0;
  660. S32 src_offset = 0;
  662. bytestream2bytestream(*dest, dest_offset, mBuffer, src_offset, total_size);
  664. return total_size;
  665. }
  667. S32 LLScriptExecuteLSL2::readState(U8 *src)
  668. {
  669. // first, blitz heap and stack
  670. S32 hr = get_register(mBuffer, LREG_HR);
  671. S32 tm = get_register(mBuffer, LREG_TM);
  672. memset(mBuffer + hr, 0, tm - hr);
  674. S32 src_offset = 0;
  675. S32 dest_offset = 0;
  676. S32 size;
  678. // read register size
  679. size = bytestream2integer(src, src_offset);
  681. // copy data into register area
  682. bytestream2bytestream(mBuffer, dest_offset, src, src_offset, size);
  683. // llinfos << "Read CE: " << getCurrentEvents() << llendl;
  684. if (get_register(mBuffer, LREG_TM) != TOP_OF_MEMORY)
  685. {
  686. llwarns << "Invalid state. Top of memory register does not match"
  687. << " constant." << llendl;
  688. reset_hp_to_safe_spot(mBuffer);
  689. return -1;
  690. }
  692. // read heap size
  693. size = bytestream2integer(src, src_offset);
  695. // set dest offset
  696. dest_offset = get_register(mBuffer, LREG_HR);
  698. if (dest_offset + size > TOP_OF_MEMORY)
  699. {
  700. reset_hp_to_safe_spot(mBuffer);
  701. return -1;
  702. }
  704. // copy data into heap area
  705. bytestream2bytestream(mBuffer, dest_offset, src, src_offset, size);
  707. // read stack size
  708. size = bytestream2integer(src, src_offset);
  710. // set dest offset
  711. dest_offset = get_register(mBuffer, LREG_SP);
  713. if (dest_offset + size > TOP_OF_MEMORY)
  714. {
  715. reset_hp_to_safe_spot(mBuffer);
  716. return -1;
  717. }
  719. // copy data into heap area
  720. bytestream2bytestream(mBuffer, dest_offset, src, src_offset, size);
  722. // Return offset to first byte after read data.
  723. return src_offset;
  724. }
  726. void LLScriptExecuteLSL2::reset()
  727. {
  728. LLScriptExecute::reset();
  730. const U8 *src = getBytecode();
  731. S32 size = getBytecodeSize();
  733. if (!src)
  734. return;
  736. // first, blitz heap and stack
  737. S32 hr = get_register(mBuffer, LREG_HR);
  738. S32 tm = get_register(mBuffer, LREG_TM);
  739. memset(mBuffer + hr, 0, tm - hr);
  741. S32 dest_offset = 0;
  742. S32 src_offset = 0;
  744. bytestream2bytestream(mBuffer, dest_offset, src, src_offset, size);
  745. }
  747. S32 LLScriptExecuteLSL2::getMajorVersion() const
  748. {
  749. S32 version = getVersion();
  750. S32 major_version = 0;
  751. if (version == LSL2_VERSION1_END_NUMBER){
  752. major_version = 1;
  753. }
  754. else if (version == LSL2_VERSION_NUMBER)
  755. {
  756. major_version = 2;
  757. }
  758. return major_version;
  759. }
  761. U32 LLScriptExecuteLSL2::getUsedMemory()
  762. {
  763. return getBytecodeSize();
  764. }
  766. LLScriptExecute::LLScriptExecute() :
  767. mReset(FALSE)
  768. {
  769. }
  771. void LLScriptExecute::reset()
  772. {
  773. mReset = FALSE;
  774. }
  776. bool LLScriptExecute::isYieldDue() const
  777. {
  778. if(mReset)
  779. {
  780. return true;
  781. }
  783. if(getSleep() > 0.f)
  784. {
  785. return true;
  786. }
  788. if(isFinished())
  789. {
  790. return true;
  791. }
  793. // State changes can occur within a single time slice,
  794. // but LLScriptData's clean up is required. Yield here
  795. // to allow LLScriptData to perform cleanup and then call
  796. // runQuanta again.
  797. if(isStateChangePending())
  798. {
  799. return true;
  800. }
  802. return false;
  803. }
  805. // Run smallest number of instructions possible: 
  806. // a single instruction for LSL2, a segment between save tests for Mono
  807. void LLScriptExecute::runInstructions(BOOL b_print, const LLUUID &id, 
  808.  const char **errorstr, 
  809.  U32& events_processed,
  810.  F32 quanta)
  811. {
  812. //  is there a fault?
  813. // if yes, print out message and exit
  814. S32 value = getVersion();
  815. S32 major_version = 0;
  816. if (value == LSL2_VERSION1_END_NUMBER)
  817. {
  818. major_version = 1;
  819. }
  820. else if (value == LSL2_VERSION_NUMBER)
  821. {
  822. major_version = 2;
  823. }
  824. else
  825. {
  826. setFault(LSRF_VERSION_MISMATCH);
  827. }
  828. value = getFaults();
  829. if (value > LSRF_INVALID && value < LSRF_EOF)
  830. {
  831. if (b_print)
  832. {
  833. printf("Error!n");
  834. }
  835. *errorstr = LSCRIPTRunTimeFaultStrings[value];
  836. return;
  837. }
  838. else
  839. {
  840. *errorstr = NULL;
  841. }
  843. if (! isFinished())
  844. {
  845. resumeEventHandler(b_print, id, quanta);
  846. return;
  847. }
  848. else
  849. {
  850. // make sure that IE is zero
  851. setCurrentHandler(0);
  853. // if no, we're in a state and waiting for an event
  854. U64 current_events = getCurrentEvents();
  855. U64 event_register = getEventHandlers();
  857. // check NS to see if need to switch states (NS != CS)
  858. if (isStateChangePending())
  859. {
  860. // ok, blow away any pending events
  861. deleteAllEvents();
  863. // if yes, check state exit flag is set
  864. if (current_events & LSCRIPTStateBitField[LSTT_STATE_EXIT])
  865. {
  866. // if yes, clear state exit flag
  867. setCurrentHandler(LSCRIPTStateBitField[LSTT_STATE_EXIT]);
  868. current_events &= ~LSCRIPTStateBitField[LSTT_STATE_EXIT];
  869. setCurrentEvents(current_events);
  871. // check state exit event handler
  872. // if there is a handler, call it
  873. if (event_register & LSCRIPTStateBitField[LSTT_STATE_EXIT])
  874. {
  875. ++events_processed;
  876. callEventHandler(LSTT_STATE_EXIT, id, quanta);
  877. return;
  878. }
  879. }
  881. // if no handler or no state exit flag switch to new state
  882. // set state entry flag and clear other CE flags
  883. current_events = LSCRIPTStateBitField[LSTT_STATE_ENTRY];
  884. setCurrentEvents(current_events);
  886. U64 handled_events = nextState();
  887. setEventHandlers(handled_events);
  888. }
  890. // try to get next event from stack
  891. BOOL b_done = FALSE;
  892. LSCRIPTStateEventType event = LSTT_NULL;
  894. current_events = getCurrentEvents();
  895. event_register = getEventHandlers();
  897. // first, check to see if state_entry or onrez are raised and handled
  898. if ((current_events & LSCRIPTStateBitField[LSTT_STATE_ENTRY])
  899. &&(current_events & event_register))
  900. {
  901. ++events_processed;
  902. callEventHandler(LSTT_STATE_ENTRY, id, quanta);
  903. b_done = TRUE;
  904. }
  905. else if ((current_events & LSCRIPTStateBitField[LSTT_REZ])
  906.  &&(current_events & event_register))
  907. {
  908. ++events_processed;
  909. callQueuedEventHandler(LSTT_REZ, id, quanta);
  910. b_done = TRUE;
  911. }
  913. if (!b_done)
  914. {
  915. // Call handler for next queued event.
  916. if(getEventCount() > 0)
  917. {
  918. ++events_processed;
  919. callNextQueuedEventHandler(event_register, id, quanta);
  920. }
  921. else
  922. {
  923. // if no data waiting, do it the old way:
  924. U64 handled_current = current_events & event_register;
  925. if (handled_current)
  926. {
  927. event = return_first_event((S32)handled_current);
  928. ++events_processed;
  929. callEventHandler(event, id, quanta);
  930. }
  931. }
  932. b_done = TRUE;
  933. }
  934. }
  935. }
  937. // Run for a single timeslice, or until a yield or state transition is due
  938. F32 LLScriptExecute::runQuanta(BOOL b_print, const LLUUID &id, const char **errorstr, F32 quanta, U32& events_processed, LLTimer& timer)
  939. {
  940. S32 timer_checks = 0;
  941. F32 inloop = 0;
  943. // Loop while not finished, yield not due and time remaining
  944. // NOTE: Default implementation does not do adaptive timer skipping
  945. // to preserve current LSL behaviour and not break scripts that rely
  946. // on current execution speed.
  947. while(true)
  948. {
  949. runInstructions(b_print, id, errorstr,
  950. events_processed, quanta);
  952. if(isYieldDue())
  953. {
  954. break;
  955. }
  956. else if(timer_checks++ >= LLScriptExecute::sTimerCheckSkip)
  957. {
  958. inloop = timer.getElapsedTimeF32();
  959. if(inloop > quanta)
  960. {
  961. break;
  962. }
  963. timer_checks = 0;
  964. }
  965. }
  966. if (inloop == 0.0f)
  967. {
  968. inloop = timer.getElapsedTimeF32();
  969. }
  970. return inloop;
  971. }
  973. F32 LLScriptExecute::runNested(BOOL b_print, const LLUUID &id, const char **errorstr, F32 quanta, U32& events_processed, LLTimer& timer)
  974. {
  975. return LLScriptExecute::runQuanta(b_print, id, errorstr, quanta, events_processed, timer);
  976. }
  978. BOOL run_noop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  979. {
  980. if (b_print)
  981. printf("[0x%X]tNOOPn", offset);
  982. offset++;
  983. return FALSE;
  984. }
  986. BOOL run_pop(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  987. {
  988. if (b_print)
  989. printf("[0x%X]tPOPn", offset);
  990. offset++;
  991. lscript_poparg(buffer, LSCRIPTDataSize[LST_INTEGER]);
  992. return FALSE;
  993. }
  995. BOOL run_pops(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  996. {
  997. if (b_print)
  998. printf("[0x%X]tPOPSn", offset);
  999. offset++;
  1000. S32 address = lscript_pop_int(buffer);
  1001. if (address)
  1002. lsa_decrease_ref_count(buffer, address);
  1003. return FALSE;
  1004. }
  1006. BOOL run_popl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1007. {
  1008. if (b_print)
  1009. printf("[0x%X]tPOPLn", offset);
  1010. offset++;
  1011. S32 address = lscript_pop_int(buffer);
  1012. if (address)
  1013. lsa_decrease_ref_count(buffer, address);
  1014. return FALSE;
  1015. }
  1017. BOOL run_popv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1018. {
  1019. if (b_print)
  1020. printf("[0x%X]tPOPVn", offset);
  1021. offset++;
  1022. lscript_poparg(buffer, LSCRIPTDataSize[LST_VECTOR]);
  1023. return FALSE;
  1024. }
  1026. BOOL run_popq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1027. {
  1028. if (b_print)
  1029. printf("[0x%X]tPOPQn", offset);
  1030. offset++;
  1031. lscript_poparg(buffer, LSCRIPTDataSize[LST_QUATERNION]);
  1032. return FALSE;
  1033. }
  1035. BOOL run_poparg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1036. {
  1037. if (b_print)
  1038. printf("[0x%X]tPOPARG ", offset);
  1039. offset++;
  1040. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1041. if (b_print)
  1042. printf("%dn", arg);
  1043. lscript_poparg(buffer, arg);
  1044. return FALSE;
  1045. }
  1047. BOOL run_popip(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1048. {
  1049. if (b_print)
  1050. printf("[0x%X]tPOPIPn", offset);
  1051. offset++;
  1052. offset = lscript_pop_int(buffer);
  1053. return FALSE;
  1054. }
  1056. BOOL run_popbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1057. {
  1058. if (b_print)
  1059. printf("[0x%X]tPOPBPn", offset);
  1060. offset++;
  1061. S32 bp = lscript_pop_int(buffer);
  1062. set_bp(buffer, bp);
  1063. return FALSE;
  1064. }
  1066. BOOL run_popsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1067. {
  1068. if (b_print)
  1069. printf("[0x%X]tPOPSPn", offset);
  1070. offset++;
  1071. S32 sp = lscript_pop_int(buffer);
  1072. set_sp(buffer, sp);
  1073. return FALSE;
  1074. }
  1076. BOOL run_popslr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1077. {
  1078. if (b_print)
  1079. printf("[0x%X]tPOPSLRn", offset);
  1080. offset++;
  1081. S32 slr = lscript_pop_int(buffer);
  1082. set_register(buffer, LREG_SLR, slr);
  1083. return FALSE;
  1084. }
  1086. BOOL run_dup(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1087. {
  1088. if (b_print)
  1089. printf("[0x%X]tDUPn", offset);
  1090. offset++;
  1091. S32 sp = get_register(buffer, LREG_SP);
  1092. S32 value = bytestream2integer(buffer, sp);
  1093. lscript_push(buffer, value);
  1094. return FALSE;
  1095. }
  1097. BOOL run_dups(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1098. {
  1099. if (b_print)
  1100. printf("[0x%X]tDUPSn", offset);
  1101. offset++;
  1102. S32 sp = get_register(buffer, LREG_SP);
  1103. S32 value = bytestream2integer(buffer, sp);
  1104. lscript_push(buffer, value);
  1105. lsa_increase_ref_count(buffer, value);
  1106. return FALSE;
  1107. }
  1109. BOOL run_dupl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1110. {
  1111. if (b_print)
  1112. printf("[0x%X]tDUPLn", offset);
  1113. offset++;
  1114. S32 sp = get_register(buffer, LREG_SP);
  1115. S32 value = bytestream2integer(buffer, sp);
  1116. lscript_push(buffer, value);
  1117. lsa_increase_ref_count(buffer, value);
  1118. return FALSE;
  1119. }
  1121. BOOL run_dupv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1122. {
  1123. if (b_print)
  1124. printf("[0x%X]tDUPVn", offset);
  1125. offset++;
  1126. S32 sp = get_register(buffer, LREG_SP);
  1127. LLVector3 value;
  1128. bytestream2vector(value, buffer, sp);
  1129. lscript_push(buffer, value);
  1130. return FALSE;
  1131. }
  1133. BOOL run_dupq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1134. {
  1135. if (b_print)
  1136. printf("[0x%X]tDUPVn", offset);
  1137. offset++;
  1138. S32 sp = get_register(buffer, LREG_SP);
  1139. LLQuaternion value;
  1140. bytestream2quaternion(value, buffer, sp);
  1141. lscript_push(buffer, value);
  1142. return FALSE;
  1143. }
  1145. BOOL run_store(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1146. {
  1147. if (b_print)
  1148. printf("[0x%X]tSTORE ", offset);
  1149. offset++;
  1150. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1151. if (b_print)
  1152. printf("0x%Xn", arg);
  1153. S32 sp = get_register(buffer, LREG_SP);
  1154. S32 value = bytestream2integer(buffer, sp);
  1155. lscript_local_store(buffer, arg, value);
  1156. return FALSE;
  1157. }
  1159. BOOL run_stores(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1160. {
  1161. if (b_print)
  1162. printf("[0x%X]tSTORES ", offset);
  1163. offset++;
  1164. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1165. if (b_print)
  1166. printf("0x%Xn", arg);
  1167. S32 sp = get_register(buffer, LREG_SP);
  1168. S32 value = bytestream2integer(buffer, sp);
  1170. S32 address = lscript_local_get(buffer, arg);
  1172. lscript_local_store(buffer, arg, value);
  1173. lsa_increase_ref_count(buffer, value);
  1174. if (address)
  1175. lsa_decrease_ref_count(buffer, address);
  1176. return FALSE;
  1177. }
  1179. BOOL run_storel(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1180. {
  1181. if (b_print)
  1182. printf("[0x%X]tSTOREL ", offset);
  1183. offset++;
  1184. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1185. if (b_print)
  1186. printf("0x%Xn", arg);
  1187. S32 sp = get_register(buffer, LREG_SP);
  1188. S32 value = bytestream2integer(buffer, sp);
  1190. S32 address = lscript_local_get(buffer, arg);
  1192. lscript_local_store(buffer, arg, value);
  1193. lsa_increase_ref_count(buffer, value);
  1194. if (address)
  1195. lsa_decrease_ref_count(buffer, address);
  1196. return FALSE;
  1197. }
  1199. BOOL run_storev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1200. {
  1201. if (b_print)
  1202. printf("[0x%X]tSTOREV ", offset);
  1203. offset++;
  1204. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1205. if (b_print)
  1206. printf("0x%Xn", arg);
  1207. LLVector3 value;
  1208. S32 sp = get_register(buffer, LREG_SP);
  1209. bytestream2vector(value, buffer, sp);
  1210. lscript_local_store(buffer, arg, value);
  1211. return FALSE;
  1212. }
  1214. BOOL run_storeq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1215. {
  1216. if (b_print)
  1217. printf("[0x%X]tSTOREQ ", offset);
  1218. offset++;
  1219. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1220. if (b_print)
  1221. printf("0x%Xn", arg);
  1222. LLQuaternion value;
  1223. S32 sp = get_register(buffer, LREG_SP);
  1224. bytestream2quaternion(value, buffer, sp);
  1225. lscript_local_store(buffer, arg, value);
  1226. return FALSE;
  1227. }
  1229. BOOL run_storeg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1230. {
  1231. if (b_print)
  1232. printf("[0x%X]tSTOREG ", offset);
  1233. offset++;
  1234. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1235. if (b_print)
  1236. printf("0x%Xn", arg);
  1237. S32 sp = get_register(buffer, LREG_SP);
  1238. S32 value = bytestream2integer(buffer, sp);
  1239. lscript_global_store(buffer, arg, value);
  1240. return FALSE;
  1241. }
  1243. BOOL run_storegs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1244. {
  1245. if (b_print)
  1246. printf("[0x%X]tSTOREGS ", offset);
  1247. offset++;
  1248. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1249. if (b_print)
  1250. printf("0x%Xn", arg);
  1251. S32 sp = get_register(buffer, LREG_SP);
  1252. S32 value = bytestream2integer(buffer, sp);
  1254. S32 address = lscript_global_get(buffer, arg);
  1256. lscript_global_store(buffer, arg, value);
  1258. lsa_increase_ref_count(buffer, value);
  1259. if (address)
  1260. lsa_decrease_ref_count(buffer, address);
  1261. return FALSE;
  1262. }
  1264. BOOL run_storegl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1265. {
  1266. if (b_print)
  1267. printf("[0x%X]tSTOREGL ", offset);
  1268. offset++;
  1269. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1270. if (b_print)
  1271. printf("0x%Xn", arg);
  1272. S32 sp = get_register(buffer, LREG_SP);
  1273. S32 value = bytestream2integer(buffer, sp);
  1275. S32 address = lscript_global_get(buffer, arg);
  1277. lscript_global_store(buffer, arg, value);
  1279. lsa_increase_ref_count(buffer, value);
  1280. if (address)
  1281. lsa_decrease_ref_count(buffer, address);
  1282. return FALSE;
  1283. }
  1285. BOOL run_storegv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1286. {
  1287. if (b_print)
  1288. printf("[0x%X]tSTOREGV ", offset);
  1289. offset++;
  1290. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1291. if (b_print)
  1292. printf("0x%Xn", arg);
  1293. LLVector3 value;
  1294. S32 sp = get_register(buffer, LREG_SP);
  1295. bytestream2vector(value, buffer, sp);
  1296. lscript_global_store(buffer, arg, value);
  1297. return FALSE;
  1298. }
  1300. BOOL run_storegq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1301. {
  1302. if (b_print)
  1303. printf("[0x%X]tSTOREGQ ", offset);
  1304. offset++;
  1305. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1306. if (b_print)
  1307. printf("0x%Xn", arg);
  1308. LLQuaternion value;
  1309. S32 sp = get_register(buffer, LREG_SP);
  1310. bytestream2quaternion(value, buffer, sp);
  1311. lscript_global_store(buffer, arg, value);
  1312. return FALSE;
  1313. }
  1315. BOOL run_loadp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1316. {
  1317. if (b_print)
  1318. printf("[0x%X]tSTOREP ", offset);
  1319. offset++;
  1320. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1321. if (b_print)
  1322. printf("0x%Xn", arg);
  1323. S32 value = lscript_pop_int(buffer);
  1324. lscript_local_store(buffer, arg, value);
  1325. return FALSE;
  1326. }
  1328. BOOL run_loadsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1329. {
  1330. if (b_print)
  1331. printf("[0x%X]tSTORESP ", offset);
  1332. offset++;
  1333. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1334. if (b_print)
  1335. printf("0x%Xn", arg);
  1336. S32 value = lscript_pop_int(buffer);
  1338. S32 address = lscript_local_get(buffer, arg);
  1339. if (address)
  1340. lsa_decrease_ref_count(buffer, address);
  1342. lscript_local_store(buffer, arg, value);
  1343. return FALSE;
  1344. }
  1346. BOOL run_loadlp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1347. {
  1348. if (b_print)
  1349. printf("[0x%X]tSTORELP ", offset);
  1350. offset++;
  1351. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1352. if (b_print)
  1353. printf("0x%Xn", arg);
  1354. S32 value = lscript_pop_int(buffer);
  1356. S32 address = lscript_local_get(buffer, arg);
  1357. if (address)
  1358. lsa_decrease_ref_count(buffer, address);
  1360. lscript_local_store(buffer, arg, value);
  1361. return FALSE;
  1362. }
  1364. BOOL run_loadvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1365. {
  1366. if (b_print)
  1367. printf("[0x%X]tSTOREVP ", offset);
  1368. offset++;
  1369. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1370. if (b_print)
  1371. printf("0x%Xn", arg);
  1372. LLVector3 value;
  1373. lscript_pop_vector(buffer, value);
  1374. lscript_local_store(buffer, arg, value);
  1375. return FALSE;
  1376. }
  1378. BOOL run_loadqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1379. {
  1380. if (b_print)
  1381. printf("[0x%X]tSTOREQP ", offset);
  1382. offset++;
  1383. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1384. if (b_print)
  1385. printf("0x%Xn", arg);
  1386. LLQuaternion value;
  1387. lscript_pop_quaternion(buffer, value);
  1388. lscript_local_store(buffer, arg, value);
  1389. return FALSE;
  1390. }
  1392. BOOL run_loadgp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1393. {
  1394. if (b_print)
  1395. printf("[0x%X]tSTOREGP ", offset);
  1396. offset++;
  1397. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1398. if (b_print)
  1399. printf("0x%Xn", arg);
  1400. S32 value = lscript_pop_int(buffer);
  1401. lscript_global_store(buffer, arg, value);
  1402. return FALSE;
  1403. }
  1405. BOOL run_loadgsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1406. {
  1407. if (b_print)
  1408. printf("[0x%X]tSTOREGSP ", offset);
  1409. offset++;
  1410. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1411. if (b_print)
  1412. printf("%dn", arg);
  1413. S32 value = lscript_pop_int(buffer);
  1415. S32 address = lscript_global_get(buffer, arg);
  1416. if (address)
  1417. lsa_decrease_ref_count(buffer, address);
  1419. lscript_global_store(buffer, arg, value);
  1420. return FALSE;
  1421. }
  1423. BOOL run_loadglp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1424. {
  1425. if (b_print)
  1426. printf("[0x%X]tSTOREGLP ", offset);
  1427. offset++;
  1428. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1429. if (b_print)
  1430. printf("0x%Xn", arg);
  1431. S32 value = lscript_pop_int(buffer);
  1433. S32 address = lscript_global_get(buffer, arg);
  1434. if (address)
  1435. lsa_decrease_ref_count(buffer, address);
  1437. lscript_global_store(buffer, arg, value);
  1438. return FALSE;
  1439. }
  1441. BOOL run_loadgvp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1442. {
  1443. if (b_print)
  1444. printf("[0x%X]tSTOREGVP ", offset);
  1445. offset++;
  1446. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1447. if (b_print)
  1448. printf("0x%Xn", arg);
  1449. LLVector3 value;
  1450. lscript_pop_vector(buffer, value);
  1451. lscript_global_store(buffer, arg, value);
  1452. return FALSE;
  1453. }
  1455. BOOL run_loadgqp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1456. {
  1457. if (b_print)
  1458. printf("[0x%X]tSTOREGQP ", offset);
  1459. offset++;
  1460. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1461. if (b_print)
  1462. printf("0x%Xn", arg);
  1463. LLQuaternion value;
  1464. lscript_pop_quaternion(buffer, value);
  1465. lscript_global_store(buffer, arg, value);
  1466. return FALSE;
  1467. }
  1469. BOOL run_push(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1470. {
  1471. if (b_print)
  1472. printf("[0x%X]tPUSH ", offset);
  1473. offset++;
  1474. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1475. if (b_print)
  1476. printf("0x%Xn", arg);
  1477. S32 value = lscript_local_get(buffer, arg);
  1478. lscript_push(buffer, value);
  1479. return FALSE;
  1480. }
  1482. BOOL run_pushs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1483. {
  1484. if (b_print)
  1485. printf("[0x%X]tPUSHS ", offset);
  1486. offset++;
  1487. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1488. if (b_print)
  1489. printf("0x%Xn", arg);
  1490. S32 value = lscript_local_get(buffer, arg);
  1491. lscript_push(buffer, value);
  1492. lsa_increase_ref_count(buffer, value);
  1493. return FALSE;
  1494. }
  1496. BOOL run_pushl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1497. {
  1498. if (b_print)
  1499. printf("[0x%X]tPUSHL ", offset);
  1500. offset++;
  1501. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1502. if (b_print)
  1503. printf("0x%Xn", arg);
  1504. S32 value = lscript_local_get(buffer, arg);
  1505. lscript_push(buffer, value);
  1506. lsa_increase_ref_count(buffer, value);
  1507. return FALSE;
  1508. }
  1510. BOOL run_pushv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1511. {
  1512. if (b_print)
  1513. printf("[0x%X]tPUSHV ", offset);
  1514. offset++;
  1515. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1516. if (b_print)
  1517. printf("0x%Xn", arg);
  1518. LLVector3 value;
  1519. lscript_local_get(buffer, arg, value);
  1520. lscript_push(buffer, value);
  1521. return FALSE;
  1522. }
  1524. BOOL run_pushq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1525. {
  1526. if (b_print)
  1527. printf("[0x%X]tPUSHQ ", offset);
  1528. offset++;
  1529. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1530. if (b_print)
  1531. printf("0x%Xn", arg);
  1532. LLQuaternion value;
  1533. lscript_local_get(buffer, arg, value);
  1534. lscript_push(buffer, value);
  1535. return FALSE;
  1536. }
  1538. BOOL run_pushg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1539. {
  1540. if (b_print)
  1541. printf("[0x%X]tPUSHG ", offset);
  1542. offset++;
  1543. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1544. if (b_print)
  1545. printf("0x%Xn", arg);
  1546. S32 value = lscript_global_get(buffer, arg);
  1547. lscript_push(buffer, value);
  1548. return FALSE;
  1549. }
  1551. BOOL run_pushgs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1552. {
  1553. if (b_print)
  1554. printf("[0x%X]tPUSHGS ", offset);
  1555. offset++;
  1556. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1557. if (b_print)
  1558. printf("0x%Xn", arg);
  1559. S32 value = lscript_global_get(buffer, arg);
  1560. lscript_push(buffer, value);
  1561. lsa_increase_ref_count(buffer, value);
  1562. return FALSE;
  1563. }
  1565. BOOL run_pushgl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1566. {
  1567. if (b_print)
  1568. printf("[0x%X]tPUSHGL ", offset);
  1569. offset++;
  1570. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1571. if (b_print)
  1572. printf("0x%Xn", arg);
  1573. S32 value = lscript_global_get(buffer, arg);
  1574. lscript_push(buffer, value);
  1575. lsa_increase_ref_count(buffer, value);
  1576. return FALSE;
  1577. }
  1579. BOOL run_pushgv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1580. {
  1581. if (b_print)
  1582. printf("[0x%X]tPUSHGV ", offset);
  1583. offset++;
  1584. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1585. if (b_print)
  1586. printf("0x%Xn", arg);
  1587. LLVector3 value;
  1588. lscript_global_get(buffer, arg, value);
  1589. lscript_push(buffer, value);
  1590. return FALSE;
  1591. }
  1593. BOOL run_pushgq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1594. {
  1595. if (b_print)
  1596. printf("[0x%X]tPUSHGQ ", offset);
  1597. offset++;
  1598. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1599. if (b_print)
  1600. printf("0x%Xn", arg);
  1601. LLQuaternion value;
  1602. lscript_global_get(buffer, arg, value);
  1603. lscript_push(buffer, value);
  1604. return FALSE;
  1605. }
  1607. BOOL run_puship(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1608. {
  1609. if (b_print)
  1610. printf("[0x%X]tPUSHIPn", offset);
  1611. offset++;
  1612. lscript_push(buffer, offset);
  1613. return FALSE;
  1614. }
  1616. BOOL run_pushbp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1617. {
  1618. if (b_print)
  1619. printf("[0x%X]tPUSHBPn", offset);
  1620. offset++;
  1621. lscript_push(buffer, get_register(buffer, LREG_BP));
  1622. return FALSE;
  1623. }
  1625. BOOL run_pushsp(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1626. {
  1627. if (b_print)
  1628. printf("[0x%X]tPUSHSPn", offset);
  1629. offset++;
  1630. lscript_push(buffer, get_register(buffer, LREG_SP));
  1631. return FALSE;
  1632. }
  1634. BOOL run_pushargb(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1635. {
  1636. if (b_print)
  1637. printf("[0x%X]tPUSHGARGB ", offset);
  1638. offset++;
  1639. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  1640. if (b_print)
  1641. printf("%dn", (U32)arg);
  1642. lscript_push(buffer, arg);
  1643. return FALSE;
  1644. }
  1646. BOOL run_pushargi(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1647. {
  1648. if (b_print)
  1649. printf("[0x%X]tPUSHARGI ", offset);
  1650. offset++;
  1651. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1652. if (b_print)
  1653. printf("%dn", arg);
  1654. lscript_push(buffer, arg);
  1655. return FALSE;
  1656. }
  1658. BOOL run_pushargf(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1659. {
  1660. if (b_print)
  1661. printf("[0x%X]tPUSHARGF ", offset);
  1662. offset++;
  1663. F32 arg = safe_instruction_bytestream2float(buffer, offset);
  1664. if (b_print)
  1665. printf("%fn", arg);
  1666. lscript_push(buffer, arg);
  1667. return FALSE;
  1668. }
  1670. BOOL run_pushargs(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1671. {
  1672. if (b_print)
  1673. printf("[0x%X]tPUSHARGS ", offset);
  1674. S32 toffset = offset;
  1675. safe_instruction_bytestream_count_char(buffer, toffset);
  1676. S32 size = toffset - offset;
  1677. char *arg = new char[size];
  1678. offset++;
  1679. safe_instruction_bytestream2char(arg, buffer, offset, size);
  1680. if (b_print)
  1681. printf("%sn", arg);
  1682. S32 address = lsa_heap_add_data(buffer, new LLScriptLibData(arg), get_max_heap_size(buffer), TRUE);
  1683. lscript_push(buffer, address);
  1684. delete [] arg;
  1685. return FALSE;
  1686. }
  1688. BOOL run_pushargv(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1689. {
  1690. if (b_print)
  1691. printf("[0x%X]tPUSHARGV ", offset);
  1692. offset++;
  1693. LLVector3 arg;
  1694. safe_instruction_bytestream2vector(arg, buffer, offset);
  1695. if (b_print)
  1696. printf("< %f, %f, %f >n", arg.mV[VX], arg.mV[VY], arg.mV[VZ]);
  1697. lscript_push(buffer, arg);
  1698. return FALSE;
  1699. }
  1700. BOOL run_pushargq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1701. {
  1702. if (b_print)
  1703. printf("[0x%X]tPUSHARGQ ", offset);
  1704. offset++;
  1705. LLQuaternion arg;
  1706. safe_instruction_bytestream2quaternion(arg, buffer, offset);
  1707. if (b_print)
  1708. printf("< %f, %f, %f, %f >n", arg.mQ[VX], arg.mQ[VY], arg.mQ[VZ], arg.mQ[VS]);
  1709. lscript_push(buffer, arg);
  1710. return FALSE;
  1711. }
  1712. BOOL run_pushe(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1713. {
  1714. if (b_print)
  1715. printf("[0x%X]tPUSHEn", offset);
  1716. offset++;
  1717. lscript_pusharge(buffer, LSCRIPTDataSize[LST_INTEGER]);
  1718. return FALSE;
  1719. }
  1720. BOOL run_pushev(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1721. {
  1722. if (b_print)
  1723. printf("[0x%X]tPUSHEVn", offset);
  1724. offset++;
  1725. lscript_pusharge(buffer, LSCRIPTDataSize[LST_VECTOR]);
  1726. return FALSE;
  1727. }
  1728. BOOL run_pusheq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1729. {
  1730. if (b_print)
  1731. printf("[0x%X]tPUSHEQn", offset);
  1732. offset++;
  1733. lscript_pusharge(buffer, LSCRIPTDataSize[LST_QUATERNION]);
  1734. return FALSE;
  1735. }
  1736. BOOL run_pusharge(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  1737. {
  1738. if (b_print)
  1739. printf("[0x%X]tPUSHARGE ", offset);
  1740. offset++;
  1741. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  1742. if (b_print)
  1743. printf("%dn", arg);
  1744. lscript_pusharge(buffer, arg);
  1745. return FALSE;
  1746. }
  1748. void print_type(U8 type)
  1749. {
  1750. if (type == LSCRIPTTypeByte[LST_INTEGER])
  1751. {
  1752. printf("integer");
  1753. }
  1754. else if (type == LSCRIPTTypeByte[LST_FLOATINGPOINT])
  1755. {
  1756. printf("float");
  1757. }
  1758. else if (type == LSCRIPTTypeByte[LST_STRING])
  1759. {
  1760. printf("string");
  1761. }
  1762. else if (type == LSCRIPTTypeByte[LST_KEY])
  1763. {
  1764. printf("key");
  1765. }
  1766. else if (type == LSCRIPTTypeByte[LST_VECTOR])
  1767. {
  1768. printf("vector");
  1769. }
  1770. else if (type == LSCRIPTTypeByte[LST_QUATERNION])
  1771. {
  1772. printf("quaternion");
  1773. }
  1774. else if (type == LSCRIPTTypeByte[LST_LIST])
  1775. {
  1776. printf("list");
  1777. }
  1778. }
  1780. void unknown_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  1781. {
  1782. printf("Unknown arithmetic operation!n");
  1783. }
  1785. void integer_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  1786. {
  1787. S32 lside = lscript_pop_int(buffer);
  1788. S32 rside = lscript_pop_int(buffer);
  1789. S32 result = 0;
  1791. switch(opcode)
  1792. {
  1793. case LOPC_ADD:
  1794. result = lside + rside;
  1795. break;
  1796. case LOPC_SUB:
  1797. result = lside - rside;
  1798. break;
  1799. case LOPC_MUL:
  1800. result = lside * rside;
  1801. break;
  1802. case LOPC_DIV:
  1803. if (rside){
  1804. if( ( rside == -1 ) || ( rside == (S32) 0xffffffff ) )// division by -1 can have funny results: multiplication is OK: SL-31252
  1805. {
  1806. result = -1 * lside;
  1807. }
  1808. else
  1809. {
  1810. result = lside / rside;
  1811. }
  1812. }
  1813. else
  1814. set_fault(buffer, LSRF_MATH);
  1815. break;
  1816. case LOPC_MOD:
  1817. if (rside)
  1818. {
  1819. if (rside == -1 || rside == 1 )  // mod(1) = mod(-1) = 0: SL-31252
  1820. {
  1821. result = 0;
  1822. }
  1823. else
  1824. {
  1825. result = lside % rside;
  1826. }
  1827. }
  1828. else
  1829. set_fault(buffer, LSRF_MATH);
  1830. break;
  1831. case LOPC_EQ:
  1832. result = (lside == rside);
  1833. break;
  1834. case LOPC_NEQ:
  1835. result = (lside != rside);
  1836. break;
  1837. case LOPC_LEQ:
  1838. result = (lside <= rside);
  1839. break;
  1840. case LOPC_GEQ:
  1841. result = (lside >= rside);
  1842. break;
  1843. case LOPC_LESS:
  1844. result = (lside < rside);
  1845. break;
  1846. case LOPC_GREATER:
  1847. result = (lside > rside);
  1848. break;
  1849. case LOPC_BITAND:
  1850. result = (lside & rside);
  1851. break;
  1852. case LOPC_BITOR:
  1853. result = (lside | rside);
  1854. break;
  1855. case LOPC_BITXOR:
  1856. result = (lside ^ rside);
  1857. break;
  1858. case LOPC_BOOLAND:
  1859. result = (lside && rside);
  1860. break;
  1861. case LOPC_BOOLOR:
  1862. result = (lside || rside);
  1863. break;
  1864. case LOPC_SHL:
  1865. result = (lside << rside);
  1866. break;
  1867. case LOPC_SHR:
  1868. result = (lside >> rside);
  1869. break;
  1870. default:
  1871. break;
  1872. }
  1873. lscript_push(buffer, result);
  1874. }
  1876. void integer_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  1877. {
  1878. S32 lside = lscript_pop_int(buffer);
  1879. F32 rside = lscript_pop_float(buffer);
  1880. S32 resulti = 0;
  1881. F32 resultf = 0;
  1883. switch(opcode)
  1884. {
  1885. case LOPC_ADD:
  1886. resultf = lside + rside;
  1887. lscript_push(buffer, resultf);
  1888. break;
  1889. case LOPC_SUB:
  1890. resultf = lside - rside;
  1891. lscript_push(buffer, resultf);
  1892. break;
  1893. case LOPC_MUL:
  1894. resultf = lside * rside;
  1895. lscript_push(buffer, resultf);
  1896. break;
  1897. case LOPC_DIV:
  1898. if (rside)
  1899. resultf = lside / rside;
  1900. else
  1901. set_fault(buffer, LSRF_MATH);
  1902. lscript_push(buffer, resultf);
  1903. break;
  1904. case LOPC_EQ:
  1905. resulti = (lside == rside);
  1906. lscript_push(buffer, resulti);
  1907. break;
  1908. case LOPC_NEQ:
  1909. resulti = (lside != rside);
  1910. lscript_push(buffer, resulti);
  1911. break;
  1912. case LOPC_LEQ:
  1913. resulti = (lside <= rside);
  1914. lscript_push(buffer, resulti);
  1915. break;
  1916. case LOPC_GEQ:
  1917. resulti = (lside >= rside);
  1918. lscript_push(buffer, resulti);
  1919. break;
  1920. case LOPC_LESS:
  1921. resulti = (lside < rside);
  1922. lscript_push(buffer, resulti);
  1923. break;
  1924. case LOPC_GREATER:
  1925. resulti = (lside > rside);
  1926. lscript_push(buffer, resulti);
  1927. break;
  1928. default:
  1929. break;
  1930. }
  1931. }
  1933. void integer_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  1934. {
  1935. S32 lside = lscript_pop_int(buffer);
  1936. LLVector3 rside;
  1937. lscript_pop_vector(buffer, rside);
  1939. switch(opcode)
  1940. {
  1941. case LOPC_MUL:
  1942. rside *= (F32)lside;
  1943. lscript_push(buffer, rside);
  1944. break;
  1945. default:
  1946. break;
  1947. }
  1948. }
  1950. void float_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  1951. {
  1952. F32 lside = lscript_pop_float(buffer);
  1953. S32 rside = lscript_pop_int(buffer);
  1954. S32 resulti = 0;
  1955. F32 resultf = 0;
  1957. switch(opcode)
  1958. {
  1959. case LOPC_ADD:
  1960. resultf = lside + rside;
  1961. lscript_push(buffer, resultf);
  1962. break;
  1963. case LOPC_SUB:
  1964. resultf = lside - rside;
  1965. lscript_push(buffer, resultf);
  1966. break;
  1967. case LOPC_MUL:
  1968. resultf = lside * rside;
  1969. lscript_push(buffer, resultf);
  1970. break;
  1971. case LOPC_DIV:
  1972. if (rside)
  1973. resultf = lside / rside;
  1974. else
  1975. set_fault(buffer, LSRF_MATH);
  1976. lscript_push(buffer, resultf);
  1977. break;
  1978. case LOPC_EQ:
  1979. resulti = (lside == rside);
  1980. lscript_push(buffer, resulti);
  1981. break;
  1982. case LOPC_NEQ:
  1983. resulti = (lside != rside);
  1984. lscript_push(buffer, resulti);
  1985. break;
  1986. case LOPC_LEQ:
  1987. resulti = (lside <= rside);
  1988. lscript_push(buffer, resulti);
  1989. break;
  1990. case LOPC_GEQ:
  1991. resulti = (lside >= rside);
  1992. lscript_push(buffer, resulti);
  1993. break;
  1994. case LOPC_LESS:
  1995. resulti = (lside < rside);
  1996. lscript_push(buffer, resulti);
  1997. break;
  1998. case LOPC_GREATER:
  1999. resulti = (lside > rside);
  2000. lscript_push(buffer, resulti);
  2001. break;
  2002. default:
  2003. break;
  2004. }
  2005. }
  2007. void float_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2008. {
  2009. F32 lside = lscript_pop_float(buffer);
  2010. F32 rside = lscript_pop_float(buffer);
  2011. F32 resultf = 0;
  2012. S32 resulti = 0;
  2014. switch(opcode)
  2015. {
  2016. case LOPC_ADD:
  2017. resultf = lside + rside;
  2018. lscript_push(buffer, resultf);
  2019. break;
  2020. case LOPC_SUB:
  2021. resultf = lside - rside;
  2022. lscript_push(buffer, resultf);
  2023. break;
  2024. case LOPC_MUL:
  2025. resultf = lside * rside;
  2026. lscript_push(buffer, resultf);
  2027. break;
  2028. case LOPC_DIV:
  2029. if (rside)
  2030. resultf = lside / rside;
  2031. else
  2032. set_fault(buffer, LSRF_MATH);
  2033. lscript_push(buffer, resultf);
  2034. break;
  2035. case LOPC_EQ:
  2036. resulti = (lside == rside);
  2037. lscript_push(buffer, resulti);
  2038. break;
  2039. case LOPC_NEQ:
  2040. resulti = (lside != rside);
  2041. lscript_push(buffer, resulti);
  2042. break;
  2043. case LOPC_LEQ:
  2044. resulti = (lside <= rside);
  2045. lscript_push(buffer, resulti);
  2046. break;
  2047. case LOPC_GEQ:
  2048. resulti = (lside >= rside);
  2049. lscript_push(buffer, resulti);
  2050. break;
  2051. case LOPC_LESS:
  2052. resulti = (lside < rside);
  2053. lscript_push(buffer, resulti);
  2054. break;
  2055. case LOPC_GREATER:
  2056. resulti = (lside > rside);
  2057. lscript_push(buffer, resulti);
  2058. break;
  2059. default:
  2060. break;
  2061. }
  2062. }
  2064. void float_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2065. {
  2066. F32 lside = lscript_pop_float(buffer);
  2067. LLVector3 rside;
  2068. lscript_pop_vector(buffer, rside);
  2070. switch(opcode)
  2071. {
  2072. case LOPC_MUL:
  2073. rside *= lside;
  2074. lscript_push(buffer, rside);
  2075. break;
  2076. default:
  2077. break;
  2078. }
  2079. }
  2081. void string_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2082. {
  2083. S32 lside = lscript_pop_int(buffer);
  2084. S32 rside = lscript_pop_int(buffer);
  2085. S32 resulti;
  2086. S32 address;
  2088. switch(opcode)
  2089. {
  2090. case LOPC_ADD:
  2091. address = lsa_cat_strings(buffer, lside, rside, get_max_heap_size(buffer));
  2092. lscript_push(buffer, address);
  2093. break;
  2094. case LOPC_EQ:
  2095. resulti = !lsa_cmp_strings(buffer, lside, rside);
  2096. lscript_push(buffer, resulti);
  2097. break;
  2098. case LOPC_NEQ:
  2099. resulti = lsa_cmp_strings(buffer, lside, rside);
  2100. lscript_push(buffer, resulti);
  2101. break;
  2102. default:
  2103. break;
  2104. }
  2105. }
  2107. void string_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2108. {
  2109. S32 lside = lscript_pop_int(buffer);
  2110. S32 rside = lscript_pop_int(buffer);
  2111. S32 resulti;
  2113. switch(opcode)
  2114. {
  2115. case LOPC_NEQ:
  2116. resulti = lsa_cmp_strings(buffer, lside, rside);
  2117. lscript_push(buffer, resulti);
  2118. break;
  2119. case LOPC_EQ:
  2120. resulti = !lsa_cmp_strings(buffer, lside, rside);
  2121. lscript_push(buffer, resulti);
  2122. break;
  2123. default:
  2124. break;
  2125. }
  2126. }
  2128. void key_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2129. {
  2130. S32 lside = lscript_pop_int(buffer);
  2131. S32 rside = lscript_pop_int(buffer);
  2132. S32 resulti;
  2134. switch(opcode)
  2135. {
  2136. case LOPC_NEQ:
  2137. resulti = lsa_cmp_strings(buffer, lside, rside);
  2138. lscript_push(buffer, resulti);
  2139. break;
  2140. case LOPC_EQ:
  2141. resulti = !lsa_cmp_strings(buffer, lside, rside);
  2142. lscript_push(buffer, resulti);
  2143. break;
  2144. default:
  2145. break;
  2146. }
  2147. }
  2149. void key_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2150. {
  2151. S32 lside = lscript_pop_int(buffer);
  2152. S32 rside = lscript_pop_int(buffer);
  2153. S32 resulti;
  2155. switch(opcode)
  2156. {
  2157. case LOPC_EQ:
  2158. resulti = !lsa_cmp_strings(buffer, lside, rside);
  2159. lscript_push(buffer, resulti);
  2160. break;
  2161. case LOPC_NEQ:
  2162. resulti = lsa_cmp_strings(buffer, lside, rside);
  2163. lscript_push(buffer, resulti);
  2164. break;
  2165. default:
  2166. break;
  2167. }
  2168. }
  2170. void vector_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2171. {
  2172. LLVector3 lside;
  2173. lscript_pop_vector(buffer, lside);
  2174. S32 rside = lscript_pop_int(buffer);
  2176. switch(opcode)
  2177. {
  2178. case LOPC_MUL:
  2179. lside *= (F32)rside;
  2180. lscript_push(buffer, lside);
  2181. break;
  2182. case LOPC_DIV:
  2183. if (rside)
  2184. lside *= (1.f/rside);
  2185. else
  2186. set_fault(buffer, LSRF_MATH);
  2187. lscript_push(buffer, lside);
  2188. break;
  2189. default:
  2190. break;
  2191. }
  2192. }
  2194. void vector_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2195. {
  2196. LLVector3 lside;
  2197. lscript_pop_vector(buffer, lside);
  2198. F32 rside = lscript_pop_float(buffer);
  2200. switch(opcode)
  2201. {
  2202. case LOPC_MUL:
  2203. lside *= rside;
  2204. lscript_push(buffer, lside);
  2205. break;
  2206. case LOPC_DIV:
  2207. if (rside)
  2208. lside *= (1.f/rside);
  2209. else
  2210. set_fault(buffer, LSRF_MATH);
  2211. lscript_push(buffer, lside);
  2212. break;
  2213. default:
  2214. break;
  2215. }
  2216. }
  2218. void vector_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2219. {
  2220. LLVector3 lside;
  2221. lscript_pop_vector(buffer, lside);
  2222. LLVector3 rside;
  2223. lscript_pop_vector(buffer, rside);
  2224. S32 resulti = 0;
  2225. F32 resultf = 0.f;
  2227. switch(opcode)
  2228. {
  2229. case LOPC_ADD:
  2230. lside += rside;
  2231. lscript_push(buffer, lside);
  2232. break;
  2233. case LOPC_SUB:
  2234. lside -= rside;
  2235. lscript_push(buffer, lside);
  2236. break;
  2237. case LOPC_MUL:
  2238. resultf = lside * rside;
  2239. lscript_push(buffer, resultf);
  2240. break;
  2241. case LOPC_MOD:
  2242. lside = lside % rside;
  2243. lscript_push(buffer, lside);
  2244. break;
  2245. case LOPC_EQ:
  2246. resulti = (lside == rside);
  2247. lscript_push(buffer, resulti);
  2248. break;
  2249. case LOPC_NEQ:
  2250. resulti = (lside != rside);
  2251. lscript_push(buffer, resulti);
  2252. break;
  2253. default:
  2254. break;
  2255. }
  2256. }
  2258. void vector_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2259. {
  2260. LLVector3 lside;
  2261. lscript_pop_vector(buffer, lside);
  2262. LLQuaternion rside;
  2263. lscript_pop_quaternion(buffer, rside);
  2265. switch(opcode)
  2266. {
  2267. case LOPC_MUL:
  2268. lside = lside * rside;
  2269. lscript_push(buffer, lside);
  2270. break;
  2271. case LOPC_DIV:
  2272. lside = lside * rside.conjQuat();
  2273. lscript_push(buffer, lside);
  2274. break;
  2275. default:
  2276. break;
  2277. }
  2278. }
  2280. void quaternion_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2281. {
  2282. LLQuaternion lside;
  2283. lscript_pop_quaternion(buffer, lside);
  2284. LLQuaternion rside;
  2285. lscript_pop_quaternion(buffer, rside);
  2286. S32 resulti = 0;
  2288. switch(opcode)
  2289. {
  2290. case LOPC_ADD:
  2291. lside = lside + rside;
  2292. lscript_push(buffer, lside);
  2293. break;
  2294. case LOPC_SUB:
  2295. lside = lside - rside;
  2296. lscript_push(buffer, lside);
  2297. break;
  2298. case LOPC_MUL:
  2299. lside *= rside;
  2300. lscript_push(buffer, lside);
  2301. break;
  2302. case LOPC_DIV:
  2303. lside = lside * rside.conjQuat();
  2304. lscript_push(buffer, lside);
  2305. break;
  2306. case LOPC_EQ:
  2307. resulti = (lside == rside);
  2308. lscript_push(buffer, resulti);
  2309. break;
  2310. case LOPC_NEQ:
  2311. resulti = (lside != rside);
  2312. lscript_push(buffer, resulti);
  2313. break;
  2314. default:
  2315. break;
  2316. }
  2317. }
  2319. void integer_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2320. {
  2321. S32 lside = lscript_pop_int(buffer);
  2322. S32 rside = lscript_pop_int(buffer);
  2323. S32 address;
  2325. switch(opcode)
  2326. {
  2327. case LOPC_ADD:
  2328. {
  2329. LLScriptLibData *list = new LLScriptLibData;
  2330. list->mType = LST_LIST;
  2331. list->mListp = new LLScriptLibData(lside);
  2332. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2333. lscript_push(buffer, address);
  2334. list->mListp = NULL;
  2335. delete list;
  2336. }
  2337. break;
  2338. default:
  2339. break;
  2340. }
  2341. }
  2343. void float_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2344. {
  2345. F32 lside = lscript_pop_float(buffer);
  2346. S32 rside = lscript_pop_int(buffer);
  2347. S32 address;
  2349. switch(opcode)
  2350. {
  2351. case LOPC_ADD:
  2352. {
  2353. LLScriptLibData *list = new LLScriptLibData;
  2354. list->mType = LST_LIST;
  2355. list->mListp = new LLScriptLibData(lside);
  2356. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2357. lscript_push(buffer, address);
  2358. list->mListp = NULL;
  2359. delete list;
  2360. }
  2361. break;
  2362. default:
  2363. break;
  2364. }
  2365. }
  2367. void string_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2368. {
  2369. S32 lside = lscript_pop_int(buffer);
  2370. S32 rside = lscript_pop_int(buffer);
  2371. S32 address;
  2373. switch(opcode)
  2374. {
  2375. case LOPC_ADD:
  2376. {
  2377. LLScriptLibData *string = lsa_get_data(buffer, lside, TRUE);
  2378. LLScriptLibData *list = new LLScriptLibData;
  2379. list->mType = LST_LIST;
  2380. list->mListp = string;
  2381. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2382. lscript_push(buffer, address);
  2383. list->mListp = NULL;
  2384. delete list;
  2385. }
  2386. break;
  2387. default:
  2388. break;
  2389. }
  2390. }
  2392. void key_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2393. {
  2394. S32 lside = lscript_pop_int(buffer);
  2395. S32 rside = lscript_pop_int(buffer);
  2396. S32 address;
  2398. switch(opcode)
  2399. {
  2400. case LOPC_ADD:
  2401. {
  2402. LLScriptLibData *key = lsa_get_data(buffer, lside, TRUE);
  2403. // need to convert key to key, since it comes out like a string
  2404. if (key->mType == LST_STRING)
  2405. {
  2406. key->mKey = key->mString;
  2407. key->mString = NULL;
  2408. key->mType = LST_KEY;
  2409. }
  2410. LLScriptLibData *list = new LLScriptLibData;
  2411. list->mType = LST_LIST;
  2412. list->mListp = key;
  2413. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2414. lscript_push(buffer, address);
  2415. list->mListp = NULL;
  2416. delete list;
  2417. }
  2418. break;
  2419. default:
  2420. break;
  2421. }
  2422. }
  2424. void vector_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2425. {
  2426. LLVector3 lside;
  2427. lscript_pop_vector(buffer, lside);
  2428. S32 rside = lscript_pop_int(buffer);
  2429. S32 address;
  2431. switch(opcode)
  2432. {
  2433. case LOPC_ADD:
  2434. {
  2435. LLScriptLibData *list = new LLScriptLibData;
  2436. list->mType = LST_LIST;
  2437. list->mListp = new LLScriptLibData(lside);
  2438. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2439. lscript_push(buffer, address);
  2440. list->mListp = NULL;
  2441. delete list;
  2442. }
  2443. break;
  2444. default:
  2445. break;
  2446. }
  2447. }
  2449. void quaternion_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2450. {
  2451. LLQuaternion lside;
  2452. lscript_pop_quaternion(buffer, lside);
  2453. S32 rside = lscript_pop_int(buffer);
  2454. S32 address;
  2456. switch(opcode)
  2457. {
  2458. case LOPC_ADD:
  2459. {
  2460. LLScriptLibData *list = new LLScriptLibData;
  2461. list->mType = LST_LIST;
  2462. list->mListp = new LLScriptLibData(lside);
  2463. address = lsa_preadd_lists(buffer, list, rside, get_max_heap_size(buffer));
  2464. lscript_push(buffer, address);
  2465. list->mListp = NULL;
  2466. delete list;
  2467. }
  2468. break;
  2469. default:
  2470. break;
  2471. }
  2472. }
  2474. void list_integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2475. {
  2476. S32 lside = lscript_pop_int(buffer);
  2477. S32 rside = lscript_pop_int(buffer);
  2478. S32 address;
  2480. switch(opcode)
  2481. {
  2482. case LOPC_ADD:
  2483. {
  2484. LLScriptLibData *list = new LLScriptLibData;
  2485. list->mType = LST_LIST;
  2486. list->mListp = new LLScriptLibData(rside);
  2487. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2488. list->mListp = NULL;
  2489. delete list;
  2490. lscript_push(buffer, address);
  2491. }
  2492. break;
  2493. default:
  2494. break;
  2495. }
  2496. }
  2498. void list_float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2499. {
  2500. S32 lside = lscript_pop_int(buffer);
  2501. F32 rside = lscript_pop_float(buffer);
  2502. S32 address;
  2504. switch(opcode)
  2505. {
  2506. case LOPC_ADD:
  2507. {
  2508. LLScriptLibData *list = new LLScriptLibData;
  2509. list->mType = LST_LIST;
  2510. list->mListp = new LLScriptLibData(rside);
  2511. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2512. list->mListp = NULL;
  2513. delete list;
  2514. lscript_push(buffer, address);
  2515. }
  2516. break;
  2517. default:
  2518. break;
  2519. }
  2520. }
  2522. void list_string_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2523. {
  2524. S32 lside = lscript_pop_int(buffer);
  2525. S32 rside = lscript_pop_int(buffer);
  2526. S32 address;
  2528. switch(opcode)
  2529. {
  2530. case LOPC_ADD:
  2531. {
  2532. LLScriptLibData *string = lsa_get_data(buffer, rside, TRUE);
  2533. LLScriptLibData *list = new LLScriptLibData;
  2534. list->mType = LST_LIST;
  2535. list->mListp = string;
  2536. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2537. list->mListp = NULL;
  2538. delete list;
  2539. lscript_push(buffer, address);
  2540. }
  2541. break;
  2542. default:
  2543. break;
  2544. }
  2545. }
  2547. void list_key_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2548. {
  2549. S32 lside = lscript_pop_int(buffer);
  2550. S32 rside = lscript_pop_int(buffer);
  2551. S32 address;
  2553. switch(opcode)
  2554. {
  2555. case LOPC_ADD:
  2556. {
  2557. LLScriptLibData *key = lsa_get_data(buffer, rside, TRUE);
  2558. // need to convert key to key, since it comes out like a string
  2559. if (key->mType == LST_STRING)
  2560. {
  2561. key->mKey = key->mString;
  2562. key->mString = NULL;
  2563. key->mType = LST_KEY;
  2564. }
  2565. LLScriptLibData *list = new LLScriptLibData;
  2566. list->mType = LST_LIST;
  2567. list->mListp = key;
  2568. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2569. list->mListp = NULL;
  2570. delete list;
  2571. lscript_push(buffer, address);
  2572. }
  2573. break;
  2574. default:
  2575. break;
  2576. }
  2577. }
  2579. void list_vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2580. {
  2581. S32 lside = lscript_pop_int(buffer);
  2582. LLVector3 rside;
  2583. lscript_pop_vector(buffer, rside);
  2584. S32 address;
  2586. switch(opcode)
  2587. {
  2588. case LOPC_ADD:
  2589. {
  2590. LLScriptLibData *list = new LLScriptLibData;
  2591. list->mType = LST_LIST;
  2592. list->mListp = new LLScriptLibData(rside);
  2593. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2594. list->mListp = NULL;
  2595. delete list;
  2596. lscript_push(buffer, address);
  2597. }
  2598. break;
  2599. default:
  2600. break;
  2601. }
  2602. }
  2604. void list_quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2605. {
  2606. S32 lside = lscript_pop_int(buffer);
  2607. LLQuaternion rside;
  2608. lscript_pop_quaternion(buffer, rside);
  2609. S32 address;
  2611. switch(opcode)
  2612. {
  2613. case LOPC_ADD:
  2614. {
  2615. LLScriptLibData *list = new LLScriptLibData;
  2616. list->mType = LST_LIST;
  2617. list->mListp = new LLScriptLibData(rside);
  2618. address = lsa_postadd_lists(buffer, lside, list, get_max_heap_size(buffer));
  2619. list->mListp = NULL;
  2620. delete list;
  2621. lscript_push(buffer, address);
  2622. }
  2623. break;
  2624. default:
  2625. break;
  2626. }
  2627. }
  2629. void list_list_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2630. {
  2631. S32 lside = lscript_pop_int(buffer);
  2632. S32 rside = lscript_pop_int(buffer);
  2633. S32 resulti;
  2634. S32 address;
  2636. switch(opcode)
  2637. {
  2638. case LOPC_ADD:
  2639. address = lsa_cat_lists(buffer, lside, rside, get_max_heap_size(buffer));
  2640. lscript_push(buffer, address);
  2641. break;
  2642. case LOPC_EQ:
  2643. resulti = !lsa_cmp_lists(buffer, lside, rside);
  2644. lscript_push(buffer, resulti);
  2645. break;
  2646. case LOPC_NEQ:
  2647. resulti = lsa_cmp_lists(buffer, lside, rside);
  2648. lscript_push(buffer, resulti);
  2649. break;
  2650. default:
  2651. break;
  2652. }
  2653. }
  2655. static U8 safe_op_index(U8 index)
  2656. {
  2657. if(index >= LST_EOF)
  2658. {
  2659. // Operations on LST_NULL will always be unknown_operation.
  2660. index = LST_NULL;
  2661. }
  2662. return index;
  2663. }
  2665. BOOL run_add(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2666. {
  2667. if (b_print)
  2668. printf("[0x%X]tADD ", offset);
  2669. offset++;
  2670. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2671. U8 arg1 = safe_op_index(arg >> 4);
  2672. U8 arg2 = safe_op_index(arg & 0xf);
  2673. if (b_print)
  2674. {
  2675. print_type(arg1);
  2676. printf(", ");
  2677. print_type(arg2);
  2678. printf("n");
  2679. }
  2680. binary_operations[arg1][arg2](buffer, LOPC_ADD);
  2681. return FALSE;
  2682. }
  2684. BOOL run_sub(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2685. {
  2686. if (b_print)
  2687. printf("[0x%X]tSUB ", offset);
  2688. offset++;
  2689. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2690. U8 arg1 = safe_op_index(arg >> 4);
  2691. U8 arg2 = safe_op_index(arg & 0xf);
  2692. if (b_print)
  2693. {
  2694. print_type(arg1);
  2695. printf(", ");
  2696. print_type(arg2);
  2697. printf("n");
  2698. }
  2699. binary_operations[arg1][arg2](buffer, LOPC_SUB);
  2700. return FALSE;
  2701. }
  2702. BOOL run_mul(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2703. {
  2704. if (b_print)
  2705. printf("[0x%X]tMUL ", offset);
  2706. offset++;
  2707. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2708. U8 arg1 = safe_op_index(arg >> 4);
  2709. U8 arg2 = safe_op_index(arg & 0xf);
  2710. if (b_print)
  2711. {
  2712. print_type(arg1);
  2713. printf(", ");
  2714. print_type(arg2);
  2715. printf("n");
  2716. }
  2717. binary_operations[arg1][arg2](buffer, LOPC_MUL);
  2718. return FALSE;
  2719. }
  2720. BOOL run_div(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2721. {
  2722. if (b_print)
  2723. printf("[0x%X]tDIV ", offset);
  2724. offset++;
  2725. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2726. U8 arg1 = safe_op_index(arg >> 4);
  2727. U8 arg2 = safe_op_index(arg & 0xf);
  2728. if (b_print)
  2729. {
  2730. print_type(arg1);
  2731. printf(", ");
  2732. print_type(arg2);
  2733. printf("n");
  2734. }
  2735. binary_operations[arg1][arg2](buffer, LOPC_DIV);
  2736. return FALSE;
  2737. }
  2738. BOOL run_mod(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2739. {
  2740. if (b_print)
  2741. printf("[0x%X]tMOD ", offset);
  2742. offset++;
  2743. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2744. U8 arg1 = safe_op_index(arg >> 4);
  2745. U8 arg2 = safe_op_index(arg & 0xf);
  2746. if (b_print)
  2747. {
  2748. print_type(arg1);
  2749. printf(", ");
  2750. print_type(arg2);
  2751. printf("n");
  2752. }
  2753. binary_operations[arg1][arg2](buffer, LOPC_MOD);
  2754. return FALSE;
  2755. }
  2757. BOOL run_eq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2758. {
  2759. if (b_print)
  2760. printf("[0x%X]tEQ ", offset);
  2761. offset++;
  2762. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2763. U8 arg1 = safe_op_index(arg >> 4);
  2764. U8 arg2 = safe_op_index(arg & 0xf);
  2765. if (b_print)
  2766. {
  2767. print_type(arg1);
  2768. printf(", ");
  2769. print_type(arg2);
  2770. printf("n");
  2771. }
  2772. binary_operations[arg1][arg2](buffer, LOPC_EQ);
  2773. return FALSE;
  2774. }
  2775. BOOL run_neq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2776. {
  2777. if (b_print)
  2778. printf("[0x%X]tNEQ ", offset);
  2779. offset++;
  2780. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2781. U8 arg1 = safe_op_index(arg >> 4);
  2782. U8 arg2 = safe_op_index(arg & 0xf);
  2783. if (b_print)
  2784. {
  2785. print_type(arg1);
  2786. printf(", ");
  2787. print_type(arg2);
  2788. printf("n");
  2789. }
  2790. binary_operations[arg1][arg2](buffer, LOPC_NEQ);
  2791. return FALSE;
  2792. }
  2793. BOOL run_leq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2794. {
  2795. if (b_print)
  2796. printf("[0x%X]tLEQ ", offset);
  2797. offset++;
  2798. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2799. U8 arg1 = safe_op_index(arg >> 4);
  2800. U8 arg2 = safe_op_index(arg & 0xf);
  2801. if (b_print)
  2802. {
  2803. print_type(arg1);
  2804. printf(", ");
  2805. print_type(arg2);
  2806. printf("n");
  2807. }
  2808. binary_operations[arg1][arg2](buffer, LOPC_LEQ);
  2809. return FALSE;
  2810. }
  2811. BOOL run_geq(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2812. {
  2813. if (b_print)
  2814. printf("[0x%X]tGEQ ", offset);
  2815. offset++;
  2816. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2817. U8 arg1 = safe_op_index(arg >> 4);
  2818. U8 arg2 = safe_op_index(arg & 0xf);
  2819. if (b_print)
  2820. {
  2821. print_type(arg1);
  2822. printf(", ");
  2823. print_type(arg2);
  2824. printf("n");
  2825. }
  2826. binary_operations[arg1][arg2](buffer, LOPC_GEQ);
  2827. return FALSE;
  2828. }
  2829. BOOL run_less(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2830. {
  2831. if (b_print)
  2832. printf("[0x%X]tLESS ", offset);
  2833. offset++;
  2834. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2835. U8 arg1 = safe_op_index(arg >> 4);
  2836. U8 arg2 = safe_op_index(arg & 0xf);
  2837. if (b_print)
  2838. {
  2839. print_type(arg1);
  2840. printf(", ");
  2841. print_type(arg2);
  2842. printf("n");
  2843. }
  2844. binary_operations[arg1][arg2](buffer, LOPC_LESS);
  2845. return FALSE;
  2846. }
  2847. BOOL run_greater(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2848. {
  2849. if (b_print)
  2850. printf("[0x%X]tGREATER ", offset);
  2851. offset++;
  2852. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  2853. U8 arg1 = safe_op_index(arg >> 4);
  2854. U8 arg2 = safe_op_index(arg & 0xf);
  2855. if (b_print)
  2856. {
  2857. print_type(arg1);
  2858. printf(", ");
  2859. print_type(arg2);
  2860. printf("n");
  2861. }
  2862. binary_operations[arg1][arg2](buffer, LOPC_GREATER);
  2863. return FALSE;
  2864. }
  2866. BOOL run_bitand(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2867. {
  2868. if (b_print)
  2869. printf("[0x%X]tBITANDn", offset);
  2870. offset++;
  2871. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITAND);
  2872. return FALSE;
  2873. }
  2874. BOOL run_bitor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2875. {
  2876. if (b_print)
  2877. printf("[0x%X]tBITORn", offset);
  2878. offset++;
  2879. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITOR);
  2880. return FALSE;
  2881. }
  2882. BOOL run_bitxor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2883. {
  2884. if (b_print)
  2885. printf("[0x%X]tBITXORn", offset);
  2886. offset++;
  2887. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BITXOR);
  2888. return FALSE;
  2889. }
  2890. BOOL run_booland(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2891. {
  2892. if (b_print)
  2893. printf("[0x%X]tBOOLANDn", offset);
  2894. offset++;
  2895. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BOOLAND);
  2896. return FALSE;
  2897. }
  2898. BOOL run_boolor(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2899. {
  2900. if (b_print)
  2901. printf("[0x%X]tBOOLORn", offset);
  2902. offset++;
  2903. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_BOOLOR);
  2904. return FALSE;
  2905. }
  2907. BOOL run_shl(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2908. {
  2909. if (b_print)
  2910. printf("[0x%X]tSHLn", offset);
  2911. offset++;
  2912. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_SHL);
  2913. return FALSE;
  2914. }
  2915. BOOL run_shr(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2916. {
  2917. if (b_print)
  2918. printf("[0x%X]tSHRn", offset);
  2919. offset++;
  2920. binary_operations[LST_INTEGER][LST_INTEGER](buffer, LOPC_SHR);
  2921. return FALSE;
  2922. }
  2924. void integer_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2925. {
  2926. S32 lside = lscript_pop_int(buffer);
  2927. S32 result = 0;
  2929. switch(opcode)
  2930. {
  2931. case LOPC_NEG:
  2932. result = -lside;
  2933. break;
  2934. case LOPC_BITNOT:
  2935. result = ~lside;
  2936. break;
  2937. case LOPC_BOOLNOT:
  2938. result = !lside;
  2939. break;
  2940. default:
  2941. break;
  2942. }
  2943. lscript_push(buffer, result);
  2944. }
  2946. void float_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2947. {
  2948. F32 lside = lscript_pop_float(buffer);
  2949. F32 result = 0;
  2951. switch(opcode)
  2952. {
  2953. case LOPC_NEG:
  2954. result = -lside;
  2955. lscript_push(buffer, result);
  2956. break;
  2957. default:
  2958. break;
  2959. }
  2960. }
  2962. void vector_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2963. {
  2964. LLVector3 lside;
  2965. lscript_pop_vector(buffer, lside);
  2966. LLVector3 result;
  2968. switch(opcode)
  2969. {
  2970. case LOPC_NEG:
  2971. result = -lside;
  2972. lscript_push(buffer, result);
  2973. break;
  2974. default:
  2975. break;
  2976. }
  2977. }
  2979. void quaternion_operation(U8 *buffer, LSCRIPTOpCodesEnum opcode)
  2980. {
  2981. LLQuaternion lside;
  2982. lscript_pop_quaternion(buffer, lside);
  2983. LLQuaternion result;
  2985. switch(opcode)
  2986. {
  2987. case LOPC_NEG:
  2988. result = -lside;
  2989. lscript_push(buffer, result);
  2990. break;
  2991. default:
  2992. break;
  2993. }
  2994. }
  2996. BOOL run_neg(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  2997. {
  2998. if (b_print)
  2999. printf("[0x%X]tNEG ", offset);
  3000. offset++;
  3001. U8 arg = safe_op_index(safe_instruction_bytestream2byte(buffer, offset));
  3002. if (b_print)
  3003. {
  3004. print_type(arg);
  3005. printf("n");
  3006. }
  3007. unary_operations[arg](buffer, LOPC_NEG);
  3008. return FALSE;
  3009. }
  3011. BOOL run_bitnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3012. {
  3013. if (b_print)
  3014. printf("[0x%X]tBITNOTn", offset);
  3015. offset++;
  3016. unary_operations[LST_INTEGER](buffer, LOPC_BITNOT);
  3017. return FALSE;
  3018. }
  3020. BOOL run_boolnot(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3021. {
  3022. if (b_print)
  3023. printf("[0x%X]tBOOLNOTn", offset);
  3024. offset++;
  3025. unary_operations[LST_INTEGER](buffer, LOPC_BOOLNOT);
  3026. return FALSE;
  3027. }
  3029. BOOL run_jump(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3030. {
  3031. if (b_print)
  3032. printf("[0x%X]tJUMP ", offset);
  3033. offset++;
  3034. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  3035. if (b_print)
  3036. printf("%dn", arg);
  3037. offset += arg;
  3038. return FALSE;
  3039. }
  3041. BOOL run_jumpif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3042. {
  3043. if (b_print)
  3044. printf("[0x%X]tJUMPIF ", offset);
  3045. offset++;
  3046. U8 type = safe_instruction_bytestream2byte(buffer, offset);
  3047. if (b_print)
  3048. {
  3049. print_type(type);
  3050. printf(", ");
  3051. }
  3052. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  3053. if (b_print)
  3054. printf("%dn", arg);
  3056. if (type == LST_INTEGER)
  3057. {
  3058. S32 test = lscript_pop_int(buffer);
  3059. if (test)
  3060. {
  3061. offset += arg;
  3062. }
  3063. }
  3064. else if (type == LST_FLOATINGPOINT)
  3065. {
  3066. F32 test = lscript_pop_float(buffer);
  3067. if (test)
  3068. {
  3069. offset += arg;
  3070. }
  3071. }
  3072. else if (type == LST_VECTOR)
  3073. {
  3074. LLVector3 test;
  3075. lscript_pop_vector(buffer, test);
  3076. if (!test.isExactlyZero())
  3077. {
  3078. offset += arg;
  3079. }
  3080. }
  3081. else if (type == LST_QUATERNION)
  3082. {
  3083. LLQuaternion test;
  3084. lscript_pop_quaternion(buffer, test);
  3085. if (!test.isIdentity())
  3086. {
  3087. offset += arg;
  3088. }
  3089. }
  3090. else if (type == LST_STRING)
  3091. {
  3092. S32 base_address = lscript_pop_int(buffer);
  3093. // this bit of nastiness is to get around that code paths to
  3094. // local variables can result in lack of initialization and
  3095. // function clean up of ref counts isn't based on scope (a
  3096. // mistake, I know)
  3097. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3098. if (address)
  3099. {
  3100. S32 string = address;
  3101. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3102. if (safe_heap_check_address(buffer, string, 1))
  3103. {
  3104. S32 toffset = string;
  3105. safe_heap_bytestream_count_char(buffer, toffset);
  3106. S32 size = toffset - string;
  3107. char *sdata = new char[size];
  3108. bytestream2char(sdata, buffer, string, size);
  3109. if (strlen(sdata)) /*Flawfinder: ignore*/
  3110. {
  3111. offset += arg;
  3112. }
  3113. delete [] sdata;
  3114. }
  3115. lsa_decrease_ref_count(buffer, base_address);
  3116. }
  3117. }
  3118. else if (type == LST_KEY)
  3119. {
  3120. S32 base_address = lscript_pop_int(buffer);
  3121. // this bit of nastiness is to get around that code paths to
  3122. // local variables can result in lack of initialization and
  3123. // function clean up of ref counts isn't based on scope (a
  3124. // mistake, I know)
  3125. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3126. if (address)
  3127. {
  3128. S32 string = address;
  3129. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3130. if (safe_heap_check_address(buffer, string, 1))
  3131. {
  3132. S32 toffset = string;
  3133. safe_heap_bytestream_count_char(buffer, toffset);
  3134. S32 size = toffset - string;
  3135. char *sdata = new char[size];
  3136. bytestream2char(sdata, buffer, string, size);
  3137. if (strlen(sdata)) /*Flawfinder: ignore*/
  3138. {
  3139. LLUUID id;
  3140. if (id.set(sdata) && id.notNull())
  3141. offset += arg;
  3142. }
  3143. delete [] sdata;
  3144. }
  3145. lsa_decrease_ref_count(buffer, base_address);
  3146. }
  3147. }
  3148. else if (type == LST_LIST)
  3149. {
  3150. S32 base_address = lscript_pop_int(buffer);
  3151. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3152. if (address)
  3153. {
  3154. if (safe_heap_check_address(buffer, address + SIZEOF_SCRIPT_ALLOC_ENTRY, 1))
  3155. {
  3156. LLScriptLibData *list = lsa_get_list_ptr(buffer, base_address, TRUE);
  3157. if (list && list->getListLength())
  3158. {
  3159. offset += arg;
  3160. }
  3161. delete list;
  3162. }
  3163. }
  3164. }
  3165. return FALSE;
  3166. }
  3168. BOOL run_jumpnif(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3169. {
  3170. if (b_print)
  3171. printf("[0x%X]tJUMPNIF ", offset);
  3172. offset++;
  3173. U8 type = safe_instruction_bytestream2byte(buffer, offset);
  3174. if (b_print)
  3175. {
  3176. print_type(type);
  3177. printf(", ");
  3178. }
  3179. S32 arg = safe_instruction_bytestream2integer(buffer, offset);
  3180. if (b_print)
  3181. printf("%dn", arg);
  3183. if (type == LST_INTEGER)
  3184. {
  3185. S32 test = lscript_pop_int(buffer);
  3186. if (!test)
  3187. {
  3188. offset += arg;
  3189. }
  3190. }
  3191. else if (type == LST_FLOATINGPOINT)
  3192. {
  3193. F32 test = lscript_pop_float(buffer);
  3194. if (!test)
  3195. {
  3196. offset += arg;
  3197. }
  3198. }
  3199. else if (type == LST_VECTOR)
  3200. {
  3201. LLVector3 test;
  3202. lscript_pop_vector(buffer, test);
  3203. if (test.isExactlyZero())
  3204. {
  3205. offset += arg;
  3206. }
  3207. }
  3208. else if (type == LST_QUATERNION)
  3209. {
  3210. LLQuaternion test;
  3211. lscript_pop_quaternion(buffer, test);
  3212. if (test.isIdentity())
  3213. {
  3214. offset += arg;
  3215. }
  3216. }
  3217. else if (type == LST_STRING)
  3218. {
  3219. S32 base_address = lscript_pop_int(buffer);
  3220. // this bit of nastiness is to get around that code paths to
  3221. // local variables can result in lack of initialization and
  3222. // function clean up of ref counts isn't based on scope (a
  3223. // mistake, I know)
  3224. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3225. if (address)
  3226. {
  3227. S32 string = address;
  3228. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3229. if (safe_heap_check_address(buffer, string, 1))
  3230. {
  3231. S32 toffset = string;
  3232. safe_heap_bytestream_count_char(buffer, toffset);
  3233. S32 size = toffset - string;
  3234. char *sdata = new char[size];
  3235. bytestream2char(sdata, buffer, string, size);
  3236. if (!strlen(sdata)) /*Flawfinder: ignore*/
  3237. {
  3238. offset += arg;
  3239. }
  3240. delete [] sdata;
  3241. }
  3242. lsa_decrease_ref_count(buffer, base_address);
  3243. }
  3244. }
  3245. else if (type == LST_KEY)
  3246. {
  3247. S32 base_address = lscript_pop_int(buffer);
  3248. // this bit of nastiness is to get around that code paths to
  3249. // local variables can result in lack of initialization and
  3250. // function clean up of ref counts isn't based on scope (a
  3251. // mistake, I know)
  3252. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3253. if (address)
  3254. {
  3255. S32 string = address;
  3256. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3257. if (safe_heap_check_address(buffer, string, 1))
  3258. {
  3259. S32 toffset = string;
  3260. safe_heap_bytestream_count_char(buffer, toffset);
  3261. S32 size = toffset - string;
  3262. char *sdata = new char[size];
  3263. bytestream2char(sdata, buffer, string, size);
  3264. if (strlen(sdata)) /*Flawfinder: ignore*/
  3265. {
  3266. LLUUID id;
  3267. if (!id.set(sdata) || id.isNull())
  3268. offset += arg;
  3269. }
  3270. else
  3271. {
  3272. offset += arg;
  3273. }
  3274. delete [] sdata;
  3275. }
  3276. lsa_decrease_ref_count(buffer, base_address);
  3277. }
  3278. }
  3279. else if (type == LST_LIST)
  3280. {
  3281. S32 base_address = lscript_pop_int(buffer);
  3282. // this bit of nastiness is to get around that code paths to
  3283. // local variables can result in lack of initialization and
  3284. // function clean up of ref counts isn't based on scope (a
  3285. // mistake, I know)
  3286. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3287. if (address)
  3288. {
  3289. if (safe_heap_check_address(buffer, address + SIZEOF_SCRIPT_ALLOC_ENTRY, 1))
  3290. {
  3291. LLScriptLibData *list = lsa_get_list_ptr(buffer, base_address, TRUE);
  3292. if (!list || !list->getListLength())
  3293. {
  3294. offset += arg;
  3295. }
  3296. delete list;
  3297. }
  3298. }
  3299. }
  3300. return FALSE;
  3301. }
  3303. BOOL run_state(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3304. {
  3305. if (b_print)
  3306. printf("[0x%X]tSTATE ", offset);
  3307. offset++;
  3308. S32 state = safe_instruction_bytestream2integer(buffer, offset);
  3309. if (b_print)
  3310. printf("%dn", state);
  3312. S32 bp = lscript_pop_int(buffer);
  3313. set_bp(buffer, bp);
  3315. offset = lscript_pop_int(buffer);
  3317. S32 major_version = 0;
  3318. S32 value = get_register(buffer, LREG_VN);
  3319. if (value == LSL2_VERSION1_END_NUMBER)
  3320. {
  3321. major_version = 1;
  3322. }
  3323. else if (value == LSL2_VERSION_NUMBER)
  3324. {
  3325. major_version = 2;
  3326. }
  3328. S32 current_state = get_register(buffer, LREG_CS);
  3329. if (state != current_state)
  3330. {
  3331. U64 ce = get_event_register(buffer, LREG_CE, major_version);
  3332. ce |= LSCRIPTStateBitField[LSTT_STATE_EXIT];
  3333. set_event_register(buffer, LREG_CE, ce, major_version);
  3334. }
  3335. set_register(buffer, LREG_NS, state);
  3336. return FALSE;
  3337. }
  3339. BOOL run_call(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3340. {
  3341. if (b_print)
  3342. printf("[0x%X]tCALL ", offset);
  3343. offset++;
  3344. S32 func = safe_instruction_bytestream2integer(buffer, offset);
  3345. if (b_print)
  3346. printf("%dn", func);
  3348. lscript_local_store(buffer, -8, offset);
  3350. S32 minimum = get_register(buffer, LREG_GFR);
  3351. S32 maximum = get_register(buffer, LREG_SR);
  3352. S32 lookup = minimum + func*4 + 4;
  3353. S32 function;
  3355. if (  (lookup >= minimum)
  3356. &&(lookup < maximum))
  3357. {
  3358. function = bytestream2integer(buffer, lookup) + minimum;
  3359. if (  (lookup >= minimum)
  3360. &&(lookup < maximum))
  3361. {
  3362. offset = function;
  3363. offset += bytestream2integer(buffer, function);
  3364. }
  3365. else
  3366. {
  3367. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  3368. }
  3369. }
  3370. else
  3371. {
  3372. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  3373. }
  3374. return FALSE;
  3375. }
  3377. BOOL run_return(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3378. {
  3379. if (b_print)
  3380. printf("[0x%X]tRETURNn", offset);
  3381. offset++;
  3383. // SEC-53: babbage: broken instructions may allow inbalanced pushes and
  3384. // pops which can cause caller BP and return IP to be corrupted, so restore
  3385. // SP from BP before popping caller BP and IP.
  3386. S32 bp = get_register(buffer, LREG_BP);
  3387. set_sp(buffer, bp);
  3389. bp = lscript_pop_int(buffer);
  3390. set_bp(buffer, bp);
  3391. offset = lscript_pop_int(buffer);
  3392. return FALSE;
  3393. }
  3397. BOOL run_cast(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3398. {
  3399. char caststr[1024]; /*Flawfinder: ignore*/
  3400. if (b_print)
  3401. printf("[0x%X]tCAST ", offset);
  3402. offset++;
  3403. U8 arg = safe_instruction_bytestream2byte(buffer, offset);
  3404. U8 from = arg >> 4;
  3405. U8 to = arg & 0xf;
  3406. if (b_print)
  3407. {
  3408. print_type(from);
  3409. printf(", ");
  3410. print_type(to);
  3411. printf("n");
  3412. }
  3414. switch(from)
  3415. {
  3416. case LST_INTEGER:
  3417. {
  3418. switch(to)
  3419. {
  3420. case LST_INTEGER:
  3421. break;
  3422. case LST_FLOATINGPOINT:
  3423. {
  3424. S32 source = lscript_pop_int(buffer);
  3425. F32 dest = (F32)source;
  3426. lscript_push(buffer, dest);
  3427. }
  3428. break;
  3429. case LST_STRING:
  3430. {
  3431. S32 address, source = lscript_pop_int(buffer);
  3432. snprintf(caststr, sizeof(caststr), "%d", source); /* Flawfinder: ignore */
  3433. address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
  3434. lscript_push(buffer, address);
  3435. }
  3436. break;
  3437. case LST_LIST:
  3438. {
  3439. S32 address, source = lscript_pop_int(buffer);
  3440. LLScriptLibData *list = new LLScriptLibData;
  3441. list->mType = LST_LIST;
  3442. list->mListp = new LLScriptLibData(source);
  3443. address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3444. lscript_push(buffer, address);
  3445. }
  3446. break;
  3447. default:
  3448. break;
  3449. }
  3450. }
  3451. break;
  3452. case LST_FLOATINGPOINT:
  3453. {
  3454. switch(to)
  3455. {
  3456. case LST_INTEGER:
  3457. {
  3458. F32 source = lscript_pop_float(buffer);
  3459. S32 dest = (S32)source;
  3460. lscript_push(buffer, dest);
  3461. }
  3462. break;
  3463. case LST_FLOATINGPOINT:
  3464. break;
  3465. case LST_STRING:
  3466. {
  3467. S32 address;
  3468. F32 source = lscript_pop_float(buffer);
  3469. snprintf(caststr, sizeof(caststr), "%f", source); /* Flawfinder: ignore */
  3470. address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
  3471. lscript_push(buffer, address);
  3472. }
  3473. break;
  3474. case LST_LIST:
  3475. {
  3476. S32 address;
  3477. F32 source = lscript_pop_float(buffer);
  3478. LLScriptLibData *list = new LLScriptLibData;
  3479. list->mType = LST_LIST;
  3480. list->mListp = new LLScriptLibData(source);
  3481. address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3482. lscript_push(buffer, address);
  3483. }
  3484. break;
  3485. default:
  3486. break;
  3487. }
  3488. }
  3489. break;
  3490. case LST_STRING:
  3491. {
  3492. switch(to)
  3493. {
  3494. case LST_INTEGER:
  3495. {
  3496. S32 base_address = lscript_pop_int(buffer);
  3497. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3498. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3499. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3500. if (address)
  3501. {
  3502. S32 string = address;
  3503. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3504. if (safe_heap_check_address(buffer, string, 1))
  3505. {
  3506. S32 toffset = string;
  3507. safe_heap_bytestream_count_char(buffer, toffset);
  3508. S32 size = toffset - string;
  3509. char *arg = new char[size];
  3510. bytestream2char(arg, buffer, string, size);
  3511. // S32 length = strlen(arg);
  3512. S32 dest;
  3513. S32 base;
  3515. // Check to see if this is a hexidecimal number.
  3516. if (  (arg[0] == '0') &&
  3517.   (arg[1] == 'x' || arg[1] == 'X') )
  3518. {
  3519. // Let strtoul do a hex conversion.
  3520. base = 16;
  3521. }
  3522. else
  3523. {
  3524. // Force base-10, so octal is never used.
  3525. base = 10;
  3526. }
  3528. dest = strtoul(arg, NULL, base);
  3530. lscript_push(buffer, dest);
  3531. delete [] arg;
  3532. }
  3533. lsa_decrease_ref_count(buffer, base_address);
  3534. }
  3535. }
  3536. break;
  3537. case LST_FLOATINGPOINT:
  3538. {
  3539. S32 base_address = lscript_pop_int(buffer);
  3540. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3541. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3542. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3543. if (address)
  3544. {
  3545. S32 string = address;
  3546. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3547. if (safe_heap_check_address(buffer, string, 1))
  3548. {
  3549. S32 toffset = string;
  3550. safe_heap_bytestream_count_char(buffer, toffset);
  3551. S32 size = toffset - string;
  3552. char *arg = new char[size];
  3553. bytestream2char(arg, buffer, string, size);
  3554. F32 dest = (F32)atof(arg);
  3557. lscript_push(buffer, dest);
  3558. delete [] arg;
  3559. }
  3560. lsa_decrease_ref_count(buffer, base_address);
  3561. }
  3562. }
  3563. break;
  3564. case LST_STRING:
  3565. break;
  3566. case LST_LIST:
  3567. {
  3568. S32 saddress = lscript_pop_int(buffer);
  3569. LLScriptLibData *string = lsa_get_data(buffer, saddress, TRUE);
  3570. LLScriptLibData *list = new LLScriptLibData;
  3571. list->mType = LST_LIST;
  3572. list->mListp = string;
  3573. S32 address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3574. lscript_push(buffer, address);
  3575. }
  3576. break;
  3577. case LST_VECTOR:
  3578. {
  3579. S32 base_address = lscript_pop_int(buffer);
  3580. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3581. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3582. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3583. if (address)
  3584. {
  3585. S32 string = address;
  3586. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3587. if (safe_heap_check_address(buffer, string, 1))
  3588. {
  3589. S32 toffset = string;
  3590. safe_heap_bytestream_count_char(buffer, toffset);
  3591. S32 size = toffset - string;
  3592. char *arg = new char[size];
  3593. bytestream2char(arg, buffer, string, size);
  3594. LLVector3 vec;
  3595. S32 num = sscanf(arg, "<%f, %f, %f>", &vec.mV[VX], &vec.mV[VY], &vec.mV[VZ]);
  3596. if (num != 3)
  3597. {
  3598. vec = LLVector3::zero;
  3599. }
  3600. lscript_push(buffer, vec);
  3601. delete [] arg;
  3602. }
  3603. lsa_decrease_ref_count(buffer, base_address);
  3604. }
  3605. }
  3606. break;
  3607. case LST_QUATERNION:
  3608. {
  3609. S32 base_address = lscript_pop_int(buffer);
  3610. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3611. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3612. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3613. if (address)
  3614. {
  3615. S32 string = address;
  3616. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3617. if (safe_heap_check_address(buffer, string, 1))
  3618. {
  3619. S32 toffset = string;
  3620. safe_heap_bytestream_count_char(buffer, toffset);
  3621. S32 size = toffset - string;
  3622. char *arg = new char[size];
  3623. bytestream2char(arg, buffer, string, size);
  3624. LLQuaternion quat;
  3625. S32 num = sscanf(arg, "<%f, %f, %f, %f>", &quat.mQ[VX], &quat.mQ[VY], &quat.mQ[VZ], &quat.mQ[VW]);
  3626. if (num != 4)
  3627. {
  3628. quat = LLQuaternion::DEFAULT;
  3630. }
  3631. lscript_push(buffer, quat);
  3632. delete [] arg;
  3633. }
  3634. lsa_decrease_ref_count(buffer, base_address);
  3635. }
  3636. }
  3637. break;
  3638. default:
  3639. break;
  3640. }
  3641. }
  3642. break;
  3643. case LST_KEY:
  3644. {
  3645. switch(to)
  3646. {
  3647. case LST_KEY:
  3648. break;
  3649. case LST_STRING:
  3650. break;
  3651. case LST_LIST:
  3652. {
  3653. S32 saddress = lscript_pop_int(buffer);
  3654. LLScriptLibData *string = lsa_get_data(buffer, saddress, TRUE);
  3655. LLScriptLibData *list = new LLScriptLibData;
  3656. list->mType = LST_LIST;
  3657. list->mListp = string;
  3658. S32 address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3659. lscript_push(buffer, address);
  3660. }
  3661. break;
  3662. default:
  3663. break;
  3664. }
  3665. }
  3666. break;
  3667. case LST_VECTOR:
  3668. {
  3669. switch(to)
  3670. {
  3671. case LST_VECTOR:
  3672. break;
  3673. case LST_STRING:
  3674. {
  3675. S32 address;
  3676. LLVector3 source;
  3677. lscript_pop_vector(buffer, source);
  3678. snprintf(caststr, sizeof(caststr), "<%5.5f, %5.5f, %5.5f>", source.mV[VX], source.mV[VY], source.mV[VZ]); /* Flawfinder: ignore */
  3679. address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
  3680. lscript_push(buffer, address);
  3681. }
  3682. break;
  3683. case LST_LIST:
  3684. {
  3685. S32 address;
  3686. LLVector3 source;
  3687. lscript_pop_vector(buffer, source);
  3688. LLScriptLibData *list = new LLScriptLibData;
  3689. list->mType = LST_LIST;
  3690. list->mListp = new LLScriptLibData(source);
  3691. address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3692. lscript_push(buffer, address);
  3693. }
  3694. break;
  3695. default:
  3696. break;
  3697. }
  3698. }
  3699. break;
  3700. case LST_QUATERNION:
  3701. {
  3702. switch(to)
  3703. {
  3704. case LST_QUATERNION:
  3705. break;
  3706. case LST_STRING:
  3707. {
  3708. S32 address;
  3709. LLQuaternion source;
  3710. lscript_pop_quaternion(buffer, source);
  3711. snprintf(caststr, sizeof(caststr), "<%5.5f, %5.5f, %5.5f, %5.5f>", source.mQ[VX], source.mQ[VY], source.mQ[VZ], source.mQ[VS]); /* Flawfinder: ignore */
  3712. address = lsa_heap_add_data(buffer, new LLScriptLibData(caststr), get_max_heap_size(buffer), TRUE);
  3713. lscript_push(buffer, address);
  3714. }
  3715. break;
  3716. case LST_LIST:
  3717. {
  3718. S32 address;
  3719. LLQuaternion source;
  3720. lscript_pop_quaternion(buffer, source);
  3721. LLScriptLibData *list = new LLScriptLibData;
  3722. list->mType = LST_LIST;
  3723. list->mListp = new LLScriptLibData(source);
  3724. address = lsa_heap_add_data(buffer, list, get_max_heap_size(buffer), TRUE);
  3725. lscript_push(buffer, address);
  3726. }
  3727. break;
  3728. default:
  3729. break;
  3730. }
  3731. }
  3732. break;
  3733. case LST_LIST:
  3734. {
  3735. switch(to)
  3736. {
  3737. case LST_LIST:
  3738. break;
  3739. case LST_STRING:
  3740. {
  3741. S32 address = lscript_pop_int(buffer);
  3742. LLScriptLibData *list = lsa_get_data(buffer, address, TRUE);
  3743. LLScriptLibData *list_root = list;
  3745. std::ostringstream dest;
  3746. while (list)
  3747. {
  3748. list->print(dest, FALSE);
  3749. list = list->mListp;
  3750. }
  3751. delete list_root;
  3752. char *tmp = strdup(dest.str().c_str());
  3753. LLScriptLibData *string = new LLScriptLibData(tmp);
  3754. free(tmp);
  3755. tmp = NULL;
  3756. S32 destaddress = lsa_heap_add_data(buffer, string, get_max_heap_size(buffer), TRUE);
  3757. lscript_push(buffer, destaddress);
  3758. }
  3759. break;
  3760. default:
  3761. break;
  3762. }
  3763. }
  3764. break;
  3765. default:
  3766. break;
  3767. }
  3768. return FALSE;
  3769. }
  3771. BOOL run_stacktos(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3772. {
  3773. offset++;
  3774. S32 length = lscript_pop_int(buffer);
  3775. S32 i;
  3776. char *arg = new char[length];
  3777. S32 fault;
  3778. for (i = 0; i < length; i++)
  3779. {
  3780. fault = get_register(buffer, LREG_FR);
  3781. if (fault)
  3782. break;
  3784. arg[length - i - 1] = lscript_pop_char(buffer);
  3785. }
  3786. S32 address = lsa_heap_add_data(buffer, new LLScriptLibData(arg), get_max_heap_size(buffer), TRUE);
  3787. lscript_push(buffer, address);
  3788. delete [] arg;
  3789. return FALSE;
  3790. }
  3792. void lscript_stacktol_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
  3793. {
  3794. S32 address, string;
  3795. S32 base_address;
  3797. switch(type)
  3798. {
  3799. case LST_INTEGER:
  3800. data->mType = LST_INTEGER;
  3801. data->mInteger = lscript_pop_int(buffer);
  3802. break;
  3803. case LST_FLOATINGPOINT:
  3804. data->mType = LST_FLOATINGPOINT;
  3805. data->mFP = lscript_pop_float(buffer);
  3806. break;
  3807. case LST_KEY:
  3808. data->mType = LST_KEY;
  3810. base_address = lscript_pop_int(buffer);
  3811. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3812. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3813. address = base_address + get_register(buffer, LREG_HR) - 1;
  3815. if (address)
  3816. {
  3817. string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
  3818. if (safe_heap_check_address(buffer, string, 1))
  3819. {
  3820. S32 toffset = string;
  3821. safe_heap_bytestream_count_char(buffer, toffset);
  3822. S32 size = toffset - string;
  3823. data->mKey = new char[size];
  3824. bytestream2char(data->mKey, buffer, string, size);
  3825. }
  3826. lsa_decrease_ref_count(buffer, base_address);
  3827. }
  3828. else
  3829. {
  3830. data->mKey = new char[1];
  3831. data->mKey[0] = 0;
  3832. }
  3833. break;
  3834. case LST_STRING:
  3835. data->mType = LST_STRING;
  3837. base_address = lscript_pop_int(buffer);
  3838. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3839. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3840. address = base_address + get_register(buffer, LREG_HR) - 1;
  3842. if (address)
  3843. {
  3844. string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
  3845. if (safe_heap_check_address(buffer, string, 1))
  3846. {
  3847. S32 toffset = string;
  3848. safe_heap_bytestream_count_char(buffer, toffset);
  3849. S32 size = toffset - string;
  3850. data->mString = new char[size];
  3851. bytestream2char(data->mString, buffer, string, size);
  3852. }
  3853. lsa_decrease_ref_count(buffer, base_address);
  3854. }
  3855. else
  3856. {
  3857. data->mString = new char[1];
  3858. data->mString[0] = 0;
  3859. }
  3860. break;
  3861. case LST_VECTOR:
  3862. data->mType = LST_VECTOR;
  3863. lscript_pop_vector(buffer, data->mVec);
  3864. break;
  3865. case LST_QUATERNION:
  3866. data->mType = LST_QUATERNION;
  3867. lscript_pop_quaternion(buffer, data->mQuat);
  3868. break;
  3869. case LST_LIST:
  3870. data->mType = LST_LIST;
  3871. address = lscript_pop_int(buffer);
  3872. data->mListp = lsa_get_data(buffer, address, TRUE);
  3873. break;
  3874. }
  3875. }
  3877. BOOL run_stacktol(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3878. {
  3879. offset++;
  3880. S32 length = safe_instruction_bytestream2integer(buffer, offset);
  3881. S32 i;
  3882. S32 fault;
  3884. S8 type;
  3886. LLScriptLibData *data = new LLScriptLibData, *tail;
  3887. data->mType = LST_LIST;
  3889. for (i = 0; i < length; i++)
  3890. {
  3891. fault = get_register(buffer, LREG_FR);
  3892. if (fault)
  3893. break;
  3895. type = lscript_pop_char(buffer);
  3897. tail = new LLScriptLibData;
  3899. lscript_stacktol_pop_variable(tail, buffer, type);
  3901. tail->mListp = data->mListp;
  3902. data->mListp = tail;
  3903. }
  3904. S32 address = lsa_heap_add_data(buffer,data, get_max_heap_size(buffer), TRUE);
  3905. lscript_push(buffer, address);
  3906. return FALSE;
  3907. }
  3909. BOOL run_print(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  3910. {
  3911. if (b_print)
  3912. printf("[0x%X]tPRINT ", offset);
  3913. offset++;
  3914. U8 type = safe_instruction_bytestream2byte(buffer, offset);
  3915. if (b_print)
  3916. {
  3917. print_type(type);
  3918. printf("n");
  3919. }
  3920. switch(type)
  3921. {
  3922. case LST_INTEGER:
  3923. {
  3924. S32 source = lscript_pop_int(buffer);
  3925. printf("%dn", source);
  3926. }
  3927. break;
  3928. case LST_FLOATINGPOINT:
  3929. {
  3930. F32 source = lscript_pop_float(buffer);
  3931. printf("%fn", source);
  3932. }
  3933. break;
  3934. case LST_STRING:
  3935. {
  3936. S32 base_address = lscript_pop_int(buffer);
  3937. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  3938. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  3939. S32 address = base_address + get_register(buffer, LREG_HR) - 1;
  3941. if (address)
  3942. {
  3943. S32 string = address;
  3944. string += SIZEOF_SCRIPT_ALLOC_ENTRY;
  3945. if (safe_heap_check_address(buffer, string, 1))
  3946. {
  3947. S32 toffset = string;
  3948. safe_heap_bytestream_count_char(buffer, toffset);
  3949. S32 size = toffset - string;
  3950. char *arg = new char[size];
  3951. bytestream2char(arg, buffer, string, size);
  3952. printf("%sn", arg);
  3953. delete [] arg;
  3954. }
  3955. lsa_decrease_ref_count(buffer, base_address);
  3956. }
  3957. }
  3958. break;
  3959. case LST_VECTOR:
  3960. {
  3961. LLVector3 source;
  3962. lscript_pop_vector(buffer, source);
  3963. printf("< %f, %f, %f >n", source.mV[VX], source.mV[VY], source.mV[VZ]);
  3964. }
  3965. break;
  3966. case LST_QUATERNION:
  3967. {
  3968. LLQuaternion source;
  3969. lscript_pop_quaternion(buffer, source);
  3970. printf("< %f, %f, %f, %f >n", source.mQ[VX], source.mQ[VY], source.mQ[VZ], source.mQ[VS]);
  3971. }
  3972. break;
  3973. case LST_LIST:
  3974. {
  3975. S32 base_address = lscript_pop_int(buffer);
  3976. LLScriptLibData *data = lsa_get_data(buffer, base_address, TRUE);
  3977. LLScriptLibData *print = data;
  3979. printf("listn");
  3981. while (print)
  3982. {
  3983. switch(print->mType)
  3984. {
  3985. case LST_INTEGER:
  3986. {
  3987. printf("%dn", print->mInteger);
  3988. }
  3989. break;
  3990. case LST_FLOATINGPOINT:
  3991. {
  3992. printf("%fn", print->mFP);
  3993. }
  3994. break;
  3995. case LST_STRING:
  3996. {
  3997. printf("%sn", print->mString);
  3998. }
  3999. break;
  4000. case LST_KEY:
  4001. {
  4002. printf("%sn", print->mKey);
  4003. }
  4004. break;
  4005. case LST_VECTOR:
  4006. {
  4007. printf("< %f, %f, %f >n", print->mVec.mV[VX], print->mVec.mV[VY], print->mVec.mV[VZ]);
  4008. }
  4009. break;
  4010. case LST_QUATERNION:
  4011. {
  4012. printf("< %f, %f, %f, %f >n", print->mQuat.mQ[VX], print->mQuat.mQ[VY], print->mQuat.mQ[VZ], print->mQuat.mQ[VS]);
  4013. }
  4014. break;
  4015. default:
  4016. break;
  4017. }
  4018. print = print->mListp;
  4019. }
  4020. delete data;
  4021. }
  4022. break;
  4023. default:
  4024. break;
  4025. }
  4026. return FALSE;
  4027. }
  4030. void lscript_run(const std::string& filename, BOOL b_debug)
  4031. {
  4032. LLTimer timer;
  4034. const char *error;
  4035. LLScriptExecuteLSL2 *execute = NULL;
  4037. if (filename.empty())
  4038. {
  4039. llerrs << "filename is NULL" << llendl;
  4040. // Just reporting error is likely not enough. Need
  4041. // to check how to abort or error out gracefully
  4042. // from this function. XXXTBD
  4043. }
  4044. LLFILE* file = LLFile::fopen(filename, "r");  /* Flawfinder: ignore */
  4045. if(file)
  4046. {
  4047. execute = new LLScriptExecuteLSL2(file);
  4048. fclose(file);
  4049. }
  4050. if (execute)
  4051. {
  4052. timer.reset();
  4053. F32 time_slice = 3600.0f; // 1 hr.
  4054. U32 events_processed = 0;
  4056. do {
  4057. LLTimer timer2;
  4058. execute->runQuanta(b_debug, LLUUID::null, &error,
  4059.    time_slice, events_processed, timer2);
  4060. } while (!execute->isFinished());
  4062. F32 time = timer.getElapsedTimeF32();
  4063. F32 ips = execute->mInstructionCount / time;
  4064. llinfos << execute->mInstructionCount << " instructions in " << time << " seconds" << llendl;
  4065. llinfos << ips/1000 << "K instructions per second" << llendl;
  4066. printf("ip: 0x%Xn", get_register(execute->mBuffer, LREG_IP));
  4067. printf("sp: 0x%Xn", get_register(execute->mBuffer, LREG_SP));
  4068. printf("bp: 0x%Xn", get_register(execute->mBuffer, LREG_BP));
  4069. printf("hr: 0x%Xn", get_register(execute->mBuffer, LREG_HR));
  4070. printf("hp: 0x%Xn", get_register(execute->mBuffer, LREG_HP));
  4071. delete execute;
  4072. fclose(file);
  4073. }
  4074. }
  4076. void lscript_pop_variable(LLScriptLibData *data, U8 *buffer, char type)
  4077. {
  4078. S32 address, string;
  4079. S32 base_address;
  4081. switch(type)
  4082. {
  4083. case 'i':
  4084. data->mType = LST_INTEGER;
  4085. data->mInteger = lscript_pop_int(buffer);
  4086. break;
  4087. case 'f':
  4088. data->mType = LST_FLOATINGPOINT;
  4089. data->mFP = lscript_pop_float(buffer);
  4090. break;
  4091. case 'k':
  4092. data->mType = LST_KEY;
  4093. data->mKey = NULL;
  4095. base_address = lscript_pop_int(buffer);
  4096. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  4097. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  4098. address = base_address + get_register(buffer, LREG_HR) - 1;
  4100. if (address)
  4101. {
  4102. string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
  4103. if (safe_heap_check_address(buffer, string, 1))
  4104. {
  4105. S32 toffset = string;
  4106. safe_heap_bytestream_count_char(buffer, toffset);
  4107. S32 size = toffset - string;
  4108. data->mKey = new char[size];
  4109. bytestream2char(data->mKey, buffer, string, size);
  4110. }
  4111. lsa_decrease_ref_count(buffer, base_address);
  4112. }
  4113. if (data->mKey == NULL)
  4114. {
  4115. data->mKey = new char[1];
  4116. data->mKey[0] = 0;
  4117. }
  4118. break;
  4119. case 's':
  4120. data->mType = LST_STRING;
  4121. data->mString = NULL;
  4123. base_address = lscript_pop_int(buffer);
  4124. // this bit of nastiness is to get around that code paths to local variables can result in lack of initialization
  4125. // and function clean up of ref counts isn't based on scope (a mistake, I know)
  4126. address = base_address + get_register(buffer, LREG_HR) - 1;
  4128. if (address)
  4129. {
  4130. string = address + SIZEOF_SCRIPT_ALLOC_ENTRY;
  4131. if (safe_heap_check_address(buffer, string, 1))
  4132. {
  4133. S32 toffset = string;
  4134. safe_heap_bytestream_count_char(buffer, toffset);
  4135. S32 size = toffset - string;
  4136. data->mString = new char[size];
  4137. bytestream2char(data->mString, buffer, string, size);
  4138. }
  4139. lsa_decrease_ref_count(buffer, base_address);
  4140. }
  4141. if (data->mString == NULL)
  4142. {
  4143. data->mString = new char[1];
  4144. data->mString[0] = 0;
  4145. }
  4146. break;
  4147. case 'l':
  4148. {
  4149. S32 base_address = lscript_pop_int(buffer);
  4150. data->mType = LST_LIST;
  4151. data->mListp = lsa_get_list_ptr(buffer, base_address, TRUE);
  4152. }
  4153. break;
  4154. case 'v':
  4155. data->mType = LST_VECTOR;
  4156. lscript_pop_vector(buffer, data->mVec);
  4157. break;
  4158. case 'q':
  4159. data->mType = LST_QUATERNION;
  4160. lscript_pop_quaternion(buffer, data->mQuat);
  4161. break;
  4162. }
  4163. }
  4165. void lscript_push_return_variable(LLScriptLibData *data, U8 *buffer)
  4166. {
  4167. S32 address;
  4168. switch(data->mType)
  4169. {
  4170. case LST_INTEGER:
  4171. lscript_local_store(buffer, -12, data->mInteger);
  4172. break;
  4173. case LST_FLOATINGPOINT:
  4174. lscript_local_store(buffer, -12, data->mFP);
  4175. break;
  4176. case LST_KEY:
  4177. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4178. lscript_local_store(buffer, -12, address);
  4179. break;
  4180. case LST_STRING:
  4181. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4182. lscript_local_store(buffer, -12, address);
  4183. break;
  4184. case LST_LIST:
  4185. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4186. lscript_local_store(buffer, -12, address);
  4187. break;
  4188. case LST_VECTOR:
  4189. lscript_local_store(buffer, -20, data->mVec);
  4190. break;
  4191. case LST_QUATERNION:
  4192. lscript_local_store(buffer, -24, data->mQuat);
  4193. break;
  4194. default:
  4195. break;
  4196. }
  4197. }
  4199. S32 lscript_push_variable(LLScriptLibData *data, U8 *buffer)
  4200. {
  4201. S32 address;
  4202. switch(data->mType)
  4203. {
  4204. case LST_INTEGER:
  4205. lscript_push(buffer, data->mInteger);
  4206. break;
  4207. case LST_FLOATINGPOINT:
  4208. lscript_push(buffer, data->mFP);
  4209. return 4;
  4210. break;
  4211. case LST_KEY:
  4212. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4213. lscript_push(buffer, address);
  4214. return 4;
  4215. break;
  4216. case LST_STRING:
  4217. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4218. lscript_push(buffer, address);
  4219. return 4;
  4220. break;
  4221. case LST_LIST:
  4222. address = lsa_heap_add_data(buffer, data, get_max_heap_size(buffer), FALSE);
  4223. lscript_push(buffer, address);
  4224. return 4;
  4225. break;
  4226. case LST_VECTOR:
  4227. lscript_push(buffer, data->mVec);
  4228. return 12;
  4229. break;
  4230. case LST_QUATERNION:
  4231. lscript_push(buffer, data->mQuat);
  4232. return 16;
  4233. break;
  4234. default:
  4235. break;
  4236. }
  4237. return 4;
  4238. }
  4241. // Shared code for run_calllib() and run_calllib_two_byte()
  4242. BOOL run_calllib_common(U8 *buffer, S32 &offset, const LLUUID &id, U16 arg)
  4243. {
  4244. if (arg >= gScriptLibrary.mFunctions.size())
  4245. {
  4246. set_fault(buffer, LSRF_BOUND_CHECK_ERROR);
  4247. return FALSE;
  4248. }
  4249. LLScriptLibraryFunction const & function = gScriptLibrary.mFunctions[arg];
  4251. // pull out the arguments and the return values
  4252. LLScriptLibData *arguments = NULL;
  4253. LLScriptLibData *returnvalue = NULL;
  4255. S32 i, number;
  4257. if (function.mReturnType)
  4258. {
  4259. returnvalue = new LLScriptLibData;
  4260. }
  4262. if (function.mArgs)
  4263. {
  4264. number = (S32)strlen(function.mArgs); //Flawfinder: ignore
  4265. arguments = new LLScriptLibData[number];
  4266. }
  4267. else
  4268. {
  4269. number = 0;
  4270. }
  4272. for (i = number - 1; i >= 0; i--)
  4273. {
  4274. lscript_pop_variable(&arguments[i], buffer, function.mArgs[i]);
  4275. }
  4277. // Actually execute the function call
  4278. function.mExecFunc(returnvalue, arguments, id);
  4280. add_register_fp(buffer, LREG_ESR, -(function.mEnergyUse));
  4281. add_register_fp(buffer, LREG_SLR, function.mSleepTime);
  4283. if (returnvalue)
  4284. {
  4285. returnvalue->mType = char2type(*function.mReturnType);
  4286. lscript_push_return_variable(returnvalue, buffer);
  4287. }
  4289. delete [] arguments;
  4290. delete returnvalue;
  4292. // reset the BP after calling the library files
  4293. S32 bp = lscript_pop_int(buffer);
  4294. set_bp(buffer, bp);
  4296. // pop off the spot for the instruction pointer
  4297. lscript_poparg(buffer, 4);
  4298. return FALSE;
  4299. }
  4302. BOOL run_calllib(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  4303. {
  4304. offset++;
  4305. U16 arg = (U16) safe_instruction_bytestream2byte(buffer, offset);
  4306. if (b_print &&
  4307. arg < gScriptLibrary.mFunctions.size())
  4308. {
  4309. printf("[0x%X]tCALLLIB ", offset);
  4310. LLScriptLibraryFunction const & function = gScriptLibrary.mFunctions[arg];
  4311. printf("%d (%s)n", (U32)arg, function.mName);
  4312. //printf("%sn", function.mDesc);
  4313. }
  4314. return run_calllib_common(buffer, offset, id, arg);
  4315. }
  4317. BOOL run_calllib_two_byte(U8 *buffer, S32 &offset, BOOL b_print, const LLUUID &id)
  4318. {
  4319. offset++;
  4320. U16 arg = safe_instruction_bytestream2u16(buffer, offset);
  4321. if (b_print &&
  4322. arg < gScriptLibrary.mFunctions.size())
  4323. {
  4324. printf("[0x%X]tCALLLIB ", (offset-1));
  4325. LLScriptLibraryFunction const & function = gScriptLibrary.mFunctions[arg];
  4326. printf("%d (%s)n", (U32)arg, function.mName);
  4327. //printf("%sn", function.mDesc);
  4328. }
  4329. return run_calllib_common(buffer, offset, id, arg);
  4330. }