C++调用LuaJit的Demo

woaidaima2016

头文件

1. 
   
2. #pragma once
   
3. 
   
4. extern "C"
   
5. {
   
6. #include <luajit/src/lua.h>
   
7. #include <luajit/src/lualib.h>
   
8. #include <luajit/src/lauxlib.h>
   
9. #include <luajit/src/luajit.h>
   
10. }
    
11. 
    
12. class ScriptVM
    
13. {
    
14. public:
    
15.         ScriptVM();
    
16.         ~ScriptVM();
    
17. 
    
18.         bool Init();
    
19.         void Destroy();
    
20.         void ExecuteScriptFile(const char* sScriptName, bool bForceReload = false, bool bAssertOnError = true);
    
21.         //void ExecuteScript(const char* sScript, bool bAssertOnError = true);
    
22. protected:
    
23.         bool LoadFileToBuffer(const std::string& path, std::vector<uint8_t>& buffer);
    
24. private:
    
25.         lua_State* m_pLua;
    
26. };
    

复制代码

源文件

1. #include "pch.h"
   
2. #include "script_vm.h"
   
3. 
   
4. static int wrap_exceptions(lua_State* L, lua_CFunction f)
   
5. {
   
6.         try
   
7.         {
   
8.                 return f(L);  // Call wrapped function and return result.
   
9.         }
   
10.         catch (const char* s)
    
11.         {  
    
12.                 // Catch and convert exceptions.
    
13.                 lua_pushstring(L, s);
    
14.         }
    
15. 
    
16.         catch (std::exception& e)
    
17.         {
    
18.                 lua_pushstring(L, e.what());
    
19.         }
    
20. 
    
21.         catch (...)
    
22.         {
    
23.                 lua_pushliteral(L, "caught (...)");
    
24.         }
    
25. 
    
26.         return lua_error(L);  // Rethrow as a Lua error.
    
27. }
    
28. 
    
29. static void error_msg(bool bUseAssert, const char* pacFmt, ...)
    
30. {
    
31.         //#if defined(_DEBUG)
    
32.         char acTemp[2048];
    
33. 
    
34.         va_list args;
    
35.         va_start(args, pacFmt);
    
36.         vsprintf_s(acTemp, pacFmt, args);
    
37.         va_end(args);
    
38.         if (bUseAssert)
    
39.         {
    
40.                 assert(acTemp);
    
41.         }
    
42.         //#endif
    
43. }
    
44. 
    
45. void report_last_error(lua_State* pLua, bool bUseAssert)
    
46. {
    
47.         lua_getglobal(pLua, "_ALERT");
    
48.         error_msg(bUseAssert, "%s\n", lua_tostring(pLua, -2));
    
49.         error_msg(bUseAssert, "%s\n", lua_tostring(pLua, -1));
    
50.         lua_pop(pLua, 2);  /* remove error_msg message and _ALERT */
    
51. }
    
52. 
    
53. std::string& std_string_format(std::string& _str, const char* _Format, ...)
    
54. {
    
55.         std::string tmp;
    
56. 
    
57.         va_list marker = NULL;
    
58.         va_start(marker, _Format);
    
59. 
    
60.         size_t num_of_chars = _vscprintf(_Format, marker);
    
61. 
    
62.         if (num_of_chars > tmp.capacity())
    
63.         {
    
64.                 tmp.resize(num_of_chars + 1);
    
65.         }
    
66. 
    
67.         vsprintf_s((char*)tmp.data(), tmp.capacity(), _Format, marker);
    
68. 
    
69.         va_end(marker);
    
70. 
    
71.         _str = tmp.c_str();
    
72.         return _str;
    
73. }
    
74. 
    
75. ScriptVM::ScriptVM()
    
76. {
    
77. }
    
78. 
    
79. ScriptVM::~ScriptVM()
    
80. {
    
81. }
    
82. 
    
83. int PrintStringList(lua_State* pLuaState)
    
