Graphite Version 3
An experimental 3D geometry processing program
Loading...
Searching...
No Matches
lua_wrap.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2000-2022 Inria
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * * Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * * Neither the name of the ALICE Project-Team nor the names of its
14 * contributors may be used to endorse or promote products derived from this
15 * software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 *
29 * Contact: Bruno Levy
30 *
31 * https://www.inria.fr/fr/bruno-levy
32 *
33 * Inria,
34 * Domaine de Voluceau,
35 * 78150 Le Chesnay - Rocquencourt
36 * FRANCE
37 *
38 */
39
40#ifndef GEOGRAM_LUA_LUA_WRAP
41
42#include <geogram/basic/common.h>
43#include <geogram/basic/assert.h>
44#include <geogram/basic/numeric.h>
45#include <geogram/basic/string.h>
46#include <geogram/basic/memory.h>
47
48extern "C" {
49#include <geogram/third_party/lua/lua.h>
50#include <geogram/third_party/lua/lauxlib.h>
51#include <geogram/third_party/lua/lualib.h>
52}
53
54#ifdef GEO_COMPILER_MSVC
55#pragma warning( push )
56#pragma warning( disable: 4702 )
57#endif
58
64namespace GEO {
65
70 typedef int (*lua_test_func)(lua_State* L, int idx);
71
72
84 inline int my_lua_isboolean(lua_State* L, int idx) {
85 return lua_isboolean(L,idx);
86 }
87
99 inline int my_lua_islightuserdata(lua_State* L, int idx) {
100 return lua_islightuserdata(L,idx);
101 }
102
112 inline int my_lua_ispositiveinteger(lua_State* L, int idx) {
113 if(!lua_isinteger(L,idx)) {
114 return 0;
115 }
116 lua_Integer x = lua_tointeger(L,idx);
117 return (x > 0) ? 1 : 0;
118 }
119
128 inline void lua_set_error(lua_State* L, const char* error) {
129 lua_pushstring(L, error);
130 lua_setfield(L,LUA_REGISTRYINDEX,"last_geogram_error");
131 }
132
141 inline void lua_set_error(lua_State* L, const std::string& error) {
142 lua_set_error(L,error.c_str());
143 }
144
149 inline void lua_clear_error(lua_State* L) {
150 lua_pushnil(L);
151 lua_setfield(L,LUA_REGISTRYINDEX,"last_geogram_error");
152 }
153
159 inline bool lua_has_error(lua_State* L) {
160 lua_getfield(L,LUA_REGISTRYINDEX,"last_geogram_error");
161 bool result = !lua_isnil(L,-1);
162 lua_pop(L,1);
163 return result;
164 }
165
178 inline bool lua_check_type(lua_State* L, int idx, lua_test_func test) {
179 if(!test(L,idx)) {
180 std::string error = std::string("Argument ") +
181 String::to_string(idx) + ": wrong argument type (" +
182 "got " + lua_typename(L,lua_type(L,idx)) + ")";
183 lua_set_error(L, error.c_str());
184 return false;
185 }
186 return true;
187 }
188
201 inline bool lua_check_nb_args(lua_State* L, int expected_nb_args) {
202 if(lua_gettop(L) != expected_nb_args) {
203 std::string error =
204 "Expected " + String::to_string(expected_nb_args)
205 + " arg(s), got " + String::to_string(lua_gettop(L));
206 lua_set_error(L,error.c_str());
207 return false;
208 }
209 return true;
210 }
211
225 inline int lua_notify_last_error(lua_State* L) {
226 std::string error;
227 lua_getfield(L,LUA_REGISTRYINDEX,"last_geogram_error");
228 if(lua_isstring(L,-1)) {
229 error += lua_tostring(L,-1);
230 }
231 lua_pop(L,1);
232 lua_clear_error(L);
233 return luaL_error(L,error.c_str());
234 }
235
236 /**********************************************************************/
237
243 template <class T> class lua_to {
244 public:
257 lua_to(lua_State* L, int idx) {
258 geo_argused(L);
259 geo_argused(idx);
260 geo_assert_not_reached;
261 }
262
275 static bool can_convert(lua_State* L, int idx) {
276 geo_argused(L);
277 geo_argused(idx);
278 geo_assert_not_reached;
279 }
280
285 operator T() const {
286 geo_assert_not_reached;
287 }
288 protected:
289 T x_;
290 };
291
295 template<> class lua_to<int> {
296 public:
297 lua_to(lua_State* L, int idx) {
298 x_ = int(lua_tointeger(L,idx));
299 }
300 static bool can_convert(lua_State* L, int idx) {
301 return lua_check_type(L, idx, lua_isinteger);
302 }
303 operator int() const {
304 return x_;
305 }
306 private:
307 int x_;
308 };
309
313 template<> class lua_to<Numeric::uint32> {
314 public:
315 lua_to(lua_State* L, int idx) {
316 x_ = Numeric::uint32(lua_tointeger(L,idx));
317 }
318 static bool can_convert(lua_State* L, int idx) {
319 return lua_check_type(L, idx, my_lua_ispositiveinteger);
320 }
321 operator Numeric::uint32() const {
322 return x_;
323 }
324 private:
325 Numeric::uint32 x_;
326 };
327
331 template<> class lua_to<Numeric::uint64> {
332 public:
333 lua_to(lua_State* L, int idx) {
334 x_ = Numeric::uint64(lua_tointeger(L,idx));
335 }
336 static bool can_convert(lua_State* L, int idx) {
337 return lua_check_type(L, idx, my_lua_ispositiveinteger);
338 }
339 operator Numeric::uint64() const {
340 return x_;
341 }
342 private:
343 Numeric::uint64 x_;
344 };
345
346
350 template<> class lua_to<Numeric::int64> {
351 public:
352 lua_to(lua_State* L, int idx) {
353 x_ = Numeric::int64(lua_tointeger(L,idx));
354 }
355 static bool can_convert(lua_State* L, int idx) {
356 return lua_check_type(L, idx, lua_isinteger);
357 }
358 operator Numeric::int64() const {
359 return x_;
360 }
361 private:
362 Numeric::int64 x_;
363 };
364
368 template<> class lua_to<float> {
369 public:
370 lua_to(lua_State* L, int idx) {
371 x_ = float(lua_tonumber(L,idx));
372 }
373 static bool can_convert(lua_State* L, int idx) {
374 return lua_check_type(L, idx, lua_isnumber);
375 }
376 operator float() const {
377 return x_;
378 }
379 private:
380 float x_;
381 };
382
386 template<> class lua_to<double> {
387 public:
388 lua_to(lua_State* L, int idx) {
389 x_ = double(lua_tonumber(L,idx));
390 }
391 static bool can_convert(lua_State* L, int idx) {
392 return lua_check_type(L, idx, lua_isnumber);
393 }
394 operator double() const {
395 return x_;
396 }
397 private:
398 double x_;
399 };
400
404 template<> class lua_to<bool> {
405 public:
406 lua_to(lua_State* L, int idx) {
407 x_ = (lua_toboolean(L,idx) != 0);
408 }
409 static bool can_convert(lua_State* L, int idx) {
410 return lua_check_type(L, idx, my_lua_isboolean);
411 }
412 operator bool() const {
413 return x_;
414 }
415 private:
416 bool x_;
417 };
418
422 template<> class lua_to<const char*> {
423 public:
424 lua_to(lua_State* L, int idx) {
425 x_ = lua_tostring(L,idx);
426 }
427 static bool can_convert(lua_State* L, int idx) {
428 return lua_check_type(L, idx, lua_isstring);
429 }
430 operator const char*() const {
431 return x_;
432 }
433 private:
434 const char* x_;
435 };
436
440 template<> class lua_to<const std::string&> {
441 public:
442 lua_to(lua_State* L, int idx) {
443 x_ = lua_tostring(L,idx);
444 }
445 static bool can_convert(lua_State* L, int idx) {
446 return lua_check_type(L, idx, lua_isstring);
447 }
448 operator const std::string&() const {
449 return x_;
450 }
451 private:
452 std::string x_;
453 };
454
458 template<> class lua_to<std::string> {
459 public:
460 lua_to(lua_State* L, int idx) {
461 x_ = lua_tostring(L,idx);
462 }
463 static bool can_convert(lua_State* L, int idx) {
464 return lua_check_type(L, idx, lua_isstring);
465 }
466 operator std::string() const {
467 return x_;
468 }
469 private:
470 std::string x_;
471 };
472
473 /**********************************************************************/
474
484 template<class T> inline void lua_push(lua_State* L, T x) {
485 geo_argused(L);
486 geo_argused(x);
487 geo_assert_not_reached;
488 }
489
493 template<> inline void lua_push(lua_State* L, int x) {
494 lua_pushinteger(L,lua_Integer(x));
495 }
496
497
501 template<> inline void lua_push(lua_State* L, Numeric::uint32 x) {
502 lua_pushinteger(L,lua_Integer(x));
503 }
504
508 template<> inline void lua_push(lua_State* L, Numeric::uint64 x) {
509 lua_pushinteger(L,lua_Integer(x));
510 }
511
515 template<> inline void lua_push(lua_State* L, Numeric::int64 x) {
516 lua_pushinteger(L,lua_Integer(x));
517 }
518
522 template<> inline void lua_push(lua_State* L, float x) {
523 lua_pushnumber(L,lua_Number(x));
524 }
525
529 template<> inline void lua_push(lua_State* L, double x) {
530 lua_pushnumber(L,lua_Number(x));
531 }
532
536 template<> inline void lua_push(lua_State* L, bool x) {
537 lua_pushboolean(L,x?1:0);
538 }
539
543 template<> inline void lua_push(lua_State* L, const char* x) {
544 lua_pushstring(L,x);
545 }
546
550 template<> inline void lua_push(lua_State* L, const std::string& x) {
551 lua_pushstring(L,x.c_str());
552 }
553
557 template<> inline void lua_push(lua_State* L, std::string x) {
558 lua_pushstring(L,x.c_str());
559 }
560
566 template<class T> inline void lua_push(
567 lua_State* L, const std::vector<T>& x
568 ) {
569 lua_newtable(L);
570 for(size_t i=0; i<x.size(); ++i) {
571 lua_push(L,x[i]);
572 lua_seti(L,-2,lua_Integer(i+1));
573 }
574 }
575
586#define LUA_DECLAREENUMTYPE(T) \
587 template<> inline void lua_push(lua_State* L, T x) { \
588 lua_push(L, int(x)); \
589 } \
590 \
591 template<> class lua_to<T> : public GEO::lua_to<int> { \
592 public: \
593 lua_to(lua_State* L, int idx) : lua_to<int>(L,idx) { \
594 } \
595 operator T() const { \
596 return T(lua_to<int>::operator int()); \
597 } \
598 }
599
600 /**********************************************************************/
601
609 template <class R> inline int lua_wrap(lua_State* L, R (*fptr)(void)) {
610 if(!lua_check_nb_args(L,0)) {
611 return lua_notify_last_error(L);
612 }
613 R retval = fptr();
614 lua_push(L,retval);
615 return 1;
616 }
617
625 template <class R, class T1> inline int lua_wrap(
626 lua_State* L, R (*fptr)(T1)
627 ) {
628 if(
629 !lua_check_nb_args(L,1) ||
630 !lua_to<T1>::can_convert(L,1)
631 ) {
632 return lua_notify_last_error(L);
633 }
634 R retval = fptr(
635 lua_to<T1>(L,1)
636 );
637 lua_push(L,retval);
638 return 1;
639 }
640
648 template <class R, class T1, class T2> inline int lua_wrap(
649 lua_State* L, R (*fptr)(T1,T2)
650 ) {
651 if(
652 !lua_check_nb_args(L,2) ||
653 !lua_to<T1>::can_convert(L,1) ||
654 !lua_to<T2>::can_convert(L,2)
655 ) {
656 return lua_notify_last_error(L);
657 }
658 R retval = fptr(
659 lua_to<T1>(L,1),
660 lua_to<T2>(L,2)
661 );
662 lua_push(L,retval);
663 return 1;
664 }
665
673 template <class R, class T1, class T2, class T3> inline int lua_wrap(
674 lua_State* L, R (*fptr)(T1,T2,T3)
675 ) {
676 if(
677 !lua_check_nb_args(L,3) ||
678 !lua_to<T1>::can_convert(L,1) ||
679 !lua_to<T2>::can_convert(L,2) ||
680 !lua_to<T3>::can_convert(L,3)
681 ) {
682 return lua_notify_last_error(L);
683 }
684 R retval = fptr(
685 lua_to<T1>(L,1),
686 lua_to<T2>(L,2),
687 lua_to<T3>(L,3)
688 );
689 lua_push(L,retval);
690 return 1;
691 }
692
700 template <class R, class T1, class T2, class T3, class T4>
701 inline int lua_wrap(lua_State* L, R (*fptr)(T1,T2,T3,T4)) {
702 if(
703 !lua_check_nb_args(L,4) ||
704 !lua_to<T1>::can_convert(L,1) ||
705 !lua_to<T2>::can_convert(L,2) ||
706 !lua_to<T3>::can_convert(L,3) ||
707 !lua_to<T4>::can_convert(L,4)
708 ) {
709 return lua_notify_last_error(L);
710 }
711 R retval = fptr(
712 lua_to<T1>(L,1),
713 lua_to<T2>(L,2),
714 lua_to<T3>(L,3),
715 lua_to<T4>(L,4)
716 );
717 lua_push(L,retval);
718 return 1;
719 }
720
721 /*************************************************************************/
722
729 template <> inline int lua_wrap(lua_State* L, void (*fptr)(void)) {
730 if(!lua_check_nb_args(L,0)) {
731 return lua_notify_last_error(L);
732 }
733 fptr();
734 return 0;
735 }
736
743 template <class T1> inline int lua_wrap(lua_State* L, void (*fptr)(T1)) {
744 if(
745 !lua_check_nb_args(L,1) ||
746 !lua_to<T1>::can_convert(L,1)
747 ) {
748 return lua_notify_last_error(L);
749 }
750 fptr(
751 lua_to<T1>(L,1)
752 );
753 return 0;
754 }
755
762 template <class T1, class T2> inline int lua_wrap(
763 lua_State* L, void (*fptr)(T1,T2)
764 ) {
765 if(
766 !lua_check_nb_args(L,2) ||
767 !lua_to<T1>::can_convert(L,1) ||
768 !lua_to<T2>::can_convert(L,2)
769 ) {
770 return lua_notify_last_error(L);
771 }
772 fptr(
773 lua_to<T1>(L,1),
774 lua_to<T2>(L,2)
775 );
776 return 0;
777 }
778
785 template <class T1, class T2, class T3>
786 inline int lua_wrap(lua_State* L, void (*fptr)(T1,T2,T3)) {
787 if(
788 !lua_check_nb_args(L,3) ||
789 !lua_to<T1>::can_convert(L,1) ||
790 !lua_to<T2>::can_convert(L,2) ||
791 !lua_to<T3>::can_convert(L,3)
792 ) {
793 return lua_notify_last_error(L);
794 }
795 fptr(
796 lua_to<T1>(L,1),
797 lua_to<T2>(L,2),
798 lua_to<T3>(L,3)
799 );
800 return 0;
801 }
802
809 template <class T1, class T2, class T3, class T4>
810 inline int lua_wrap(lua_State* L, void (*fptr)(T1,T2,T3,T4)) {
811 if(
812 !lua_check_nb_args(L,4) ||
813 !lua_to<T1>::can_convert(L,1) ||
814 !lua_to<T2>::can_convert(L,2) ||
815 !lua_to<T3>::can_convert(L,3) ||
816 !lua_to<T4>::can_convert(L,4)
817 ) {
818 return lua_notify_last_error(L);
819 }
820 fptr(
821 lua_to<T1>(L,1),
822 lua_to<T2>(L,2),
823 lua_to<T3>(L,3),
824 lua_to<T4>(L,4)
825 );
826 return 0;
827 }
828
835 template <
836 class T1, class T2, class T3, class T4, class T5
837 >
838 inline int lua_wrap(
839 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5)
840 ) {
841 if(
842 !lua_check_nb_args(L,5) ||
843 !lua_to<T1>::can_convert(L,1) ||
844 !lua_to<T2>::can_convert(L,2) ||
845 !lua_to<T3>::can_convert(L,3) ||
846 !lua_to<T4>::can_convert(L,4) ||
847 !lua_to<T5>::can_convert(L,5)
848 ) {
849 return lua_notify_last_error(L);
850 }
851 fptr(
852 lua_to<T1>(L,1),
853 lua_to<T2>(L,2),
854 lua_to<T3>(L,3),
855 lua_to<T4>(L,4),
856 lua_to<T5>(L,5)
857 );
858 return 0;
859 }
860
867 template <
868 class T1, class T2, class T3, class T4, class T5, class T6
869 >
870 inline int lua_wrap(
871 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6)
872 ) {
873 if(
874 !lua_check_nb_args(L,6) ||
875 !lua_to<T1>::can_convert(L,1) ||
876 !lua_to<T2>::can_convert(L,2) ||
877 !lua_to<T3>::can_convert(L,3) ||
878 !lua_to<T4>::can_convert(L,4) ||
879 !lua_to<T5>::can_convert(L,5) ||
880 !lua_to<T6>::can_convert(L,6)
881 ) {
882 return lua_notify_last_error(L);
883 }
884 fptr(
885 lua_to<T1>(L,1),
886 lua_to<T2>(L,2),
887 lua_to<T3>(L,3),
888 lua_to<T4>(L,4),
889 lua_to<T5>(L,5),
890 lua_to<T6>(L,6)
891 );
892 return 0;
893 }
894
901 template <
902 class T1, class T2, class T3, class T4, class T5,
903 class T6, class T7
904 >
905 inline int lua_wrap(
906 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7)
907 ) {
908 if(
909 !lua_check_nb_args(L,7) ||
910 !lua_to<T1>::can_convert(L,1) ||
911 !lua_to<T2>::can_convert(L,2) ||
912 !lua_to<T3>::can_convert(L,3) ||
913 !lua_to<T4>::can_convert(L,4) ||
914 !lua_to<T5>::can_convert(L,5) ||
915 !lua_to<T6>::can_convert(L,6) ||
916 !lua_to<T7>::can_convert(L,7)
917 ) {
918 return lua_notify_last_error(L);
919 }
920 fptr(
921 lua_to<T1>(L,1),
922 lua_to<T2>(L,2),
923 lua_to<T3>(L,3),
924 lua_to<T4>(L,4),
925 lua_to<T5>(L,5),
926 lua_to<T6>(L,6),
927 lua_to<T7>(L,7)
928 );
929 return 0;
930 }
931
932
939 template <
940 class T1, class T2, class T3, class T4, class T5,
941 class T6, class T7, class T8
942 >
943 inline int lua_wrap(
944 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8)
945 ) {
946 if(
947 !lua_check_nb_args(L,8) ||
948 !lua_to<T1>::can_convert(L,1) ||
949 !lua_to<T2>::can_convert(L,2) ||
950 !lua_to<T3>::can_convert(L,3) ||
951 !lua_to<T4>::can_convert(L,4) ||
952 !lua_to<T5>::can_convert(L,5) ||
953 !lua_to<T6>::can_convert(L,6) ||
954 !lua_to<T7>::can_convert(L,7) ||
955 !lua_to<T8>::can_convert(L,8)
956 ) {
957 return lua_notify_last_error(L);
958 }
959 fptr(
960 lua_to<T1>(L,1),
961 lua_to<T2>(L,2),
962 lua_to<T3>(L,3),
963 lua_to<T4>(L,4),
964 lua_to<T5>(L,5),
965 lua_to<T6>(L,6),
966 lua_to<T7>(L,7),
967 lua_to<T8>(L,8)
968 );
969 return 0;
970 }
971
972
979 template <
980 class T1, class T2, class T3, class T4, class T5,
981 class T6, class T7, class T8, class T9
982 >
983 inline int lua_wrap(
984 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8,T9)
985 ) {
986 if(
987 !lua_check_nb_args(L,9) ||
988 !lua_to<T1>::can_convert(L,1) ||
989 !lua_to<T2>::can_convert(L,2) ||
990 !lua_to<T3>::can_convert(L,3) ||
991 !lua_to<T4>::can_convert(L,4) ||
992 !lua_to<T5>::can_convert(L,5) ||
993 !lua_to<T6>::can_convert(L,6) ||
994 !lua_to<T7>::can_convert(L,7) ||
995 !lua_to<T8>::can_convert(L,8) ||
996 !lua_to<T9>::can_convert(L,9)
997 ) {
998 return lua_notify_last_error(L);
999 }
1000 fptr(
1001 lua_to<T1>(L,1),
1002 lua_to<T2>(L,2),
1003 lua_to<T3>(L,3),
1004 lua_to<T4>(L,4),
1005 lua_to<T5>(L,5),
1006 lua_to<T6>(L,6),
1007 lua_to<T7>(L,7),
1008 lua_to<T8>(L,8),
1009 lua_to<T9>(L,9)
1010 );
1011 return 0;
1012 }
1013
1014
1021 template <
1022 class T1, class T2, class T3, class T4, class T5,
1023 class T6, class T7, class T8, class T9, class T10
1024 >
1025 inline int lua_wrap(
1026 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)
1027 ) {
1028 if(
1029 !lua_check_nb_args(L,10) ||
1030 !lua_to<T1>::can_convert(L,1) ||
1031 !lua_to<T2>::can_convert(L,2) ||
1032 !lua_to<T3>::can_convert(L,3) ||
1033 !lua_to<T4>::can_convert(L,4) ||
1034 !lua_to<T5>::can_convert(L,5) ||
1035 !lua_to<T6>::can_convert(L,6) ||
1036 !lua_to<T7>::can_convert(L,7) ||
1037 !lua_to<T8>::can_convert(L,8) ||
1038 !lua_to<T9>::can_convert(L,9) ||
1039 !lua_to<T10>::can_convert(L,10)
1040 ) {
1041 return lua_notify_last_error(L);
1042 }
1043 fptr(
1044 lua_to<T1>(L,1),
1045 lua_to<T2>(L,2),
1046 lua_to<T3>(L,3),
1047 lua_to<T4>(L,4),
1048 lua_to<T5>(L,5),
1049 lua_to<T6>(L,6),
1050 lua_to<T7>(L,7),
1051 lua_to<T8>(L,8),
1052 lua_to<T9>(L,9),
1053 lua_to<T10>(L,10)
1054 );
1055 return 0;
1056 }
1057
1058
1065 template <
1066 class T1, class T2, class T3, class T4, class T5,
1067 class T6, class T7, class T8, class T9, class T10,
1068 class T11
1069 >
1070 inline int lua_wrap(
1071 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)
1072 ) {
1073 if(
1074 !lua_check_nb_args(L,11) ||
1075 !lua_to<T1>::can_convert(L,1) ||
1076 !lua_to<T2>::can_convert(L,2) ||
1077 !lua_to<T3>::can_convert(L,3) ||
1078 !lua_to<T4>::can_convert(L,4) ||
1079 !lua_to<T5>::can_convert(L,5) ||
1080 !lua_to<T6>::can_convert(L,6) ||
1081 !lua_to<T7>::can_convert(L,7) ||
1082 !lua_to<T8>::can_convert(L,8) ||
1083 !lua_to<T9>::can_convert(L,9) ||
1084 !lua_to<T10>::can_convert(L,10) ||
1085 !lua_to<T11>::can_convert(L,11)
1086 ) {
1087 return lua_notify_last_error(L);
1088 }
1089 fptr(
1090 lua_to<T1>(L,1),
1091 lua_to<T2>(L,2),
1092 lua_to<T3>(L,3),
1093 lua_to<T4>(L,4),
1094 lua_to<T5>(L,5),
1095 lua_to<T6>(L,6),
1096 lua_to<T7>(L,7),
1097 lua_to<T8>(L,8),
1098 lua_to<T9>(L,9),
1099 lua_to<T10>(L,10),
1100 lua_to<T11>(L,11)
1101 );
1102 return 0;
1103 }
1104
1111 template <
1112 class T1, class T2, class T3, class T4, class T5,
1113 class T6, class T7, class T8, class T9, class T10,
1114 class T11, class T12
1115 >
1116 inline int lua_wrap(
1117 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)
1118 ) {
1119 if(
1120 !lua_check_nb_args(L,12) ||
1121 !lua_to<T1>::can_convert(L,1) ||
1122 !lua_to<T2>::can_convert(L,2) ||
1123 !lua_to<T3>::can_convert(L,3) ||
1124 !lua_to<T4>::can_convert(L,4) ||
1125 !lua_to<T5>::can_convert(L,5) ||
1126 !lua_to<T6>::can_convert(L,6) ||
1127 !lua_to<T7>::can_convert(L,7) ||
1128 !lua_to<T8>::can_convert(L,8) ||
1129 !lua_to<T9>::can_convert(L,9) ||
1130 !lua_to<T10>::can_convert(L,10) ||
1131 !lua_to<T11>::can_convert(L,11) ||
1132 !lua_to<T12>::can_convert(L,12)
1133 ) {
1134 return lua_notify_last_error(L);
1135 }
1136 fptr(
1137 lua_to<T1>(L,1),
1138 lua_to<T2>(L,2),
1139 lua_to<T3>(L,3),
1140 lua_to<T4>(L,4),
1141 lua_to<T5>(L,5),
1142 lua_to<T6>(L,6),
1143 lua_to<T7>(L,7),
1144 lua_to<T8>(L,8),
1145 lua_to<T9>(L,9),
1146 lua_to<T10>(L,10),
1147 lua_to<T11>(L,11),
1148 lua_to<T12>(L,12)
1149 );
1150 return 0;
1151 }
1152
1153
1160 template <
1161 class T1, class T2, class T3, class T4, class T5,
1162 class T6, class T7, class T8, class T9, class T10,
1163 class T11, class T12, class T13
1164 >
1165 inline int lua_wrap(
1166 lua_State* L, void (*fptr)(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)
1167 ) {
1168 if(
1169 !lua_check_nb_args(L,13) ||
1170 !lua_to<T1>::can_convert(L,1) ||
1171 !lua_to<T2>::can_convert(L,2) ||
1172 !lua_to<T3>::can_convert(L,3) ||
1173 !lua_to<T4>::can_convert(L,4) ||
1174 !lua_to<T5>::can_convert(L,5) ||
1175 !lua_to<T6>::can_convert(L,6) ||
1176 !lua_to<T7>::can_convert(L,7) ||
1177 !lua_to<T8>::can_convert(L,8) ||
1178 !lua_to<T9>::can_convert(L,9) ||
1179 !lua_to<T10>::can_convert(L,10) ||
1180 !lua_to<T11>::can_convert(L,11) ||
1181 !lua_to<T12>::can_convert(L,12) ||
1182 !lua_to<T12>::can_convert(L,13)
1183 ) {
1184 return lua_notify_last_error(L);
1185 }
1186 fptr(
1187 lua_to<T1>(L,1),
1188 lua_to<T2>(L,2),
1189 lua_to<T3>(L,3),
1190 lua_to<T4>(L,4),
1191 lua_to<T5>(L,5),
1192 lua_to<T6>(L,6),
1193 lua_to<T7>(L,7),
1194 lua_to<T8>(L,8),
1195 lua_to<T9>(L,9),
1196 lua_to<T10>(L,10),
1197 lua_to<T11>(L,11),
1198 lua_to<T12>(L,12),
1199 lua_to<T13>(L,13)
1200 );
1201 return 0;
1202 }
1203
1210 template<> inline int lua_wrap(lua_State* L, lua_CFunction fptr) {
1211 return fptr(L);
1212 }
1213
1214
1215 /*************************************************************************/
1216
1224 template <class FPTR> class lua_wrapper {
1225 public:
1226
1235 static int call(lua_State* L) {
1236 FPTR f = FPTR(
1237 Memory::generic_pointer_to_function_pointer(
1238 lua_touserdata(L, lua_upvalueindex(1))
1239 )
1240 );
1241 return lua_wrap(L, f);
1242 }
1243
1250 static void push(lua_State* L, FPTR f) {
1251 lua_pushlightuserdata(
1252 L,
1253 Memory::function_pointer_to_generic_pointer(
1254 Memory::function_pointer(f)
1255 )
1256 );
1257 lua_pushcclosure(L, lua_wrapper<FPTR>::call, 1);
1258 }
1259 };
1260
1261 /**************************************************************************/
1262
1269 template <class FPTR> inline void lua_pushwrapper(lua_State* L, FPTR f) {
1270 lua_wrapper<FPTR>::push(L,f);
1271 }
1272
1277 template<> inline void lua_pushwrapper(lua_State* L, lua_CFunction f) {
1278 lua_pushcfunction(L,f);
1279 }
1280
1281 /**************************************************************************/
1282
1291 template <class FPTR> inline void lua_bindwrapperwithname(
1292 lua_State* L, FPTR f, const std::string& name
1293 ) {
1294 geo_assert(lua_gettop(L) > 0);
1295 geo_assert(lua_istable(L,-1));
1296 lua_pushstring(L,name.c_str());
1297 lua_pushwrapper(L,f);
1298 lua_settable(L,-3);
1299 }
1300
1301
1308 template <class FPTR> inline void lua_bindwrapperwithnameglobal(
1309 lua_State* L, FPTR f, const std::string& name
1310 ) {
1311 lua_pushwrapper(L,f);
1312 lua_setglobal(L,name.c_str());
1313 }
1314
1315 /**************************************************************************/
1316
1324 inline std::string lua_wrappername(lua_State* L, const char* functionname) {
1325 geo_argused(L);
1326 std::string result(functionname);
1327 size_t pos = result.find_last_of(":");
1328 if(pos != std::string::npos) {
1329 result = result.substr(pos+1, result.length()-pos);
1330 }
1331 return result;
1332 }
1333
1334 /**************************************************************************/
1335
1351#define lua_bindwrapper(L, f) lua_bindwrapperwithname( \
1352 (L),(f),GEO::lua_wrappername(L,#f) \
1353 )
1354
1369#define lua_bindwrapperglobal(L, f) lua_bindwrapperwithnameglobal( \
1370 (L),(f),GEO::lua_wrappername(L,#f) \
1371 )
1372
1373
1374 /*************************************************************************/
1375
1376}
1377
1378#ifdef GEO_COMPILER_MSVC
1379#pragma warning( pop )
1380#endif
1381
1382#endif
assert.h
Assertion checking mechanism.
geo_assert_not_reached
#define geo_assert_not_reached
Sets a non reachable point in the program.
Definition assert.h:177
geo_assert
#define geo_assert(x)
Verifies that a condition is met.
Definition assert.h:149
GEO::lua_to
Converts LUA variables to C++ variables.
Definition lua_wrap.h:243
GEO::lua_to::can_convert
static bool can_convert(lua_State *L, int idx)
Tests whether a LUA variable can be converted to a C++ variable.
Definition lua_wrap.h:275
GEO::lua_to::lua_to
lua_to(lua_State *L, int idx)
lua_to constructor.
Definition lua_wrap.h:257
GEO::lua_wrapper
Manages wrappers around C++ functions to be called from LUA.
Definition lua_wrap.h:1224
GEO::lua_wrapper::call
static int call(lua_State *L)
Implementation of the wrapper.
Definition lua_wrap.h:1235
GEO::lua_wrapper::push
static void push(lua_State *L, FPTR f)
Pushes a wrapper for a given C++ function onto the LUA stack.
Definition lua_wrap.h:1250
common.h
Common include file, providing basic definitions. Should be included before anything else by all head...
memory.h
Types and functions for memory manipulation.
GEO::Memory::function_pointer
void(* function_pointer)()
Generic function pointer.
Definition memory.h:107
GEO::Memory::function_pointer_to_generic_pointer
pointer function_pointer_to_generic_pointer(function_pointer fptr)
Converts a function pointer to a generic pointer.
Definition memory.h:142
GEO::Memory::generic_pointer_to_function_pointer
function_pointer generic_pointer_to_function_pointer(pointer ptr)
Converts a generic pointer to a function pointer.
Definition memory.h:161
GEO::Numeric::uint64
uint64_t uint64
Definition numeric.h:144
GEO::Numeric::uint32
uint32_t uint32
Definition numeric.h:141
GEO::Numeric::int64
int64_t int64
Definition numeric.h:132
GEO
Global Vorpaline namespace.
Definition lua_grob_shader.h:53
GEO::lua_wrappername
std::string lua_wrappername(lua_State *L, const char *functionname)
Converts a C++ function name into a LUA function name.
Definition lua_wrap.h:1324
GEO::my_lua_isboolean
int my_lua_isboolean(lua_State *L, int idx)
Tests whether a LUA variable is a boolean.
Definition lua_wrap.h:84
GEO::lua_bindwrapperwithnameglobal
void lua_bindwrapperwithnameglobal(lua_State *L, FPTR f, const std::string &name)
Binds a wrapper to a name in the global scole.
Definition lua_wrap.h:1308
GEO::lua_check_type
bool lua_check_type(lua_State *L, int idx, lua_test_func test)
Tests whether a LUA variable has the correct type.
Definition lua_wrap.h:178
GEO::lua_set_error
void lua_set_error(lua_State *L, const char *error)
Memorizes an error message in LUA registry.
Definition lua_wrap.h:128
GEO::lua_bindwrapperwithname
void lua_bindwrapperwithname(lua_State *L, FPTR f, const std::string &name)
Binds a wrapper to a name in the table at the top of the LUA stack.
Definition lua_wrap.h:1291
GEO::lua_clear_error
void lua_clear_error(lua_State *L)
Clears the last error message in LUA registry.
Definition lua_wrap.h:149
GEO::geo_argused
void geo_argused(const T &)
Suppresses compiler warnings about unused parameters.
Definition argused.h:60
GEO::my_lua_islightuserdata
int my_lua_islightuserdata(lua_State *L, int idx)
Tests whether a LUA variable is a light user data.
Definition lua_wrap.h:99
GEO::lua_push
void lua_push(lua_State *L, T x)
Converts and pushes a C++ variable onto the LUA stack.
Definition lua_wrap.h:484
GEO::lua_check_nb_args
bool lua_check_nb_args(lua_State *L, int expected_nb_args)
Tests whether the expected number of arguments was pushed onto the stack.
Definition lua_wrap.h:201
GEO::my_lua_ispositiveinteger
int my_lua_ispositiveinteger(lua_State *L, int idx)
Tests whether a LUA variable is a positive integer.
Definition lua_wrap.h:112
GEO::lua_has_error
bool lua_has_error(lua_State *L)
Tests whether an error message was memorized in the registry.
Definition lua_wrap.h:159
GEO::lua_notify_last_error
int lua_notify_last_error(lua_State *L)
Takes the last error message memorized in the registry and sends it back to LUA.
Definition lua_wrap.h:225
GEO::lua_test_func
int(* lua_test_func)(lua_State *L, int idx)
A pointer to a LUA function to test an argument in the LUA stack.
Definition lua_wrap.h:70
GEO::lua_pushwrapper
void lua_pushwrapper(lua_State *L, FPTR f)
Pushes a wrapper for a given C++ function onto the LUA stack.
Definition lua_wrap.h:1269
GEO::lua_wrap
int lua_wrap(lua_State *L, R(*fptr)(void))
Calls a C++ function from LUA.
Definition lua_wrap.h:609
numeric.h
Types and functions for numbers manipulation.
string.h
Functions for string manipulation.