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

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

游戏引擎

开发平台：

C++ Builder

lscript_readlso.cpp：源码内容
  1. /** 
  2.  * @file lscript_readlso.cpp
  3.  * @brief classes to read lso file
  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 "lscript_readlso.h"
  36. #include "lscript_library.h"
  37. #include "lscript_alloc.h"
  39. LLScriptLSOParse::LLScriptLSOParse(LLFILE *fp)
  40. {
  41. U8  sizearray[4];
  42. size_t filesize;
  43. S32 pos = 0;
  44. if (fread(&sizearray, 1, 4, fp) != 4)
  45. {
  46. llwarns << "Short read" << llendl;
  47. filesize = 0;
  48. } else {
  49. filesize = bytestream2integer(sizearray, pos);
  50. }
  51. mRawData = new U8[filesize];
  52. fseek(fp, 0, SEEK_SET);
  53. if (fread(mRawData, 1, filesize, fp) != filesize)
  54. {
  55. llwarns << "Short read" << llendl;
  56. }
  58. initOpCodePrinting();
  59. }
  61. LLScriptLSOParse::LLScriptLSOParse(U8 *buffer)
  62. {
  63. mRawData = buffer;
  64. initOpCodePrinting();
  65. }
  67. LLScriptLSOParse::~LLScriptLSOParse()
  68. {
  69. delete [] mRawData;
  70. }
  72. void LLScriptLSOParse::printData(LLFILE *fp)
  73. {
  77. printNameDesc(fp);
  79. printRegisters(fp);
  81. printGlobals(fp);
  83. printGlobalFunctions(fp);
  85. printStates(fp);
  87. printHeap(fp);
  88. }
  90. void LLScriptLSOParse::printNameDesc(LLFILE *fp)
  91. {
  92. fprintf(fp, "=============================nn");
  93. }
  95. S32 gMajorVersion = 0;
  97. void LLScriptLSOParse::printRegisters(LLFILE *fp)
  98. {
  99. // print out registers first
  100. S32 i;
  102. fprintf(fp, "=============================n");
  103. fprintf(fp, "Registersn");
  104. fprintf(fp, "=============================n");
  105. S32 version = get_register(mRawData, LREG_VN);
  106. if (version == LSL2_VERSION1_END_NUMBER)
  107. {
  108. gMajorVersion = LSL2_MAJOR_VERSION_ONE;
  109. }
  110. else if (version == LSL2_VERSION_NUMBER)
  111. {
  112. gMajorVersion = LSL2_MAJOR_VERSION_TWO;
  113. }
  114. for (i = LREG_IP; i < LREG_EOF; i++)
  115. {
  116. if (i < LREG_NCE)
  117. {
  118. fprintf(fp, "%s: 0x%Xn", gLSCRIPTRegisterNames[i], get_register(mRawData, (LSCRIPTRegisters)i));
  119. }
  120. else if (gMajorVersion == LSL2_MAJOR_VERSION_TWO)
  121. {
  122. U64 data = get_register_u64(mRawData, (LSCRIPTRegisters)i);
  123. fprintf(fp, "%s: 0x%X%Xn", gLSCRIPTRegisterNames[i], (U32)(data>>32), (U32)(data && 0xFFFFFFFF));
  124. }
  125. }
  126. fprintf(fp, "=============================nn");
  127. }
  129. void LLScriptLSOParse::printGlobals(LLFILE *fp)
  130. {
  131. // print out registers first
  132. S32 offset, varoffset;
  133. S32 ivalue;
  134. F32 fpvalue;
  135. LLVector3 vvalue;
  136. LLQuaternion qvalue;
  137. char name[256]; /*Flawfinder: ignore*/
  138. U8 type;
  140. S32 global_v_offset = get_register(mRawData, LREG_GVR);
  141. S32 global_f_offset = get_register(mRawData, LREG_GFR);
  143. fprintf(fp, "=============================n");
  144. fprintf(fp, "[0x%X] Global Variablesn", global_v_offset);
  145. fprintf(fp, "=============================n");
  148. while (global_v_offset < global_f_offset)
  149. {
  151. // get offset to skip past name
  152. varoffset = global_v_offset;
  153. offset = bytestream2integer(mRawData, global_v_offset);
  155. // get typeexport
  156. type = *(mRawData + global_v_offset++);
  158. // set name
  159. bytestream2char(name, mRawData, global_v_offset, sizeof(name));
  161. switch(type)
  162. {
  163. case LST_INTEGER:
  164. ivalue = bytestream2integer(mRawData, global_v_offset);
  165. fprintf(fp, "[0x%X] integer %s = %dn", varoffset, name, ivalue);
  166. break;
  167. case LST_FLOATINGPOINT:
  168. fpvalue = bytestream2float(mRawData, global_v_offset);
  169. fprintf(fp, "[0x%X] integer %s = %fn", varoffset, name, fpvalue);
  170. break;
  171. case LST_STRING:
  172. ivalue = bytestream2integer(mRawData, global_v_offset);
  173. fprintf(fp, "[0x%X] string %s = 0x%Xn", varoffset, name, ivalue + get_register(mRawData, LREG_HR) - 1);
  174. break;
  175. case LST_KEY:
  176. ivalue = bytestream2integer(mRawData, global_v_offset);
  177. fprintf(fp, "[0x%X] key %s = 0x%Xn", varoffset, name, ivalue + get_register(mRawData, LREG_HR) - 1);
  178. break;
  179. case LST_VECTOR:
  180. bytestream2vector(vvalue, mRawData, global_v_offset);
  181. fprintf(fp, "[0x%X] vector %s = < %f, %f, %f >n", varoffset, name, vvalue.mV[VX], vvalue.mV[VY], vvalue.mV[VZ]);
  182. break;
  183. case LST_QUATERNION:
  184. bytestream2quaternion(qvalue, mRawData, global_v_offset);
  185. fprintf(fp, "[0x%X] quaternion %s = < %f, %f, %f, %f >n", varoffset, name, qvalue.mQ[VX], qvalue.mQ[VY], qvalue.mQ[VZ], qvalue.mQ[VS]);
  186. break;
  187. case LST_LIST:
  188. ivalue = bytestream2integer(mRawData, global_v_offset);
  189. fprintf(fp, "[0x%X] list %s = 0x%Xn", varoffset, name, ivalue + get_register(mRawData, LREG_HR) - 1);
  190. break;
  191. default:
  192. break;
  193. }
  194. }
  196. fprintf(fp, "=============================nn");
  197. }
  199. void LLScriptLSOParse::printGlobalFunctions(LLFILE *fp)
  200. {
  201. // print out registers first
  202. S32 i, offset;
  203. // LLVector3 vvalue; unused
  204. // LLQuaternion qvalue; unused
  205. char name[256]; /*Flawfinder: ignore*/
  206. U8 type;
  208. offset = get_register(mRawData, LREG_GFR);
  209. S32 start_of_state = get_register(mRawData, LREG_SR);
  210. if (start_of_state == offset)
  211. return;
  213. S32 global_f_offset = get_register(mRawData, LREG_GFR);
  215. fprintf(fp, "=============================n");
  216. fprintf(fp, "[0x%X] Global Functionsn", global_f_offset);
  217. fprintf(fp, "=============================n");
  220. S32 num_functions = bytestream2integer(mRawData, offset);
  221. S32 orig_function_offset;
  222. S32 function_offset;
  223. S32 next_function_offset = 0;
  224. S32 function_number = 0;
  225. S32 opcode_start;
  226. S32 opcode_end;
  228. for (i = 0; i < num_functions; i++)
  229. {
  230. // jump to function
  231. // if this is the first function
  232. if (i == 0)
  233. {
  234. if (i < num_functions - 1)
  235. {
  236. function_offset = bytestream2integer(mRawData, offset);
  237. next_function_offset = bytestream2integer(mRawData, offset);
  238. function_offset += global_f_offset;
  239. opcode_end = next_function_offset + global_f_offset;
  240. }
  241. else
  242. {
  243. function_offset = bytestream2integer(mRawData, offset);
  244. function_offset += global_f_offset;
  245. opcode_end = get_register(mRawData, LREG_SR);
  246. }
  247. }
  248. else if (i < num_functions - 1)
  249. {
  250. function_offset = next_function_offset;
  251. next_function_offset = bytestream2integer(mRawData, offset);
  252. function_offset += global_f_offset;
  253. opcode_end = next_function_offset + global_f_offset;
  254. }
  255. else
  256. {
  257. function_offset = next_function_offset;
  258. function_offset += global_f_offset;
  259. opcode_end = get_register(mRawData, LREG_SR);
  260. }
  261. orig_function_offset = function_offset;
  262. // where do the opcodes start
  263. opcode_start = bytestream2integer(mRawData, function_offset);
  264. opcode_start += orig_function_offset;
  265. bytestream2char(name, mRawData, function_offset, sizeof(name));
  266. // get return type
  267. type = *(mRawData + function_offset++);
  268. fprintf(fp, "[Function #%d] [0x%X] %sn", function_number, orig_function_offset, name);
  269. fprintf(fp, "tReturn Type: %sn", LSCRIPTTypeNames[type]);
  270. type = *(mRawData + function_offset++);
  271. S32 params;
  272. params = 0;
  273. S32 pcount = 0;
  274. while (type)
  275. {
  276. bytestream2char(name, mRawData, function_offset, sizeof(name));
  277. fprintf(fp, "tParameter #%d: %s %sn", pcount++, LSCRIPTTypeNames[type], name);
  278. type = *(mRawData + function_offset++);
  279. }
  280. fprintf(fp, "ttOpCodes: 0x%X - 0x%Xn", opcode_start, opcode_end);
  281. printOpCodeRange(fp, opcode_start, opcode_end, 2);
  282. function_number++;
  283. }
  285. fprintf(fp, "=============================nn");
  286. }
  288. void LLScriptLSOParse::printStates(LLFILE *fp)
  289. {
  290. // print out registers first
  291. S32 i, offset;
  292. U32  j, k;
  293. // LLVector3 vvalue; unused
  294. // LLQuaternion qvalue; unused
  295. char name[256]; /*Flawfinder: ignore*/
  297. S32 state_offset = get_register(mRawData, LREG_SR);
  299. fprintf(fp, "=============================n");
  300. fprintf(fp, "[0x%X] Statesn", state_offset);
  301. fprintf(fp, "=============================n");
  303. offset = state_offset;
  304. S32 num_states = bytestream2integer(mRawData, offset);
  305. S32 state_info_offset;
  306. S32 event_jump_table;
  307. U64 event_handlers;
  308. S32 event_offset;
  309. S32 original_event_offset;
  310. S32 opcode_start;
  311. S32 worst_case_opcode_end;
  312. S32 opcode_end;
  313. S32 stack_size;
  314. S32 read_ahead;
  315. S32 first_jump = 0;
  317. for (i = 0; i < num_states; i++)
  318. {
  319. state_info_offset = bytestream2integer(mRawData, offset);
  320. if (gMajorVersion == LSL2_MAJOR_VERSION_TWO)
  321. event_handlers = bytestream2u64(mRawData, offset);
  322. else
  323. event_handlers = bytestream2integer(mRawData, offset);
  324. if (!first_jump)
  325. {
  326. first_jump = state_info_offset;
  327. }
  328. read_ahead = offset;
  329. if (offset < first_jump + state_offset)
  330. {
  331. worst_case_opcode_end = bytestream2integer(mRawData, read_ahead) + state_offset;
  332. }
  333. else
  334. {
  335. worst_case_opcode_end = get_register(mRawData, LREG_HR);
  336. }
  337. state_info_offset += state_offset;
  338. fprintf(fp, "[0x%X] ", state_info_offset);
  339. state_info_offset += LSCRIPTDataSize[LST_INTEGER];
  340. bytestream2char(name, mRawData, state_info_offset, sizeof(name));
  341. fprintf(fp, "%sn", name);
  343. event_jump_table = state_info_offset;
  345. // run run through the handlers
  346. for (j = LSTT_STATE_BEGIN; j < LSTT_STATE_END; j++)
  347. {
  348. if (event_handlers & LSCRIPTStateBitField[j])
  349. {
  350. event_offset = bytestream2integer(mRawData, state_info_offset);
  351. stack_size = bytestream2integer(mRawData, state_info_offset);
  353. read_ahead = event_jump_table;
  355. S32 temp_end;
  356. S32 dummy;
  358. opcode_end = worst_case_opcode_end;
  360. for (k = LSTT_STATE_BEGIN; k < LSTT_STATE_END; k++)
  361. {
  362. if (event_handlers & LSCRIPTStateBitField[k])
  363. {
  364. temp_end = bytestream2integer(mRawData, read_ahead);
  365. dummy = bytestream2integer(mRawData, read_ahead);
  366. if (  (temp_end < opcode_end)
  367. &&(temp_end > event_offset))
  368. {
  369. opcode_end = temp_end;
  370. }
  371. }
  372. }
  374. if (event_offset)
  375. {
  376. event_offset += event_jump_table;
  377. if (opcode_end < worst_case_opcode_end)
  378. opcode_end += event_jump_table;
  379. original_event_offset = event_offset;
  381. fprintf(fp, "t[0x%X] ", event_offset);
  383. opcode_start = bytestream2integer(mRawData, event_offset);
  384. opcode_start += original_event_offset;
  386. switch(j)
  387. {
  388. case LSTT_STATE_ENTRY: // LSTT_STATE_ENTRY
  389. bytestream2char(name, mRawData, event_offset, sizeof(name));
  390. fprintf(fp, "%sn", name);
  391. break;
  392. case LSTT_STATE_EXIT: // LSTT_STATE_EXIT
  393. bytestream2char(name, mRawData, event_offset, sizeof(name));
  394. fprintf(fp, "%sn", name);
  395. break;
  396. case LSTT_TOUCH_START: // LSTT_TOUCH_START
  397. bytestream2char(name, mRawData, event_offset, sizeof(name));
  398. fprintf(fp, "%sn", name);
  399. bytestream2char(name, mRawData, event_offset, sizeof(name));
  400. fprintf(fp, "ttkey %sn", name);
  401. bytestream2char(name, mRawData, event_offset, sizeof(name));
  402. fprintf(fp, "ttvector %sn", name);
  403. break;
  404. case LSTT_TOUCH: // LSTT_TOUCH
  405. bytestream2char(name, mRawData, event_offset, sizeof(name));
  406. fprintf(fp, "%sn", name);
  407. bytestream2char(name, mRawData, event_offset, sizeof(name));
  408. fprintf(fp, "ttkey %sn", name);
  409. bytestream2char(name, mRawData, event_offset, sizeof(name));
  410. fprintf(fp, "ttvector %sn", name);
  411. break;
  412. case LSTT_TOUCH_END: // LSTT_TOUCH_END
  413. bytestream2char(name, mRawData, event_offset, sizeof(name));
  414. fprintf(fp, "%sn", name);
  415. bytestream2char(name, mRawData, event_offset, sizeof(name));
  416. fprintf(fp, "ttkey %sn", name);
  417. bytestream2char(name, mRawData, event_offset, sizeof(name));
  418. fprintf(fp, "ttvector %sn", name);
  419. break;
  420. case LSTT_COLLISION_START: // LSTT_COLLISION_START
  421. bytestream2char(name, mRawData, event_offset, sizeof(name));
  422. fprintf(fp, "%sn", name);
  423. bytestream2char(name, mRawData, event_offset, sizeof(name));
  424. fprintf(fp, "ttkey %sn", name);
  425. bytestream2char(name, mRawData, event_offset, sizeof(name));
  426. fprintf(fp, "ttvector %sn", name);
  427. bytestream2char(name, mRawData, event_offset, sizeof(name));
  428. fprintf(fp, "ttvector %sn", name);
  429. break;
  430. case LSTT_COLLISION: // LSTT_COLLISION
  431. bytestream2char(name, mRawData, event_offset, sizeof(name));
  432. fprintf(fp, "%sn", name);
  433. bytestream2char(name, mRawData, event_offset, sizeof(name));
  434. fprintf(fp, "ttkey %sn", name);
  435. bytestream2char(name, mRawData, event_offset, sizeof(name));
  436. fprintf(fp, "ttvector %sn", name);
  437. bytestream2char(name, mRawData, event_offset, sizeof(name));
  438. fprintf(fp, "ttvector %sn", name);
  439. break;
  440. case LSTT_COLLISION_END: // LSTT_COLLISION_END
  441. bytestream2char(name, mRawData, event_offset, sizeof(name));
  442. fprintf(fp, "%sn", name);
  443. bytestream2char(name, mRawData, event_offset, sizeof(name));
  444. fprintf(fp, "ttkey %sn", name);
  445. bytestream2char(name, mRawData, event_offset, sizeof(name));
  446. fprintf(fp, "ttvector %sn", name);
  447. bytestream2char(name, mRawData, event_offset, sizeof(name));
  448. fprintf(fp, "ttvector %sn", name);
  449. break;
  450. case LSTT_LAND_COLLISION_START: // LSTT_LAND_COLLISION_START
  451. bytestream2char(name, mRawData, event_offset, sizeof(name));
  452. fprintf(fp, "%sn", name);
  453. bytestream2char(name, mRawData, event_offset, sizeof(name));
  454. fprintf(fp, "ttvector %sn", name);
  455. break;
  456. case LSTT_LAND_COLLISION: // LSTT_LAND_COLLISION
  457. bytestream2char(name, mRawData, event_offset, sizeof(name));
  458. fprintf(fp, "%sn", name);
  459. bytestream2char(name, mRawData, event_offset, sizeof(name));
  460. fprintf(fp, "ttvector %sn", name);
  461. break;
  462. case LSTT_LAND_COLLISION_END: // LSTT_LAND_COLLISION_END
  463. bytestream2char(name, mRawData, event_offset, sizeof(name));
  464. fprintf(fp, "%sn", name);
  465. bytestream2char(name, mRawData, event_offset, sizeof(name));
  466. fprintf(fp, "ttvector %sn", name);
  467. break;
  468. case LSTT_INVENTORY: // LSTT_INVENTORY
  469. bytestream2char(name, mRawData, event_offset, sizeof(name));
  470. fprintf(fp, "%sn", name);
  471. bytestream2char(name, mRawData, event_offset, sizeof(name));
  472. fprintf(fp, "ttinteger %sn", name);
  473. break;
  474. case LSTT_ATTACH: // LSTT_ATTACH
  475. bytestream2char(name, mRawData, event_offset, sizeof(name));
  476. fprintf(fp, "%sn", name);
  477. bytestream2char(name, mRawData, event_offset, sizeof(name));
  478. fprintf(fp, "ttkey %sn", name);
  479. break;
  480. case LSTT_DATASERVER: // LSTT_DATASERVER
  481. bytestream2char(name, mRawData, event_offset, sizeof(name));
  482. fprintf(fp, "%sn", name);
  483. bytestream2char(name, mRawData, event_offset, sizeof(name));
  484. fprintf(fp, "ttkey %sn", name);
  485. bytestream2char(name, mRawData, event_offset, sizeof(name));
  486. fprintf(fp, "ttstring %sn", name);
  487. break;
  488. case LSTT_TIMER: // LSTT_TIMER
  489. bytestream2char(name, mRawData, event_offset, sizeof(name));
  490. fprintf(fp, "%sn", name);
  491. break;
  492. case LSTT_MOVING_START: // LSTT_MOVING_START
  493. bytestream2char(name, mRawData, event_offset, sizeof(name));
  494. fprintf(fp, "%sn", name);
  495. break;
  496. case LSTT_MOVING_END: // LSTT_MOVING_END
  497. bytestream2char(name, mRawData, event_offset, sizeof(name));
  498. fprintf(fp, "%sn", name);
  499. break;
  500. case LSTT_CHAT: // LSTT_CHAT
  501. bytestream2char(name, mRawData, event_offset, sizeof(name));
  502. fprintf(fp, "%sn", name);
  503. bytestream2char(name, mRawData, event_offset, sizeof(name));
  504. fprintf(fp, "ttinteger %sn", name);
  505. bytestream2char(name, mRawData, event_offset, sizeof(name));
  506. fprintf(fp, "ttkey %sn", name);
  507. bytestream2char(name, mRawData, event_offset, sizeof(name));
  508. fprintf(fp, "ttstring %sn", name);
  509. break;
  510. case LSTT_OBJECT_REZ: // LSTT_OBJECT_REZ
  511. bytestream2char(name, mRawData, event_offset, sizeof(name));
  512. fprintf(fp, "%sn", name);
  513. bytestream2char(name, mRawData, event_offset, sizeof(name));
  514. fprintf(fp, "ttkey %sn", name);
  515. break;
  516. case LSTT_REMOTE_DATA: // LSTT_REMOTE_DATA
  517. bytestream2char(name, mRawData, event_offset, sizeof(name));
  518. fprintf(fp, "%sn", name);
  519. bytestream2char(name, mRawData, event_offset, sizeof(name));
  520. fprintf(fp, "ttinteger %sn", name);
  521. bytestream2char(name, mRawData, event_offset, sizeof(name));
  522. fprintf(fp, "ttkey %sn", name);
  523. bytestream2char(name, mRawData, event_offset, sizeof(name));
  524. fprintf(fp, "ttinteger %sn", name);
  525. bytestream2char(name, mRawData, event_offset, sizeof(name));
  526. fprintf(fp, "ttstring %sn", name);
  527. break;
  528. case LSTT_REZ: // LSTT_REZ
  529. bytestream2char(name, mRawData, event_offset, sizeof(name));
  530. fprintf(fp, "%sn", name);
  531. break;
  532. case LSTT_SENSOR: // LSTT_SENSOR
  533. bytestream2char(name, mRawData, event_offset, sizeof(name));
  534. fprintf(fp, "%sn", name);
  535. bytestream2char(name, mRawData, event_offset, sizeof(name));
  536. fprintf(fp, "ttinteger %sn", name);
  537. break;
  538. case LSTT_NO_SENSOR: // LSTT_NO_SENSOR
  539. bytestream2char(name, mRawData, event_offset, sizeof(name));
  540. fprintf(fp, "%sn", name);
  541. break;
  542. case LSTT_CONTROL: // LSTT_CONTROL
  543. bytestream2char(name, mRawData, event_offset, sizeof(name));
  544. fprintf(fp, "%sn", name);
  545. bytestream2char(name, mRawData, event_offset, sizeof(name));
  546. fprintf(fp, "ttkey %sn", name);
  547. bytestream2char(name, mRawData, event_offset, sizeof(name));
  548. fprintf(fp, "ttinteger %sn", name);
  549. bytestream2char(name, mRawData, event_offset, sizeof(name));
  550. fprintf(fp, "ttinteger %sn", name);
  551. break;
  552. case LSTT_LINK_MESSAGE: // LSTT_LINK_MESSAGE
  553. bytestream2char(name, mRawData, event_offset, sizeof(name));
  554. fprintf(fp, "%sn", name);
  555. bytestream2char(name, mRawData, event_offset, sizeof(name));
  556. fprintf(fp, "ttinteger %sn", name);
  557. bytestream2char(name, mRawData, event_offset, sizeof(name));
  558. fprintf(fp, "ttstring %sn", name);
  559. bytestream2char(name, mRawData, event_offset, sizeof(name));
  560. fprintf(fp, "ttkey %sn", name);
  561. break;
  562. case LSTT_MONEY: // LSTT_MONEY
  563. bytestream2char(name, mRawData, event_offset, sizeof(name));
  564. fprintf(fp, "%sn", name);
  565. bytestream2char(name, mRawData, event_offset, sizeof(name));
  566. fprintf(fp, "ttkey %sn", name);
  567. bytestream2char(name, mRawData, event_offset, sizeof(name));
  568. fprintf(fp, "ttinteger %sn", name);
  569. break;
  570. case LSTT_EMAIL: // LSTT_EMAIL
  571. bytestream2char(name, mRawData, event_offset, sizeof(name));
  572. fprintf(fp, "%sn", name);
  573. bytestream2char(name, mRawData, event_offset, sizeof(name));
  574. fprintf(fp, "ttstring %sn", name);
  575. bytestream2char(name, mRawData, event_offset, sizeof(name));
  576. fprintf(fp, "ttstring %sn", name);
  577. bytestream2char(name, mRawData, event_offset, sizeof(name));
  578. fprintf(fp, "ttstring %sn", name);
  579. bytestream2char(name, mRawData, event_offset, sizeof(name));
  580. fprintf(fp, "ttinteger %sn", name);
  581. break;
  582. case LSTT_AT_TARGET: // LSTT_AT_TARGET
  583. bytestream2char(name, mRawData, event_offset, sizeof(name));
  584. fprintf(fp, "%sn", name);
  585. bytestream2char(name, mRawData, event_offset, sizeof(name));
  586. fprintf(fp, "ttinteger %sn", name);
  587. bytestream2char(name, mRawData, event_offset, sizeof(name));
  588. fprintf(fp, "ttvector %sn", name);
  589. bytestream2char(name, mRawData, event_offset, sizeof(name));
  590. fprintf(fp, "ttvector %sn", name);
  591. break;
  592. case LSTT_NOT_AT_TARGET: // LSTT_NOT_AT_TARGET
  593. bytestream2char(name, mRawData, event_offset, sizeof(name));
  594. fprintf(fp, "%sn", name);
  595. break;
  596. case LSTT_AT_ROT_TARGET: // LSTT_AT_ROT_TARGET
  597. bytestream2char(name, mRawData, event_offset, sizeof(name));
  598. fprintf(fp, "%sn", name);
  599. bytestream2char(name, mRawData, event_offset, sizeof(name));
  600. fprintf(fp, "ttinteger %sn", name);
  601. bytestream2char(name, mRawData, event_offset, sizeof(name));
  602. fprintf(fp, "ttquaternion %sn", name);
  603. bytestream2char(name, mRawData, event_offset, sizeof(name));
  604. fprintf(fp, "ttquaternion %sn", name);
  605. break;
  606. case LSTT_NOT_AT_ROT_TARGET: // LSTT_NOT_AT_TARGET
  607. bytestream2char(name, mRawData, event_offset, sizeof(name));
  608. fprintf(fp, "%sn", name);
  609. break;
  610. case LSTT_RTPERMISSIONS: // LSTT_RTPERMISSIONS
  611. bytestream2char(name, mRawData, event_offset, sizeof(name));
  612. fprintf(fp, "%sn", name);
  613. fprintf(fp, "ttinteger %sn", name);
  614. bytestream2char(name, mRawData, event_offset, sizeof(name));
  615. break;
  616. case LSTT_HTTP_RESPONSE: // LSTT_REMOTE_DATA ?!?!?!
  617. bytestream2char(name, mRawData, event_offset, sizeof(name));
  618. fprintf(fp, "%sn", name);
  619. bytestream2char(name, mRawData, event_offset, sizeof(name));
  620. fprintf(fp, "ttkey %sn", name);
  621. bytestream2char(name, mRawData, event_offset, sizeof(name));
  622. fprintf(fp, "ttinteger %sn", name);
  623. bytestream2char(name, mRawData, event_offset, sizeof(name));
  624. fprintf(fp, "ttlist %sn", name);
  625. bytestream2char(name, mRawData, event_offset, sizeof(name));
  626. fprintf(fp, "ttstring %sn", name);
  627. break;
  628. case LSTT_HTTP_REQUEST: // LSTT_HTTP_REQUEST
  629. bytestream2char(name, mRawData, event_offset, sizeof(name));
  630. fprintf(fp, "%sn", name);
  631. bytestream2char(name, mRawData, event_offset, sizeof(name));
  632. fprintf(fp, "ttkey %sn", name);
  633. bytestream2char(name, mRawData, event_offset, sizeof(name));
  634. fprintf(fp, "ttstring %sn", name);
  635. bytestream2char(name, mRawData, event_offset, sizeof(name));
  636. fprintf(fp, "ttstring %sn", name);
  637. break;
  638. default:
  639. break;
  640. }
  641. fprintf(fp, "ttStack Size: %dn", stack_size);
  642. fprintf(fp, "tttOpCodes: 0x%X - 0x%Xn", opcode_start, opcode_end);
  643. printOpCodeRange(fp, opcode_start, opcode_end, 3);
  644. }
  645. }
  646. }
  647. }
  648. fprintf(fp, "=============================nn");
  649. }
  651. void LLScriptLSOParse::printHeap(LLFILE *fp)
  652. {
  653. // print out registers first
  655. S32 heap_offset = get_register(mRawData, LREG_HR);
  656. S32 heap_pointer = get_register(mRawData, LREG_HP);
  657. fprintf(fp, "=============================n");
  658. fprintf(fp, "[0x%X - 0x%X] Heapn", heap_offset, heap_pointer);
  659. fprintf(fp, "=============================n");
  661. lsa_fprint_heap(mRawData, fp);
  663. fprintf(fp, "=============================nn");
  664. }
  666. void lso_print_tabs(LLFILE *fp, S32 tabs)
  667. {
  668. S32 i;
  669. for (i = 0; i < tabs; i++)
  670. {
  671. fprintf(fp, "t");
  672. }
  673. }
  675. void LLScriptLSOParse::printOpCodes(LLFILE *fp, S32 &offset, S32 tabs)
  676. {
  677. U8 opcode = *(mRawData + offset);
  678. mPrintOpCodes[opcode](fp, mRawData, offset, tabs);
  679. }
  681. void LLScriptLSOParse::printOpCodeRange(LLFILE *fp, S32 start, S32 end, S32 tabs)
  682. {
  683. while (start < end)
  684. {
  685. printOpCodes(fp, start, tabs);
  686. }
  687. }
  689. void LLScriptLSOParse::initOpCodePrinting()
  690. {
  691. S32 i;
  692. for (i = 0; i < 256; i++)
  693. {
  694. mPrintOpCodes[i] = print_noop;
  695. }
  696. mPrintOpCodes[LSCRIPTOpCodes[LOPC_NOOP]] = print_noop;
  698. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POP]] = print_pop;
  699. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPS]] = print_pops;
  700. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPL]] = print_popl;
  701. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPV]] = print_popv;
  702. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPQ]] = print_popq;
  703. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPARG]] = print_poparg;
  704. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPIP]] = print_popip;
  705. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPBP]] = print_popbp;
  706. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPSP]] = print_popsp;
  707. mPrintOpCodes[LSCRIPTOpCodes[LOPC_POPSLR]] = print_popslr;
  709. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DUP]] = print_dup;
  710. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DUPS]] = print_dups;
  711. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DUPL]] = print_dupl;
  712. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DUPV]] = print_dupv;
  713. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DUPQ]] = print_dupq;
  715. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STORE]] = print_store;
  716. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STORES]] = print_stores;
  717. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREL]] = print_storel;
  718. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREV]] = print_storev;
  719. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREQ]] = print_storeq;
  720. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREG]] = print_storeg;
  721. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREGS]] = print_storegs;
  722. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREGL]] = print_storegl;
  723. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREGV]] = print_storegv;
  724. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STOREGQ]] = print_storegq;
  725. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADP]] = print_loadp;
  726. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADSP]] = print_loadsp;
  727. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADLP]] = print_loadlp;
  728. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADVP]] = print_loadvp;
  729. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADQP]] = print_loadqp;
  730. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADGP]] = print_loadgp;
  731. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADGSP]] = print_loadgsp;
  732. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADGLP]] = print_loadglp;
  733. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADGVP]] = print_loadgvp;
  734. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LOADGQP]] = print_loadgqp;
  736. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSH]] = print_push;
  737. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHS]] = print_pushs;
  738. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHL]] = print_pushl;
  739. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHV]] = print_pushv;
  740. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHQ]] = print_pushq;
  741. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHG]] = print_pushg;
  742. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHGS]] = print_pushgs;
  743. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHGL]] = print_pushgl;
  744. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHGV]] = print_pushgv;
  745. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHGQ]] = print_pushgq;
  746. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHIP]] = print_puship;
  747. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHSP]] = print_pushsp;
  748. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHBP]] = print_pushbp;
  749. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGB]] = print_pushargb;
  750. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGI]] = print_pushargi;
  751. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGF]] = print_pushargf;
  752. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGS]] = print_pushargs;
  753. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGV]] = print_pushargv;
  754. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGQ]] = print_pushargq;
  755. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHE]] = print_pushe;
  756. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHEV]] = print_pushev;
  757. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHEQ]] = print_pusheq;
  758. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PUSHARGE]] = print_pusharge;
  760. mPrintOpCodes[LSCRIPTOpCodes[LOPC_ADD]] = print_add;
  761. mPrintOpCodes[LSCRIPTOpCodes[LOPC_SUB]] = print_sub;
  762. mPrintOpCodes[LSCRIPTOpCodes[LOPC_MUL]] = print_mul;
  763. mPrintOpCodes[LSCRIPTOpCodes[LOPC_DIV]] = print_div;
  764. mPrintOpCodes[LSCRIPTOpCodes[LOPC_MOD]] = print_mod;
  766. mPrintOpCodes[LSCRIPTOpCodes[LOPC_EQ]] = print_eq;
  767. mPrintOpCodes[LSCRIPTOpCodes[LOPC_NEQ]] = print_neq;
  768. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LEQ]] = print_leq;
  769. mPrintOpCodes[LSCRIPTOpCodes[LOPC_GEQ]] = print_geq;
  770. mPrintOpCodes[LSCRIPTOpCodes[LOPC_LESS]] = print_less;
  771. mPrintOpCodes[LSCRIPTOpCodes[LOPC_GREATER]] = print_greater;
  773. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BITAND]] = print_bitand;
  774. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BITOR]] = print_bitor;
  775. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BITXOR]] = print_bitxor;
  777. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BOOLAND]] = print_booland;
  778. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BOOLOR]] = print_boolor;
  780. mPrintOpCodes[LSCRIPTOpCodes[LOPC_SHL]] = print_shl;
  781. mPrintOpCodes[LSCRIPTOpCodes[LOPC_SHR]] = print_shr;
  783. mPrintOpCodes[LSCRIPTOpCodes[LOPC_NEG]] = print_neg;
  784. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BITNOT]] = print_bitnot;
  785. mPrintOpCodes[LSCRIPTOpCodes[LOPC_BOOLNOT]] = print_boolnot;
  787. mPrintOpCodes[LSCRIPTOpCodes[LOPC_JUMP]] = print_jump;
  788. mPrintOpCodes[LSCRIPTOpCodes[LOPC_JUMPIF]] = print_jumpif;
  789. mPrintOpCodes[LSCRIPTOpCodes[LOPC_JUMPNIF]] = print_jumpnif;
  791. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STATE]] = print_state;
  792. mPrintOpCodes[LSCRIPTOpCodes[LOPC_CALL]] = print_call;
  793. mPrintOpCodes[LSCRIPTOpCodes[LOPC_RETURN]] = print_return;
  794. mPrintOpCodes[LSCRIPTOpCodes[LOPC_CAST]] = print_cast;
  795. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STACKTOS]] = print_stacktos;
  796. mPrintOpCodes[LSCRIPTOpCodes[LOPC_STACKTOL]] = print_stacktol;
  798. mPrintOpCodes[LSCRIPTOpCodes[LOPC_PRINT]] = print_print;
  800. mPrintOpCodes[LSCRIPTOpCodes[LOPC_CALLLIB]] = print_calllib;
  802. mPrintOpCodes[LSCRIPTOpCodes[LOPC_CALLLIB_TWO_BYTE]] = print_calllib_two_byte;
  803. }
  805. void print_noop(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  806. {
  807. lso_print_tabs(fp, tabs);
  808. fprintf(fp, "[0x%X]tNOOPn", offset++);
  809. }
  811. void print_pop(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  812. {
  813. lso_print_tabs(fp, tabs);
  814. fprintf(fp, "[0x%X]tPOPn", offset++);
  815. }
  817. void print_pops(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  818. {
  819. lso_print_tabs(fp, tabs);
  820. fprintf(fp, "[0x%X]tPOPSn", offset++);
  821. }
  823. void print_popl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  824. {
  825. lso_print_tabs(fp, tabs);
  826. fprintf(fp, "[0x%X]tPOPLn", offset++);
  827. }
  829. void print_popv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  830. {
  831. lso_print_tabs(fp, tabs);
  832. fprintf(fp, "[0x%X]tPOPVn", offset++);
  833. }
  835. void print_popq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  836. {
  837. lso_print_tabs(fp, tabs);
  838. fprintf(fp, "[0x%X]tPOPQn", offset++);
  839. }
  841. void print_poparg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  842. {
  843. S32 arg;
  844. lso_print_tabs(fp, tabs);
  845. fprintf(fp, "[0x%X]tPOPARG ", offset++);
  846. arg = bytestream2integer(buffer, offset);
  847. fprintf(fp, "%dn", arg);
  848. }
  850. void print_popip(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  851. {
  852. lso_print_tabs(fp, tabs);
  853. fprintf(fp, "[0x%X]tPOPIPn", offset++);
  854. }
  856. void print_popbp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  857. {
  858. lso_print_tabs(fp, tabs);
  859. fprintf(fp, "[0x%X]tPOPBPn", offset++);
  860. }
  862. void print_popsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  863. {
  864. lso_print_tabs(fp, tabs);
  865. fprintf(fp, "[0x%X]tPOPSPn", offset++);
  866. }
  868. void print_popslr(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  869. {
  870. lso_print_tabs(fp, tabs);
  871. fprintf(fp, "[0x%X]tPOPSLRn", offset++);
  872. }
  874. void print_dup(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  875. {
  876. lso_print_tabs(fp, tabs);
  877. fprintf(fp, "[0x%X]tDUPn", offset++);
  878. }
  880. void print_dups(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  881. {
  882. lso_print_tabs(fp, tabs);
  883. fprintf(fp, "[0x%X]tDUPSn", offset++);
  884. }
  886. void print_dupl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  887. {
  888. lso_print_tabs(fp, tabs);
  889. fprintf(fp, "[0x%X]tDUPLn", offset++);
  890. }
  892. void print_dupv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  893. {
  894. lso_print_tabs(fp, tabs);
  895. fprintf(fp, "[0x%X]tDUPVn", offset++);
  896. }
  898. void print_dupq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  899. {
  900. lso_print_tabs(fp, tabs);
  901. fprintf(fp, "[0x%X]tDUPQn", offset++);
  902. }
  904. void print_store(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  905. {
  906. S32 arg;
  907. lso_print_tabs(fp, tabs);
  908. fprintf(fp, "[0x%X]tSTORE $BP + ", offset++);
  909. arg = bytestream2integer(buffer, offset);
  910. fprintf(fp, "%dn", arg);
  911. }
  913. void print_stores(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  914. {
  915. S32 arg;
  916. lso_print_tabs(fp, tabs);
  917. fprintf(fp, "[0x%X]tSTORES $BP + ", offset++);
  918. arg = bytestream2integer(buffer, offset);
  919. fprintf(fp, "%dn", arg);
  920. }
  922. void print_storel(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  923. {
  924. S32 arg;
  925. lso_print_tabs(fp, tabs);
  926. fprintf(fp, "[0x%X]tSTOREL $BP + ", offset++);
  927. arg = bytestream2integer(buffer, offset);
  928. fprintf(fp, "%dn", arg);
  929. }
  931. void print_storev(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  932. {
  933. S32 arg;
  934. lso_print_tabs(fp, tabs);
  935. fprintf(fp, "[0x%X]tSTOREV $BP + ", offset++);
  936. arg = bytestream2integer(buffer, offset);
  937. fprintf(fp, "%dn", arg);
  938. }
  940. void print_storeq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  941. {
  942. S32 arg;
  943. lso_print_tabs(fp, tabs);
  944. fprintf(fp, "[0x%X]tSTOREQ $BP + ", offset++);
  945. arg = bytestream2integer(buffer, offset);
  946. fprintf(fp, "%dn", arg);
  947. }
  949. void print_storeg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  950. {
  951. S32 arg;
  952. lso_print_tabs(fp, tabs);
  953. fprintf(fp, "[0x%X]tSTOREG ", offset++);
  954. arg = bytestream2integer(buffer, offset);
  955. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  956. }
  958. void print_storegs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  959. {
  960. S32 arg;
  961. lso_print_tabs(fp, tabs);
  962. fprintf(fp, "[0x%X]tSTOREGS ", offset++);
  963. arg = bytestream2integer(buffer, offset);
  964. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  965. }
  967. void print_storegl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  968. {
  969. S32 arg;
  970. lso_print_tabs(fp, tabs);
  971. fprintf(fp, "[0x%X]tSTOREGL ", offset++);
  972. arg = bytestream2integer(buffer, offset);
  973. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  974. }
  976. void print_storegv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  977. {
  978. S32 arg;
  979. lso_print_tabs(fp, tabs);
  980. fprintf(fp, "[0x%X]tSTOREGV ", offset++);
  981. arg = bytestream2integer(buffer, offset);
  982. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  983. }
  985. void print_storegq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  986. {
  987. S32 arg;
  988. lso_print_tabs(fp, tabs);
  989. fprintf(fp, "[0x%X]tSTOREGQ ", offset++);
  990. arg = bytestream2integer(buffer, offset);
  991. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  992. }
  994. void print_loadp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  995. {
  996. S32 arg;
  997. lso_print_tabs(fp, tabs);
  998. fprintf(fp, "[0x%X]tSTOREP $BP + ", offset++);
  999. arg = bytestream2integer(buffer, offset);
  1000. fprintf(fp, "%dn", arg);
  1001. }
  1003. void print_loadsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1004. {
  1005. S32 arg;
  1006. lso_print_tabs(fp, tabs);
  1007. fprintf(fp, "[0x%X]tSTOREPS $BP + ", offset++);
  1008. arg = bytestream2integer(buffer, offset);
  1009. fprintf(fp, "%dn", arg);
  1010. }
  1012. void print_loadlp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1013. {
  1014. S32 arg;
  1015. lso_print_tabs(fp, tabs);
  1016. fprintf(fp, "[0x%X]tSTOREPL $BP + ", offset++);
  1017. arg = bytestream2integer(buffer, offset);
  1018. fprintf(fp, "%dn", arg);
  1019. }
  1021. void print_loadvp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1022. {
  1023. S32 arg;
  1024. lso_print_tabs(fp, tabs);
  1025. fprintf(fp, "[0x%X]tSTOREVP $BP + ", offset++);
  1026. arg = bytestream2integer(buffer, offset);
  1027. fprintf(fp, "%dn", arg);
  1028. }
  1030. void print_loadqp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1031. {
  1032. S32 arg;
  1033. lso_print_tabs(fp, tabs);
  1034. fprintf(fp, "[0x%X]tSTOREQP $BP + ", offset++);
  1035. arg = bytestream2integer(buffer, offset);
  1036. fprintf(fp, "%dn", arg);
  1037. }
  1039. void print_loadgp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1040. {
  1041. S32 arg;
  1042. lso_print_tabs(fp, tabs);
  1043. fprintf(fp, "[0x%X]tSTOREGP ", offset++);
  1044. arg = bytestream2integer(buffer, offset);
  1045. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  1046. }
  1048. void print_loadgsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1049. {
  1050. S32 arg;
  1051. lso_print_tabs(fp, tabs);
  1052. fprintf(fp, "[0x%X]tSTOREGSP ", offset++);
  1053. arg = bytestream2integer(buffer, offset);
  1054. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  1055. }
  1057. void print_loadglp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1058. {
  1059. S32 arg;
  1060. lso_print_tabs(fp, tabs);
  1061. fprintf(fp, "[0x%X]tSTOREGLP ", offset++);
  1062. arg = bytestream2integer(buffer, offset);
  1063. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  1064. }
  1066. void print_loadgvp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1067. {
  1068. S32 arg;
  1069. lso_print_tabs(fp, tabs);
  1070. fprintf(fp, "[0x%X]tSTOREGVP ", offset++);
  1071. arg = bytestream2integer(buffer, offset);
  1072. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  1073. }
  1075. void print_loadgqp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1076. {
  1077. S32 arg;
  1078. lso_print_tabs(fp, tabs);
  1079. fprintf(fp, "[0x%X]tSTOREGQP ", offset++);
  1080. arg = bytestream2integer(buffer, offset);
  1081. fprintf(fp, "%dn", arg + get_register(buffer, LREG_GVR));
  1082. }
  1084. void print_push(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1085. {
  1086. S32 arg;
  1087. lso_print_tabs(fp, tabs);
  1088. fprintf(fp, "[0x%X]tPUSH $BP + ", offset++);
  1089. arg = bytestream2integer(buffer, offset);
  1090. fprintf(fp, "%dn", arg);
  1091. }
  1093. void print_pushs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1094. {
  1095. S32 arg;
  1096. lso_print_tabs(fp, tabs);
  1097. fprintf(fp, "[0x%X]tPUSHS $BP + ", offset++);
  1098. arg = bytestream2integer(buffer, offset);
  1099. fprintf(fp, "%dn", arg);
  1100. }
  1102. void print_pushl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1103. {
  1104. S32 arg;
  1105. lso_print_tabs(fp, tabs);
  1106. fprintf(fp, "[0x%X]tPUSHL $BP + ", offset++);
  1107. arg = bytestream2integer(buffer, offset);
  1108. fprintf(fp, "%dn", arg);
  1109. }
  1111. void print_pushv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1112. {
  1113. S32 arg;
  1114. lso_print_tabs(fp, tabs);
  1115. fprintf(fp, "[0x%X]tPUSHV $BP + ", offset++);
  1116. arg = bytestream2integer(buffer, offset);
  1117. fprintf(fp, "%dn", arg);
  1118. }
  1120. void print_pushq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1121. {
  1122. S32 arg;
  1123. lso_print_tabs(fp, tabs);
  1124. fprintf(fp, "[0x%X]tPUSHQ $BP + ", offset++);
  1125. arg = bytestream2integer(buffer, offset);
  1126. fprintf(fp, "%dn", arg);
  1127. }
  1129. void print_pushg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1130. {
  1131. S32 arg;
  1132. lso_print_tabs(fp, tabs);
  1133. fprintf(fp, "[0x%X]tPUSHG ", offset++);
  1134. arg = bytestream2integer(buffer, offset);
  1135. fprintf(fp, "0x%Xn", arg + get_register(buffer, LREG_GVR));
  1136. }
  1138. void print_pushgs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1139. {
  1140. S32 arg;
  1141. lso_print_tabs(fp, tabs);
  1142. fprintf(fp, "[0x%X]tPUSHGS ", offset++);
  1143. arg = bytestream2integer(buffer, offset);
  1144. fprintf(fp, "0x%Xn", arg + get_register(buffer, LREG_GVR));
  1145. }
  1147. void print_pushgl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1148. {
  1149. S32 arg;
  1150. lso_print_tabs(fp, tabs);
  1151. fprintf(fp, "[0x%X]tPUSHGL ", offset++);
  1152. arg = bytestream2integer(buffer, offset);
  1153. fprintf(fp, "0x%Xn", arg + get_register(buffer, LREG_GVR));
  1154. }
  1156. void print_pushgv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1157. {
  1158. S32 arg;
  1159. lso_print_tabs(fp, tabs);
  1160. fprintf(fp, "[0x%X]tPUSHGV ", offset++);
  1161. arg = bytestream2integer(buffer, offset);
  1162. fprintf(fp, "0x%Xn", arg + get_register(buffer, LREG_GVR));
  1163. }
  1165. void print_pushgq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1166. {
  1167. S32 arg;
  1168. lso_print_tabs(fp, tabs);
  1169. fprintf(fp, "[0x%X]tPUSHGQ ", offset++);
  1170. arg = bytestream2integer(buffer, offset);
  1171. fprintf(fp, "0x%Xn", arg + get_register(buffer, LREG_GVR));
  1172. }
  1174. void print_puship(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1175. {
  1176. lso_print_tabs(fp, tabs);
  1177. fprintf(fp, "[0x%X]tPUSHIPn", offset++);
  1178. }
  1180. void print_pushbp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1181. {
  1182. lso_print_tabs(fp, tabs);
  1183. fprintf(fp, "[0x%X]tPUSHBPn", offset++);
  1184. }
  1186. void print_pushsp(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1187. {
  1188. lso_print_tabs(fp, tabs);
  1189. fprintf(fp, "[0x%X]tPUSHSPn", offset++);
  1190. }
  1192. void print_pushargb(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1193. {
  1194. U8 arg;
  1195. lso_print_tabs(fp, tabs);
  1196. fprintf(fp, "[0x%X]tPUSHARGB ", offset++);
  1197. arg = *(buffer + offset++);
  1198. fprintf(fp, "%dn", (U32)arg);
  1199. }
  1201. void print_pushargi(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1202. {
  1203. S32 arg;
  1204. lso_print_tabs(fp, tabs);
  1205. fprintf(fp, "[0x%X]tPUSHARGI ", offset++);
  1206. arg = bytestream2integer(buffer, offset);
  1207. fprintf(fp, "%dn", arg);
  1208. }
  1210. void print_pushargf(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1211. {
  1212. F32 arg;
  1213. lso_print_tabs(fp, tabs);
  1214. fprintf(fp, "[0x%X]tPUSHARGF ", offset++);
  1215. arg = bytestream2float(buffer, offset);
  1216. fprintf(fp, "%fn", arg);
  1217. }
  1219. void print_pushargs(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1220. {
  1221. char arg[1024]; /*Flawfinder: ignore*/
  1222. lso_print_tabs(fp, tabs);
  1223. fprintf(fp, "[0x%X]tPUSHARGS ", offset++);
  1224. bytestream2char(arg, buffer, offset, sizeof(arg));
  1225. fprintf(fp, "%sn", arg);
  1226. }
  1228. void print_pushargv(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1229. {
  1230. LLVector3 arg;
  1231. lso_print_tabs(fp, tabs);
  1232. fprintf(fp, "[0x%X]tPUSHARGV ", offset++);
  1233. bytestream2vector(arg, buffer, offset);
  1234. fprintf(fp, "< %f, %f, %f >n", arg.mV[VX], arg.mV[VY], arg.mV[VZ]);
  1235. }
  1237. void print_pushargq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1238. {
  1239. LLQuaternion arg;
  1240. lso_print_tabs(fp, tabs);
  1241. fprintf(fp, "[0x%X]tPUSHARGV ", offset++);
  1242. bytestream2quaternion(arg, buffer, offset);
  1243. fprintf(fp, "< %f, %f, %f, %f >n", arg.mQ[VX], arg.mQ[VY], arg.mQ[VZ], arg.mQ[VS]);
  1244. }
  1246. void print_pushe(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1247. {
  1248. lso_print_tabs(fp, tabs);
  1249. fprintf(fp, "[0x%X]tPUSHEn", offset++);
  1250. }
  1252. void print_pushev(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1253. {
  1254. lso_print_tabs(fp, tabs);
  1255. fprintf(fp, "[0x%X]tPUSHEVn", offset++);
  1256. }
  1258. void print_pusheq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1259. {
  1260. lso_print_tabs(fp, tabs);
  1261. fprintf(fp, "[0x%X]tPUSHEQn", offset++);
  1262. }
  1264. void print_pusharge(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1265. {
  1266. S32 arg;
  1267. lso_print_tabs(fp, tabs);
  1268. fprintf(fp, "[0x%X]tPUSHARGE ", offset++);
  1269. arg = bytestream2integer(buffer, offset);
  1270. fprintf(fp, "%dn", arg);
  1271. }
  1274. void print_add(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1275. {
  1276. U8 types;
  1277. U8 type1;
  1278. U8 type2;
  1279. lso_print_tabs(fp, tabs);
  1280. fprintf(fp, "[0x%X]tADD ", offset++);
  1281. types = *(buffer + offset++);
  1282. type1 = types >> 4;
  1283. type2 = types & 0xf;
  1284. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1285. }
  1287. void print_sub(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1288. {
  1289. U8 types;
  1290. U8 type1;
  1291. U8 type2;
  1292. lso_print_tabs(fp, tabs);
  1293. fprintf(fp, "[0x%X]tSUB ", offset++);
  1294. types = *(buffer + offset++);
  1295. type1 = types >> 4;
  1296. type2 = types & 0xf;
  1297. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1298. }
  1300. void print_mul(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1301. {
  1302. U8 types;
  1303. U8 type1;
  1304. U8 type2;
  1305. lso_print_tabs(fp, tabs);
  1306. fprintf(fp, "[0x%X]tMUL ", offset++);
  1307. types = *(buffer + offset++);
  1308. type1 = types >> 4;
  1309. type2 = types & 0xf;
  1310. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1311. }
  1313. void print_div(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1314. {
  1315. U8 types;
  1316. U8 type1;
  1317. U8 type2;
  1318. lso_print_tabs(fp, tabs);
  1319. fprintf(fp, "[0x%X]tDIV ", offset++);
  1320. types = *(buffer + offset++);
  1321. type1 = types >> 4;
  1322. type2 = types & 0xf;
  1323. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1324. }
  1326. void print_mod(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1327. {
  1328. U8 types;
  1329. U8 type1;
  1330. U8 type2;
  1331. lso_print_tabs(fp, tabs);
  1332. fprintf(fp, "[0x%X]tMOD ", offset++);
  1333. types = *(buffer + offset++);
  1334. type1 = types >> 4;
  1335. type2 = types & 0xf;
  1336. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1337. }
  1339. void print_eq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1340. {
  1341. U8 types;
  1342. U8 type1;
  1343. U8 type2;
  1344. lso_print_tabs(fp, tabs);
  1345. fprintf(fp, "[0x%X]tEQ ", offset++);
  1346. types = *(buffer + offset++);
  1347. type1 = types >> 4;
  1348. type2 = types & 0xf;
  1349. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1350. }
  1352. void print_neq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1353. {
  1354. U8 types;
  1355. U8 type1;
  1356. U8 type2;
  1357. lso_print_tabs(fp, tabs);
  1358. fprintf(fp, "[0x%X]tNEQ ", offset++);
  1359. types = *(buffer + offset++);
  1360. type1 = types >> 4;
  1361. type2 = types & 0xf;
  1362. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1363. }
  1365. void print_leq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1366. {
  1367. U8 types;
  1368. U8 type1;
  1369. U8 type2;
  1370. lso_print_tabs(fp, tabs);
  1371. fprintf(fp, "[0x%X]tLEQ ", offset++);
  1372. types = *(buffer + offset++);
  1373. type1 = types >> 4;
  1374. type2 = types & 0xf;
  1375. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1376. }
  1378. void print_geq(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1379. {
  1380. U8 types;
  1381. U8 type1;
  1382. U8 type2;
  1383. lso_print_tabs(fp, tabs);
  1384. fprintf(fp, "[0x%X]tGEQ ", offset++);
  1385. types = *(buffer + offset++);
  1386. type1 = types >> 4;
  1387. type2 = types & 0xf;
  1388. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1389. }
  1391. void print_less(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1392. {
  1393. U8 types;
  1394. U8 type1;
  1395. U8 type2;
  1396. lso_print_tabs(fp, tabs);
  1397. fprintf(fp, "[0x%X]tLESS ", offset++);
  1398. types = *(buffer + offset++);
  1399. type1 = types >> 4;
  1400. type2 = types & 0xf;
  1401. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1402. }
  1404. void print_greater(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1405. {
  1406. U8 types;
  1407. U8 type1;
  1408. U8 type2;
  1409. lso_print_tabs(fp, tabs);
  1410. fprintf(fp, "[0x%X]tGREATER ", offset++);
  1411. types = *(buffer + offset++);
  1412. type1 = types >> 4;
  1413. type2 = types & 0xf;
  1414. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1415. }
  1418. void print_bitand(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1419. {
  1420. lso_print_tabs(fp, tabs);
  1421. fprintf(fp, "[0x%X]tBITANDn", offset++);
  1422. }
  1424. void print_bitor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1425. {
  1426. lso_print_tabs(fp, tabs);
  1427. fprintf(fp, "[0x%X]tBITORn", offset++);
  1428. }
  1430. void print_bitxor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1431. {
  1432. lso_print_tabs(fp, tabs);
  1433. fprintf(fp, "[0x%X]tBITXORn", offset++);
  1434. }
  1436. void print_booland(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1437. {
  1438. lso_print_tabs(fp, tabs);
  1439. fprintf(fp, "[0x%X]tBOOLANDn", offset++);
  1440. }
  1442. void print_boolor(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1443. {
  1444. lso_print_tabs(fp, tabs);
  1445. fprintf(fp, "[0x%X]tBOOLORn", offset++);
  1446. }
  1448. void print_shl(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1449. {
  1450. lso_print_tabs(fp, tabs);
  1451. fprintf(fp, "[0x%X]tSHLn", offset++);
  1452. }
  1454. void print_shr(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1455. {
  1456. lso_print_tabs(fp, tabs);
  1457. fprintf(fp, "[0x%X]tSHRn", offset++);
  1458. }
  1461. void print_neg(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1462. {
  1463. U8 type;
  1464. lso_print_tabs(fp, tabs);
  1465. fprintf(fp, "[0x%X]tNEG ", offset++);
  1466. type = *(buffer + offset++);
  1467. fprintf(fp, "%sn", LSCRIPTTypeNames[type]);
  1468. }
  1470. void print_bitnot(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1471. {
  1472. lso_print_tabs(fp, tabs);
  1473. fprintf(fp, "[0x%X]tBITNOTn", offset++);
  1474. }
  1476. void print_boolnot(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1477. {
  1478. lso_print_tabs(fp, tabs);
  1479. fprintf(fp, "[0x%X]tBOOLNOTn", offset++);
  1480. }
  1482. void print_jump(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1483. {
  1484. S32 arg;
  1485. lso_print_tabs(fp, tabs);
  1486. fprintf(fp, "[0x%X]tJUMP ", offset++);
  1487. arg = bytestream2integer(buffer, offset);
  1488. fprintf(fp, "%dn", arg);
  1489. }
  1491. void print_jumpif(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1492. {
  1493. S32 arg;
  1494. U8 type;
  1495. lso_print_tabs(fp, tabs);
  1496. fprintf(fp, "[0x%X]tJUMPIF ", offset++);
  1497. type = *(buffer + offset++);
  1498. arg = bytestream2integer(buffer, offset);
  1499. fprintf(fp, "%s, %dn", LSCRIPTTypeNames[type], arg);
  1500. }
  1502. void print_jumpnif(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1503. {
  1504. S32 arg;
  1505. U8 type;
  1506. lso_print_tabs(fp, tabs);
  1507. fprintf(fp, "[0x%X]tJUMPNIF ", offset++);
  1508. type = *(buffer + offset++);
  1509. arg = bytestream2integer(buffer, offset);
  1510. fprintf(fp, "%s, %dn", LSCRIPTTypeNames[type], arg);
  1511. }
  1513. void print_state(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1514. {
  1515. S32 arg;
  1516. lso_print_tabs(fp, tabs);
  1517. fprintf(fp, "[0x%X]tSTATE ", offset++);
  1518. arg = bytestream2integer(buffer, offset);
  1519. fprintf(fp, "%dn", arg);
  1520. }
  1522. void print_call(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1523. {
  1524. S32 arg;
  1525. lso_print_tabs(fp, tabs);
  1526. fprintf(fp, "[0x%X]tCALL ", offset++);
  1527. arg = bytestream2integer(buffer, offset);
  1528. fprintf(fp, "%dn", arg);
  1529. }
  1531. void print_return(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1532. {
  1533. lso_print_tabs(fp, tabs);
  1534. fprintf(fp, "[0x%X]tRETURNn", offset++);
  1535. }
  1537. void print_cast(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1538. {
  1539. U8 types;
  1540. U8 type1;
  1541. U8 type2;
  1542. lso_print_tabs(fp, tabs);
  1543. fprintf(fp, "[0x%X]tCAST ", offset++);
  1544. types = *(buffer + offset++);
  1545. type1 = types >> 4;
  1546. type2 = types & 0xf;
  1547. fprintf(fp, "%s, %sn", LSCRIPTTypeNames[type1], LSCRIPTTypeNames[type2]);
  1548. }
  1550. void print_stacktos(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1551. {
  1552. S32 arg;
  1553. lso_print_tabs(fp, tabs);
  1554. fprintf(fp, "[0x%X]tSTACKTOS ", offset++);
  1555. arg = bytestream2integer(buffer, offset);
  1556. fprintf(fp, "%dn", arg);
  1557. }
  1559. void print_stacktol(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1560. {
  1561. S32 arg;
  1562. lso_print_tabs(fp, tabs);
  1563. fprintf(fp, "[0x%X]tSTACKTOL ", offset++);
  1564. arg = bytestream2integer(buffer, offset);
  1565. fprintf(fp, "%dn", arg);
  1566. }
  1568. void print_print(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1569. {
  1570. lso_print_tabs(fp, tabs);
  1571. fprintf(fp, "[0x%X]tPRINT ", offset++);
  1572. U8 type = *(buffer + offset++);
  1573. fprintf(fp, "%sn", LSCRIPTTypeNames[type]);
  1574. }
  1576. void print_calllib(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1577. {
  1578. U8 arg;
  1579. lso_print_tabs(fp, tabs);
  1580. fprintf(fp, "[0x%X]tCALLLIB ", offset++);
  1581. arg = *(buffer + offset++);
  1582. fprintf(fp, "%d (%s)n", (U32)arg, gScriptLibrary.mFunctions[arg].mName);
  1583. }
  1586. void print_calllib_two_byte(LLFILE *fp, U8 *buffer, S32 &offset, S32 tabs)
  1587. {
  1588. U16 arg;
  1589. lso_print_tabs(fp, tabs);
  1590. fprintf(fp, "[0x%X]tCALLLIB_TWO_BYTE ", offset++);
  1591. arg = bytestream2u16(buffer, offset);
  1592. fprintf(fp, "%d (%s)n", (U32)arg, gScriptLibrary.mFunctions[arg].mName);
  1593. }