84. {
    
85.         luaJIT_setmode(pLuaState, -1, LUAJIT_MODE_ALLFUNC | LUAJIT_MODE_ALLSUBFUNC | LUAJIT_MODE_ON);
    
86.         // Get the number of strings
    
87. 
    
88.         int iStringCount = lua_gettop(pLuaState);
    
89. 
    
90.         // Loop through each string and print it, followed by a newline
    
91. 
    
92.         for (int iCurrStringIndex = 1; iCurrStringIndex <= iStringCount; ++iCurrStringIndex)
    
93.         {
    
94.                 // First make sure that the current parameter on the stack is a string
    
95. 
    
96.                 if (!lua_isstring(pLuaState, 1))
    
97.                 {
    
98.                         // If not, print an error
    
99. 
    
100.                         lua_error(pLuaState);
     
101.                 }
     
102.                 else
     
103.                 {
     
104.                         // Otherwise, print a tab, the string, and finally a newline
     
105. 
     
106.                         printf("\t");
     
107.                         printf(lua_tostring(pLuaState, iCurrStringIndex));
     
108.                         printf("\n");
     
109.                 }
     
110.         }
     
111. 
     
112.         // Return zero, as this function does not return any results
     
113. 
     
114.         return 0;
     
115. }
     
116. 
     
117. bool ScriptVM::Init()
     
118. {
     
119.         m_pLua = luaL_newstate();
     
120. 
     
121.         lua_cpcall(m_pLua, luaopen_base, 0);
     
122. 
     
123.         lua_cpcall(m_pLua, luaopen_io, 0);
     
124. 
     
125.         lua_cpcall(m_pLua, luaopen_string, 0);
     
126. 
     
127.         lua_cpcall(m_pLua, luaopen_table, 0);
     
128. 
     
129.         lua_cpcall(m_pLua, luaopen_math, 0);
     
130. 
     
131.         lua_cpcall(m_pLua, luaopen_debug, 0);
     
132. 
     
133.         lua_cpcall(m_pLua, luaopen_os, 0);
     
134. 
     
135.         lua_cpcall(m_pLua, luaopen_package, 0);
     
136. 
     
137.         //luaopen_base(m_pLua);
     
138. 
     
139.         //luaopen_io(m_pLua);
     
140. 
     
141.         //luaopen_table(m_pLua);
     
142. 
     
143.         //luaopen_math(m_pLua);
     
144. 
     
145.         //luaopen_string(m_pLua);
     
146. 
     
147.         //luaopen_debug(m_pLua);
     
148. 
     
149.         //tolua_open_binding(m_pLua);
     
150. 
     
151.         //lua_setgcthreshold(m_pLua, 200); //200k garbage collection threshold
     
152. 
     
153.         lua_register(m_pLua, "PrintStringList", PrintStringList);
     
154. 
     
155.         //lua_register(m_pLua, "dofile", OverrideDofile);
     
156. 
     
157.         // 添加 LuaJIT 的支持
     
158.         lua_pushlightuserdata(m_pLua, (void*)wrap_exceptions);
     
159.         luaJIT_setmode(m_pLua, 0, LUAJIT_MODE_ENGINE | LUAJIT_MODE_ON);
     
160. 
     
161.         return true;
     
162. }
     
163. 
     
164. void ScriptVM::Destroy()
     
165. {
     
166.         lua_close(m_pLua);
     
167. }
     
168. 
     
169. bool ScriptVM::LoadFileToBuffer(const std::string& path, std::vector<uint8_t>& buffer)
     
170. {
     
171.         std::ifstream file(path, std::ios::binary | std::ios::ate);
     
172.         if (!file.is_open())
     
173.                 return false;
     
174. 
     
175.         std::streamsize size = file.tellg();
     
176.         if (size <= 0)
     
177.                 return false;
     
178. 
     
179.         buffer.resize(static_cast<size_t>(size));
     
180.         file.seekg(0, std::ios::beg);
     
181.         if (!file.read(reinterpret_cast<char*>(buffer.data()), size))
     
182.                 return false;
     
183. 
     
184.         return true;
     
185. }
     
186. 
     
187. 
     
188. void ScriptVM::ExecuteScriptFile(const char* sScriptName, bool bForceReload /* = false*/, bool bAssertOnError /*= true*/)
     
