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

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

游戏引擎

开发平台：

C++ Builder

lscript_tree.cpp：源码内容
  1. mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2. fprintf(fp, " )");
  3. break;
  4. default:
  5. mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  6. break;
  7. }
  8. }
  10. S32 LLScriptSensorEvent::getSize()
  11. {
  12. // integer = 4
  13. return 4;
  14. }
  16. void LLScriptObjectRezEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  17. {
  18. if (gErrorToText.getErrors())
  19. {
  20. return;
  21. }
  22. switch(pass)
  23. {
  24. case LSCP_PRETTY_PRINT:
  25. case LSCP_EMIT_ASSEMBLY:
  26. fdotabs(fp, tabs, tabsize);
  27. fprintf(fp, "object_rez( key ");
  28. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  29. fprintf(fp, " )n");
  30. break;
  31. case LSCP_SCOPE_PASS1:
  32.   checkForDuplicateHandler(fp, this, scope, "object_rez");
  33. if (scope->checkEntry(mID->mName))
  34. {
  35. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  36. }
  37. else
  38. {
  39. mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
  40. }
  41. break;
  42. case LSCP_RESOURCE:
  43. {
  44. // we're just tryng to determine how much space the variable needs
  45. if (mID->mScopeEntry)
  46. {
  47. mID->mScopeEntry->mOffset = (S32)count;
  48. mID->mScopeEntry->mSize = 4;
  49. count += mID->mScopeEntry->mSize;
  50. }
  51. }
  52. break;
  53. case LSCP_EMIT_BYTE_CODE:
  54. {
  55. #ifdef LSL_INCLUDE_DEBUG_INFO
  56. char name[] = "sensor";
  57. chunk->addBytes(name, strlen(name) + 1);
  58. chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
  59. #endif
  60. }
  61. break;
  62. case LSCP_EMIT_CIL_ASSEMBLY:
  63. fdotabs(fp, tabs, tabsize);
  64. fprintf(fp, "object_rez( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  65. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  66. fprintf(fp, " )");
  67. break;
  68. default:
  69. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  70. break;
  71. }
  72. }
  74. S32 LLScriptObjectRezEvent::getSize()
  75. {
  76. // key = 4
  77. return 4;
  78. }
  80. void LLScriptControlEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  81. {
  82. if (gErrorToText.getErrors())
  83. {
  84. return;
  85. }
  86. switch(pass)
  87. {
  88. case LSCP_PRETTY_PRINT:
  89. case LSCP_EMIT_ASSEMBLY:
  90. fdotabs(fp, tabs, tabsize);
  91. fprintf(fp, "control( key ");
  92. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  93. fprintf(fp, ", integer ");
  94. mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  95. fprintf(fp, ", integer ");
  96. mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  97. fprintf(fp, " )n");
  98. break;
  99. case LSCP_SCOPE_PASS1:
  100.   checkForDuplicateHandler(fp, this, scope, "control");
  101. if (scope->checkEntry(mName->mName))
  102. {
  103. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  104. }
  105. else
  106. {
  107. mName->mScopeEntry = scope->addEntry(mName->mName, LIT_VARIABLE, LST_KEY);
  108. }
  109. if (scope->checkEntry(mLevels->mName))
  110. {
  111. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  112. }
  113. else
  114. {
  115. mLevels->mScopeEntry = scope->addEntry(mLevels->mName, LIT_VARIABLE, LST_INTEGER);
  116. }
  117. if (scope->checkEntry(mEdges->mName))
  118. {
  119. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  120. }
  121. else
  122. {
  123. mEdges->mScopeEntry = scope->addEntry(mEdges->mName, LIT_VARIABLE, LST_INTEGER);
  124. }
  125. break;
  126. case LSCP_RESOURCE:
  127. {
  128. // we're just tryng to determine how much space the variable needs
  129. if (mName->mScopeEntry)
  130. {
  131. mName->mScopeEntry->mOffset = (S32)count;
  132. mName->mScopeEntry->mSize = 4;
  133. count += mName->mScopeEntry->mSize;
  134. mLevels->mScopeEntry->mOffset = (S32)count;
  135. mLevels->mScopeEntry->mSize = 4;
  136. count += mLevels->mScopeEntry->mSize;
  137. mEdges->mScopeEntry->mOffset = (S32)count;
  138. mEdges->mScopeEntry->mSize = 4;
  139. count += mEdges->mScopeEntry->mSize;
  140. }
  141. }
  142. break;
  143. case LSCP_EMIT_BYTE_CODE:
  144. {
  145. #ifdef LSL_INCLUDE_DEBUG_INFO
  146. char name[] = "control";
  147. chunk->addBytes(name, strlen(name) + 1);
  148. chunk->addBytes(mName->mName, strlen(mName->mName) + 1);
  149. chunk->addBytes(mLevels->mName, strlen(mLevels->mName) + 1);
  150. chunk->addBytes(mEdges->mName, strlen(mEdges->mName) + 1);
  151. #endif
  152. }
  153. break;
  154. case LSCP_EMIT_CIL_ASSEMBLY:
  155. fdotabs(fp, tabs, tabsize);
  156. fprintf(fp, "control( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  157. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  158. fprintf(fp, ", int32 ");
  159. mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  160. fprintf(fp, ", int32 ");
  161. mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  162. fprintf(fp, " )");
  163. break;
  164. default:
  165. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  166. mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  167. mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  168. break;
  169. }
  170. }
  172. S32 LLScriptControlEvent::getSize()
  173. {
  174. // key + integer + integer = 12
  175. return 12;
  176. }
  178. void LLScriptLinkMessageEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  179. {
  180. if (gErrorToText.getErrors())
  181. {
  182. return;
  183. }
  184. switch(pass)
  185. {
  186. case LSCP_PRETTY_PRINT:
  187. case LSCP_EMIT_ASSEMBLY:
  188. fdotabs(fp, tabs, tabsize);
  189. fprintf(fp, "link_message( integer ");
  190. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  191. fprintf(fp, ", integer ");
  192. mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  193. fprintf(fp, ", string ");
  194. mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  195. fprintf(fp, ", key ");
  196. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  197. fprintf(fp, " )n");
  198. break;
  199. case LSCP_SCOPE_PASS1:
  200.   checkForDuplicateHandler(fp, this, scope, "link_message");
  201. if (scope->checkEntry(mSender->mName))
  202. {
  203. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  204. }
  205. else
  206. {
  207. mSender->mScopeEntry = scope->addEntry(mSender->mName, LIT_VARIABLE, LST_INTEGER);
  208. }
  209. if (scope->checkEntry(mNum->mName))
  210. {
  211. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  212. }
  213. else
  214. {
  215. mNum->mScopeEntry = scope->addEntry(mNum->mName, LIT_VARIABLE, LST_INTEGER);
  216. }
  217. if (scope->checkEntry(mStr->mName))
  218. {
  219. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  220. }
  221. else
  222. {
  223. mStr->mScopeEntry = scope->addEntry(mStr->mName, LIT_VARIABLE, LST_STRING);
  224. }
  225. if (scope->checkEntry(mID->mName))
  226. {
  227. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  228. }
  229. else
  230. {
  231. mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
  232. }
  233. break;
  234. case LSCP_RESOURCE:
  235. {
  236. // we're just tryng to determine how much space the variable needs
  237. if (mSender->mScopeEntry)
  238. {
  239. mSender->mScopeEntry->mOffset = (S32)count;
  240. mSender->mScopeEntry->mSize = 4;
  241. count += mSender->mScopeEntry->mSize;
  242. mNum->mScopeEntry->mOffset = (S32)count;
  243. mNum->mScopeEntry->mSize = 4;
  244. count += mNum->mScopeEntry->mSize;
  245. mStr->mScopeEntry->mOffset = (S32)count;
  246. mStr->mScopeEntry->mSize = 4;
  247. count += mStr->mScopeEntry->mSize;
  248. mID->mScopeEntry->mOffset = (S32)count;
  249. mID->mScopeEntry->mSize = 4;
  250. count += mID->mScopeEntry->mSize;
  251. }
  252. }
  253. break;
  254. case LSCP_EMIT_BYTE_CODE:
  255. {
  256. #ifdef LSL_INCLUDE_DEBUG_INFO
  257. char name[] = "link_message";
  258. chunk->addBytes(name, strlen(name) + 1);
  259. chunk->addBytes(mSender->mName, strlen(mSender->mName) + 1);
  260. chunk->addBytes(mNum->mName, strlen(mNum->mName) + 1);
  261. chunk->addBytes(mStr->mName, strlen(mStr->mName) + 1);
  262. chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
  263. #endif
  264. }
  265. break;
  266. case LSCP_EMIT_CIL_ASSEMBLY:
  267. fdotabs(fp, tabs, tabsize);
  268. fprintf(fp, "link_message( int32 ");
  269. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  270. fprintf(fp, ", int32 ");
  271. mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  272. fprintf(fp, ", string ");
  273. mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  274. fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  275. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  276. fprintf(fp, " )");
  277. break;
  278. default:
  279. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  280. mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  281. mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  282. mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  283. break;
  284. }
  285. }
  287. S32 LLScriptLinkMessageEvent::getSize()
  288. {
  289. // integer + key + integer + string = 16
  290. return 16;
  291. }
  293. void LLScriptRemoteEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  294. {
  295. if (gErrorToText.getErrors())
  296. {
  297. return;
  298. }
  299. switch(pass)
  300. {
  301. case LSCP_PRETTY_PRINT:
  302. case LSCP_EMIT_ASSEMBLY:
  303. fdotabs(fp, tabs, tabsize);
  304. fprintf(fp, "remote_event( integer ");
  305. mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  306. fprintf(fp, ", key ");
  307. mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  308. fprintf(fp, ", key ");
  309. mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  310. fprintf(fp, ", string ");
  311. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  312. fprintf(fp, ", integer ");
  313. mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  314. fprintf(fp, ", string ");
  315. mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  316. fprintf(fp, " )n");
  317. break;
  318. case LSCP_SCOPE_PASS1:
  319.   checkForDuplicateHandler(fp, this, scope, "remote_event");
  320. if (scope->checkEntry(mType->mName))
  321. {
  322. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  323. }
  324. else
  325. {
  326. mType->mScopeEntry = scope->addEntry(mType->mName, LIT_VARIABLE, LST_INTEGER);
  327. }
  328. if (scope->checkEntry(mChannel->mName))
  329. {
  330. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  331. }
  332. else
  333. {
  334. mChannel->mScopeEntry = scope->addEntry(mChannel->mName, LIT_VARIABLE, LST_KEY);
  335. }
  336. if (scope->checkEntry(mMessageID->mName))
  337. {
  338. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  339. }
  340. else
  341. {
  342. mMessageID->mScopeEntry = scope->addEntry(mMessageID->mName, LIT_VARIABLE, LST_KEY);
  343. }
  344. if (scope->checkEntry(mSender->mName))
  345. {
  346. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  347. }
  348. else
  349. {
  350. mSender->mScopeEntry = scope->addEntry(mSender->mName, LIT_VARIABLE, LST_STRING);
  351. }
  352. if (scope->checkEntry(mIntVal->mName))
  353. {
  354. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  355. }
  356. else
  357. {
  358. mIntVal->mScopeEntry = scope->addEntry(mIntVal->mName, LIT_VARIABLE, LST_INTEGER);
  359. }
  360. if (scope->checkEntry(mStrVal->mName))
  361. {
  362. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  363. }
  364. else
  365. {
  366. mStrVal->mScopeEntry = scope->addEntry(mStrVal->mName, LIT_VARIABLE, LST_STRING);
  367. }
  368. break;
  369. case LSCP_RESOURCE:
  370. {
  371. // we're just tryng to determine how much space the variable needs
  372. if (mType->mScopeEntry)
  373. {
  374. mType->mScopeEntry->mOffset = (S32)count;
  375. mType->mScopeEntry->mSize = 4;
  376. count += mType->mScopeEntry->mSize;
  377. mChannel->mScopeEntry->mOffset = (S32)count;
  378. mChannel->mScopeEntry->mSize = 4;
  379. count += mChannel->mScopeEntry->mSize;
  380. mMessageID->mScopeEntry->mOffset = (S32)count;
  381. mMessageID->mScopeEntry->mSize = 4;
  382. count += mMessageID->mScopeEntry->mSize;
  383. mSender->mScopeEntry->mOffset = (S32)count;
  384. mSender->mScopeEntry->mSize = 4;
  385. count += mSender->mScopeEntry->mSize;
  386. mIntVal->mScopeEntry->mOffset = (S32)count;
  387. mIntVal->mScopeEntry->mSize = 4;
  388. count += mIntVal->mScopeEntry->mSize;
  389. mStrVal->mScopeEntry->mOffset = (S32)count;
  390. mStrVal->mScopeEntry->mSize = 4;
  391. count += mStrVal->mScopeEntry->mSize;
  392. }
  393. }
  394. break;
  395. case LSCP_EMIT_BYTE_CODE:
  396. {
  397. #ifdef LSL_INCLUDE_DEBUG_INFO
  398. char name[] = "remote_event";
  399. chunk->addBytes(name, strlen(name) + 1);
  400. chunk->addBytes(mType->mName, strlen(mType->mName) + 1);
  401. chunk->addBytes(mChannel->mName, strlen(mChannel->mName) + 1);
  402. chunk->addBytes(mMessageID->mName, strlen(mMessageID->mName) + 1);
  403. chunk->addBytes(mSender->mName, strlen(mSender->mName) + 1);
  404. chunk->addBytes(mIntVal->mName, strlen(mIntVal->mName) + 1);
  405. chunk->addBytes(mStrVal->mName, strlen(mStrVal->mName) + 1);
  406. #endif
  407. }
  408. break;
  409. case LSCP_EMIT_CIL_ASSEMBLY:
  410. fdotabs(fp, tabs, tabsize);
  411. fprintf(fp, "remote_event( int32 ");
  412. mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  413. fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  414. mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  415. fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  416. mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  417. fprintf(fp, ", string ");
  418. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  419. fprintf(fp, ", int32 ");
  420. mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  421. fprintf(fp, ", string ");
  422. mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  423. fprintf(fp, " )");
  424. break;
  425. default:
  426. mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  427. mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  428. mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  429. mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  430. mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  431. mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  432. break;
  433. }
  434. }
  436. S32 LLScriptRemoteEvent::getSize()
  437. {
  438. // integer + key + key + string + integer + string = 24
  439. return 24;
  440. }
  442. void LLScriptHTTPResponseEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  443. {
  444. if (gErrorToText.getErrors())
  445. {
  446. return;
  447. }
  448. switch(pass)
  449. {
  450. case LSCP_PRETTY_PRINT:
  451. case LSCP_EMIT_ASSEMBLY:
  452. fdotabs(fp, tabs, tabsize);
  453. fprintf(fp, "http_response( key ");
  454. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  455. fprintf(fp, ", integer ");
  456. mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  457. fprintf(fp, ", class [mscorlib]System.Collections.ArrayList ");
  458. mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  459. fprintf(fp, ", string ");
  460. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  461. fprintf(fp, " )n");
  462. break;
  464. case LSCP_SCOPE_PASS1:
  465.   checkForDuplicateHandler(fp, this, scope, "http_response");
  466. if (scope->checkEntry(mRequestId->mName))
  467. {
  468. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  469. }
  470. else
  471. {
  472. mRequestId->mScopeEntry = scope->addEntry(mRequestId->mName, LIT_VARIABLE, LST_KEY);
  473. }
  475. if (scope->checkEntry(mStatus->mName))
  476. {
  477. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  478. }
  479. else
  480. {
  481. mStatus->mScopeEntry = scope->addEntry(mStatus->mName, LIT_VARIABLE, LST_INTEGER);
  482. }
  484. if (scope->checkEntry(mMetadata->mName))
  485. {
  486. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  487. }
  488. else
  489. {
  490. mMetadata->mScopeEntry = scope->addEntry(mMetadata->mName, LIT_VARIABLE, LST_LIST);
  491. }
  493. if (scope->checkEntry(mBody->mName))
  494. {
  495. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  496. }
  497. else
  498. {
  499. mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
  500. }
  501. break;
  503. case LSCP_RESOURCE:
  504. {
  505. // we're just tryng to determine how much space the variable needs
  506. if (mRequestId->mScopeEntry)
  507. {
  508. mRequestId->mScopeEntry->mOffset = (S32)count;
  509. mRequestId->mScopeEntry->mSize = 4;
  510. count += mRequestId->mScopeEntry->mSize;
  512. mStatus->mScopeEntry->mOffset = (S32)count;
  513. mStatus->mScopeEntry->mSize = 4;
  514. count += mStatus->mScopeEntry->mSize;
  516. mMetadata->mScopeEntry->mOffset = (S32)count;
  517. mMetadata->mScopeEntry->mSize = 4;
  518. count += mMetadata->mScopeEntry->mSize;
  520. mBody->mScopeEntry->mOffset = (S32)count;
  521. mBody->mScopeEntry->mSize = 4;
  522. count += mBody->mScopeEntry->mSize;
  523. }
  524. }
  525. break;
  527. case LSCP_EMIT_BYTE_CODE:
  528. {
  529. #ifdef LSL_INCLUDE_DEBUG_INFO
  530. char name[] = "http_response";
  531. chunk->addBytes(name, strlen(name) + 1);
  532. chunk->addBytes(mRequestId->mName, strlen(mRequestId->mName) + 1);
  533. chunk->addBytes(mStatus->mName, strlen(mStatus->mName) + 1);
  534. chunk->addBytes(mMetadata->mName, strlen(mMetadata->mName) + 1);
  535. chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1);
  536. #endif
  537. }
  538. break;
  539. case LSCP_EMIT_CIL_ASSEMBLY:
  540.         fdotabs(fp, tabs, tabsize);
  541.             fprintf(fp, "http_response( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  542. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  543. fprintf(fp, ", int32 ");
  544. mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  545. fprintf(fp, ", class [mscorlib]System.Collections.ArrayList ");
  546. mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  547. fprintf(fp, ", string ");
  548. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  549. fprintf(fp, " )n");
  550. break;
  551. default:
  552. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  553. mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  554. mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  555. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  556. break;
  557. }
  558. }
  560. S32 LLScriptHTTPResponseEvent::getSize()
  561. {
  562. // key + integer + list + string = 16
  563. return 16;
  564. }
  566. void LLScriptHTTPRequestEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  567. {
  568. if (gErrorToText.getErrors())
  569. {
  570. return;
  571. }
  572. switch(pass)
  573. {
  574. case LSCP_PRETTY_PRINT:
  575. case LSCP_EMIT_ASSEMBLY:
  576. fdotabs(fp, tabs, tabsize);
  577. fprintf(fp, "http_request( key ");
  578. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  579. fprintf(fp, ", string ");
  580. mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  581. fprintf(fp, ", string ");
  582. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  583. fprintf(fp, " )n");
  584. break;
  586. case LSCP_SCOPE_PASS1:
  587. checkForDuplicateHandler(fp, this, scope, "http_request");
  588. if (scope->checkEntry(mRequestId->mName))
  589. {
  590. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  591. }
  592. else
  593. {
  594. mRequestId->mScopeEntry = scope->addEntry(mRequestId->mName, LIT_VARIABLE, LST_KEY);
  595. }
  597. if (scope->checkEntry(mMethod->mName))
  598. {
  599. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  600. }
  601. else
  602. {
  603. mMethod->mScopeEntry = scope->addEntry(mMethod->mName, LIT_VARIABLE, LST_STRING);
  604. }
  606. if (scope->checkEntry(mBody->mName))
  607. {
  608. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  609. }
  610. else
  611. {
  612. mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
  613. }
  614. break;
  616. case LSCP_RESOURCE:
  617. {
  618. // we're just tryng to determine how much space the variable needs
  619. if (mRequestId->mScopeEntry)
  620. {
  621. mRequestId->mScopeEntry->mOffset = (S32)count;
  622. mRequestId->mScopeEntry->mSize = 4;
  623. count += mRequestId->mScopeEntry->mSize;
  625. mMethod->mScopeEntry->mOffset = (S32)count;
  626. mMethod->mScopeEntry->mSize = 4;
  627. count += mMethod->mScopeEntry->mSize;
  629. mBody->mScopeEntry->mOffset = (S32)count;
  630. mBody->mScopeEntry->mSize = 4;
  631. count += mBody->mScopeEntry->mSize;
  632. }
  633. }
  634. break;
  636. case LSCP_EMIT_BYTE_CODE:
  637. {
  638. #ifdef LSL_INCLUDE_DEBUG_INFO
  639. char name[] = "http_request";
  640. chunk->addBytes(name, strlen(name) + 1);  /*Flawfinder: ignore*/
  641. chunk->addBytes(mRequestId->mName, strlen(mRequestId->mName) + 1);  /*Flawfinder: ignore*/
  642. chunk->addBytes(mMethod->mName, strlen(mMethod->mName) + 1);  /*Flawfinder: ignore*/
  643. chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1);  /*Flawfinder: ignore*/
  644. #endif
  645. }
  646. break;
  647. case LSCP_EMIT_CIL_ASSEMBLY:
  648.         fdotabs(fp, tabs, tabsize);
  649.             fprintf(fp, "http_request( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  650. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  651. fprintf(fp, ", string ");
  652. mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  653. fprintf(fp, ", string ");
  654. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  655. fprintf(fp, " )n");
  656. break;
  657. default:
  658. mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  659. mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  660. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  661. break;
  662. }
  663. }
  665. S32 LLScriptHTTPRequestEvent::getSize()
  666. {
  667. // key + string + string = 12
  668. return 12;
  669. }
  671. void LLScriptMoneyEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  672. {
  673. if (gErrorToText.getErrors())
  674. {
  675. return;
  676. }
  677. switch(pass)
  678. {
  679. case LSCP_PRETTY_PRINT:
  680. case LSCP_EMIT_ASSEMBLY:
  681. fdotabs(fp, tabs, tabsize);
  682. fprintf(fp, "money( key ");
  683. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  684. fprintf(fp, ", integer ");
  685. mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  686. fprintf(fp, " )n");
  687. break;
  688. case LSCP_SCOPE_PASS1:
  689.   checkForDuplicateHandler(fp, this, scope, "money");
  690. if (scope->checkEntry(mName->mName))
  691. {
  692. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  693. }
  694. else
  695. {
  696. mName->mScopeEntry = scope->addEntry(mName->mName, LIT_VARIABLE, LST_KEY);
  697. }
  698. if (scope->checkEntry(mAmount->mName))
  699. {
  700. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  701. }
  702. else
  703. {
  704. mAmount->mScopeEntry = scope->addEntry(mAmount->mName, LIT_VARIABLE, LST_INTEGER);
  705. }
  706. break;
  707. case LSCP_RESOURCE:
  708. {
  709. // we're just tryng to determine how much space the variable needs
  710. if (mName->mScopeEntry)
  711. {
  712. mName->mScopeEntry->mOffset = (S32)count;
  713. mName->mScopeEntry->mSize = 4;
  714. count += mName->mScopeEntry->mSize;
  715. mAmount->mScopeEntry->mOffset = (S32)count;
  716. mAmount->mScopeEntry->mSize = 4;
  717. count += mAmount->mScopeEntry->mSize;
  718. }
  719. }
  720. break;
  721. case LSCP_EMIT_BYTE_CODE:
  722. {
  723. #ifdef LSL_INCLUDE_DEBUG_INFO
  724. char name[] = "money";
  725. chunk->addBytes(name, strlen(name) + 1);
  726. chunk->addBytes(mName->mName, strlen(mName->mName) + 1);
  727. chunk->addBytes(mAmount->mName, strlen(mAmount->mName) + 1);
  728. #endif
  729. }
  730. break;
  731. case LSCP_EMIT_CIL_ASSEMBLY:
  732. fdotabs(fp, tabs, tabsize);
  733. fprintf(fp, "money( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
  734. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  735. fprintf(fp, ", int32 ");
  736. mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  737. fprintf(fp, " )");
  738. break;
  739. default:
  740. mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  741. mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  742. break;
  743. }
  744. }
  746. S32 LLScriptMoneyEvent::getSize()
  747. {
  748. // key + integer = 8
  749. return 8;
  750. }
  752. void LLScriptEmailEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  753. {
  754. if (gErrorToText.getErrors())
  755. {
  756. return;
  757. }
  758. switch(pass)
  759. {
  760. case LSCP_PRETTY_PRINT:
  761. case LSCP_EMIT_ASSEMBLY:
  762. fdotabs(fp, tabs, tabsize);
  763. fprintf(fp, "email( string ");
  764. mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  765. fprintf(fp, ", string ");
  766. mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  767. fprintf(fp, ", string ");
  768. mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  769. fprintf(fp, ", string ");
  770. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  771. fprintf(fp, ", integer ");
  772. mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  773. fprintf(fp, " )n");
  774. break;
  775. case LSCP_SCOPE_PASS1:
  776.   checkForDuplicateHandler(fp, this, scope, "email");
  777. if (scope->checkEntry(mTime->mName))
  778. {
  779. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  780. }
  781. else
  782. {
  783. mTime->mScopeEntry = scope->addEntry(mTime->mName, LIT_VARIABLE, LST_STRING);
  784. }
  785. if (scope->checkEntry(mAddress->mName))
  786. {
  787. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  788. }
  789. else
  790. {
  791. mAddress->mScopeEntry = scope->addEntry(mAddress->mName, LIT_VARIABLE, LST_STRING);
  792. }
  793. if (scope->checkEntry(mSubject->mName))
  794. {
  795. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  796. }
  797. else
  798. {
  799. mSubject->mScopeEntry = scope->addEntry(mSubject->mName, LIT_VARIABLE, LST_STRING);
  800. }
  801. if (scope->checkEntry(mBody->mName))
  802. {
  803. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  804. }
  805. else
  806. {
  807. mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
  808. }
  809. if (scope->checkEntry(mNumber->mName))
  810. {
  811. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  812. }
  813. else
  814. {
  815. mNumber->mScopeEntry = scope->addEntry(mNumber->mName, LIT_VARIABLE, LST_INTEGER);
  816. }
  817. break;
  818. case LSCP_RESOURCE:
  819. {
  820. // we're just tryng to determine how much space the variable needs
  821. if (mAddress->mScopeEntry)
  822. {
  823. mTime->mScopeEntry->mOffset = (S32)count;
  824. mTime->mScopeEntry->mSize = 4;
  825. count += mTime->mScopeEntry->mSize;
  826. mAddress->mScopeEntry->mOffset = (S32)count;
  827. mAddress->mScopeEntry->mSize = 4;
  828. count += mAddress->mScopeEntry->mSize;
  829. mSubject->mScopeEntry->mOffset = (S32)count;
  830. mSubject->mScopeEntry->mSize = 4;
  831. count += mSubject->mScopeEntry->mSize;
  832. mBody->mScopeEntry->mOffset = (S32)count;
  833. mBody->mScopeEntry->mSize = 4;
  834. count += mBody->mScopeEntry->mSize;
  835. mNumber->mScopeEntry->mOffset = (S32)count;
  836. mNumber->mScopeEntry->mSize = 4;
  837. count += mNumber->mScopeEntry->mSize;
  838. }
  839. }
  840. break;
  841. case LSCP_EMIT_BYTE_CODE:
  842. {
  843. #ifdef LSL_INCLUDE_DEBUG_INFO
  844. char name[] = "email";
  845. chunk->addBytes(name, strlen(name) + 1);
  846. chunk->addBytes(mTime->mName, strlen(mTime->mName) + 1);
  847. chunk->addBytes(mAddress->mName, strlen(mAddress->mName) + 1);
  848. chunk->addBytes(mSubject->mName, strlen(mSubject->mName) + 1);
  849. chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1);
  850. chunk->addBytes(mNumber->mName, strlen(mNumber->mName) + 1);
  851. #endif
  852. }
  853. break;
  854. case LSCP_EMIT_CIL_ASSEMBLY:
  855. fdotabs(fp, tabs, tabsize);
  856. fprintf(fp, "email( string ");
  857. mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  858. fprintf(fp, ", string ");
  859. mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  860. fprintf(fp, ", string ");
  861. mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  862. fprintf(fp, ", string ");
  863. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  864. fprintf(fp, ", int32 ");
  865. mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  866. fprintf(fp, " )");
  867. break;
  868. default:
  869. mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  870. mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  871. mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  872. mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  873. mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  874. break;
  875. }
  876. }
  878. S32 LLScriptEmailEvent::getSize()
  879. {
  880. // string + string + string + string + integer = 16
  881. return 20;
  882. }
  884. void LLScriptRezEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  885. {
  886. if (gErrorToText.getErrors())
  887. {
  888. return;
  889. }
  890. switch(pass)
  891. {
  892. case LSCP_PRETTY_PRINT:
  893. case LSCP_EMIT_ASSEMBLY:
  894. fdotabs(fp, tabs, tabsize);
  895. fprintf(fp, "rez( integer ");
  896. mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  897. fprintf(fp, " )n");
  898. break;
  899. case LSCP_SCOPE_PASS1:
  900. checkForDuplicateHandler(fp, this, scope, "on_rez");
  901. if (scope->checkEntry(mStartParam->mName))
  902. {
  903. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  904. }
  905. else
  906. {
  907. mStartParam->mScopeEntry = scope->addEntry(mStartParam->mName, LIT_VARIABLE, LST_INTEGER);
  908. }
  909. break;
  910. case LSCP_RESOURCE:
  911. {
  912. // we're just tryng to determine how much space the variable needs
  913. if (mStartParam->mScopeEntry)
  914. {
  915. mStartParam->mScopeEntry->mOffset = (S32)count;
  916. mStartParam->mScopeEntry->mSize = 4;
  917. count += mStartParam->mScopeEntry->mSize;
  918. }
  919. }
  920. break;
  921. case LSCP_EMIT_BYTE_CODE:
  922. {
  923. #ifdef LSL_INCLUDE_DEBUG_INFO
  924. char name[] = "rez";
  925. chunk->addBytes(name, strlen(name) + 1);
  926. chunk->addBytes(mStartParam->mName, strlen(mStartParam->mName) + 1);
  927. #endif
  928. }
  929. break;
  930. case LSCP_EMIT_CIL_ASSEMBLY:
  931. fdotabs(fp, tabs, tabsize);
  932. fprintf(fp, "rez( int32 ");
  933. mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  934. fprintf(fp, " )");
  935. break;
  936. default:
  937. mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  938. break;
  939. }
  940. }
  942. S32 LLScriptRezEvent::getSize()
  943. {
  944. // integer = 4
  945. return 4;
  946. }
  948. void LLScriptNoSensorEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  949. {
  950. if (gErrorToText.getErrors())
  951. {
  952. return;
  953. }
  954. switch(pass)
  955. {
  956. case LSCP_PRETTY_PRINT:
  957. fdotabs(fp, tabs, tabsize);
  958. fprintf(fp, "no_sensor()n");
  959. break;
  960. case LSCP_EMIT_ASSEMBLY:
  961. fprintf(fp, "no_sensor()n");
  962. break;
  963.         case LSCP_SCOPE_PASS1:
  964.               checkForDuplicateHandler(fp, this, scope, "no_sensor");
  965.         break;
  966.    case LSCP_EMIT_BYTE_CODE:
  967. {
  968. #ifdef LSL_INCLUDE_DEBUG_INFO
  969. char name[] = "no_sensor";
  970. chunk->addBytes(name, strlen(name) + 1);
  971. #endif
  972. }
  973. break;
  974. case LSCP_EMIT_CIL_ASSEMBLY:
  975. fprintf(fp, "no_sensor()");
  976. break;
  977. default:
  978. break;
  979. }
  980. }
  982. S32 LLScriptNoSensorEvent::getSize()
  983. {
  984. return 0;
  985. }
  987. void LLScriptAtTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  988. {
  989. if (gErrorToText.getErrors())
  990. {
  991. return;
  992. }
  993. switch(pass)
  994. {
  995. case LSCP_PRETTY_PRINT:
  996. case LSCP_EMIT_ASSEMBLY:
  997. fdotabs(fp, tabs, tabsize);
  998. fprintf(fp, "at_target( integer ");
  999. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1000. fprintf(fp, ", vector ");
  1001. mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1002. fprintf(fp, ", vector ");
  1003. mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1004. fprintf(fp, " )n");
  1005. break;
  1006. case LSCP_SCOPE_PASS1:
  1007.         checkForDuplicateHandler(fp, this, scope, "at_target");
  1008. if (scope->checkEntry(mTargetNumber->mName))
  1009. {
  1010. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1011. }
  1012. else
  1013. {
  1014. mTargetNumber->mScopeEntry = scope->addEntry(mTargetNumber->mName, LIT_VARIABLE, LST_INTEGER);
  1015. }
  1016. if (scope->checkEntry(mTargetPosition->mName))
  1017. {
  1018. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1019. }
  1020. else
  1021. {
  1022. mTargetPosition->mScopeEntry = scope->addEntry(mTargetPosition->mName, LIT_VARIABLE, LST_VECTOR);
  1023. }
  1024. if (scope->checkEntry(mOurPosition->mName))
  1025. {
  1026. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1027. }
  1028. else
  1029. {
  1030. mOurPosition->mScopeEntry = scope->addEntry(mOurPosition->mName, LIT_VARIABLE, LST_VECTOR);
  1031. }
  1032. break;
  1033. case LSCP_RESOURCE:
  1034. {
  1035. // we're just tryng to determine how much space the variable needs
  1036. if (mTargetNumber->mScopeEntry)
  1037. {
  1038. mTargetNumber->mScopeEntry->mOffset = (S32)count;
  1039. mTargetNumber->mScopeEntry->mSize = 4;
  1040. count += mTargetNumber->mScopeEntry->mSize;
  1041. mTargetPosition->mScopeEntry->mOffset = (S32)count;
  1042. mTargetPosition->mScopeEntry->mSize = 12;
  1043. count += mTargetPosition->mScopeEntry->mSize;
  1044. mOurPosition->mScopeEntry->mOffset = (S32)count;
  1045. mOurPosition->mScopeEntry->mSize = 12;
  1046. count += mOurPosition->mScopeEntry->mSize;
  1047. }
  1048. }
  1049. break;
  1050. case LSCP_EMIT_BYTE_CODE:
  1051. {
  1052. #ifdef LSL_INCLUDE_DEBUG_INFO
  1053. char name[] = "at_target";
  1054. chunk->addBytes(name, strlen(name) + 1);
  1055. chunk->addBytes(mTargetNumber->mName, strlen(mTargetNumber->mName) + 1);
  1056. chunk->addBytes(mTargetPosition->mName, strlen(mTargetPosition->mName) + 1);
  1057. chunk->addBytes(mOurPosition->mName, strlen(mOurPosition->mName) + 1);
  1058. #endif
  1059. }
  1060. break;
  1061. case LSCP_EMIT_CIL_ASSEMBLY:
  1062. fdotabs(fp, tabs, tabsize);
  1063. fprintf(fp, "at_target( int32 ");
  1064. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1065. fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Vector ");
  1066. mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1067. fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Vector ");
  1068. mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1069. fprintf(fp, " )");
  1070. break;
  1071. default:
  1072. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1073. mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1074. mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1075. break;
  1076. }
  1077. }
  1079. S32 LLScriptAtTarget::getSize()
  1080. {
  1081. // integer + vector + vector = 28
  1082. return 28;
  1083. }
  1087. void LLScriptNotAtTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1088. {
  1089. if (gErrorToText.getErrors())
  1090. {
  1091. return;
  1092. }
  1093. switch(pass)
  1094. {
  1095. case LSCP_PRETTY_PRINT:
  1096. fdotabs(fp, tabs, tabsize);
  1097. fprintf(fp, "not_at_target()n");
  1098. break;
  1099. case LSCP_EMIT_ASSEMBLY:
  1100. fprintf(fp, "not_at_target()n");
  1101. break;
  1102.         case LSCP_SCOPE_PASS1:
  1103.         checkForDuplicateHandler(fp, this, scope, "not_at_target");
  1104.         break;
  1106. case LSCP_EMIT_BYTE_CODE:
  1107. {
  1108. #ifdef LSL_INCLUDE_DEBUG_INFO
  1109. char name[] = "not_at_target";
  1110. chunk->addBytes(name, strlen(name) + 1);
  1111. #endif
  1112. }
  1113. break;
  1114. case LSCP_EMIT_CIL_ASSEMBLY:
  1115. fprintf(fp, "not_at_target()");
  1116. break;
  1117. default:
  1118. break;
  1119. }
  1120. }
  1122. S32 LLScriptNotAtTarget::getSize()
  1123. {
  1124. return 0;
  1125. }
  1127. void LLScriptAtRotTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1128. {
  1129. if (gErrorToText.getErrors())
  1130. {
  1131. return;
  1132. }
  1133. switch(pass)
  1134. {
  1135. case LSCP_PRETTY_PRINT:
  1136. case LSCP_EMIT_ASSEMBLY:
  1137. fdotabs(fp, tabs, tabsize);
  1138. fprintf(fp, "at_rot_target( integer ");
  1139. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1140. fprintf(fp, ", quaternion ");
  1141. mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1142. fprintf(fp, ", quaternion ");
  1143. mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1144. fprintf(fp, " )n");
  1145. break;
  1146. case LSCP_SCOPE_PASS1:
  1147. checkForDuplicateHandler(fp, this, scope, "at_rot_target");
  1148. if (scope->checkEntry(mTargetNumber->mName))
  1149. {
  1150. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1151. }
  1152. else
  1153. {
  1154. mTargetNumber->mScopeEntry = scope->addEntry(mTargetNumber->mName, LIT_VARIABLE, LST_INTEGER);
  1155. }
  1156. if (scope->checkEntry(mTargetRotation->mName))
  1157. {
  1158. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1159. }
  1160. else
  1161. {
  1162. mTargetRotation->mScopeEntry = scope->addEntry(mTargetRotation->mName, LIT_VARIABLE, LST_QUATERNION);
  1163. }
  1164. if (scope->checkEntry(mOurRotation->mName))
  1165. {
  1166. gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
  1167. }
  1168. else
  1169. {
  1170. mOurRotation->mScopeEntry = scope->addEntry(mOurRotation->mName, LIT_VARIABLE, LST_QUATERNION);
  1171. }
  1172. break;
  1173. case LSCP_RESOURCE:
  1174. {
  1175. // we're just tryng to determine how much space the variable needs
  1176. if (mTargetNumber->mScopeEntry)
  1177. {
  1178. mTargetNumber->mScopeEntry->mOffset = (S32)count;
  1179. mTargetNumber->mScopeEntry->mSize = 4;
  1180. count += mTargetNumber->mScopeEntry->mSize;
  1181. mTargetRotation->mScopeEntry->mOffset = (S32)count;
  1182. mTargetRotation->mScopeEntry->mSize = 16;
  1183. count += mTargetRotation->mScopeEntry->mSize;
  1184. mOurRotation->mScopeEntry->mOffset = (S32)count;
  1185. mOurRotation->mScopeEntry->mSize = 16;
  1186. count += mOurRotation->mScopeEntry->mSize;
  1187. }
  1188. }
  1189. break;
  1190. case LSCP_EMIT_BYTE_CODE:
  1191. {
  1192. #ifdef LSL_INCLUDE_DEBUG_INFO
  1193. char name[] = "at_rot_target";
  1194. chunk->addBytes(name, strlen(name) + 1);
  1195. chunk->addBytes(mTargetNumber->mName, strlen(mTargetNumber->mName) + 1);
  1196. chunk->addBytes(mTargetRotation->mName, strlen(mTargetRotation->mName) + 1);
  1197. chunk->addBytes(mOurRotation->mName, strlen(mOurRotation->mName) + 1);
  1198. #endif
  1199. }
  1200. break;
  1201. case LSCP_EMIT_CIL_ASSEMBLY:
  1202. fdotabs(fp, tabs, tabsize);
  1203. fprintf(fp, "at_rot_target( int32 ");
  1204. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1205. fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Quaternion ");
  1206. mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1207. fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Quaternion ");
  1208. mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1209. fprintf(fp, " )");
  1210. break;
  1211. default:
  1212. mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1213. mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1214. mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1215. break;
  1216. }
  1217. }
  1219. S32 LLScriptAtRotTarget::getSize()
  1220. {
  1221. // integer + quaternion + quaternion = 36
  1222. return 36;
  1223. }
  1227. void LLScriptNotAtRotTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1228. {
  1229. if (gErrorToText.getErrors())
  1230. {
  1231. return;
  1232. }
  1233. switch(pass)
  1234. {
  1235. case LSCP_PRETTY_PRINT:
  1236. fdotabs(fp, tabs, tabsize);
  1237. fprintf(fp, "not_at_rot_target()n");
  1238. break;
  1239. case LSCP_EMIT_ASSEMBLY:
  1240. fprintf(fp, "not_at_rot_target()n");
  1241. break;
  1242. case LSCP_EMIT_BYTE_CODE:
  1243. {
  1244. #ifdef LSL_INCLUDE_DEBUG_INFO
  1245. char name[] = "not_at_rot_target";
  1246. chunk->addBytes(name, strlen(name) + 1);
  1247. #endif
  1248. }
  1249. break;
  1250.         case LSCP_SCOPE_PASS1:
  1251.   checkForDuplicateHandler(fp, this, scope, "not_at_rot_target");
  1252.   break;
  1254. case LSCP_EMIT_CIL_ASSEMBLY:
  1255. fprintf(fp, "not_at_rot_target()");
  1256. break;
  1257. default:
  1258. break;
  1259. }
  1260. }
  1262. S32 LLScriptNotAtRotTarget::getSize()
  1263. {
  1264. return 0;
  1265. }
  1269. void LLScriptExpression::addExpression(LLScriptExpression *expression)
  1270. {
  1271. if (mNextp)
  1272. {
  1273. expression->mNextp = mNextp;
  1274. }
  1275. mNextp = expression;
  1276. }
  1278. void LLScriptExpression::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1279. {
  1280. fprintf(fp, "Expression Base Class -- should never get here!n");
  1281. }
  1283. S32 LLScriptExpression::getSize()
  1284. {
  1285. printf("Expression Base Class -- should never get here!n");
  1286. return 0;
  1287. }
  1289. void LLScriptExpression::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1290. {
  1291. if (gErrorToText.getErrors())
  1292. {
  1293. return;
  1294. }
  1295. switch(pass)
  1296. {
  1297. case LSCP_PRETTY_PRINT:
  1298. if (mNextp)
  1299. {
  1300. fprintf(fp, ", ");
  1301. mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1302. }
  1303. break;
  1304. default:
  1305. if (mNextp)
  1306. {
  1307. mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1308. }
  1309. break;
  1310. }
  1311. }
  1313. void LLScriptForExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1314. {
  1315. if (gErrorToText.getErrors())
  1316. {
  1317. return;
  1318. }
  1319. switch(pass)
  1320. {
  1321. case LSCP_PRETTY_PRINT:
  1322. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1323. if (mSecondp)
  1324. {
  1325. fprintf(fp, ", ");
  1326. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1327. }
  1328. break;
  1329. case LSCP_EMIT_ASSEMBLY:
  1330. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1331. if (mFirstp->mReturnType)
  1332. {
  1333. fprintf(fp, "%sn", LSCRIPTTypePop[mFirstp->mReturnType]);
  1334. }
  1335. if (mSecondp)
  1336. {
  1337. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1338. if (mSecondp->mReturnType)
  1339. {
  1340. fprintf(fp, "%sn", LSCRIPTTypePop[mSecondp->mReturnType]);
  1341. }
  1342. }
  1343. break;
  1344. case LSCP_TO_STACK:
  1345. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1346. switch(mFirstp->mReturnType)
  1347. {
  1348. case LST_INTEGER:
  1349. case LST_FLOATINGPOINT:
  1350. chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
  1351. break;
  1352. case LST_STRING:
  1353. case LST_KEY:
  1354. chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
  1355. break;
  1356. case LST_LIST:
  1357. chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
  1358. break;
  1359. case LST_VECTOR:
  1360. chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
  1361. break;
  1362. case LST_QUATERNION:
  1363. chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
  1364. break;
  1365. default:
  1366. break;
  1367. }
  1368. if (mSecondp)
  1369. {
  1370. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1371. switch(mSecondp->mReturnType)
  1372. {
  1373. case LST_INTEGER:
  1374. case LST_FLOATINGPOINT:
  1375. chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
  1376. break;
  1377. case LST_STRING:
  1378. case LST_KEY:
  1379. chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
  1380. break;
  1381. case LST_LIST:
  1382. chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
  1383. break;
  1384. case LST_VECTOR:
  1385. chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
  1386. break;
  1387. case LST_QUATERNION:
  1388. chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
  1389. break;
  1390. default:
  1391. break;
  1392. }
  1393. }
  1394. break;
  1395. case LSCP_EMIT_CIL_ASSEMBLY:
  1396. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1397. if (mFirstp->mReturnType)
  1398. {
  1399. fprintf(fp, "popn");
  1400. }
  1401. if (mSecondp)
  1402. {
  1403. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1404. if (mSecondp->mReturnType)
  1405. {
  1406. fprintf(fp, "popn");
  1407. }
  1408. }
  1409. break;
  1410. default:
  1411. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1412. if (mSecondp)
  1413. {
  1414. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1415. }
  1416. break;
  1417. }
  1418. }
  1420. S32 LLScriptForExpressionList::getSize()
  1421. {
  1422. return 0;
  1423. }
  1425. // CIL code generation requires both caller and callee scope entries, so cannot use normal recurse signature.
  1426. // TODO: Refactor general purpose recurse calls in to pass specific virtuals using visitor pattern to select method by pass and node type.
  1427. static void print_cil_func_expression_list(LLScriptFuncExpressionList* self, LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata, LLScriptScopeEntry *callee_entry)
  1428. {
  1429. self->mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1430. LSCRIPTType argtype = callee_entry->mFunctionArgs.getType(entrycount);
  1431. if (argtype != self->mFirstp->mReturnType)
  1432. {
  1433. print_cil_cast(fp, self->mFirstp->mReturnType, argtype);
  1434. }
  1435. entrycount++;
  1436. if (self->mSecondp)
  1437. {
  1438. llassert(LET_FUNC_EXPRESSION_LIST == self->mSecondp->mType);
  1439. print_cil_func_expression_list((LLScriptFuncExpressionList*) self->mSecondp, fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL, callee_entry);
  1441. }
  1442. }
  1444. void LLScriptFuncExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1445. {
  1446. if (gErrorToText.getErrors())
  1447. {
  1448. return;
  1449. }
  1450. switch(pass)
  1451. {
  1452. case LSCP_PRETTY_PRINT:
  1453. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1454. if (mSecondp)
  1455. {
  1456. fprintf(fp, ", ");
  1457. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1458. }
  1459. break;
  1460. case LSCP_TYPE:
  1461. {
  1462. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1463. if (!entry->mFunctionArgs.getType(entrycount))
  1464. {
  1465. gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
  1466. }
  1467. if (!legal_assignment(entry->mFunctionArgs.getType(entrycount), mFirstp->mReturnType))
  1468. {
  1469. gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
  1470. }
  1471. count++;
  1472. entrycount++;
  1473. if (mSecondp)
  1474. {
  1475. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1476. if (mSecondp->mReturnType)
  1477. {
  1478. count++;
  1479. if (!entry->mFunctionArgs.getType(entrycount))
  1480. {
  1481. gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
  1482. }
  1483. if (!legal_assignment(entry->mFunctionArgs.getType(entrycount), mSecondp->mReturnType))
  1484. {
  1485. gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
  1486. }
  1487. }
  1488. }
  1489. }
  1490. break;
  1491. case LSCP_EMIT_ASSEMBLY:
  1492. {
  1493. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1494. LSCRIPTType argtype = entry->mFunctionArgs.getType(entrycount);
  1495. if (argtype != mFirstp->mReturnType)
  1496. {
  1497. fprintf(fp, "CAST %s->%sn", LSCRIPTTypeNames[mFirstp->mReturnType], LSCRIPTTypeNames[argtype]);
  1498. }
  1499. entrycount++;
  1500. if (mSecondp)
  1501. {
  1502. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1503. if (mSecondp->mReturnType)
  1504. {
  1505. argtype = entry->mFunctionArgs.getType(entrycount);
  1506. if (argtype != mSecondp->mReturnType)
  1507. {
  1508. fprintf(fp, "CAST %s->%sn", LSCRIPTTypeNames[mSecondp->mReturnType], LSCRIPTTypeNames[argtype]);
  1509. }
  1510. }
  1511. }
  1512. }
  1513. break;
  1514. case LSCP_TO_STACK:
  1515. {
  1516. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1517. LSCRIPTType argtype = entry->mFunctionArgs.getType(entrycount);
  1518. if (argtype != mFirstp->mReturnType)
  1519. {
  1520. chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
  1521. U8 castbyte = LSCRIPTTypeByte[argtype] | LSCRIPTTypeHi4Bits[mFirstp->mReturnType];
  1522. chunk->addByte(castbyte);
  1523. }
  1524. entrycount++;
  1525. if (mSecondp)
  1526. {
  1527. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1528. if (mSecondp->mReturnType)
  1529. {
  1530. argtype = entry->mFunctionArgs.getType(entrycount);
  1531. if (argtype != mSecondp->mReturnType)
  1532. {
  1533. chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
  1534. U8 castbyte = LSCRIPTTypeByte[argtype] | LSCRIPTTypeHi4Bits[mSecondp->mReturnType];
  1535. chunk->addByte(castbyte);
  1536. }
  1537. }
  1538. }
  1539. }
  1540. break;
  1541. default:
  1542. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1543. if (mSecondp)
  1544. {
  1545. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1546. }
  1547. break;
  1548. }
  1549. }
  1551. S32 LLScriptFuncExpressionList::getSize()
  1552. {
  1553. return 0;
  1554. }
  1556. void LLScriptListExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1557. {
  1558. if (gErrorToText.getErrors())
  1559. {
  1560. return;
  1561. }
  1562. switch(pass)
  1563. {
  1564. case LSCP_PRETTY_PRINT:
  1565. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1566. if (mSecondp)
  1567. {
  1568. fprintf(fp, ", ");
  1569. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1570. }
  1571. break;
  1572. case LSCP_EMIT_ASSEMBLY:
  1573. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1574. if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
  1575. {
  1576. fprintf(fp, "%sn", LSCRIPTListDescription[mFirstp->mReturnType]);
  1577. count++;
  1578. }
  1579. if (mSecondp)
  1580. {
  1581. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1582. if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
  1583. {
  1584. fprintf(fp, "%sn", LSCRIPTListDescription[mSecondp->mReturnType]);
  1585. count++;
  1586. }
  1587. }
  1588. break;
  1589. case LSCP_TO_STACK:
  1590. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1591. if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
  1592. {
  1593. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGB]);
  1594. chunk->addByte(LSCRIPTTypeByte[mFirstp->mReturnType]);
  1595. count++;
  1596. }
  1597. if (mSecondp)
  1598. {
  1599. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1600. if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
  1601. {
  1602. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGB]);
  1603. chunk->addByte(LSCRIPTTypeByte[mSecondp->mReturnType]);
  1604. count++;
  1605. }
  1606. }
  1607. break;
  1608. case LSCP_EMIT_CIL_ASSEMBLY:
  1609. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1610. if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
  1611. {
  1612. // Box value.
  1613. print_cil_box(fp, mFirstp->mReturnType);
  1614. ++count;
  1615. }
  1616. if (mSecondp)
  1617. {
  1618. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1619. if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
  1620. {
  1621. // Box value.
  1622. print_cil_box(fp, mSecondp->mReturnType);
  1623. ++count;
  1624. }
  1625. }
  1626. break;
  1627. default:
  1628. mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1629. if (mSecondp)
  1630. {
  1631. mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1632. }
  1633. break;
  1634. }
  1635. }
  1637. S32 LLScriptListExpressionList::getSize()
  1638. {
  1639. return 0;
  1640. }
  1642. // Returns true if identifier is a parameter and false if identifier is a local variable within function_scope.
  1643. bool is_parameter(LLScriptIdentifier* identifier, LLScriptScopeEntry* function_scope)
  1644. {
  1645. // Function stores offset of first local.
  1646. if(0 == function_scope->mOffset)
  1647. {
  1648. // Function offset 0 -> no parameters -> identifier is a local.
  1649. return false;
  1650. }
  1651. else
  1652. {
  1653. // Compare variable offset with function offset to
  1654. // determine whether variable is local or parameter.
  1655. return (identifier->mScopeEntry->mOffset < function_scope->mOffset);
  1656. }
  1657. }
  1659. // If assignment is to global variable, pushes this pointer on to stack.
  1660. static void print_cil_load_address(LLFILE* fp, LLScriptExpression* exp, LLScriptScopeEntry* function_scope)
  1661. {
  1662. LLScriptLValue *lvalue = (LLScriptLValue *) exp;
  1663. LLScriptIdentifier *ident = lvalue->mIdentifier;
  1665. // If global (member), load this pointer.
  1666. if(ident->mScopeEntry->mIDType == LIT_GLOBAL)
  1667. {
  1668. fprintf(fp, "ldarg.0n");
  1669. }
  1671. // If accessor, load value type address, consumed by ldfld.
  1672. if(lvalue->mAccessor)
  1673. {
  1674. if(ident->mScopeEntry->mIDType == LIT_VARIABLE)
  1675. {
  1676. if(is_parameter(ident, function_scope))
  1677. {
  1678. // Parameter, load by name.
  1679. fprintf(fp, "ldarga.s '%s'n", ident->mScopeEntry->mIdentifier);
  1680. }
  1681. else
  1682. {
  1683. // Local, load by index.
  1684. fprintf(fp, "ldloca.s %dn", ident->mScopeEntry->mCount);
  1685. }
  1686. }
  1687. else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
  1688. {
  1689. fprintf(fp, "ldflda ");
  1690. print_cil_member(fp, ident);
  1691. }
  1692. }
  1693. }
  1695. static void print_cil_accessor(LLFILE* fp, LLScriptLValue *lvalue)
  1697. {
  1698. LLScriptIdentifier *ident = lvalue->mIdentifier;
  1699. print_cil_type(fp, lvalue->mReturnType);
  1700. fprintf(fp, " ");
  1701. print_cil_type(fp, ident->mScopeEntry->mType);
  1702. fprintf(fp, "::%sn", lvalue->mAccessor->mName);
  1703. }
  1705. void LLScriptLValue::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  1706. {
  1707. if (gErrorToText.getErrors())
  1708. {
  1709. return;
  1710. }
  1711. switch(pass)
  1712. {
  1713. case LSCP_PRETTY_PRINT:
  1714. mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1715. if (mAccessor)
  1716. {
  1717. fprintf(fp, ".");
  1718. mAccessor->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1719. }
  1720. break;
  1721. case LSCP_EMIT_ASSEMBLY:
  1722. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1723. {
  1724. if (mAccessor)
  1725. {
  1726. fprintf(fp, "%s%d [%s.%s]n", LSCRIPTTypeLocalPush[mReturnType], mIdentifier->mScopeEntry->mOffset + mOffset, mIdentifier->mName, mAccessor->mName);
  1727. }
  1728. else
  1729. {
  1730. fprintf(fp, "%s%d [%s]n", LSCRIPTTypeLocalPush[mIdentifier->mScopeEntry->mType], mIdentifier->mScopeEntry->mOffset, mIdentifier->mName);
  1731. }
  1732. }
  1733. else if (mIdentifier->mScopeEntry->mIDType == LIT_GLOBAL)
  1734. {
  1735. if (mAccessor)
  1736. {
  1737. fprintf(fp, "%s%d [%s.%s]n", LSCRIPTTypeGlobalPush[mReturnType], mIdentifier->mScopeEntry->mOffset + mOffset, mIdentifier->mName, mAccessor->mName);
  1738. }
  1739. else
  1740. {
  1741. fprintf(fp, "%s%d [%s]n", LSCRIPTTypeGlobalPush[mIdentifier->mScopeEntry->mType], mIdentifier->mScopeEntry->mOffset, mIdentifier->mName);
  1742. }
  1743. }
  1744. else
  1745. {
  1746. fprintf(fp, "Unexpected LValue!n");
  1747. }
  1748. break;
  1749. case LSCP_SCOPE_PASS1:
  1750. {
  1751. LLScriptScopeEntry *entry = scope->findEntry(mIdentifier->mName);
  1752. if (!entry || (  (entry->mIDType != LIT_GLOBAL) && (entry->mIDType != LIT_VARIABLE)))
  1753. {
  1754. gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
  1755. }
  1756. else
  1757. {
  1758. // if we did find it, make sure this identifier is associated with the correct scope entry
  1759. mIdentifier->mScopeEntry = entry;
  1760. }
  1761. }
  1762. break;
  1763. case LSCP_TYPE:
  1764. // if we have an accessor, we need to change what type our identifier returns and set our offset value
  1765. if (mIdentifier->mScopeEntry)
  1766. {
  1767. if (mAccessor)
  1768. {
  1769. BOOL b_ok = FALSE;
  1770. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1771. {
  1772. if (mIdentifier->mScopeEntry->mType == LST_VECTOR)
  1773. {
  1774. if (!strcmp("x", mAccessor->mName))
  1775. {
  1776. mOffset = 0;
  1777. b_ok = TRUE;
  1778. }
  1779. else if (!strcmp("y", mAccessor->mName))
  1780. {
  1781. mOffset = 4;
  1782. b_ok = TRUE;
  1783. }
  1784. else if (!strcmp("z", mAccessor->mName))
  1785. {
  1786. mOffset = 8;
  1787. b_ok = TRUE;
  1788. }
  1789. }
  1790. else if (mIdentifier->mScopeEntry->mType == LST_QUATERNION)
  1791. {
  1792. if (!strcmp("x", mAccessor->mName))
  1793. {
  1794. mOffset = 0;
  1795. b_ok = TRUE;
  1796. }
  1797. else if (!strcmp("y", mAccessor->mName))
  1798. {
  1799. mOffset = 4;
  1800. b_ok = TRUE;
  1801. }
  1802. else if (!strcmp("z", mAccessor->mName))
  1803. {
  1804. mOffset = 8;
  1805. b_ok = TRUE;
  1806. }
  1807. else if (!strcmp("s", mAccessor->mName))
  1808. {
  1809. mOffset = 12;
  1810. b_ok = TRUE;
  1811. }
  1812. }
  1813. }
  1814. else
  1815. {
  1816. if (mIdentifier->mScopeEntry->mType == LST_VECTOR)
  1817. {
  1818. if (!strcmp("x", mAccessor->mName))
  1819. {
  1820. mOffset = 8;
  1821. b_ok = TRUE;
  1822. }
  1823. else if (!strcmp("y", mAccessor->mName))
  1824. {
  1825. mOffset = 4;
  1826. b_ok = TRUE;
  1827. }
  1828. else if (!strcmp("z", mAccessor->mName))
  1829. {
  1830. mOffset = 0;
  1831. b_ok = TRUE;
  1832. }
  1833. }
  1834. else if (mIdentifier->mScopeEntry->mType == LST_QUATERNION)
  1835. {
  1836. if (!strcmp("x", mAccessor->mName))
  1837. {
  1838. mOffset = 12;
  1839. b_ok = TRUE;
  1840. }
  1841. else if (!strcmp("y", mAccessor->mName))
  1842. {
  1843. mOffset = 8;
  1844. b_ok = TRUE;
  1845. }
  1846. else if (!strcmp("z", mAccessor->mName))
  1847. {
  1848. mOffset = 4;
  1849. b_ok = TRUE;
  1850. }
  1851. else if (!strcmp("s", mAccessor->mName))
  1852. {
  1853. mOffset = 0;
  1854. b_ok = TRUE;
  1855. }
  1856. }
  1857. }
  1858. if (b_ok)
  1859. {
  1860. mReturnType = type =  LST_FLOATINGPOINT;
  1861. }
  1862. else
  1863. {
  1864. gErrorToText.writeError(fp, this, LSERROR_VECTOR_METHOD_ERROR);
  1865. }
  1866. }
  1867. else
  1868. {
  1869. mReturnType = type = mIdentifier->mScopeEntry->mType;
  1870. }
  1871. }
  1872. else
  1873. {
  1874. mReturnType = type = LST_UNDEFINED;
  1875. }
  1876. break;
  1877. case LSCP_TO_STACK:
  1878. {
  1879. switch(mReturnType)
  1880. {
  1881. case LST_INTEGER:
  1882. case LST_FLOATINGPOINT:
  1883. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1884. {
  1885. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSH]);
  1886. }
  1887. else
  1888. {
  1889. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHG]);
  1890. }
  1891. break;
  1892. case LST_KEY:
  1893. case LST_STRING:
  1894. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1895. {
  1896. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHS]);
  1897. }
  1898. else
  1899. {
  1900. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGS]);
  1901. }
  1902. break;
  1903. case LST_LIST:
  1904. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1905. {
  1906. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHL]);
  1907. }
  1908. else
  1909. {
  1910. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGL]);
  1911. }
  1912. break;
  1913. case LST_VECTOR:
  1914. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1915. {
  1916. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHV]);
  1917. }
  1918. else
  1919. {
  1920. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGV]);
  1921. }
  1922. break;
  1923. case LST_QUATERNION:
  1924. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1925. {
  1926. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHQ]);
  1927. }
  1928. else
  1929. {
  1930. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGQ]);
  1931. }
  1932. break;
  1933. default:
  1934. if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1935. {
  1936. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSH]);
  1937. }
  1938. else
  1939. {
  1940. chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHG]);
  1941. }
  1942. break;
  1943. }
  1944. S32 address = mIdentifier->mScopeEntry->mOffset + mOffset;
  1945. chunk->addInteger(address);
  1946. }
  1947. break;
  1948. case LSCP_EMIT_CIL_ASSEMBLY:
  1949. print_cil_load_address(fp, this, entry);
  1950. if(mAccessor)
  1951. {
  1952. fprintf(fp, "ldfld ");
  1953. print_cil_accessor(fp, this);
  1954. }
  1955. else if(mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
  1956. {
  1957. if(is_parameter(mIdentifier, entry))
  1958. {
  1959. // Parameter, load by name.
  1960. fprintf(fp, "ldarg.s '%s'n", mIdentifier->mScopeEntry->mIdentifier);
  1961. }
  1962. else
  1963. {
  1964. // Local, load by index.
  1965. fprintf(fp, "ldloc.s %dn", mIdentifier->mScopeEntry->mCount);
  1966. }
  1967. }
  1968. else if (mIdentifier->mScopeEntry->mIDType == LIT_GLOBAL)
  1969. {
  1970. fprintf(fp, "ldfld ");
  1971. print_cil_member(fp, mIdentifier);
  1972. }
  1973. else
  1974. {
  1975. fprintf(fp, "Unexpected LValue!n");
  1976. }
  1977. break;
  1978. default:
  1979. mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1980. break;
  1981. }
  1982. gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  1983. }
  1985. S32 LLScriptLValue::getSize()
  1986. {
  1987. return 0;
  1988. }
  1990. static void print_assignment(LLFILE *fp, LLScriptExpression *exp)
  1991. {
  1992. LLScriptLValue *lvalue = (LLScriptLValue *)exp;
  1993. LLScriptIdentifier *ident = lvalue->mIdentifier;
  1994. if (lvalue->mAccessor)
  1995. {
  1996. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  1997. {
  1998. fprintf(fp, "%s%d [%s.%s]n", LSCRIPTTypeLocalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset + lvalue->mOffset, ident->mName, lvalue->mAccessor->mName);
  1999. }
  2000. else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
  2001. {
  2002. fprintf(fp, "%s%d [%s.%s]n", LSCRIPTTypeGlobalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset + lvalue->mOffset, ident->mName, lvalue->mAccessor->mName);
  2003. }
  2004. }
  2005. else
  2006. {
  2007. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2008. {
  2009. fprintf(fp, "%s%d [%s]n", LSCRIPTTypeLocalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset, ident->mName);
  2010. }
  2011. else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
  2012. {
  2013. fprintf(fp, "%s%d [%s]n", LSCRIPTTypeGlobalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset, ident->mName);
  2014. }
  2015. }
  2016. }
  2018. static void print_cil_assignment(LLFILE *fp, LLScriptExpression *exp, LLScriptScopeEntry* function_scope)
  2019. {
  2020. LLScriptLValue *lvalue = (LLScriptLValue *) exp;
  2021. LLScriptIdentifier *ident = lvalue->mIdentifier;
  2022. if (lvalue->mAccessor)
  2023. {
  2024. // Object address loaded, store in to field.
  2025. fprintf(fp, "stfld ");
  2026. print_cil_accessor(fp, lvalue);
  2028. // Load object address.
  2029. print_cil_load_address(fp, exp, function_scope);
  2031. // Load field.
  2032. fprintf(fp, "ldfld ");
  2033. print_cil_accessor(fp, lvalue);
  2034. }
  2035. else
  2036. {
  2037. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2038. {
  2039. // Language semantics require value of assignment to be left on stack. 
  2040. // TODO: Optimise away redundant dup/pop pairs.
  2041. fprintf(fp, "dupn"); 
  2042. if(is_parameter(ident, function_scope))
  2043. {
  2044. // Parameter, store by name.
  2045. fprintf(fp, "starg.s '%s'n", ident->mScopeEntry->mIdentifier);
  2046. }
  2047. else
  2048. {
  2049. // Local, store by index.
  2050. fprintf(fp, "stloc.s %dn", ident->mScopeEntry->mCount);
  2051. }
  2052. }
  2053. else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
  2054. {
  2055. // Object address loaded, store in to field.
  2056. fprintf(fp, "stfld ");
  2057. print_cil_member(fp, ident);
  2059. // Load object address.
  2060. print_cil_load_address(fp, exp, function_scope);
  2062. // Load field.
  2063. fprintf(fp, "ldfld ");
  2064. print_cil_member(fp, ident);
  2065. }
  2066. }
  2067. }
  2069. void print_cast(LLFILE *fp, LSCRIPTType ret_type, LSCRIPTType right_type)
  2070. {
  2071. if (right_type != ret_type)
  2072. {
  2073. fprintf(fp, "CAST %s->%sn", LSCRIPTTypeNames[right_type], LSCRIPTTypeNames[ret_type]);
  2074. }
  2075. }
  2077. void cast2stack(LLScriptByteCodeChunk *chunk, LSCRIPTType ret_type, LSCRIPTType right_type)
  2078. {
  2079. if (right_type != ret_type)
  2080. {
  2081. chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
  2082. U8 castbyte = LSCRIPTTypeByte[right_type] | LSCRIPTTypeHi4Bits[ret_type];
  2083. chunk->addByte(castbyte);
  2084. }
  2085. }
  2087. void operation2stack(LLScriptByteCodeChunk *chunk, LSCRIPTType ret_type, LSCRIPTType right_type)
  2088. {
  2089. U8 typebyte = LSCRIPTTypeByte[right_type] | LSCRIPTTypeHi4Bits[ret_type];
  2090. chunk->addByte(typebyte);
  2091. }
  2093. void store2stack(LLScriptExpression *exp, LLScriptExpression *lv, LLScriptByteCodeChunk *chunk, LSCRIPTType right_type)
  2094. {
  2095. LLScriptLValue *lvalue = (LLScriptLValue *)lv;
  2096. LLScriptIdentifier *ident = lvalue->mIdentifier;
  2097. LSCRIPTType rettype = exp->mReturnType;
  2099. if (exp->mRightType != LST_NULL)
  2100. {
  2101. if (legal_binary_expression(rettype, exp->mLeftType, exp->mRightType, exp->mType)) 
  2102. cast2stack(chunk, right_type, exp->mReturnType);
  2103. }
  2104. switch(exp->mReturnType)
  2105. {
  2106. case LST_INTEGER:
  2107. case LST_FLOATINGPOINT:
  2108. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2109. {
  2110. chunk->addByte(LSCRIPTOpCodes[LOPC_STORE]);
  2111. }
  2112. else
  2113. {
  2114. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREG]);
  2115. }
  2116. break;
  2117. case LST_KEY:
  2118. case LST_STRING:
  2119. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2120. {
  2121. chunk->addByte(LSCRIPTOpCodes[LOPC_STORES]);
  2122. }
  2123. else
  2124. {
  2125. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGS]);
  2126. }
  2127. break;
  2128. case LST_LIST:
  2129. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2130. {
  2131. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREL]);
  2132. }
  2133. else
  2134. {
  2135. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGL]);
  2136. }
  2137. break;
  2138. case LST_VECTOR:
  2139. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2140. {
  2141. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREV]);
  2142. }
  2143. else
  2144. {
  2145. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGV]);
  2146. }
  2147. break;
  2148. case LST_QUATERNION:
  2149. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2150. {
  2151. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREQ]);
  2152. }
  2153. else
  2154. {
  2155. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGQ]);
  2156. }
  2157. break;
  2158. default:
  2159. if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
  2160. {
  2161. chunk->addByte(LSCRIPTOpCodes[LOPC_STORE]);
  2162. }
  2163. else
  2164. {
  2165. chunk->addByte(LSCRIPTOpCodes[LOPC_STOREG]);
  2166. }
  2167. break;
  2168. }
  2169. S32 address = ident->mScopeEntry->mOffset + lvalue->mOffset;
  2170. chunk->addInteger(address);
  2171. }
  2173. void LLScriptAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  2174. {
  2175. if (gErrorToText.getErrors())
  2176. {
  2177. return;
  2178. }
  2179. switch(pass)
  2180. {
  2181. case LSCP_PRETTY_PRINT:
  2182. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2183. fprintf(fp, " = ");
  2184. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2185. break;
  2186. case LSCP_EMIT_ASSEMBLY:
  2187. {
  2188. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2189. print_cast(fp, mReturnType, mRightType);
  2190. print_assignment(fp, mLValue);
  2191. }
  2192. break;
  2193. case LSCP_TYPE:
  2194. {
  2195. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2196. mLeftType = type;
  2197. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2198. mRightType = type;
  2199. if (!legal_assignment(mLeftType, mRightType))
  2200. {
  2201. gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
  2202. }
  2203. type = mReturnType = mLeftType;
  2204. }
  2205. break;
  2206. case LSCP_TO_STACK:
  2207. {
  2208. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2209. store2stack(this, mLValue, chunk, mRightType);
  2210. }
  2211. break;
  2212. case LSCP_EMIT_CIL_ASSEMBLY:
  2213. {
  2214. print_cil_load_address(fp, mLValue, entry);
  2215. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2216. print_cil_assignment_cast(fp, mRightType, mReturnType);
  2217. print_cil_assignment(fp, mLValue, entry);
  2218. }
  2219. break;
  2220. default:
  2221. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2222. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2223. break;
  2224. }
  2225. gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2226. }
  2228. S32 LLScriptAssignment::getSize()
  2229. {
  2230. return 0;
  2231. }
  2233. static void print_cil_add(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
  2234. {
  2235. if(LST_LIST == right_type && LST_LIST != left_type)
  2236. {
  2237. print_cil_box(fp, left_type);
  2238. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Prepend(class [mscorlib]System.Collections.ArrayList, object)n");
  2239. return;
  2240. }
  2242. switch(left_type)
  2243. {
  2244. case LST_INTEGER:
  2245. case LST_FLOATINGPOINT:
  2247. // Numeric addition.
  2248. fprintf(fp, "addn");
  2249. break;
  2251. case LST_STRING:
  2252. case LST_KEY:
  2254. // String concatenation.
  2255. fprintf(fp, "call string valuetype [LslUserScript]LindenLab.SecondLife.LslUserScript::Add(string, string)n");
  2256. break;
  2258. case LST_VECTOR:
  2260. // Vector addition.
  2261. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Add'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2262. break;
  2264. case LST_QUATERNION:
  2266. // Rotation addition.
  2267. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Add'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)n");
  2268. break;
  2270. case LST_LIST:
  2271. switch(right_type)
  2272. {
  2273. case LST_LIST:
  2274. // Concatenate lists.
  2275. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(class [mscorlib]System.Collections.ArrayList, class [mscorlib]System.Collections.ArrayList)n");
  2276. break;
  2277. case LST_INTEGER:
  2278. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(int32, class [mscorlib]System.Collections.ArrayList)n");
  2279. break;
  2280. case LST_FLOATINGPOINT:
  2281. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(float32, class [mscorlib]System.Collections.ArrayList)n");
  2282. break;
  2283. case LST_STRING:
  2284. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(string, class [mscorlib]System.Collections.ArrayList)n");
  2285. break;
  2286. case LST_KEY:
  2287. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Key, class [mscorlib]System.Collections.ArrayList)n");
  2288. break;
  2289. case LST_VECTOR:
  2290. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Vector, class [mscorlib]System.Collections.ArrayList)n");
  2291. break;
  2292. case LST_QUATERNION:
  2293. fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Quaternion, class [mscorlib]System.Collections.ArrayList)n");
  2294. break;
  2295. default:
  2296. break;
  2297. }
  2299. default:
  2300. break;
  2301. }
  2302. }
  2304. void LLScriptAddAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  2305. {
  2306. if (gErrorToText.getErrors())
  2307. {
  2308. return;
  2309. }
  2310. switch(pass)
  2311. {
  2312. case LSCP_PRETTY_PRINT:
  2313. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2314. fprintf(fp, " += ");
  2315. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2316. break;
  2317. case LSCP_EMIT_ASSEMBLY:
  2318. {
  2319. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2320. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2321. fprintf(fp, "ADD %s, %sn", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
  2322. print_assignment(fp, mLValue);
  2323. }
  2324. break;
  2325. case LSCP_TYPE:
  2326. {
  2327. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2328. mLeftType = type;
  2329. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2330. mRightType = type;
  2331. if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
  2332. {
  2333. gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
  2334. }
  2335. type = mReturnType;
  2336. }
  2337. break;
  2338. case LSCP_TO_STACK:
  2339. {
  2340. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2341. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2342. chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
  2343. operation2stack(chunk, mReturnType, mRightType);
  2344. store2stack(this, mLValue, chunk, mReturnType);
  2345. }
  2346. break;
  2347. case LSCP_EMIT_CIL_ASSEMBLY:
  2348. {
  2349. print_cil_load_address(fp, mLValue, entry);
  2350. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2351. print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
  2352. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2353. print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2354. print_cil_add(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2355. print_cil_assignment(fp, mLValue, entry);
  2356. }
  2357. break;
  2358. default:
  2359. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2360. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2361. break;
  2362. }
  2363. gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2364. }
  2366. S32 LLScriptAddAssignment::getSize()
  2367. {
  2368. return 0;
  2369. }
  2371. static void print_cil_sub(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
  2372. {
  2373. switch(left_type)
  2374. {
  2375. case LST_INTEGER:
  2376. if(LST_INTEGER == right_type)
  2377. {
  2378. fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Subtract(int32, int32)n");
  2379. break;
  2380. }
  2381. case LST_FLOATINGPOINT:
  2382. // Numeric subtraction.
  2383. fprintf(fp, "call float64 [LslUserScript]LindenLab.SecondLife.LslUserScript::Subtract(float64, float64)n");
  2384. break;
  2385. case LST_VECTOR:
  2387. // Vector subtraction.
  2388. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Subtract'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2389. break;
  2391. case LST_QUATERNION:
  2393. // Rotation subtraction.
  2394. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Subtract'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)n");
  2395. break;
  2397. default:
  2399. // Error.
  2400. break;
  2401. }
  2402. }
  2404. void LLScriptSubAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  2405. {
  2406. if (gErrorToText.getErrors())
  2407. {
  2408. return;
  2409. }
  2410. switch(pass)
  2411. {
  2412. case LSCP_PRETTY_PRINT:
  2413. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2414. fprintf(fp, " -= ");
  2415. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2416. break;
  2417. case LSCP_EMIT_ASSEMBLY:
  2418. {
  2419. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2420. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2421. fprintf(fp, "SUB %s, %sn", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
  2422. print_assignment(fp, mLValue);
  2423. }
  2424. break;
  2425. case LSCP_TYPE:
  2426. {
  2427. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2428. mLeftType = type;
  2429. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2430. mRightType = type;
  2431. if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
  2432. {
  2433. gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
  2434. }
  2435. type = mReturnType;
  2436. }
  2437. break;
  2438. case LSCP_TO_STACK:
  2439. {
  2440. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2441. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2442. chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
  2443. operation2stack(chunk, mReturnType, mRightType);
  2444. store2stack(this, mLValue, chunk, mReturnType);
  2445. }
  2446. break;
  2447. case LSCP_EMIT_CIL_ASSEMBLY:
  2448. {
  2449. print_cil_load_address(fp, mLValue, entry);
  2450. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2451. print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
  2452. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2453. print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2454. print_cil_sub(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2455. print_cil_assignment(fp, mLValue, entry);
  2456. }
  2457. break;
  2458. default:
  2459. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2460. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2461. break;
  2462. }
  2463. gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2464. }
  2466. S32 LLScriptSubAssignment::getSize()
  2467. {
  2468. return 0;
  2469. }
  2471. static void print_cil_neg(LLFILE* fp, LSCRIPTType type)
  2472. {
  2473.         switch(type)
  2474. {
  2475. case LST_INTEGER:
  2476. case LST_FLOATINGPOINT:
  2477.   fprintf(fp, "negn");
  2478.   break;
  2479. case LST_VECTOR:
  2480.   fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Negate'(class [ScriptTypes]LindenLab.SecondLife.Vector)n");   
  2481.   break;
  2482. case LST_QUATERNION:
  2483.   fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Negate'(class [ScriptTypes]LindenLab.SecondLife.Quaternion)n");   
  2484.   break;
  2485. default:
  2486.   break;
  2487. }
  2488. }
  2490. static void print_cil_mul(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
  2491. {
  2492. switch(left_type)
  2493. {
  2494. case LST_INTEGER:
  2496. switch(right_type)
  2497. {
  2498. case LST_INTEGER:
  2499. case LST_FLOATINGPOINT:
  2501. // Numeric multiplication.
  2502. fprintf(fp, "muln");
  2503. break;
  2505. case LST_VECTOR:
  2507. // Vector scaling.
  2508. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, float32)n");
  2509. break;
  2510. default:
  2511. break;
  2512. }
  2513. break;
  2515. case LST_FLOATINGPOINT:
  2517. switch(right_type)
  2518. {
  2519. case LST_INTEGER:
  2520. case LST_FLOATINGPOINT:
  2522. // Numeric multiplication.
  2523. fprintf(fp, "muln");
  2524. break;
  2526. case LST_VECTOR:
  2528. // Vector scaling.
  2529. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, float32)n");
  2530. break;
  2532. default:
  2533. break;
  2534. }
  2535. break;
  2537. case LST_VECTOR:
  2539. switch(right_type)
  2540. {
  2541. case LST_INTEGER:
  2542. case LST_FLOATINGPOINT:
  2544. // Vector scaling.
  2545. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(float32, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2546. break;
  2548. case LST_VECTOR:
  2550. // Dot product.
  2551. fprintf(fp, "call float32 class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2552. break;
  2554. case LST_QUATERNION:
  2556. // Vector rotation.
  2557. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2558. break;
  2560. default:
  2561. break;
  2562. }
  2563. break;
  2565. case LST_QUATERNION:
  2567. // Rotation multiplication.
  2568. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)n");
  2569. break;
  2571. default:
  2573. // Error.
  2574. break;
  2575. }
  2576. }
  2578. void LLScriptMulAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  2579. {
  2580. if (gErrorToText.getErrors())
  2581. {
  2582. return;
  2583. }
  2584. switch(pass)
  2585. {
  2586. case LSCP_PRETTY_PRINT:
  2587. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2588. fprintf(fp, " *= ");
  2589. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2590. break;
  2591. case LSCP_EMIT_ASSEMBLY:
  2592. {
  2593. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2594. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2595. fprintf(fp, "MUL %s, %sn", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
  2596. print_assignment(fp, mLValue);
  2597. }
  2598. break;
  2599. case LSCP_TYPE:
  2600. {
  2601. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2602. mLeftType = type;
  2603. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2604. mRightType = type;
  2605. if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType) /*|| !legal_assignment(mLValue->mReturnType, mReturnType)*/)
  2606. {
  2607. gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
  2608. }
  2609. type = mReturnType;
  2610. }
  2611. break;
  2612. case LSCP_TO_STACK:
  2613. {
  2614. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2615. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2616. chunk->addByte(LSCRIPTOpCodes[LOPC_MUL]);
  2617. operation2stack(chunk, mReturnType, mRightType);
  2618. store2stack(this, mLValue, chunk, mReturnType);
  2619. }
  2620. break;
  2621. case LSCP_EMIT_CIL_ASSEMBLY:
  2622. {
  2623. print_cil_load_address(fp, mLValue, entry);
  2624. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2625. print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
  2626. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2627. print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2628. print_cil_mul(fp, mLValue->mReturnType, mRightSide->mReturnType);
  2629. if((mLValue->mReturnType == LST_INTEGER) && 
  2630.    (mRightSide->mReturnType == LST_FLOATINGPOINT))
  2631. {
  2632.     print_cil_cast(fp, LST_FLOATINGPOINT, LST_INTEGER);
  2633. } 
  2634. print_cil_assignment(fp, mLValue, entry);
  2635. }
  2636. break;
  2637. default:
  2638. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2639. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2640. break;
  2641. }
  2642. gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2643. }
  2645. S32 LLScriptMulAssignment::getSize()
  2646. {
  2647. return 0;
  2648. }
  2650. static void print_cil_div(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
  2651. {
  2652. switch(left_type)
  2653. {
  2654. case LST_INTEGER:
  2655. if(LST_INTEGER == right_type)
  2656. {
  2657. fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Divide(int32, int32)n");
  2658. break;
  2659. }
  2660. case LST_FLOATINGPOINT:
  2662. // Numeric division.
  2663. fprintf(fp, "call float64 [LslUserScript]LindenLab.SecondLife.LslUserScript::Divide(float64, float64)n");
  2664. break;
  2666. case LST_VECTOR:
  2668. switch(right_type)
  2669. {
  2670. case LST_INTEGER:
  2671. case LST_FLOATINGPOINT:
  2673. // Scale.
  2674. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(float32, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2675. break;
  2677. case LST_QUATERNION:
  2679. // Inverse rotation.
  2680. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Vector)n");
  2681. break;
  2683. default:
  2684. break;
  2685. }
  2686. break;
  2688. case LST_QUATERNION:
  2690. fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)n");
  2691. break;
  2693. default:
  2695. // Error.
  2696. break;
  2697. }
  2698. }
  2700. void LLScriptDivAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
  2701. {
  2702. if (gErrorToText.getErrors())
  2703. {
  2704. return;
  2705. }
  2706. switch(pass)
  2707. {
  2708. case LSCP_PRETTY_PRINT:
  2709. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2710. fprintf(fp, " /= ");
  2711. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2712. break;
  2713. case LSCP_EMIT_ASSEMBLY:
  2714. {
  2715. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2716. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2717. fprintf(fp, "DIV %s, %sn", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
  2718. print_assignment(fp, mLValue);
  2719. }
  2720. break;
  2721. case LSCP_TYPE:
  2722. {
  2723. mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2724. mLeftType = type;
  2725. mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
  2726. mRightType = type;