Fixes to compile on linux64

SquiLu-ext/sq_axtls.c

@@ -60,7 +60,7 @@ static SQRESULT ssl_constructor(HSQUIRRELVM v, SSL *ssl, int free_on_gc)
 	return SQ_ERROR;
 }
 
-static int sq_ssl_read(HSQUIRRELVM v){
+static SQRESULT sq_ssl_read(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	uint8_t *in_data;
@@ -70,7 +70,7 @@ static int sq_ssl_read(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_write(HSQUIRRELVM v){
+static SQRESULT sq_ssl_write(HSQUIRRELVM v){
     SQ_FUNC_VARS(v);
     GET_ssl_INSTANCE();
     SQ_GET_STRING(v, 2, out_data);
@@ -83,7 +83,7 @@ static int sq_ssl_write(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_get_session_id(HSQUIRRELVM v){
+static SQRESULT sq_ssl_get_session_id(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	const uint8_t * result = ssl_get_session_id(self);
@@ -91,7 +91,7 @@ static int sq_ssl_get_session_id(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_get_session_id_size(HSQUIRRELVM v){
+static SQRESULT sq_ssl_get_session_id_size(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	uint8_t result = ssl_get_session_id_size(self);
@@ -99,7 +99,7 @@ static int sq_ssl_get_session_id_size(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_get_cipher_id(HSQUIRRELVM v){
+static SQRESULT sq_ssl_get_cipher_id(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	uint8_t result = ssl_get_cipher_id(self);
@@ -107,7 +107,7 @@ static int sq_ssl_get_cipher_id(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_handshake_status(HSQUIRRELVM v){
+static SQRESULT sq_ssl_handshake_status(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	int result = ssl_handshake_status(self);
@@ -115,7 +115,7 @@ static int sq_ssl_handshake_status(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_verify_cert(HSQUIRRELVM v){
+static SQRESULT sq_ssl_verify_cert(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	int result = ssl_verify_cert(self);
@@ -123,7 +123,7 @@ static int sq_ssl_verify_cert(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_get_cert_dn(HSQUIRRELVM v){
+static SQRESULT sq_ssl_get_cert_dn(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
     SQ_GET_INTEGER(v, 2, component);
@@ -132,7 +132,7 @@ static int sq_ssl_get_cert_dn(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_get_cert_subject_alt_dnsname(HSQUIRRELVM v){
+static SQRESULT sq_ssl_get_cert_subject_alt_dnsname(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
     SQ_GET_INTEGER(v, 2, dnsindex);
@@ -141,7 +141,7 @@ static int sq_ssl_get_cert_subject_alt_dnsname(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_renegotiate(HSQUIRRELVM v){
+static SQRESULT sq_ssl_renegotiate(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_INSTANCE();
 	int result = ssl_renegotiate(self);
@@ -149,7 +149,7 @@ static int sq_ssl_renegotiate(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_ctx_server_new(HSQUIRRELVM v){
+static SQRESULT sq_ssl_ctx_server_new(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_ctx_INSTANCE();
     SQ_GET_INTEGER(v, 2, client_fd);
@@ -161,7 +161,7 @@ static int sq_ssl_ctx_server_new(HSQUIRRELVM v){
     return rc;
 }
 
-static int sq_ssl_ctx_client_new(HSQUIRRELVM v){
+static SQRESULT sq_ssl_ctx_client_new(HSQUIRRELVM v){
     SQ_FUNC_VARS(v);
     GET_ssl_ctx_INSTANCE();
     SQ_GET_INTEGER(v, 2, client_fd);
@@ -176,7 +176,7 @@ static int sq_ssl_ctx_client_new(HSQUIRRELVM v){
     return rc;
 }
 
-static int sq_ssl_ctx_find(HSQUIRRELVM v){
+static SQRESULT sq_ssl_ctx_find(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_ctx_INSTANCE();
     SQ_GET_INTEGER(v, 2, client_fd);
@@ -186,7 +186,7 @@ static int sq_ssl_ctx_find(HSQUIRRELVM v){
     return 1;
 }
 
-static int sq_ssl_ctx_obj_load(HSQUIRRELVM v){
+static SQRESULT sq_ssl_ctx_obj_load(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_ctx_INSTANCE();
 	SQ_GET_INTEGER(v, 2, obj_type);
@@ -197,7 +197,7 @@ static int sq_ssl_ctx_obj_load(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_ssl_ctx_obj_memory_load(HSQUIRRELVM v){
+static SQRESULT sq_ssl_ctx_obj_memory_load(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     GET_ssl_ctx_INSTANCE();
 	SQ_GET_INTEGER(v, 2, obj_type);
@@ -208,26 +208,26 @@ static int sq_ssl_ctx_obj_memory_load(HSQUIRRELVM v){
 	return 1;
 }
 
-static int sq_axtls_version(HSQUIRRELVM v){
+static SQRESULT sq_axtls_version(HSQUIRRELVM v){
 	sq_pushstring(v,(const char*)ssl_version(), -1);
 	return 1;
 }
 
-static int sq_axtls_get_config(HSQUIRRELVM v){
+static SQRESULT sq_axtls_get_config(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_INTEGER(v, 2, info);
 	sq_pushinteger(v, ssl_get_config(info));
 	return 1;
 }
 
-static int sq_axtls_display_error(HSQUIRRELVM v){
+static SQRESULT sq_axtls_display_error(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_INTEGER(v, 2, error);
 	ssl_display_error(error);
 	return 0;
 }
 
-static int sq_axtls_get_error(HSQUIRRELVM v){
+static SQRESULT sq_axtls_get_error(HSQUIRRELVM v){
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_INTEGER(v, 2, error);
     SQInteger buff_size = 250;

SquiLu-ext/sq_decimal.cpp

@@ -516,7 +516,7 @@ static SQRegFunction Decimal_methods[] =
 
 static const struct {
     const SQChar* name;
-    int value;
+    mpd_uint_t value;
 } ctx_constants[] = {
     /*Precision and Exponents*/
     CTXC(MAX_PREC)

SquiLu-ext/sq_fs.c

@@ -120,7 +120,7 @@ static const SQChar currFileName_key[] = _SC("currFileName");
 /*
 ** This function changes the working (current) directory
 */
-static int sqfs_chdir (HSQUIRRELVM v) {
+static SQRESULT sqfs_chdir (HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, path);
 	if (chdir(path)) {
@@ -137,7 +137,7 @@ static int sqfs_chdir (HSQUIRRELVM v) {
 ** If unable to get the current directory, it returns nil
 **  and a string describing the error
 */
-static int sqfs_currentdir (HSQUIRRELVM v) {
+static SQRESULT sqfs_currentdir (HSQUIRRELVM v) {
   SQChar *path;
   /* Passing (NULL, 0) is not guaranteed to work. Use a temp buffer and size instead. */
   char buf[LFS_MAXPATHLEN];
@@ -215,7 +215,8 @@ static int _file_lock (HSQUIRRELVM v, FILE *fh, const char *mode, const long sta
 typedef struct sqfs_Lock {
   HANDLE fd;
 } lfs_Lock;
-static int sqfs_lock_dir(HSQUIRRELVM v) {
+
+static SQRESULT sqfs_lock_dir(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, path);
   HANDLE fd;
@@ -243,7 +244,7 @@ static int sqfs_lock_dir(HSQUIRRELVM v) {
   lua_setmetatable (L, -2);
   return 1;
 }
-static int sqfs_unlock_dir(HSQUIRRELVM v) {
+static SQRESULT sqfs_unlock_dir(HSQUIRRELVM v) {
   lfs_Lock *lock = luaL_checkudata(L, 1, LOCK_METATABLE);
   CloseHandle(lock->fd);
   return 0;
@@ -252,7 +253,8 @@ static int sqfs_unlock_dir(HSQUIRRELVM v) {
 typedef struct sqfs_Lock {
   char *ln;
 } lfs_Lock;
-static int sqfs_lock_dir(HSQUIRRELVM v) {
+
+static SQRESULT sqfs_lock_dir(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, path);
   lfs_Lock *lock;
@@ -271,7 +273,7 @@ static int sqfs_lock_dir(HSQUIRRELVM v) {
   lua_setmetatable (L, -2);
   return 1;
 }
-static int lfs_unlock_dir(HSQUIRRELVM v) {
+static SQRESULT lfs_unlock_dir(HSQUIRRELVM v) {
   lfs_Lock *lock = luaL_checkudata(L, 1, LOCK_METATABLE);
   if(lock->ln) {
     unlink(lock->ln);
@@ -325,7 +327,7 @@ static int sqfs_setmode(HSQUIRRELVM v) {
 ** @param #3 Number with start position (optional).
 ** @param #4 Number with length (optional).
 */
-static int sqfs_lock (HSQUIRRELVM v) {
+static SQRESULT sqfs_lock (HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     SQ_GET_STRING(v, 3, mode);
     SQ_OPT_INTEGER(v, 4, start, 0);
@@ -346,7 +348,7 @@ static int sqfs_lock (HSQUIRRELVM v) {
 ** @param #2 Number with start position (optional).
 ** @param #3 Number with length (optional).
 */
-static int sqfs_unlock (HSQUIRRELVM v) {
+static SQRESULT sqfs_unlock (HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     SQ_OPT_INTEGER(v, 3, start, 0);
     SQ_OPT_INTEGER(v, 4, len, 0);
@@ -366,7 +368,7 @@ static int sqfs_unlock (HSQUIRRELVM v) {
 ** @param #2 Name of link.
 ** @param #3 True if link is symbolic (optional).
 */
-static int sqfs_link(HSQUIRRELVM v)
+static SQRESULT sqfs_link(HSQUIRRELVM v)
 {
 #ifndef _WIN32
     SQ_FUNC_VARS(v);
@@ -380,7 +382,7 @@ static int sqfs_link(HSQUIRRELVM v)
 #endif
 }
 
-static int sqfs_mkdir (HSQUIRRELVM v) {
+static SQRESULT sqfs_mkdir (HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, path);
 	int fail;
@@ -404,7 +406,7 @@ static int sqfs_mkdir (HSQUIRRELVM v) {
 ** Removes a directory.
 ** @param #1 Directory path.
 */
-static int sqfs_rmdir (HSQUIRRELVM v) {
+static SQRESULT sqfs_rmdir (HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, path);
 	int fail;
@@ -600,7 +602,7 @@ static const SQChar *mode2string (mode_t mode) {
 /*
 ** Set access time and modification values for file
 */
-static int sqfs_touch (HSQUIRRELVM v) {
+static SQRESULT sqfs_touch (HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     SQ_GET_STRING(v, 2, file);
 	struct utimbuf utb, *buf;
@@ -756,7 +758,7 @@ static int _file_info_ (HSQUIRRELVM v, int (*st)(const SQChar*, STAT_STRUCT*)) {
 /*
 ** Get file information using stat.
 */
-static int sqfs_attributes (HSQUIRRELVM v) {
+static SQRESULT sqfs_attributes (HSQUIRRELVM v) {
 	return _file_info_ (v, STAT_FUNC);
 }
 
@@ -765,11 +767,11 @@ static int sqfs_attributes (HSQUIRRELVM v) {
 ** Get symbolic link information using lstat.
 */
 #ifndef _WIN32
-static int sqfs_symlinkattributes (HSQUIRRELVM v) {
+static SQRESULT sqfs_symlinkattributes (HSQUIRRELVM v) {
 	return _file_info_ (v, LSTAT_FUNC);
 }
 #else
-static int sqfs_symlinkattributes (HSQUIRRELVM v) {
+static SQRESULT sqfs_symlinkattributes (HSQUIRRELVM v) {
   sq_pushliteral(v, "symlinkattributes not supported on this platform");
   return 1;
 }

SquiLu-ext/sq_mongoose.cpp

@@ -147,7 +147,8 @@ sq_http_request_read(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS(v);
     GET_http_request_INSTANCE();
-    SQ_OPT_INTEGER(v, 2, n, 1024*2000);
+    SQ_OPT_INTEGER(v, 2, n, 1024*2000);
+    if(n <= 0) return sq_throwerror(v, _SC("invalid size to read (%d)"), n);
     size_t rlen;  /* how much to read */
     size_t nr;  /* number of chars actually read */
     rlen = 8192;  /* try to read that much each time */

SquiLu-ext/sq_socket.cpp

@@ -151,13 +151,13 @@ static int inet_aton(const char *cp, struct in_addr *inp)
 //#define inet_aton(a,b) inet_pton(a,b, AF_INET)
 #endif
 
-static int socket_open(HSQUIRRELVM v)
+static SQRESULT socket_open(HSQUIRRELVM v)
 {
     lua_socket_open();
     return 0;
 }
 
-static int socket_close(HSQUIRRELVM v)
+static SQRESULT socket_close(HSQUIRRELVM v)
 {
     lua_socket_close();
     return 0;
@@ -238,7 +238,7 @@ static int timeout_meth_settimeout(HSQUIRRELVM v, p_timeout tm) {
 /*-------------------------------------------------------------------------*\
 * Returns the time the system has been up, in secconds.
 \*-------------------------------------------------------------------------*/
-static int timeout_lua_gettime(HSQUIRRELVM v)
+static SQRESULT timeout_lua_gettime(HSQUIRRELVM v)
 {
     sq_pushinteger(v, lua_timeout_gettime());
     return 1;
@@ -247,7 +247,7 @@ static int timeout_lua_gettime(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Sleep for n seconds.
 \*-------------------------------------------------------------------------*/
-static int timeout_lua_sleep(HSQUIRRELVM v)
+static SQRESULT timeout_lua_sleep(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_FLOAT(v, 2, n);
@@ -271,7 +271,7 @@ static int timeout_lua_sleep(HSQUIRRELVM v)
 * Sleep for n Milliseconds.
 * Clone of the above for murgaLua.
 \*-------------------------------------------------------------------------*/
-static int timeout_lua_sleepMillisecs(HSQUIRRELVM v)
+static SQRESULT timeout_lua_sleepMillisecs(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_FLOAT(v, 2, n);
@@ -349,7 +349,7 @@ static int inet_gethost(const char *address, struct hostent **hp) {
 * Returns all information provided by the resolver given a host name
 * or ip address
 \*-------------------------------------------------------------------------*/
-static int inet_global_tohostname(HSQUIRRELVM v) {
+static SQRESULT inet_global_tohostname(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, address);
     struct hostent *hp = NULL;
@@ -369,7 +369,7 @@ static int inet_global_tohostname(HSQUIRRELVM v) {
 * Returns all information provided by the resolver given a host name
 * or ip address
 \*-------------------------------------------------------------------------*/
-static int inet_global_toip(HSQUIRRELVM v)
+static SQRESULT inet_global_toip(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     SQ_GET_STRING(v, 2, address);
@@ -390,7 +390,7 @@ static int inet_global_toip(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Gets the host name
 \*-------------------------------------------------------------------------*/
-static int inet_global_gethostname(HSQUIRRELVM v)
+static SQRESULT inet_global_gethostname(HSQUIRRELVM v)
 {
     char name[257];
     name[256] = '\0';
@@ -557,7 +557,7 @@ static int sendraw(p_buffer buf, const char *data, size_t count, size_t *sent);
 /*-------------------------------------------------------------------------*\
 * Initializes module
 \*-------------------------------------------------------------------------*/
-static int buffer_open(HSQUIRRELVM v) {
+static SQRESULT buffer_open(HSQUIRRELVM v) {
     (void) v;
     return 0;
 }
@@ -848,25 +848,25 @@ static t_opt tcp_opt[] = {
     {NULL,          NULL}
 };
 
-static int tcp_meth_send(HSQUIRRELVM v) {
+static SQRESULT tcp_meth_send(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_client_INSTANCE_AT(v, 1);
     return buffer_meth_send(v, &tcp->buf);
 }
 
-static int tcp_meth_receive(HSQUIRRELVM v) {
+static SQRESULT tcp_meth_receive(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_client_INSTANCE_AT(v, 1);
     return buffer_meth_receive(v, &tcp->buf);
 }
 
-static int tcp_meth_getstats(HSQUIRRELVM v) {
+static SQRESULT tcp_meth_getstats(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_client_INSTANCE_AT(v, 1);
     return buffer_meth_getstats(v, &tcp->buf);
 }
 
-static int tcp_meth_setstats(HSQUIRRELVM v) {
+static SQRESULT tcp_meth_setstats(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_client_INSTANCE_AT(v, 1);
     return buffer_meth_setstats(v, &tcp->buf);
@@ -875,7 +875,7 @@ static int tcp_meth_setstats(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Just call option handler
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_setoption(HSQUIRRELVM v)
+static SQRESULT tcp_meth_setoption(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -885,7 +885,7 @@ static int tcp_meth_setoption(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Select support methods
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_getfd(HSQUIRRELVM v)
+static SQRESULT tcp_meth_getfd(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -894,7 +894,7 @@ static int tcp_meth_getfd(HSQUIRRELVM v)
 }
 
 /* this is very dangerous, but can be handy for those that are brave enough */
-static int tcp_meth_setfd(HSQUIRRELVM v)
+static SQRESULT tcp_meth_setfd(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -903,7 +903,7 @@ static int tcp_meth_setfd(HSQUIRRELVM v)
     return 0;
 }
 
-static int tcp_meth_dirty(HSQUIRRELVM v)
+static SQRESULT tcp_meth_dirty(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -945,7 +945,7 @@ static int tcp_constructor_for_socket(HSQUIRRELVM v, int idx, t_socket sock, int
     return 1;
 }
 
-static int tcp_constructor(HSQUIRRELVM v)
+static SQRESULT tcp_constructor(HSQUIRRELVM v)
 {
     t_socket sock;
     const char *err = inet_trycreate(&sock, SOCK_STREAM);
@@ -960,7 +960,7 @@ static int tcp_constructor(HSQUIRRELVM v)
 * Waits for and returns a client object attempting connection to the
 * server object
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_accept(HSQUIRRELVM v)
+static SQRESULT tcp_meth_accept(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_server_INSTANCE_AT(v, 1);
@@ -987,7 +987,7 @@ static int tcp_meth_accept(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Binds an object to an address
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_bind(HSQUIRRELVM v)
+static SQRESULT tcp_meth_bind(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_master_INSTANCE_AT(v, 1);
@@ -1001,7 +1001,7 @@ static int tcp_meth_bind(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Turns a master tcp object into a client object.
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_connect(HSQUIRRELVM v)
+static SQRESULT tcp_meth_connect(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -1018,7 +1018,7 @@ static int tcp_meth_connect(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Closes socket used by object
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_close(HSQUIRRELVM v)
+static SQRESULT tcp_meth_close(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -1029,7 +1029,7 @@ static int tcp_meth_close(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Puts the sockt in listen mode
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_listen(HSQUIRRELVM v)
+static SQRESULT tcp_meth_listen(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS(v);
     GET_tcp_master_INSTANCE_AT(v, 1);
@@ -1044,7 +1044,7 @@ static int tcp_meth_listen(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Shuts the connection down partially
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_shutdown(HSQUIRRELVM v)
+static SQRESULT tcp_meth_shutdown(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS(v);
     GET_tcp_client_INSTANCE_AT(v, 1);
@@ -1071,14 +1071,14 @@ error:
 /*-------------------------------------------------------------------------*\
 * Just call inet methods
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_getpeername(HSQUIRRELVM v)
+static SQRESULT tcp_meth_getpeername(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
     return inet_meth_getpeername(v, &tcp->sock);
 }
 
-static int tcp_meth_getsockname(HSQUIRRELVM v)
+static SQRESULT tcp_meth_getsockname(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -1088,7 +1088,7 @@ static int tcp_meth_getsockname(HSQUIRRELVM v)
 /*-------------------------------------------------------------------------*\
 * Just call tm methods
 \*-------------------------------------------------------------------------*/
-static int tcp_meth_settimeout(HSQUIRRELVM v)
+static SQRESULT tcp_meth_settimeout(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_tcp_INSTANCE_AT(v, 1);
@@ -1147,7 +1147,7 @@ static const char *udp_strerror(int err) {
 /*-------------------------------------------------------------------------*\
 * Send data through connected udp socket
 \*-------------------------------------------------------------------------*/
-static int udp_meth_send(HSQUIRRELVM v) {
+static SQRESULT udp_meth_send(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_connected_INSTANCE_AT(v, 1);
     p_timeout tm = &udp->tm;
@@ -1164,7 +1164,7 @@ static int udp_meth_send(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Send data through unconnected udp socket
 \*-------------------------------------------------------------------------*/
-static int udp_meth_sendto(HSQUIRRELVM v) {
+static SQRESULT udp_meth_sendto(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_unconnected_INSTANCE_AT(v, 1);
     size_t sent = 0;
@@ -1190,11 +1190,12 @@ static int udp_meth_sendto(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Receives data from a UDP socket
 \*-------------------------------------------------------------------------*/
-static int udp_meth_receive(HSQUIRRELVM v) {
+static SQRESULT udp_meth_receive(HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     GET_udp_INSTANCE_AT(v, 1);
     char buffer[UDP_DATAGRAMSIZE];
     SQ_OPT_INTEGER(v, 2, count, sizeof(buffer));
+    if(count <= 0) return sq_throwerror(v, _SC("invalid size for receive (%d)"), count);
     size_t got;
     int err;
     p_timeout tm = &udp->tm;
@@ -1209,7 +1210,7 @@ static int udp_meth_receive(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Receives data and sender from a UDP socket
 \*-------------------------------------------------------------------------*/
-static int udp_meth_receivefrom(HSQUIRRELVM v) {
+static SQRESULT udp_meth_receivefrom(HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     GET_udp_unconnected_INSTANCE_AT(v, 1);
     struct sockaddr_in addr;
@@ -1217,6 +1218,7 @@ static int udp_meth_receivefrom(HSQUIRRELVM v) {
     char buffer[UDP_DATAGRAMSIZE];
     size_t got;
     SQ_OPT_INTEGER(v, 2, count, sizeof(buffer));
+    if(count <= 0) return sq_throwerror(v, _SC("invalid size for receive (%d)"), count);
     int err;
     p_timeout tm = &udp->tm;
     lua_timeout_markstart(tm);
@@ -1242,7 +1244,7 @@ static int udp_meth_receivefrom(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Select support methods
 \*-------------------------------------------------------------------------*/
-static int udp_meth_getfd(HSQUIRRELVM v) {
+static SQRESULT udp_meth_getfd(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     sq_pushinteger(v, (SQInteger) udp->sock);
@@ -1250,7 +1252,7 @@ static int udp_meth_getfd(HSQUIRRELVM v) {
 }
 
 /* this is very dangerous, but can be handy for those that are brave enough */
-static int udp_meth_setfd(HSQUIRRELVM v) {
+static SQRESULT udp_meth_setfd(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     SQ_GET_INTEGER(v, 2, fd);
@@ -1258,7 +1260,7 @@ static int udp_meth_setfd(HSQUIRRELVM v) {
     return 0;
 }
 
-static int udp_meth_dirty(HSQUIRRELVM v) {
+static SQRESULT udp_meth_dirty(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     (void) udp;
@@ -1269,13 +1271,13 @@ static int udp_meth_dirty(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Just call inet methods
 \*-------------------------------------------------------------------------*/
-static int udp_meth_getpeername(HSQUIRRELVM v) {
+static SQRESULT udp_meth_getpeername(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_connected_INSTANCE_AT(v, 1);
     return inet_meth_getpeername(v, &udp->sock);
 }
 
-static int udp_meth_getsockname(HSQUIRRELVM v) {
+static SQRESULT udp_meth_getsockname(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     return inet_meth_getsockname(v, &udp->sock);
@@ -1284,7 +1286,7 @@ static int udp_meth_getsockname(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Just call option handler
 \*-------------------------------------------------------------------------*/
-static int udp_meth_setoption(HSQUIRRELVM v) {
+static SQRESULT udp_meth_setoption(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     return opt_meth_setoption(v, udp_opt, &udp->sock);
@@ -1293,7 +1295,7 @@ static int udp_meth_setoption(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Just call tm methods
 \*-------------------------------------------------------------------------*/
-static int udp_meth_settimeout(HSQUIRRELVM v) {
+static SQRESULT udp_meth_settimeout(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     return timeout_meth_settimeout(v, &udp->tm);
@@ -1302,7 +1304,7 @@ static int udp_meth_settimeout(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Turns a master udp object into a client object.
 \*-------------------------------------------------------------------------*/
-static int udp_meth_setpeername(HSQUIRRELVM v) {
+static SQRESULT udp_meth_setpeername(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     p_timeout tm = &udp->tm;
@@ -1322,7 +1324,7 @@ static int udp_meth_setpeername(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Closes socket used by object
 \*-------------------------------------------------------------------------*/
-static int udp_meth_close(HSQUIRRELVM v) {
+static SQRESULT udp_meth_close(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_INSTANCE_AT(v, 1);
     lua_socket_destroy(&udp->sock);
@@ -1332,7 +1334,7 @@ static int udp_meth_close(HSQUIRRELVM v) {
 /*-------------------------------------------------------------------------*\
 * Turns a master object into a server object
 \*-------------------------------------------------------------------------*/
-static int udp_meth_setsockname(HSQUIRRELVM v) {
+static SQRESULT udp_meth_setsockname(HSQUIRRELVM v) {
     SQ_FUNC_VARS_NO_TOP(v);
     GET_udp_unconnected_INSTANCE_AT(v, 1);
     SQ_GET_STRING(v, 2, address);
@@ -1359,7 +1361,7 @@ static SQRESULT udp_releasehook(SQUserPointer p, SQInteger size, HSQUIRRELVM v)
 }
 
 
-static int udp_constructor(HSQUIRRELVM v) {
+static SQRESULT udp_constructor(HSQUIRRELVM v) {
     t_socket sock;
     const char *err = inet_trycreate(&sock, SOCK_DGRAM);
     /* try to allocate a system socket */
@@ -1382,19 +1384,18 @@ static int udp_constructor(HSQUIRRELVM v) {
 * Internal Select function prototypes.
 \*=========================================================================*/
 static t_socket getfd(HSQUIRRELVM v);
-static int dirty(HSQUIRRELVM v);
+static SQRESULT dirty(HSQUIRRELVM v);
 static t_socket collect_fd(HSQUIRRELVM v, int tab, t_socket max_fd,
         int itab, fd_set *set);
 static int check_dirty(HSQUIRRELVM v, int tab, int dtab, fd_set *set);
 static void return_fd(HSQUIRRELVM v, fd_set *set, t_socket max_fd,
         int itab, int tab, int start);
 static void make_assoc(HSQUIRRELVM v, int tab);
-static int global_select(HSQUIRRELVM v);
 
 /*-------------------------------------------------------------------------*\
 * Waits for a set of sockets until a condition is met or timeout.
 \*-------------------------------------------------------------------------*/
-static int global_select(HSQUIRRELVM v) {
+static SQRESULT global_select(HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     int rtab, wtab, itab, ret, ndirty;
     t_socket max_fd;
@@ -1454,7 +1455,7 @@ static t_socket getfd(HSQUIRRELVM v) {
     return fd;
 }
 
-static int dirty(HSQUIRRELVM v) {
+static SQRESULT dirty(HSQUIRRELVM v) {
     int is = 0;
     SQInteger top = sq_gettop(v);
     sq_pushliteral(v, _SC("dirty"));

SquiLu-ext/sq_sqlite3.cpp

@@ -445,7 +445,7 @@ static SQRESULT sq_sqlite3_stmt_col_count(HSQUIRRELVM v){
 }
 
 static SQRESULT sq_sqlite3_stmt_colsAsArray(HSQUIRRELVM v){
-	SQ_FUNC_VARS(v);
+	SQ_FUNC_VARS_NO_TOP(v);
 	GET_sqlite3_stmt_INSTANCE();
 	int col_count = sqlite3_column_count(self);
 	sq_newarray(v, col_count);
@@ -1268,7 +1268,7 @@ static SQRESULT sq_sqlite3_last_row_id(HSQUIRRELVM v){
 /* stmt * prepare( const char * sql  ) */
 static SQRESULT sq_sqlite3_prepare(HSQUIRRELVM v){
 	SQ_FUNC_VARS_NO_TOP(v);
-	GET_sqlite3_INSTANCE();
+	//GET_sqlite3_INSTANCE();
 	SQ_GET_STRING(v, 2, sql);
 	sq_pushstring(v, SQLite3_Stmt_TAG, -1);
 	if(sq_getonroottable(v) == SQ_ERROR) return SQ_ERROR;
@@ -1282,7 +1282,7 @@ static SQRESULT sq_sqlite3_prepare(HSQUIRRELVM v){
 /* void set_busy_timeout( int nMillisecs  ) */
 static SQRESULT sq_sqlite3_set_busy_timeout(HSQUIRRELVM v){
 	SQ_FUNC_VARS_NO_TOP(v);
-	GET_sqlite3_INSTANCE();
+	//GET_sqlite3_INSTANCE();
 	SQ_GET_INTEGER(v, 2, nMillisecs);
 	//self->set_busy_timeout(nMillisecs);
 	return 0;
@@ -1391,7 +1391,7 @@ static SQRESULT sq_sqlite3_rekey(HSQUIRRELVM v) {
 ** returns: 0 to return immediatly and return SQLITE_ABORT, non-zero to continue
 */
 static int db_progress_callback(void *user) {
-    int result = 1; /* abort by default */
+    SQInteger result = 1; /* abort by default */
     sq_sqlite3_sdb *sdb = (sq_sqlite3_sdb*)user;
     HSQUIRRELVM v = sdb->v;
     int top = sq_gettop(v);

SquiLu-ext/sq_zlib.cpp

@@ -9,7 +9,7 @@ SQ_OPT_STRING_STRLEN();
 
 #define LZ_BUFFER_SIZE 8192
 
-static int sq_check_result(HSQUIRRELVM v, int result, const z_stream* stream) {
+static SQRESULT sq_check_result(HSQUIRRELVM v, int result, const z_stream* stream) {
     /* Both of these are "normal" return codes: */
     if ( result == Z_OK || result == Z_STREAM_END ) return SQ_OK;
     switch ( result ) {
@@ -142,7 +142,7 @@ static SQRESULT sq_zlib_inflate(HSQUIRRELVM v)
     return 1;
 }
 
-static int sq_zlib_version(HSQUIRRELVM v)
+static SQRESULT sq_zlib_version(HSQUIRRELVM v)
 {
     sq_pushstring(v, zlibVersion(), -1);
     return 1;

SquiLu/sq/sq.c

@@ -435,6 +435,7 @@ static char *chngChar (char *str, char oldChar, char newChar) {
 
 static SQInteger LoadFrozenScript(HSQUIRRELVM v, const SQChar* filename, int only_check)
 {
+#ifndef SQUILU_ALONE
     SQInteger retval;
     // lots of debugging to make sure that everything is ok
     //printf("%s\n", filename);
@@ -502,7 +503,7 @@ static SQInteger LoadFrozenScript(HSQUIRRELVM v, const SQChar* filename, int onl
             return _ERROR;
         }
     }
-
+#endif //SQUILU_ALONE
     return 0;
 }
 
@@ -553,11 +554,10 @@ int main(int argc, char* argv[])
 	sqstd_register_stringlib(v);
 
 #ifdef WITH_DAD_EXTRAS
+#ifndef SQUILU_ALONE
 	sqext_register_base64(v);
 	sqext_register_Sq_Fpdf(v);
 	sqext_register_SQLite3(v);
-	sqext_register_PostgreSQL(v);
-	//sqext_register_dad_utils(v);
 	sqext_register_mix(v);
 	sqext_register_sqfs(v);
 	sqext_register_sq_socket(v);
@@ -568,18 +568,23 @@ int main(int argc, char* argv[])
 	sqext_register_tinyxml2(v);
 	sqext_register_decimal(v);
 	sqext_register_markdown(v);
-	sqext_register_csv_parser(v);
 
 	sqext_register_sq_slave_vm(v);
 	//sqext_register_ThreadObjects(v);
 
+#ifdef WITH_FULL_DAD_EXTRAS
+	sqext_register_csv_parser(v);
+	sqext_register_PostgreSQL(v);
+	//sqext_register_dad_utils(v);
 	sqext_register_sq_zmq3(v);
 	//sqext_register_Java(v);
+#endif
 
 	sqext_register_rs232(v);
 #ifdef WITH_FLTK
 	sqext_register_fltklib(v);
-#endif
+#endif
+#endif //SQUILU_ALONE
 #endif
 	//aux library
 	//sets error handlers

SquiLu/sqstdlib/sqstdmath.cpp

@@ -34,7 +34,7 @@ static SQRESULT math_rand(HSQUIRRELVM v)
 	return 1;
 }
 
-static int math_random(HSQUIRRELVM v) {
+static SQRESULT math_random(HSQUIRRELVM v) {
   SQ_FUNC_VARS(v);
   /* the `%' avoids the (rare) case of r==1, and is needed also because on
      some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
@@ -181,7 +181,7 @@ static SQRESULT math_number_format(HSQUIRRELVM v) {
 	char *s, *t;  /* source, target */
 	char *dp;
 	int integral;
-	int tmplen, reslen=0;
+	size_t tmplen, reslen=0;
 	int count=0;
 	int is_negative=0;
 	int trim_right_zeros=0;
@@ -196,7 +196,8 @@ static SQRESULT math_number_format(HSQUIRRELVM v) {
 		dec = -dec;
 	}
 
-	tmplen = scsnprintf(tmpbuf, sizeof(tmpbuf), "%.*f", dec, d);
+    int idec = dec; //on 64 bits there is a warning here about SQInteger/int
+	tmplen = scsnprintf(tmpbuf, sizeof(tmpbuf), "%.*f", idec, d);
 
 	resbuf[0] = '\0';
 

SquiLu/sqstdlib/sqstdstring.cpp

@@ -6,6 +6,7 @@
 #include <stdio.h>
 #include <ctype.h>
 #include <assert.h>
+#include <stddef.h>
 
 #define MAX_FORMAT_LEN	20
 #define MAX_WFORMAT_LEN	3
@@ -117,7 +118,7 @@ SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen
                       dest = sq_getscratchpad(v,allocated);
                       size = sq_getsize(v,nparam);
 
-                      ts2 = &dest[(int)ts2]; //use saved i position saved on pointer as integer
+                      ts2 = &dest[(ptrdiff_t)ts2]; //use saved i position saved on pointer as integer
                       *ts2++ = '"';
                       while (size--) {
                         if (*ts == '\r' && *(ts+1) == '\n' ) {

SquiLu/squirrel/sqbaselib.cpp

@@ -1100,7 +1100,8 @@ STRING_TOFUNCZ(toupper)
 //DAD start
 #include "lua-regex.h"
 
-static SQRESULT process_string_gsub(LuaMatchState *ms, void *udata, char_buffer_st **b) {
+//on 64 bits there is an error SQRESULT/int
+static int process_string_gsub(LuaMatchState *ms, void *udata, char_buffer_st **b) {
     const char *str;
     SQInteger str_size;
     HSQUIRRELVM v = (HSQUIRRELVM)udata;
@@ -1233,7 +1234,8 @@ static SQRESULT process_string_gmatch_find(LuaMatchState *ms, void *udata, char_
     return result; //returning non zero means continue
 }
 
-static SQRESULT process_string_gmatch(LuaMatchState *ms, void *udata, char_buffer_st **b) {
+//on 64 bits there is an error SQRESULT/int
+static int process_string_gmatch(LuaMatchState *ms, void *udata, char_buffer_st **b) {
     return process_string_gmatch_find(ms, udata, b, false);
 }