189. {
     
190.          // 添加 LuaJIT 的支持
     
191.          luaJIT_setmode(m_pLua, -1, LUAJIT_MODE_ALLFUNC | LUAJIT_MODE_ALLSUBFUNC | LUAJIT_MODE_ON);
     
192. 
     
193.          int nSize1 = lua_gettop(m_pLua);
     
194.          //get chunk name as modified script name
     
195.          std::string sChunkName(sScriptName);
     
196.          for (unsigned int i = 0; i < sChunkName.length(); i++)
     
197.          {
     
198.                  if (sChunkName[i] == '/' || sChunkName[i] == '.')
     
199.                          sChunkName[i] = '_';
     
200.          }
     
201. 
     
202.          //get the chunk global
     
203.          lua_getglobal(m_pLua, sChunkName.c_str());
     
204.          if (bForceReload || !lua_isfunction(m_pLua, -1))//if force reload or not found
     
205.          {
     
206.                  //load it first
     
207.                 std::vector<uint8_t> Buffer;
     
208. 
     
209.                  if (LoadFileToBuffer(sScriptName, Buffer))
     
210.                  {
     
211.                          luaL_loadbuffer(m_pLua, (char*)Buffer.data(), Buffer.size(), sScriptName);
     
212. 
     
213.                          //            luaL_loadfile(m_pLua, sScriptName);
     
214.                          lua_setglobal(m_pLua, sChunkName.c_str());
     
215.                          lua_getglobal(m_pLua, sChunkName.c_str());
     
216.                  }
     
217.                  else
     
218.                          goto failed;
     
219.          }
     
220. 
     
221.          if (lua_pcall(m_pLua, 0, 0, 0) != 0)
     
222.          {
     
223.                  error_msg(bAssertOnError, "error executing script file %s: ", sScriptName);
     
224.                  report_last_error(m_pLua, bAssertOnError);
     
225.          }
     
226. 
     
227. failed:
     
228.          lua_settop(m_pLua, nSize1);
     
229. }
     
230. 
     
231. //
     
232. // void ScriptVM::ExecuteScript(const char* sScript, bool bAssertOnError)
     
233. // {
     
234. //         // 添加 LuaJIT 的支持
     
235. //         luaJIT_setmode(m_pLua, -1, LUAJIT_MODE_ALLFUNC | LUAJIT_MODE_ALLSUBFUNC | LUAJIT_MODE_ON);
     
236. //
     
237. //         int status = luaL_loadbuffer(m_pLua, sScript, strlen(sScript), sScript);
     
238. //
     
239. //         if (status)
     
240. //         {
     
241. //                 //report_last_error(m_pLua, bAssertOnError);
     
242. //         }
     
243. //         else
     
244. //         {
     
245. //                 status = lua_pcall(m_pLua, 0, LUA_MULTRET, 0);  /* call main */
     
246. //
     
247. //                 //if (status)
     
248. //                 //        report_last_error(m_pLua, bAssertOnError);
     
249. //         }
     
250. // }
     
251. //
     
252. // bool ScriptVM::ExecuteScriptFunc(const std::vector<const char*>& modules, const char* func, bool bAllowNonexist, const char* sig, ...)
     
253. // {
     
254. //         // 添加 LuaJIT 的支持
     
255. //         luaJIT_setmode(m_pLua, -1, LUAJIT_MODE_ALLFUNC | LUAJIT_MODE_ALLSUBFUNC | LUAJIT_MODE_ON);
     
256. //
     
257. //         bool bIsSuccess = false;
     
258. //
     
259. //         //PROFILE("ExecuteScriptFunc");
     
260. //
     
261. //         int nSize1 = lua_gettop(m_pLua);
     
262. //
     
263. //         //debug
     
264. //
     
265. // #if DEBUG_STACK
     
266. //         printf("debug lua: stack size before ExecuteScriptFunc = %d\n", nSize1);
     
267. // #endif
     
268. //
     
269. //         va_list    vl;
     
270. //         int    narg, nres;    /* number of arguments and results */
     
271. //         va_start(vl, sig);
     
272. //
     
273. //         //get the actual function
     
274. //         if (modules.empty()) //func is global
     
275. //         {
     
276. //                 lua_getglobal(m_pLua, func);
     
277. //
     
278. //                 if (!lua_isfunction(m_pLua, -1))
     
279. //                 {
     
280. //                         if (!bAllowNonexist)
     
281. //                                 error_msg(true, "ExecuteScriptFunc: Invalid function name: %s\n", func);
     
282. //
     
