#2257: added global memcpy/memset undef

include/tic80_types.h

···
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <string.h>
+
+#ifdef memcpy
+#undef memcpy
+#endif
+#ifdef memset
+#undef memset
+#endif
 
 typedef uint8_t u8;
 typedef uint16_t u16;

src/api/janet.c

···
     s32 size = janet_getinteger(argv, 2);
 
     tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core;
-    #undef memcpy
     core->api.memcpy(tic, dst, src, size);
     return janet_wrap_nil();
 }
···
 
     tic_core* core = getJanetMachine(); tic_mem* tic = (tic_mem*)core;
 
-    #undef memset
     core->api.memset(tic, dst, val, size);
     return janet_wrap_nil();
 }

src/api/js.c

···
     s32 size = getInteger(ctx, argv[2]);
 
     tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core;
-    #undef memcpy
     core->api.memcpy(tic, dest, src, size);
 
     return JS_UNDEFINED;
···
 
     tic_core* core = getCore(ctx); tic_mem* tic = (tic_mem*)core;
 
-    #undef memset
     core->api.memset(tic, dest, value, size);
 
     return JS_UNDEFINED;

src/api/lua.c

···
 #include "core/core.h"
 
 #include <stdlib.h>
-#include <string.h>
 #include <lua.h>
 #include <lauxlib.h>
 #include <lualib.h>
···
 
         tic_core* core = getLuaCore(lua);
         tic_mem* tic = (tic_mem*)core;
-        #undef memcpy
         core->api.memcpy(tic, dest, src, size);
     }
     else luaL_error(lua, "invalid params, memcpy(dest,src,size)\n");
···
         tic_core* core = getLuaCore(lua);
         tic_mem* tic = (tic_mem*)core;
 
-        #undef memset
         core->api.memset(tic, dest, value, size);
     }
     else luaL_error(lua, "invalid params, memset(dest,val,size)\n");

src/api/mruby.c

···
     if(size >= 0 && size <= sizeof(tic_ram) && dest >= 0 && src >= 0 && dest <= bound && src <= bound)
     {
         tic_core* core = getMRubyMachine(mrb); tic_mem* tic = (tic_mem*)core;
-        #undef memcpy
         core->api.memcpy(tic, dest, src, size);
     }
     else
···
     {
         tic_core* core = getMRubyMachine(mrb); tic_mem* tic = (tic_mem*)core;
 
-        #undef memset
         core->api.memset(tic, dest, value, size);
     }
     else

src/api/python.c

···
     if(pkpy_check_error(vm)) 
         return 0;
 
-    #undef memcpy
     core->api.memcpy(tic, dest, src, size);
 
     return 0;
···
     if(pkpy_check_error(vm)) 
         return 0;
 
-    #undef memset
     core->api.memset(tic, dest, value, size);
 
     return 0;

src/api/scheme.c

···
     const s32 source = s7_integer(s7_cadr(args));
     const s32 size = s7_integer(s7_caddr(args));
 
-    #undef memcpy
     core->api.memcpy(tic, dest, source, size);
     return s7_nil(sc);
 }
···
     const s32 value = s7_integer(s7_cadr(args));
     const s32 size = s7_integer(s7_caddr(args));
 
-    #undef memset
     core->api.memset(tic, dest, value, size);
     return s7_nil(sc);
 }

src/api/squirrel.c

···
 
         tic_core* core = getSquirrelCore(vm); tic_mem* tic = (tic_mem*)core;
 
-        #undef memcpy
         core->api.memcpy(tic, dest, src, size);
         return 0;
     }
···
 
         tic_core* core = getSquirrelCore(vm); tic_mem* tic = (tic_mem*)core;
 
-        #undef memset
         core->api.memset(tic, dest, value, size);
         return 0;
     }

src/api/wasm.c

···
 
     tic_core* core = getWasmCore(runtime); tic_mem* tic = (tic_mem*)core;
 
-    #undef memset
     core->api.memset(tic, address, value, length);
 
     m3ApiSuccess();
···
 
     tic_core* core = getWasmCore(runtime); tic_mem* tic = (tic_mem*)core;
 
-    #undef memcpy
     core->api.memcpy(tic, dest, src, length);
 
     m3ApiSuccess();

src/api/wren.c

···
 
     tic_core* core = getWrenCore(vm); tic_mem* tic = (tic_mem*)core;
 
-    #undef memcpy
     core->api.memcpy(tic, dest, src, size);
 }
 
···
 
     tic_core* core = getWrenCore(vm); tic_mem* tic = (tic_mem*)core;
 
-    #undef memset
     core->api.memset(tic, dest, value, size);
 }