283. //                         goto failed;
     
284. //                 }
     
285. //         }
     
286. //         else
     
287. //         {
     
288. //
     
289. //                 //trace down the modules
     
290. //
     
291. //                 std::vector<const char*>::const_iterator it = modules.begin();
     
292. //
     
293. //                 //get the global module name or the actual function name if there is no module
     
294. //
     
295. //                 lua_getglobal(m_pLua, *it);
     
296. //
     
297. //                 if (!lua_istable(m_pLua, -1))
     
298. //
     
299. //                 {
     
300. //
     
301. //                         if (!bAllowNonexist)
     
302. //
     
303. //                                 error_msg(true, "ExecuteScriptFunc: Invalid table name: %s\n", *it);
     
304. //
     
305. //                         goto failed;
     
306. //
     
307. //                 }
     
308. //
     
309. //
     
310. //
     
311. //                 for (++it; it != modules.end(); ++it)
     
312. //
     
313. //                 {
     
314. //
     
315. //                         lua_pushstring(m_pLua, *it);
     
316. //
     
317. //                         lua_gettable(m_pLua, -2);
     
318. //
     
319. //                         if (!lua_istable(m_pLua, -1))
     
320. //
     
321. //                         {
     
322. //
     
323. //                                 if (!bAllowNonexist)
     
324. //
     
325. //                                         error_msg(true, "ExecuteScriptFunc: Invalid table name: %s\n", *it);
     
326. //
     
327. //                                 goto failed;
     
328. //
     
329. //                         }
     
330. //
     
331. //                 }
     
332. //
     
333. //                 //get the func
     
334. //
     
335. //                 lua_pushstring(m_pLua, func);
     
336. //
     
337. //                 lua_gettable(m_pLua, -2);
     
338. //
     
339. //                 if (!lua_isfunction(m_pLua, -1))
     
340. //
     
341. //                 {
     
342. //
     
343. //                         if (!bAllowNonexist)
     
344. //
     
345. //                                 error_msg(true, "ExecuteScriptFunc: Invalid function name: %s\n", func);
     
346. //
     
347. //                         goto failed;
     
348. //
     
349. //                 }
     
350. //
     
351. //         }
     
352. //
     
353. //
     
354. //
     
355. //         /* push    arguments */
     
356. //
     
357. //         narg = 0;
     
358. //
     
359. //         while (*sig) { /* push arguments    */
     
360. //
     
361. //                 switch (*sig++) {
     
362. //
     
363. //                 case 'd': /* double    argument */
     
364. //
     
365. //                 case 'f': /* float    argument */    // NieXu: Treat float as double, same as printf()
     
366. //
     
367. //                         lua_pushnumber(m_pLua, va_arg(vl, double));
     
368. //
     
369. //                         break;
     
370. //
     
371. //                 case 'i': /* int argument */
     
372. //
     
373. //                         lua_pushnumber(m_pLua, va_arg(vl, int));
     
374. //
     
375. //                         break;
     
376. //
     
377. //                 case 's': /* string    argument */
     
378. //
     
379. //                         lua_pushstring(m_pLua, va_arg(vl, char*));
     
380. //
     
381. //                         break;
     
382. //
     
383. //                 case 'b': /* boolean argument */
     
384. //
     
385. //                         lua_pushboolean(m_pLua, va_arg(vl, bool));
     
386. //
     
387. //                         break;
     
388. //
     
389. //                 case 'u': /* light user data */
     
390. //
     
391. //                         lua_pushlightuserdata(m_pLua, va_arg(vl, void*));
     
392. //
     
393. //                         break;
     
394. //
     
395. //                 case 't': /* type user data */
     
396. //
     
397. //                 {
     
398. //
     
399. //                         void* pData = va_arg(vl, void*);
     
400. //
     
401. //                         const char* sType = va_arg(vl, const char*);
     
402. //
     
403. //                         tolua_pushusertype(m_pLua, pData, sType);
     
404. //
     
405. //                         break;
     
406. //
     
407. //                 }
     
408. //
     
409. //
     
410. //
     
411. //                 case '>':
     
412. //
     
413. //                         goto endwhile;
     
414. //
     
415. //                 default:
     
416. //
     
417. //                         error_msg(true, "invalid option (%c)\n", *(sig - 1));
     
418. //
     
419. //                         goto failed;
     
420. //
     
421. //                 }
     
422. //
     
423. //                 narg++;
     
424. //
     
425. //                 luaL_checkstack(m_pLua, 1, "too many    arguments");
     
426. //
     
427. //         }endwhile:
     
428. //
     
429. //         /* do the call */
     
430. //
     
431. //         nres = strlen(sig);    /* number of expected results */
     
432. //
     
433. //         if (lua_pcall(m_pLua, narg, nres, 0) != 0) /* do    the    call */
     
434. //
     
435. //         {
     
436. //
     
437. //                 report_last_error(m_pLua, true);
     
438. //
     
439. //                 goto failed;
     
440. //
     
441. //         }
     
442. //
     
443. //         /* retrieve    results    */
     
444. //
     
445. //         nres = -nres; /* stack index of    first result */
     
446. //
     
447. //         while (*sig)
     
448. //
     
449. //         { /* get results */
     
450. //
     
451. //                 switch (*sig++)
     
452. //
     
453. //                 {
     
454. //
     
455. //                 case 'd': /* double    result */
     
456. //
     
457. //                         if (!lua_isnumber(m_pLua, nres))
     
458. //
     
459. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
460. //
     
461. //                         *va_arg(vl, double*) = lua_tonumber(m_pLua, nres);
     
462. //
     
463. //                         break;
     
464. //
     
465. //                 case 'f': /* float    result */
     
466. //
     
467. //                         if (!lua_isnumber(m_pLua, nres))
     
468. //
     
469. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
470. //
     
471. //                         *va_arg(vl, float*) = (float)lua_tonumber(m_pLua, nres);
     
472. //
     
473. //                         break;
     
474. //
     
475. //                 case 'i': /* int result    */
     
476. //
     
477. //                         if (!lua_isnumber(m_pLua, nres))
     
478. //
     
479. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
480. //
     
481. //                         *va_arg(vl, int*) = (int)lua_tonumber(m_pLua, nres);
     
482. //
     
483. //                         break;
     
484. //
     
485. //                 case 's': /* string    result */
     
486. //
     
487. //                         if (!lua_isstring(m_pLua, nres))
     
488. //
     
489. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
490. //
     
491. //                         *va_arg(vl, std::string*) = lua_tostring(m_pLua, nres);
     
492. //
     
493. //                         break;
     
494. //
     
495. //                 case 'b': /* boolean argument */
     
496. //
     
497. //                         if (!lua_isboolean(m_pLua, nres))
     
498. //
     
499. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
500. //
     
501. //                         *va_arg(vl, bool*) = (0 != lua_toboolean(m_pLua, nres));
     
502. //
     
503. //                         break;
     
504. //
     
505. //                 case 'u': /* light user data */
     
506. //
     
507. //                         if (!lua_isuserdata(m_pLua, nres))
     
508. //
     
509. //                                 error_msg(true, "wrong    result type,function name: %s\n", func);
     
510. //
     
511. //                         *va_arg(vl, void**) = lua_touserdata(m_pLua, nres);
     
512. //
     
513. //                         break;
     
514. //
     
515. //                 default:
     
516. //
     
517. //                         error_msg(true, "invalid option (%c)\n", *(sig - 1));
     
518. //
     
519. //                 }
     
520. //
     
521. //                 nres++;
     
522. //
     
523. //         }
     
524. //
     
525. //
     
526. //
     
527. //         bIsSuccess = true;
     
528. //
     
529. // failed:
     
530. //
     
531. //         va_end(vl);
     
532. //
     
533. //         //clear the stack
     
534. //
     
535. //         lua_settop(m_pLua, nSize1);
     
536. //
     
537. //
     
538. //
     
539. // #if DEBUG_STACK
     
540. //
     
541. //         //debug
     
542. //
     
543. //         int nSize2 = lua_gettop(m_pLua);
     
544. //
     
545. //         printf("debug lua: stack size after ExecuteScriptFunc = %d\n", nSize2);
     
546. //
     
547. //         if (nSize1 != nSize2)
     
548. //
     
549. //                 stackDump(m_pLua);
     
550. //
     
551. // #endif
     
552. //
     
553. //         return bIsSuccess;
     
554. // }

复制代码