retronetworking
/
freeswitch
13
0
Fork 0
Code Pull Requests Releases Activity
freeswitch/libs/libblade/src/unqlite.c

60240 lines
1.8 MiB
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#ifndef _WIN32
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2016, Symisc Systems http://unqlite.org/
* Copyright (C) 2014, Yuras Shumovich <shumovichy@gmail.com>
* Version 1.1.7
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/*
* Copyright (C) 2012, 2016 Symisc Systems, S.U.A.R.L [M.I.A.G Mrad Chems Eddine <chm@symisc.net>].
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SYMISC SYSTEMS ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL SYMISC SYSTEMS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* $SymiscID: unqlite.c v1.1.7 Win10 2106-12-02 00:04:12 stable <chm@symisc.net> $
*/
/* This file is an amalgamation of many separate C source files from unqlite version 1.1.6
* By combining all the individual C code files into this single large file, the entire code
* can be compiled as a single translation unit. This allows many compilers to do optimization's
* that would not be possible if the files were compiled separately. Performance improvements
* are commonly seen when unqlite is compiled as a single translation unit.
*
* This file is all you need to compile unqlite. To use unqlite in other programs, you need
* this file and the "unqlite.h" header file that defines the programming interface to the
* unqlite engine.(If you do not have the "unqlite.h" header file at hand, you will find
* a copy embedded within the text of this file.Search for "Header file: <unqlite.h>" to find
* the start of the embedded unqlite.h header file.) Additional code files may be needed if
* you want a wrapper to interface unqlite with your choice of programming language.
* To get the official documentation, please visit http://unqlite.org/
*/
/*
* Make the sure the following directive is defined in the amalgamation build.
*/
#ifndef UNQLITE_AMALGAMATION
#define UNQLITE_AMALGAMATION
#define JX9_AMALGAMATION
/* Marker for routines not intended for external use */
#define JX9_PRIVATE static
#endif /* UNQLITE_AMALGAMATION */
/*
* Embedded header file for unqlite: <unqlite.h>
*/
/*
* ----------------------------------------------------------
* File: unqlite.h
* MD5: d26e9847c6587edbbb183d0115d172cb
* ----------------------------------------------------------
*/
/* This file was automatically generated. Do not edit (Except for compile time directives)! */
#ifndef _UNQLITE_H_
#define _UNQLITE_H_
/*
* Symisc UnQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2016, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/*
* Copyright (C) 2012, 2016 Symisc Systems, S.U.A.R.L [M.I.A.G Mrad Chems Eddine <chm@symisc.net>].
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SYMISC SYSTEMS ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL SYMISC SYSTEMS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* $SymiscID: unqlite.h v1.2 Win10 2106-12-02 00:04:12 stable <chm@symisc.net> $ */
#include <stdarg.h> /* needed for the definition of va_list */
/*
* Compile time engine version, signature, identification in the symisc source tree
* and copyright notice.
* Each macro have an equivalent C interface associated with it that provide the same
* information but are associated with the library instead of the header file.
* Refer to [unqlite_lib_version()], [unqlite_lib_signature()], [unqlite_lib_ident()] and
* [unqlite_lib_copyright()] for more information.
*/
/*
* The UNQLITE_VERSION C preprocessor macroevaluates to a string literal
* that is the unqlite version in the format "X.Y.Z" where X is the major
* version number and Y is the minor version number and Z is the release
* number.
*/
#define UNQLITE_VERSION "1.1.7"
/*
* The UNQLITE_VERSION_NUMBER C preprocessor macro resolves to an integer
* with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
* numbers used in [UNQLITE_VERSION].
*/
#define UNQLITE_VERSION_NUMBER 1001007
/*
* The UNQLITE_SIG C preprocessor macro evaluates to a string
* literal which is the public signature of the unqlite engine.
* This signature could be included for example in a host-application
* generated Server MIME header as follows:
* Server: YourWebServer/x.x unqlite/x.x.x \r\n
*/
#define UNQLITE_SIG "unqlite/1.1.7"
/*
* UnQLite identification in the Symisc source tree:
* Each particular check-in of a particular software released
* by symisc systems have an unique identifier associated with it.
* This macro hold the one associated with unqlite.
*/
#define UNQLITE_IDENT "unqlite:b172a1e2c3f62fb35c8e1fb2795121f82356cad6"
/*
* Copyright notice.
* If you have any questions about the licensing situation, please
* visit http://unqlite.org/licensing.html
* or contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
*/
#define UNQLITE_COPYRIGHT "Copyright (C) Symisc Systems, S.U.A.R.L [Mrad Chems Eddine <chm@symisc.net>] 2012-2016, http://unqlite.org/"
/* Make sure we can call this stuff from C++ */
#ifdef __cplusplus
extern "C" {
#endif
/* Forward declaration to public objects */
typedef struct unqlite_io_methods unqlite_io_methods;
typedef struct unqlite_kv_methods unqlite_kv_methods;
typedef struct unqlite_kv_engine unqlite_kv_engine;
typedef struct jx9_io_stream unqlite_io_stream;
typedef struct jx9_context unqlite_context;
typedef struct jx9_value unqlite_value;
typedef struct unqlite_vfs unqlite_vfs;
typedef struct unqlite_vm unqlite_vm;
typedef struct unqlite unqlite;
/*
* ------------------------------
* Compile time directives
* ------------------------------
* For most purposes, UnQLite can be built just fine using the default compilation options.
* However, if required, the compile-time options documented below can be used to omit UnQLite
* features (resulting in a smaller compiled library size) or to change the default values
* of some parameters.
* Every effort has been made to ensure that the various combinations of compilation options
* work harmoniously and produce a working library.
*
* UNQLITE_ENABLE_THREADS
* This option controls whether or not code is included in UnQLite to enable it to operate
* safely in a multithreaded environment. The default is not. All mutexing code is omitted
* and it is unsafe to use UnQLite in a multithreaded program. When compiled with the
* UNQLITE_ENABLE_THREADS directive enabled, UnQLite can be used in a multithreaded program
* and it is safe to share the same virtual machine and engine handle between two or more threads.
* The value of UNQLITE_ENABLE_THREADS can be determined at run-time using the unqlite_lib_is_threadsafe()
* interface.
* When UnQLite has been compiled with threading support then the threading mode can be altered
* at run-time using the unqlite_lib_config() interface together with one of these verbs:
* UNQLITE_LIB_CONFIG_THREAD_LEVEL_SINGLE
* UNQLITE_LIB_CONFIG_THREAD_LEVEL_MULTI
* Platforms others than Windows and UNIX systems must install their own mutex subsystem via
* unqlite_lib_config() with a configuration verb set to UNQLITE_LIB_CONFIG_USER_MUTEX.
* Otherwise the library is not threadsafe.
* Note that you must link UnQLite with the POSIX threads library under UNIX systems (i.e: -lpthread).
*
* Options To Omit/Enable Features
*
* The following options can be used to reduce the size of the compiled library by omitting optional
* features. This is probably only useful in embedded systems where space is especially tight, as even
* with all features included the UnQLite library is relatively small. Don't forget to tell your
* compiler to optimize for binary size! (the -Os option if using GCC). Telling your compiler
* to optimize for size usually has a much larger impact on library footprint than employing
* any of these compile-time options.
*
* JX9_DISABLE_BUILTIN_FUNC
* Jx9 is shipped with more than 312 built-in functions suitable for most purposes like
* string and INI processing, ZIP extracting, Base64 encoding/decoding, JSON encoding/decoding
* and so forth.
* If this directive is enabled, then all built-in Jx9 functions are omitted from the build.
* Note that special functions such as db_create(), db_store(), db_fetch(), etc. are not omitted
* from the build and are not affected by this directive.
*
* JX9_ENABLE_MATH_FUNC
* If this directive is enabled, built-in math functions such as sqrt(), abs(), log(), ceil(), etc.
* are included in the build. Note that you may need to link UnQLite with the math library in same
* Linux/BSD flavor (i.e: -lm).
*
* JX9_DISABLE_DISK_IO
* If this directive is enabled, built-in VFS functions such as chdir(), mkdir(), chroot(), unlink(),
* sleep(), etc. are omitted from the build.
*
* UNQLITE_ENABLE_JX9_HASH_IO
* If this directive is enabled, built-in hash functions such as md5(), sha1(), md5_file(), crc32(), etc.
* are included in the build.
*/
/* Symisc public definitions */
#if !defined(SYMISC_STANDARD_DEFS)
#define SYMISC_STANDARD_DEFS
#if defined (_WIN32) || defined (WIN32) || defined(__MINGW32__) || defined (_MSC_VER) || defined (_WIN32_WCE)
/* Windows Systems */
#if !defined(__WINNT__)
#define __WINNT__
#endif
/*
* Determine if we are dealing with WindowsCE - which has a much
* reduced API.
*/
#if defined(_WIN32_WCE)
#ifndef __WIN_CE__
#define __WIN_CE__
#endif /* __WIN_CE__ */
#endif /* _WIN32_WCE */
#else
/*
* By default we will assume that we are compiling on a UNIX systems.
* Otherwise the OS_OTHER directive must be defined.
*/
#if !defined(OS_OTHER)
#if !defined(__UNIXES__)
#define __UNIXES__
#endif /* __UNIXES__ */
#else
#endif /* OS_OTHER */
#endif /* __WINNT__/__UNIXES__ */
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef signed __int64 sxi64; /* 64 bits(8 bytes) signed int64 */
typedef unsigned __int64 sxu64; /* 64 bits(8 bytes) unsigned int64 */
#else
typedef signed long long int sxi64; /* 64 bits(8 bytes) signed int64 */
typedef unsigned long long int sxu64; /* 64 bits(8 bytes) unsigned int64 */
#endif /* _MSC_VER */
/* Signature of the consumer routine */
typedef int (*ProcConsumer)(const void *, unsigned int, void *);
/* Forward reference */
typedef struct SyMutexMethods SyMutexMethods;
typedef struct SyMemMethods SyMemMethods;
typedef struct SyString SyString;
typedef struct syiovec syiovec;
typedef struct SyMutex SyMutex;
typedef struct Sytm Sytm;
/* Scatter and gather array. */
struct syiovec
{
#if defined (__WINNT__)
/* Same fields type and offset as WSABUF structure defined one winsock2 header */
unsigned long nLen;
char *pBase;
#else
void *pBase;
unsigned long nLen;
#endif
};
struct SyString
{
const char *zString; /* Raw string (may not be null terminated) */
unsigned int nByte; /* Raw string length */
};
/* Time structure. */
struct Sytm
{
int tm_sec; /* seconds (0 - 60) */
int tm_min; /* minutes (0 - 59) */
int tm_hour; /* hours (0 - 23) */
int tm_mday; /* day of month (1 - 31) */
int tm_mon; /* month of year (0 - 11) */
int tm_year; /* year + 1900 */
int tm_wday; /* day of week (Sunday = 0) */
int tm_yday; /* day of year (0 - 365) */
int tm_isdst; /* is summer time in effect? */
char *tm_zone; /* abbreviation of timezone name */
long tm_gmtoff; /* offset from UTC in seconds */
};
/* Convert a tm structure (struct tm *) found in <time.h> to a Sytm structure */
#define STRUCT_TM_TO_SYTM(pTM, pSYTM) \
(pSYTM)->tm_hour = (pTM)->tm_hour;\
(pSYTM)->tm_min = (pTM)->tm_min;\
(pSYTM)->tm_sec = (pTM)->tm_sec;\
(pSYTM)->tm_mon = (pTM)->tm_mon;\
(pSYTM)->tm_mday = (pTM)->tm_mday;\
(pSYTM)->tm_year = (pTM)->tm_year + 1900;\
(pSYTM)->tm_yday = (pTM)->tm_yday;\
(pSYTM)->tm_wday = (pTM)->tm_wday;\
(pSYTM)->tm_isdst = (pTM)->tm_isdst;\
(pSYTM)->tm_gmtoff = 0;\
(pSYTM)->tm_zone = 0;
/* Convert a SYSTEMTIME structure (LPSYSTEMTIME: Windows Systems only ) to a Sytm structure */
#define SYSTEMTIME_TO_SYTM(pSYSTIME, pSYTM) \
(pSYTM)->tm_hour = (pSYSTIME)->wHour;\
(pSYTM)->tm_min = (pSYSTIME)->wMinute;\
(pSYTM)->tm_sec = (pSYSTIME)->wSecond;\
(pSYTM)->tm_mon = (pSYSTIME)->wMonth - 1;\
(pSYTM)->tm_mday = (pSYSTIME)->wDay;\
(pSYTM)->tm_year = (pSYSTIME)->wYear;\
(pSYTM)->tm_yday = 0;\
(pSYTM)->tm_wday = (pSYSTIME)->wDayOfWeek;\
(pSYTM)->tm_gmtoff = 0;\
(pSYTM)->tm_isdst = -1;\
(pSYTM)->tm_zone = 0;
/* Dynamic memory allocation methods. */
struct SyMemMethods
{
void * (*xAlloc)(unsigned int); /* [Required:] Allocate a memory chunk */
void * (*xRealloc)(void *, unsigned int); /* [Required:] Re-allocate a memory chunk */
void (*xFree)(void *); /* [Required:] Release a memory chunk */
unsigned int (*xChunkSize)(void *); /* [Optional:] Return chunk size */
int (*xInit)(void *); /* [Optional:] Initialization callback */
void (*xRelease)(void *); /* [Optional:] Release callback */
void *pUserData; /* [Optional:] First argument to xInit() and xRelease() */
};
/* Out of memory callback signature. */
typedef int (*ProcMemError)(void *);
/* Mutex methods. */
struct SyMutexMethods
{
int (*xGlobalInit)(void); /* [Optional:] Global mutex initialization */
void (*xGlobalRelease)(void); /* [Optional:] Global Release callback () */
SyMutex * (*xNew)(int); /* [Required:] Request a new mutex */
void (*xRelease)(SyMutex *); /* [Optional:] Release a mutex */
void (*xEnter)(SyMutex *); /* [Required:] Enter mutex */
int (*xTryEnter)(SyMutex *); /* [Optional:] Try to enter a mutex */
void (*xLeave)(SyMutex *); /* [Required:] Leave a locked mutex */
};
#if defined (_MSC_VER) || defined (__MINGW32__) || defined (__GNUC__) && defined (__declspec)
#define SX_APIIMPORT __declspec(dllimport)
#define SX_APIEXPORT __declspec(dllexport)
#else
#define SX_APIIMPORT
#define SX_APIEXPORT
#endif
/* Standard return values from Symisc public interfaces */
#define SXRET_OK 0 /* Not an error */
#define SXERR_MEM (-1) /* Out of memory */
#define SXERR_IO (-2) /* IO error */
#define SXERR_EMPTY (-3) /* Empty field */
#define SXERR_LOCKED (-4) /* Locked operation */
#define SXERR_ORANGE (-5) /* Out of range value */
#define SXERR_NOTFOUND (-6) /* Item not found */
#define SXERR_LIMIT (-7) /* Limit reached */
#define SXERR_MORE (-8) /* Need more input */
#define SXERR_INVALID (-9) /* Invalid parameter */
#define SXERR_ABORT (-10) /* User callback request an operation abort */
#define SXERR_EXISTS (-11) /* Item exists */
#define SXERR_SYNTAX (-12) /* Syntax error */
#define SXERR_UNKNOWN (-13) /* Unknown error */
#define SXERR_BUSY (-14) /* Busy operation */
#define SXERR_OVERFLOW (-15) /* Stack or buffer overflow */
#define SXERR_WILLBLOCK (-16) /* Operation will block */
#define SXERR_NOTIMPLEMENTED (-17) /* Operation not implemented */
#define SXERR_EOF (-18) /* End of input */
#define SXERR_PERM (-19) /* Permission error */
#define SXERR_NOOP (-20) /* No-op */
#define SXERR_FORMAT (-21) /* Invalid format */
#define SXERR_NEXT (-22) /* Not an error */
#define SXERR_OS (-23) /* System call return an error */
#define SXERR_CORRUPT (-24) /* Corrupted pointer */
#define SXERR_CONTINUE (-25) /* Not an error: Operation in progress */
#define SXERR_NOMATCH (-26) /* No match */
#define SXERR_RESET (-27) /* Operation reset */
#define SXERR_DONE (-28) /* Not an error */
#define SXERR_SHORT (-29) /* Buffer too short */
#define SXERR_PATH (-30) /* Path error */
#define SXERR_TIMEOUT (-31) /* Timeout */
#define SXERR_BIG (-32) /* Too big for processing */
#define SXERR_RETRY (-33) /* Retry your call */
#define SXERR_IGNORE (-63) /* Ignore */
#endif /* SYMISC_PUBLIC_DEFS */
/*
* Marker for exported interfaces.
*/
#define UNQLITE_APIEXPORT SX_APIEXPORT
/*
* If compiling for a processor that lacks floating point
* support, substitute integer for floating-point.
*/
#ifdef UNQLITE_OMIT_FLOATING_POINT
typedef sxi64 uqlite_real;
#else
typedef double unqlite_real;
#endif
typedef sxi64 unqlite_int64;
/* Standard UnQLite return values */
#define UNQLITE_OK SXRET_OK /* Successful result */
/* Beginning of error codes */
#define UNQLITE_NOMEM SXERR_MEM /* Out of memory */
#define UNQLITE_ABORT SXERR_ABORT /* Another thread have released this instance */
#define UNQLITE_IOERR SXERR_IO /* IO error */
#define UNQLITE_CORRUPT SXERR_CORRUPT /* Corrupt pointer */
#define UNQLITE_LOCKED SXERR_LOCKED /* Forbidden Operation */
#define UNQLITE_BUSY SXERR_BUSY /* The database file is locked */
#define UNQLITE_DONE SXERR_DONE /* Operation done */
#define UNQLITE_PERM SXERR_PERM /* Permission error */
#define UNQLITE_NOTIMPLEMENTED SXERR_NOTIMPLEMENTED /* Method not implemented by the underlying Key/Value storage engine */
#define UNQLITE_NOTFOUND SXERR_NOTFOUND /* No such record */
#define UNQLITE_NOOP SXERR_NOOP /* No such method */
#define UNQLITE_INVALID SXERR_INVALID /* Invalid parameter */
#define UNQLITE_EOF SXERR_EOF /* End Of Input */
#define UNQLITE_UNKNOWN SXERR_UNKNOWN /* Unknown configuration option */
#define UNQLITE_LIMIT SXERR_LIMIT /* Database limit reached */
#define UNQLITE_EXISTS SXERR_EXISTS /* Record exists */
#define UNQLITE_EMPTY SXERR_EMPTY /* Empty record */
#define UNQLITE_COMPILE_ERR (-70) /* Compilation error */
#define UNQLITE_VM_ERR (-71) /* Virtual machine error */
#define UNQLITE_FULL (-73) /* Full database (unlikely) */
#define UNQLITE_CANTOPEN (-74) /* Unable to open the database file */
#define UNQLITE_READ_ONLY (-75) /* Read only Key/Value storage engine */
#define UNQLITE_LOCKERR (-76) /* Locking protocol error */
/* end-of-error-codes */
/*
* Database Handle Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure an UnQLite database handle.
* These constants must be passed as the second argument to [unqlite_config()].
*
* Each options require a variable number of arguments.
* The [unqlite_config()] interface will return UNQLITE_OK on success, any other
* return value indicates failure.
* For a full discussion on the configuration verbs and their expected
* parameters, please refer to this page:
* http://unqlite.org/c_api/unqlite_config.html
*/
#define UNQLITE_CONFIG_JX9_ERR_LOG 1 /* TWO ARGUMENTS: const char **pzBuf, int *pLen */
#define UNQLITE_CONFIG_MAX_PAGE_CACHE 2 /* ONE ARGUMENT: int nMaxPage */
#define UNQLITE_CONFIG_ERR_LOG 3 /* TWO ARGUMENTS: const char **pzBuf, int *pLen */
#define UNQLITE_CONFIG_KV_ENGINE 4 /* ONE ARGUMENT: const char *zKvName */
#define UNQLITE_CONFIG_DISABLE_AUTO_COMMIT 5 /* NO ARGUMENTS */
#define UNQLITE_CONFIG_GET_KV_NAME 6 /* ONE ARGUMENT: const char **pzPtr */
/*
* UnQLite/Jx9 Virtual Machine Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the Jx9 (Via UnQLite) Virtual machine.
* These constants must be passed as the second argument to the [unqlite_vm_config()]
* interface.
* Each options require a variable number of arguments.
* The [unqlite_vm_config()] interface will return UNQLITE_OK on success, any other return
* value indicates failure.
* There are many options but the most importants are: UNQLITE_VM_CONFIG_OUTPUT which install
* a VM output consumer callback, UNQLITE_VM_CONFIG_HTTP_REQUEST which parse and register
* a HTTP request and UNQLITE_VM_CONFIG_ARGV_ENTRY which populate the $argv array.
* For a full discussion on the configuration verbs and their expected parameters, please
* refer to this page:
* http://unqlite.org/c_api/unqlite_vm_config.html
*/
#define UNQLITE_VM_CONFIG_OUTPUT 1 /* TWO ARGUMENTS: int (*xConsumer)(const void *pOut, unsigned int nLen, void *pUserData), void *pUserData */
#define UNQLITE_VM_CONFIG_IMPORT_PATH 2 /* ONE ARGUMENT: const char *zIncludePath */
#define UNQLITE_VM_CONFIG_ERR_REPORT 3 /* NO ARGUMENTS: Report all run-time errors in the VM output */
#define UNQLITE_VM_CONFIG_RECURSION_DEPTH 4 /* ONE ARGUMENT: int nMaxDepth */
#define UNQLITE_VM_OUTPUT_LENGTH 5 /* ONE ARGUMENT: unsigned int *pLength */
#define UNQLITE_VM_CONFIG_CREATE_VAR 6 /* TWO ARGUMENTS: const char *zName, unqlite_value *pValue */
#define UNQLITE_VM_CONFIG_HTTP_REQUEST 7 /* TWO ARGUMENTS: const char *zRawRequest, int nRequestLength */
#define UNQLITE_VM_CONFIG_SERVER_ATTR 8 /* THREE ARGUMENTS: const char *zKey, const char *zValue, int nLen */
#define UNQLITE_VM_CONFIG_ENV_ATTR 9 /* THREE ARGUMENTS: const char *zKey, const char *zValue, int nLen */
#define UNQLITE_VM_CONFIG_EXEC_VALUE 10 /* ONE ARGUMENT: unqlite_value **ppValue */
#define UNQLITE_VM_CONFIG_IO_STREAM 11 /* ONE ARGUMENT: const unqlite_io_stream *pStream */
#define UNQLITE_VM_CONFIG_ARGV_ENTRY 12 /* ONE ARGUMENT: const char *zValue */
#define UNQLITE_VM_CONFIG_EXTRACT_OUTPUT 13 /* TWO ARGUMENTS: const void **ppOut, unsigned int *pOutputLen */
/*
* Storage engine configuration commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the underlying storage engine (i.e Hash, B+tree, R+tree).
* These constants must be passed as the first argument to [unqlite_kv_config()].
* Each options require a variable number of arguments.
* The [unqlite_kv_config()] interface will return UNQLITE_OK on success, any other return
* value indicates failure.
* For a full discussion on the configuration verbs and their expected parameters, please
* refer to this page:
* http://unqlite.org/c_api/unqlite_kv_config.html
*/
#define UNQLITE_KV_CONFIG_HASH_FUNC 1 /* ONE ARGUMENT: unsigned int (*xHash)(const void *,unsigned int) */
#define UNQLITE_KV_CONFIG_CMP_FUNC 2 /* ONE ARGUMENT: int (*xCmp)(const void *,const void *,unsigned int) */
/*
* Global Library Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the whole library.
* These constants must be passed as the first argument to [unqlite_lib_config()].
*
* Each options require a variable number of arguments.
* The [unqlite_lib_config()] interface will return UNQLITE_OK on success, any other return
* value indicates failure.
* Notes:
* The default configuration is recommended for most applications and so the call to
* [unqlite_lib_config()] is usually not necessary. It is provided to support rare
* applications with unusual needs.
* The [unqlite_lib_config()] interface is not threadsafe. The application must insure that
* no other [unqlite_*()] interfaces are invoked by other threads while [unqlite_lib_config()]
* is running. Furthermore, [unqlite_lib_config()] may only be invoked prior to library
* initialization using [unqlite_lib_init()] or [unqlite_init()] or after shutdown
* by [unqlite_lib_shutdown()]. If [unqlite_lib_config()] is called after [unqlite_lib_init()]
* or [unqlite_init()] and before [unqlite_lib_shutdown()] then it will return UNQLITE_LOCKED.
* For a full discussion on the configuration verbs and their expected parameters, please
* refer to this page:
* http://unqlite.org/c_api/unqlite_lib.html
*/
#define UNQLITE_LIB_CONFIG_USER_MALLOC 1 /* ONE ARGUMENT: const SyMemMethods *pMemMethods */
#define UNQLITE_LIB_CONFIG_MEM_ERR_CALLBACK 2 /* TWO ARGUMENTS: int (*xMemError)(void *), void *pUserData */
#define UNQLITE_LIB_CONFIG_USER_MUTEX 3 /* ONE ARGUMENT: const SyMutexMethods *pMutexMethods */
#define UNQLITE_LIB_CONFIG_THREAD_LEVEL_SINGLE 4 /* NO ARGUMENTS */
#define UNQLITE_LIB_CONFIG_THREAD_LEVEL_MULTI 5 /* NO ARGUMENTS */
#define UNQLITE_LIB_CONFIG_VFS 6 /* ONE ARGUMENT: const unqlite_vfs *pVfs */
#define UNQLITE_LIB_CONFIG_STORAGE_ENGINE 7 /* ONE ARGUMENT: unqlite_kv_methods *pStorage */
#define UNQLITE_LIB_CONFIG_PAGE_SIZE 8 /* ONE ARGUMENT: int iPageSize */
/*
* These bit values are intended for use in the 3rd parameter to the [unqlite_open()] interface
* and in the 4th parameter to the xOpen method of the [unqlite_vfs] object.
*/
#define UNQLITE_OPEN_READONLY 0x00000001 /* Read only mode. Ok for [unqlite_open] */
#define UNQLITE_OPEN_READWRITE 0x00000002 /* Ok for [unqlite_open] */
#define UNQLITE_OPEN_CREATE 0x00000004 /* Ok for [unqlite_open] */
#define UNQLITE_OPEN_EXCLUSIVE 0x00000008 /* VFS only */
#define UNQLITE_OPEN_TEMP_DB 0x00000010 /* VFS only */
#define UNQLITE_OPEN_NOMUTEX 0x00000020 /* Ok for [unqlite_open] */
#define UNQLITE_OPEN_OMIT_JOURNALING 0x00000040 /* Omit journaling for this database. Ok for [unqlite_open] */
#define UNQLITE_OPEN_IN_MEMORY 0x00000080 /* An in memory database. Ok for [unqlite_open]*/
#define UNQLITE_OPEN_MMAP 0x00000100 /* Obtain a memory view of the whole file. Ok for [unqlite_open] */
/*
* Synchronization Type Flags
*
* When UnQLite invokes the xSync() method of an [unqlite_io_methods] object it uses
* a combination of these integer values as the second argument.
*
* When the UNQLITE_SYNC_DATAONLY flag is used, it means that the sync operation only
* needs to flush data to mass storage. Inode information need not be flushed.
* If the lower four bits of the flag equal UNQLITE_SYNC_NORMAL, that means to use normal
* fsync() semantics. If the lower four bits equal UNQLITE_SYNC_FULL, that means to use
* Mac OS X style fullsync instead of fsync().
*/
#define UNQLITE_SYNC_NORMAL 0x00002
#define UNQLITE_SYNC_FULL 0x00003
#define UNQLITE_SYNC_DATAONLY 0x00010
/*
* File Locking Levels
*
* UnQLite uses one of these integer values as the second
* argument to calls it makes to the xLock() and xUnlock() methods
* of an [unqlite_io_methods] object.
*/
#define UNQLITE_LOCK_NONE 0
#define UNQLITE_LOCK_SHARED 1
#define UNQLITE_LOCK_RESERVED 2
#define UNQLITE_LOCK_PENDING 3
#define UNQLITE_LOCK_EXCLUSIVE 4
/*
* CAPIREF: OS Interface: Open File Handle
*
* An [unqlite_file] object represents an open file in the [unqlite_vfs] OS interface
* layer.
* Individual OS interface implementations will want to subclass this object by appending
* additional fields for their own use. The pMethods entry is a pointer to an
* [unqlite_io_methods] object that defines methods for performing
* I/O operations on the open file.
*/
typedef struct unqlite_file unqlite_file;
struct unqlite_file {
const unqlite_io_methods *pMethods; /* Methods for an open file. MUST BE FIRST */
};
/*
* CAPIREF: OS Interface: File Methods Object
*
* Every file opened by the [unqlite_vfs] xOpen method populates an
* [unqlite_file] object (or, more commonly, a subclass of the
* [unqlite_file] object) with a pointer to an instance of this object.
* This object defines the methods used to perform various operations
* against the open file represented by the [unqlite_file] object.
*
* If the xOpen method sets the unqlite_file.pMethods element
* to a non-NULL pointer, then the unqlite_io_methods.xClose method
* may be invoked even if the xOpen reported that it failed. The
* only way to prevent a call to xClose following a failed xOpen
* is for the xOpen to set the unqlite_file.pMethods element to NULL.
*
* The flags argument to xSync may be one of [UNQLITE_SYNC_NORMAL] or
* [UNQLITE_SYNC_FULL]. The first choice is the normal fsync().
* The second choice is a Mac OS X style fullsync. The [UNQLITE_SYNC_DATAONLY]
* flag may be ORed in to indicate that only the data of the file
* and not its inode needs to be synced.
*
* The integer values to xLock() and xUnlock() are one of
*
* UNQLITE_LOCK_NONE
* UNQLITE_LOCK_SHARED
* UNQLITE_LOCK_RESERVED
* UNQLITE_LOCK_PENDING
* UNQLITE_LOCK_EXCLUSIVE
*
* xLock() increases the lock. xUnlock() decreases the lock.
* The xCheckReservedLock() method checks whether any database connection,
* either in this process or in some other process, is holding a RESERVED,
* PENDING, or EXCLUSIVE lock on the file. It returns true if such a lock exists
* and false otherwise.
*
* The xSectorSize() method returns the sector size of the device that underlies
* the file. The sector size is the minimum write that can be performed without
* disturbing other bytes in the file.
*
*/
struct unqlite_io_methods {
int iVersion; /* Structure version number (currently 1) */
int (*xClose)(unqlite_file*);
int (*xRead)(unqlite_file*, void*, unqlite_int64 iAmt, unqlite_int64 iOfst);
int (*xWrite)(unqlite_file*, const void*, unqlite_int64 iAmt, unqlite_int64 iOfst);
int (*xTruncate)(unqlite_file*, unqlite_int64 size);
int (*xSync)(unqlite_file*, int flags);
int (*xFileSize)(unqlite_file*, unqlite_int64 *pSize);
int (*xLock)(unqlite_file*, int);
int (*xUnlock)(unqlite_file*, int);
int (*xCheckReservedLock)(unqlite_file*, int *pResOut);
int (*xSectorSize)(unqlite_file*);
};
/*
* CAPIREF: OS Interface Object
*
* An instance of the unqlite_vfs object defines the interface between
* the UnQLite core and the underlying operating system. The "vfs"
* in the name of the object stands for "Virtual File System".
*
* Only a single vfs can be registered within the UnQLite core.
* Vfs registration is done using the [unqlite_lib_config()] interface
* with a configuration verb set to UNQLITE_LIB_CONFIG_VFS.
* Note that Windows and UNIX (Linux, FreeBSD, Solaris, Mac OS X, etc.) users
* does not have to worry about registering and installing a vfs since UnQLite
* come with a built-in vfs for these platforms that implements most the methods
* defined below.
*
* Clients running on exotic systems (ie: Other than Windows and UNIX systems)
* must register their own vfs in order to be able to use the UnQLite library.
*
* The value of the iVersion field is initially 1 but may be larger in
* future versions of UnQLite.
*
* The szOsFile field is the size of the subclassed [unqlite_file] structure
* used by this VFS. mxPathname is the maximum length of a pathname in this VFS.
*
* At least szOsFile bytes of memory are allocated by UnQLite to hold the [unqlite_file]
* structure passed as the third argument to xOpen. The xOpen method does not have to
* allocate the structure; it should just fill it in. Note that the xOpen method must
* set the unqlite_file.pMethods to either a valid [unqlite_io_methods] object or to NULL.
* xOpen must do this even if the open fails. UnQLite expects that the unqlite_file.pMethods
* element will be valid after xOpen returns regardless of the success or failure of the
* xOpen call.
*
*/
struct unqlite_vfs {
const char *zName; /* Name of this virtual file system [i.e: Windows, UNIX, etc.] */
int iVersion; /* Structure version number (currently 1) */
int szOsFile; /* Size of subclassed unqlite_file */
int mxPathname; /* Maximum file pathname length */
int (*xOpen)(unqlite_vfs*, const char *zName, unqlite_file*,unsigned int flags);
int (*xDelete)(unqlite_vfs*, const char *zName, int syncDir);
int (*xAccess)(unqlite_vfs*, const char *zName, int flags, int *pResOut);
int (*xFullPathname)(unqlite_vfs*, const char *zName,int buf_len,char *zBuf);
int (*xTmpDir)(unqlite_vfs*,char *zBuf,int buf_len);
int (*xSleep)(unqlite_vfs*, int microseconds);
int (*xCurrentTime)(unqlite_vfs*,Sytm *pOut);
int (*xGetLastError)(unqlite_vfs*, int, char *);
};
/*
* Flags for the xAccess VFS method
*
* These integer constants can be used as the third parameter to
* the xAccess method of an [unqlite_vfs] object. They determine
* what kind of permissions the xAccess method is looking for.
* With UNQLITE_ACCESS_EXISTS, the xAccess method
* simply checks whether the file exists.
* With UNQLITE_ACCESS_READWRITE, the xAccess method
* checks whether the named directory is both readable and writable
* (in other words, if files can be added, removed, and renamed within
* the directory).
* The UNQLITE_ACCESS_READWRITE constant is currently used only by the
* [temp_store_directory pragma], though this could change in a future
* release of UnQLite.
* With UNQLITE_ACCESS_READ, the xAccess method
* checks whether the file is readable. The UNQLITE_ACCESS_READ constant is
* currently unused, though it might be used in a future release of
* UnQLite.
*/
#define UNQLITE_ACCESS_EXISTS 0
#define UNQLITE_ACCESS_READWRITE 1
#define UNQLITE_ACCESS_READ 2
/*
* The type used to represent a page number. The first page in a file
* is called page 1. 0 is used to represent "not a page".
* A page number is an unsigned 64-bit integer.
*/
typedef sxu64 pgno;
/*
* A database disk page is represented by an instance
* of the follwoing structure.
*/
typedef struct unqlite_page unqlite_page;
struct unqlite_page
{
unsigned char *zData; /* Content of this page */
void *pUserData; /* Extra content */
pgno pgno; /* Page number for this page */
};
/*
* UnQLite handle to the underlying Key/Value Storage Engine (See below).
*/
typedef void * unqlite_kv_handle;
/*
* UnQLite pager IO methods.
*
* An instance of the following structure define the exported methods of the UnQLite pager
* to the underlying Key/Value storage engine.
*/
typedef struct unqlite_kv_io unqlite_kv_io;
struct unqlite_kv_io
{
unqlite_kv_handle pHandle; /* UnQLite handle passed as the first parameter to the
* method defined below.
*/
unqlite_kv_methods *pMethods; /* Underlying storage engine */
/* Pager methods */
int (*xGet)(unqlite_kv_handle,pgno,unqlite_page **);
int (*xLookup)(unqlite_kv_handle,pgno,unqlite_page **);
int (*xNew)(unqlite_kv_handle,unqlite_page **);
int (*xWrite)(unqlite_page *);
int (*xDontWrite)(unqlite_page *);
int (*xDontJournal)(unqlite_page *);
int (*xDontMkHot)(unqlite_page *);
int (*xPageRef)(unqlite_page *);
int (*xPageUnref)(unqlite_page *);
int (*xPageSize)(unqlite_kv_handle);
int (*xReadOnly)(unqlite_kv_handle);
unsigned char * (*xTmpPage)(unqlite_kv_handle);
void (*xSetUnpin)(unqlite_kv_handle,void (*xPageUnpin)(void *));
void (*xSetReload)(unqlite_kv_handle,void (*xPageReload)(void *));
void (*xErr)(unqlite_kv_handle,const char *);
};
/*
* Key/Value Storage Engine Cursor Object
*
* An instance of a subclass of the following object defines a cursor
* used to scan through a key-value storage engine.
*/
typedef struct unqlite_kv_cursor unqlite_kv_cursor;
struct unqlite_kv_cursor
{
unqlite_kv_engine *pStore; /* Must be first */
/* Subclasses will typically add additional fields */
};
/*
* Possible seek positions.
*/
#define UNQLITE_CURSOR_MATCH_EXACT 1
#define UNQLITE_CURSOR_MATCH_LE 2
#define UNQLITE_CURSOR_MATCH_GE 3
/*
* Key/Value Storage Engine.
*
* A Key-Value storage engine is defined by an instance of the following
* object.
* UnQLite works with run-time interchangeable storage engines (i.e. Hash, B+Tree, R+Tree, LSM, etc.).
* The storage engine works with key/value pairs where both the key
* and the value are byte arrays of arbitrary length and with no restrictions on content.
* UnQLite come with two built-in KV storage engine: A Virtual Linear Hash (VLH) storage
* engine is used for persistent on-disk databases with O(1) lookup time and an in-memory
* hash-table or Red-black tree storage engine is used for in-memory databases.
* Future versions of UnQLite might add other built-in storage engines (i.e. LSM).
* Registration of a Key/Value storage engine at run-time is done via [unqlite_lib_config()]
* with a configuration verb set to UNQLITE_LIB_CONFIG_STORAGE_ENGINE.
*/
struct unqlite_kv_engine
{
const unqlite_kv_io *pIo; /* IO methods: MUST be first */
/* Subclasses will typically add additional fields */
};
/*
* Key/Value Storage Engine Virtual Method Table.
*
* Key/Value storage engine methods is defined by an instance of the following
* object.
* Registration of a Key/Value storage engine at run-time is done via [unqlite_lib_config()]
* with a configuration verb set to UNQLITE_LIB_CONFIG_STORAGE_ENGINE.
*/
struct unqlite_kv_methods
{
const char *zName; /* Storage engine name [i.e. Hash, B+tree, LSM, R-tree, Mem, etc.]*/
int szKv; /* 'unqlite_kv_engine' subclass size */
int szCursor; /* 'unqlite_kv_cursor' subclass size */
int iVersion; /* Structure version, currently 1 */
/* Storage engine methods */
int (*xInit)(unqlite_kv_engine *,int iPageSize);
void (*xRelease)(unqlite_kv_engine *);
int (*xConfig)(unqlite_kv_engine *,int op,va_list ap);
int (*xOpen)(unqlite_kv_engine *,pgno);
int (*xReplace)(
unqlite_kv_engine *,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
);
int (*xAppend)(
unqlite_kv_engine *,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
);
void (*xCursorInit)(unqlite_kv_cursor *);
int (*xSeek)(unqlite_kv_cursor *,const void *pKey,int nByte,int iPos); /* Mandatory */
int (*xFirst)(unqlite_kv_cursor *);
int (*xLast)(unqlite_kv_cursor *);
int (*xValid)(unqlite_kv_cursor *);
int (*xNext)(unqlite_kv_cursor *);
int (*xPrev)(unqlite_kv_cursor *);
int (*xDelete)(unqlite_kv_cursor *);
int (*xKeyLength)(unqlite_kv_cursor *,int *);
int (*xKey)(unqlite_kv_cursor *,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
int (*xDataLength)(unqlite_kv_cursor *,unqlite_int64 *);
int (*xData)(unqlite_kv_cursor *,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
void (*xReset)(unqlite_kv_cursor *);
void (*xCursorRelease)(unqlite_kv_cursor *);
};
/*
* UnQLite journal file suffix.
*/
#ifndef UNQLITE_JOURNAL_FILE_SUFFIX
#define UNQLITE_JOURNAL_FILE_SUFFIX "_unqlite_journal"
#endif
/*
* Call Context - Error Message Serverity Level.
*
* The following constans are the allowed severity level that can
* passed as the second argument to the [unqlite_context_throw_error()] or
* [unqlite_context_throw_error_format()] interfaces.
* Refer to the official documentation for additional information.
*/
#define UNQLITE_CTX_ERR 1 /* Call context error such as unexpected number of arguments, invalid types and so on. */
#define UNQLITE_CTX_WARNING 2 /* Call context Warning */
#define UNQLITE_CTX_NOTICE 3 /* Call context Notice */
/*
* C-API-REF: Please refer to the official documentation for interfaces
* purpose and expected parameters.
*/
/* Database Engine Handle */
UNQLITE_APIEXPORT int unqlite_open(unqlite **ppDB,const char *zFilename,unsigned int iMode);
UNQLITE_APIEXPORT int unqlite_config(unqlite *pDb,int nOp,...);
UNQLITE_APIEXPORT int unqlite_close(unqlite *pDb);
/* Key/Value (KV) Store Interfaces */
UNQLITE_APIEXPORT int unqlite_kv_store(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen);
UNQLITE_APIEXPORT int unqlite_kv_append(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen);
UNQLITE_APIEXPORT int unqlite_kv_store_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...);
UNQLITE_APIEXPORT int unqlite_kv_append_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...);
UNQLITE_APIEXPORT int unqlite_kv_fetch(unqlite *pDb,const void *pKey,int nKeyLen,void *pBuf,unqlite_int64 /* in|out */*pBufLen);
UNQLITE_APIEXPORT int unqlite_kv_fetch_callback(unqlite *pDb,const void *pKey,
int nKeyLen,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
UNQLITE_APIEXPORT int unqlite_kv_delete(unqlite *pDb,const void *pKey,int nKeyLen);
UNQLITE_APIEXPORT int unqlite_kv_config(unqlite *pDb,int iOp,...);
/* Document (JSON) Store Interfaces powered by the Jx9 Scripting Language */
UNQLITE_APIEXPORT int unqlite_compile(unqlite *pDb,const char *zJx9,int nByte,unqlite_vm **ppOut);
UNQLITE_APIEXPORT int unqlite_compile_file(unqlite *pDb,const char *zPath,unqlite_vm **ppOut);
UNQLITE_APIEXPORT int unqlite_vm_config(unqlite_vm *pVm,int iOp,...);
UNQLITE_APIEXPORT int unqlite_vm_exec(unqlite_vm *pVm);
UNQLITE_APIEXPORT int unqlite_vm_reset(unqlite_vm *pVm);
UNQLITE_APIEXPORT int unqlite_vm_release(unqlite_vm *pVm);
UNQLITE_APIEXPORT int unqlite_vm_dump(unqlite_vm *pVm, int (*xConsumer)(const void *, unsigned int, void *), void *pUserData);
UNQLITE_APIEXPORT unqlite_value * unqlite_vm_extract_variable(unqlite_vm *pVm,const char *zVarname);
/* Cursor Iterator Interfaces */
UNQLITE_APIEXPORT int unqlite_kv_cursor_init(unqlite *pDb,unqlite_kv_cursor **ppOut);
UNQLITE_APIEXPORT int unqlite_kv_cursor_release(unqlite *pDb,unqlite_kv_cursor *pCur);
UNQLITE_APIEXPORT int unqlite_kv_cursor_seek(unqlite_kv_cursor *pCursor,const void *pKey,int nKeyLen,int iPos);
UNQLITE_APIEXPORT int unqlite_kv_cursor_first_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_last_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_valid_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_next_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_prev_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_key(unqlite_kv_cursor *pCursor,void *pBuf,int *pnByte);
UNQLITE_APIEXPORT int unqlite_kv_cursor_key_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
UNQLITE_APIEXPORT int unqlite_kv_cursor_data(unqlite_kv_cursor *pCursor,void *pBuf,unqlite_int64 *pnData);
UNQLITE_APIEXPORT int unqlite_kv_cursor_data_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData);
UNQLITE_APIEXPORT int unqlite_kv_cursor_delete_entry(unqlite_kv_cursor *pCursor);
UNQLITE_APIEXPORT int unqlite_kv_cursor_reset(unqlite_kv_cursor *pCursor);
/* Manual Transaction Manager */
UNQLITE_APIEXPORT int unqlite_begin(unqlite *pDb);
UNQLITE_APIEXPORT int unqlite_commit(unqlite *pDb);
UNQLITE_APIEXPORT int unqlite_rollback(unqlite *pDb);
/* Utility interfaces */
UNQLITE_APIEXPORT int unqlite_util_load_mmaped_file(const char *zFile,void **ppMap,unqlite_int64 *pFileSize);
UNQLITE_APIEXPORT int unqlite_util_release_mmaped_file(void *pMap,unqlite_int64 iFileSize);
UNQLITE_APIEXPORT int unqlite_util_random_string(unqlite *pDb,char *zBuf,unsigned int buf_size);
UNQLITE_APIEXPORT unsigned int unqlite_util_random_num(unqlite *pDb);
/* In-process extending interfaces */
UNQLITE_APIEXPORT int unqlite_create_function(unqlite_vm *pVm,const char *zName,int (*xFunc)(unqlite_context *,int,unqlite_value **),void *pUserData);
UNQLITE_APIEXPORT int unqlite_delete_function(unqlite_vm *pVm, const char *zName);
UNQLITE_APIEXPORT int unqlite_create_constant(unqlite_vm *pVm,const char *zName,void (*xExpand)(unqlite_value *, void *),void *pUserData);
UNQLITE_APIEXPORT int unqlite_delete_constant(unqlite_vm *pVm, const char *zName);
/* On Demand Object allocation interfaces */
UNQLITE_APIEXPORT unqlite_value * unqlite_vm_new_scalar(unqlite_vm *pVm);
UNQLITE_APIEXPORT unqlite_value * unqlite_vm_new_array(unqlite_vm *pVm);
UNQLITE_APIEXPORT int unqlite_vm_release_value(unqlite_vm *pVm,unqlite_value *pValue);
UNQLITE_APIEXPORT unqlite_value * unqlite_context_new_scalar(unqlite_context *pCtx);
UNQLITE_APIEXPORT unqlite_value * unqlite_context_new_array(unqlite_context *pCtx);
UNQLITE_APIEXPORT void unqlite_context_release_value(unqlite_context *pCtx,unqlite_value *pValue);
/* Dynamically Typed Value Object Management Interfaces */
UNQLITE_APIEXPORT int unqlite_value_int(unqlite_value *pVal, int iValue);
UNQLITE_APIEXPORT int unqlite_value_int64(unqlite_value *pVal, unqlite_int64 iValue);
UNQLITE_APIEXPORT int unqlite_value_bool(unqlite_value *pVal, int iBool);
UNQLITE_APIEXPORT int unqlite_value_null(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_double(unqlite_value *pVal, double Value);
UNQLITE_APIEXPORT int unqlite_value_string(unqlite_value *pVal, const char *zString, int nLen);
UNQLITE_APIEXPORT int unqlite_value_string_format(unqlite_value *pVal, const char *zFormat,...);
UNQLITE_APIEXPORT int unqlite_value_reset_string_cursor(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_resource(unqlite_value *pVal, void *pUserData);
UNQLITE_APIEXPORT int unqlite_value_release(unqlite_value *pVal);
/* Foreign Function Parameter Values */
UNQLITE_APIEXPORT int unqlite_value_to_int(unqlite_value *pValue);
UNQLITE_APIEXPORT int unqlite_value_to_bool(unqlite_value *pValue);
UNQLITE_APIEXPORT unqlite_int64 unqlite_value_to_int64(unqlite_value *pValue);
UNQLITE_APIEXPORT double unqlite_value_to_double(unqlite_value *pValue);
UNQLITE_APIEXPORT const char * unqlite_value_to_string(unqlite_value *pValue, int *pLen);
UNQLITE_APIEXPORT void * unqlite_value_to_resource(unqlite_value *pValue);
UNQLITE_APIEXPORT int unqlite_value_compare(unqlite_value *pLeft, unqlite_value *pRight, int bStrict);
/* Setting The Result Of A Foreign Function */
UNQLITE_APIEXPORT int unqlite_result_int(unqlite_context *pCtx, int iValue);
UNQLITE_APIEXPORT int unqlite_result_int64(unqlite_context *pCtx, unqlite_int64 iValue);
UNQLITE_APIEXPORT int unqlite_result_bool(unqlite_context *pCtx, int iBool);
UNQLITE_APIEXPORT int unqlite_result_double(unqlite_context *pCtx, double Value);
UNQLITE_APIEXPORT int unqlite_result_null(unqlite_context *pCtx);
UNQLITE_APIEXPORT int unqlite_result_string(unqlite_context *pCtx, const char *zString, int nLen);
UNQLITE_APIEXPORT int unqlite_result_string_format(unqlite_context *pCtx, const char *zFormat, ...);
UNQLITE_APIEXPORT int unqlite_result_value(unqlite_context *pCtx, unqlite_value *pValue);
UNQLITE_APIEXPORT int unqlite_result_resource(unqlite_context *pCtx, void *pUserData);
/* Dynamically Typed Value Object Query Interfaces */
UNQLITE_APIEXPORT int unqlite_value_is_int(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_float(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_bool(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_string(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_null(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_numeric(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_callable(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_scalar(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_json_array(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_json_object(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_resource(unqlite_value *pVal);
UNQLITE_APIEXPORT int unqlite_value_is_empty(unqlite_value *pVal);
/* JSON Array/Object Management Interfaces */
UNQLITE_APIEXPORT unqlite_value * unqlite_array_fetch(unqlite_value *pArray, const char *zKey, int nByte);
UNQLITE_APIEXPORT int unqlite_array_walk(unqlite_value *pArray, int (*xWalk)(unqlite_value *, unqlite_value *, void *), void *pUserData);
UNQLITE_APIEXPORT int unqlite_array_add_elem(unqlite_value *pArray, unqlite_value *pKey, unqlite_value *pValue);
UNQLITE_APIEXPORT int unqlite_array_add_strkey_elem(unqlite_value *pArray, const char *zKey, unqlite_value *pValue);
UNQLITE_APIEXPORT int unqlite_array_count(unqlite_value *pArray);
/* Call Context Handling Interfaces */
UNQLITE_APIEXPORT int unqlite_context_output(unqlite_context *pCtx, const char *zString, int nLen);
UNQLITE_APIEXPORT int unqlite_context_output_format(unqlite_context *pCtx,const char *zFormat, ...);
UNQLITE_APIEXPORT int unqlite_context_throw_error(unqlite_context *pCtx, int iErr, const char *zErr);
UNQLITE_APIEXPORT int unqlite_context_throw_error_format(unqlite_context *pCtx, int iErr, const char *zFormat, ...);
UNQLITE_APIEXPORT unsigned int unqlite_context_random_num(unqlite_context *pCtx);
UNQLITE_APIEXPORT int unqlite_context_random_string(unqlite_context *pCtx, char *zBuf, int nBuflen);
UNQLITE_APIEXPORT void * unqlite_context_user_data(unqlite_context *pCtx);
UNQLITE_APIEXPORT int unqlite_context_push_aux_data(unqlite_context *pCtx, void *pUserData);
UNQLITE_APIEXPORT void * unqlite_context_peek_aux_data(unqlite_context *pCtx);
UNQLITE_APIEXPORT unsigned int unqlite_context_result_buf_length(unqlite_context *pCtx);
UNQLITE_APIEXPORT const char * unqlite_function_name(unqlite_context *pCtx);
/* Call Context Memory Management Interfaces */
UNQLITE_APIEXPORT void * unqlite_context_alloc_chunk(unqlite_context *pCtx,unsigned int nByte,int ZeroChunk,int AutoRelease);
UNQLITE_APIEXPORT void * unqlite_context_realloc_chunk(unqlite_context *pCtx,void *pChunk,unsigned int nByte);
UNQLITE_APIEXPORT void unqlite_context_free_chunk(unqlite_context *pCtx,void *pChunk);
/* Global Library Management Interfaces */
UNQLITE_APIEXPORT int unqlite_lib_config(int nConfigOp,...);
UNQLITE_APIEXPORT int unqlite_lib_init(void);
UNQLITE_APIEXPORT int unqlite_lib_shutdown(void);
UNQLITE_APIEXPORT int unqlite_lib_is_threadsafe(void);
UNQLITE_APIEXPORT const char * unqlite_lib_version(void);
UNQLITE_APIEXPORT const char * unqlite_lib_signature(void);
UNQLITE_APIEXPORT const char * unqlite_lib_ident(void);
UNQLITE_APIEXPORT const char * unqlite_lib_copyright(void);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* _UNQLITE_H_ */
/*
* ----------------------------------------------------------
* File: jx9.h
* MD5: d23a1e182f596794001533e1d6aa16a0
* ----------------------------------------------------------
*/
/* This file was automatically generated. Do not edit (except for compile time directive)! */
#ifndef _JX9H_
#define _JX9H_
/*
* Symisc Jx9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/*
* Copyright (C) 2012, 2013 Symisc Systems. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Redistributions in any form must be accompanied by information on
* how to obtain complete source code for the JX9 engine and any
* accompanying software that uses the JX9 engine software.
* The source code must either be included in the distribution
* or be available for no more than the cost of distribution plus
* a nominal fee, and must be freely redistributable under reasonable
* conditions. For an executable file, complete source code means
* the source code for all modules it contains.It does not include
* source code for modules or files that typically accompany the major
* components of the operating system on which the executable file runs.
*
* THIS SOFTWARE IS PROVIDED BY SYMISC SYSTEMS ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL SYMISC SYSTEMS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* $SymiscID: jx9.h v2.1 UNIX|WIN32/64 2012-09-15 09:43 stable <chm@symisc.net> $ */
#include "unqlite.h"
/*
* Compile time engine version, signature, identification in the symisc source tree
* and copyright notice.
* Each macro have an equivalent C interface associated with it that provide the same
* information but are associated with the library instead of the header file.
* Refer to [jx9_lib_version()], [jx9_lib_signature()], [jx9_lib_ident()] and
* [jx9_lib_copyright()] for more information.
*/
/*
* The JX9_VERSION C preprocessor macroevaluates to a string literal
* that is the jx9 version in the format "X.Y.Z" where X is the major
* version number and Y is the minor version number and Z is the release
* number.
*/
#define JX9_VERSION "1.7.2"
/*
* The JX9_VERSION_NUMBER C preprocessor macro resolves to an integer
* with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
* numbers used in [JX9_VERSION].
*/
#define JX9_VERSION_NUMBER 1007002
/*
* The JX9_SIG C preprocessor macro evaluates to a string
* literal which is the public signature of the jx9 engine.
* This signature could be included for example in a host-application
* generated Server MIME header as follows:
* Server: YourWebServer/x.x Jx9/x.x.x \r\n
*/
#define JX9_SIG "Jx9/1.7.2"
/*
* JX9 identification in the Symisc source tree:
* Each particular check-in of a particular software released
* by symisc systems have an unique identifier associated with it.
* This macro hold the one associated with jx9.
*/
#define JX9_IDENT "jx9:d217a6e8c7f10fb35a8becb2793101fd2036aeb7"
/*
* Copyright notice.
* If you have any questions about the licensing situation, please
* visit http://jx9.symisc.net/licensing.html
* or contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
*/
#define JX9_COPYRIGHT "Copyright (C) Symisc Systems 2012-2013, http://jx9.symisc.net/"
/* Forward declaration to public objects */
typedef struct jx9_io_stream jx9_io_stream;
typedef struct jx9_context jx9_context;
typedef struct jx9_value jx9_value;
typedef struct jx9_vfs jx9_vfs;
typedef struct jx9_vm jx9_vm;
typedef struct jx9 jx9;
#include "unqlite.h"
#if !defined( UNQLITE_ENABLE_JX9_HASH_FUNC )
#define JX9_DISABLE_HASH_FUNC
#endif /* UNQLITE_ENABLE_JX9_HASH_FUNC */
#ifdef UNQLITE_ENABLE_THREADS
#define JX9_ENABLE_THREADS
#endif /* UNQLITE_ENABLE_THREADS */
/* Standard JX9 return values */
#define JX9_OK SXRET_OK /* Successful result */
/* beginning-of-error-codes */
#define JX9_NOMEM UNQLITE_NOMEM /* Out of memory */
#define JX9_ABORT UNQLITE_ABORT /* Foreign Function request operation abort/Another thread have released this instance */
#define JX9_IO_ERR UNQLITE_IOERR /* IO error */
#define JX9_CORRUPT UNQLITE_CORRUPT /* Corrupt pointer/Unknown configuration option */
#define JX9_LOOKED UNQLITE_LOCKED /* Forbidden Operation */
#define JX9_COMPILE_ERR UNQLITE_COMPILE_ERR /* Compilation error */
#define JX9_VM_ERR UNQLITE_VM_ERR /* Virtual machine error */
/* end-of-error-codes */
/*
* If compiling for a processor that lacks floating point
* support, substitute integer for floating-point.
*/
#ifdef JX9_OMIT_FLOATING_POINT
typedef sxi64 jx9_real;
#else
typedef double jx9_real;
#endif
typedef sxi64 jx9_int64;
/*
* Engine Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the JX9 engine.
* These constants must be passed as the second argument to the [jx9_config()]
* interface.
* Each options require a variable number of arguments.
* The [jx9_config()] interface will return JX9_OK on success, any other
* return value indicates failure.
* For a full discussion on the configuration verbs and their expected
* parameters, please refer to this page:
* http://jx9.symisc.net/c_api_func.html#jx9_config
*/
#define JX9_CONFIG_ERR_ABORT 1 /* RESERVED FOR FUTURE USE */
#define JX9_CONFIG_ERR_LOG 2 /* TWO ARGUMENTS: const char **pzBuf, int *pLen */
/*
* Virtual Machine Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the JX9 Virtual machine.
* These constants must be passed as the second argument to the [jx9_vm_config()]
* interface.
* Each options require a variable number of arguments.
* The [jx9_vm_config()] interface will return JX9_OK on success, any other return
* value indicates failure.
* There are many options but the most importants are: JX9_VM_CONFIG_OUTPUT which install
* a VM output consumer callback, JX9_VM_CONFIG_HTTP_REQUEST which parse and register
* a HTTP request and JX9_VM_CONFIG_ARGV_ENTRY which populate the $argv array.
* For a full discussion on the configuration verbs and their expected parameters, please
* refer to this page:
* http://jx9.symisc.net/c_api_func.html#jx9_vm_config
*/
#define JX9_VM_CONFIG_OUTPUT UNQLITE_VM_CONFIG_OUTPUT /* TWO ARGUMENTS: int (*xConsumer)(const void *pOut, unsigned int nLen, void *pUserData), void *pUserData */
#define JX9_VM_CONFIG_IMPORT_PATH UNQLITE_VM_CONFIG_IMPORT_PATH /* ONE ARGUMENT: const char *zIncludePath */
#define JX9_VM_CONFIG_ERR_REPORT UNQLITE_VM_CONFIG_ERR_REPORT /* NO ARGUMENTS: Report all run-time errors in the VM output */
#define JX9_VM_CONFIG_RECURSION_DEPTH UNQLITE_VM_CONFIG_RECURSION_DEPTH /* ONE ARGUMENT: int nMaxDepth */
#define JX9_VM_OUTPUT_LENGTH UNQLITE_VM_OUTPUT_LENGTH /* ONE ARGUMENT: unsigned int *pLength */
#define JX9_VM_CONFIG_CREATE_VAR UNQLITE_VM_CONFIG_CREATE_VAR /* TWO ARGUMENTS: const char *zName, jx9_value *pValue */
#define JX9_VM_CONFIG_HTTP_REQUEST UNQLITE_VM_CONFIG_HTTP_REQUEST /* TWO ARGUMENTS: const char *zRawRequest, int nRequestLength */
#define JX9_VM_CONFIG_SERVER_ATTR UNQLITE_VM_CONFIG_SERVER_ATTR /* THREE ARGUMENTS: const char *zKey, const char *zValue, int nLen */
#define JX9_VM_CONFIG_ENV_ATTR UNQLITE_VM_CONFIG_ENV_ATTR /* THREE ARGUMENTS: const char *zKey, const char *zValue, int nLen */
#define JX9_VM_CONFIG_EXEC_VALUE UNQLITE_VM_CONFIG_EXEC_VALUE /* ONE ARGUMENT: jx9_value **ppValue */
#define JX9_VM_CONFIG_IO_STREAM UNQLITE_VM_CONFIG_IO_STREAM /* ONE ARGUMENT: const jx9_io_stream *pStream */
#define JX9_VM_CONFIG_ARGV_ENTRY UNQLITE_VM_CONFIG_ARGV_ENTRY /* ONE ARGUMENT: const char *zValue */
#define JX9_VM_CONFIG_EXTRACT_OUTPUT UNQLITE_VM_CONFIG_EXTRACT_OUTPUT /* TWO ARGUMENTS: const void **ppOut, unsigned int *pOutputLen */
/*
* Global Library Configuration Commands.
*
* The following set of constants are the available configuration verbs that can
* be used by the host-application to configure the whole library.
* These constants must be passed as the first argument to the [jx9_lib_config()]
* interface.
* Each options require a variable number of arguments.
* The [jx9_lib_config()] interface will return JX9_OK on success, any other return
* value indicates failure.
* Notes:
* The default configuration is recommended for most applications and so the call to
* [jx9_lib_config()] is usually not necessary. It is provided to support rare
* applications with unusual needs.
* The [jx9_lib_config()] interface is not threadsafe. The application must insure that
* no other [jx9_*()] interfaces are invoked by other threads while [jx9_lib_config()]
* is running. Furthermore, [jx9_lib_config()] may only be invoked prior to library
* initialization using [jx9_lib_init()] or [jx9_init()] or after shutdown
* by [jx9_lib_shutdown()]. If [jx9_lib_config()] is called after [jx9_lib_init()]
* or [jx9_init()] and before [jx9_lib_shutdown()] then it will return jx9LOCKED.
* For a full discussion on the configuration verbs and their expected parameters, please
* refer to this page:
* http://jx9.symisc.net/c_api_func.html#Global_Library_Management_Interfaces
*/
#define JX9_LIB_CONFIG_USER_MALLOC 1 /* ONE ARGUMENT: const SyMemMethods *pMemMethods */
#define JX9_LIB_CONFIG_MEM_ERR_CALLBACK 2 /* TWO ARGUMENTS: int (*xMemError)(void *), void *pUserData */
#define JX9_LIB_CONFIG_USER_MUTEX 3 /* ONE ARGUMENT: const SyMutexMethods *pMutexMethods */
#define JX9_LIB_CONFIG_THREAD_LEVEL_SINGLE 4 /* NO ARGUMENTS */
#define JX9_LIB_CONFIG_THREAD_LEVEL_MULTI 5 /* NO ARGUMENTS */
#define JX9_LIB_CONFIG_VFS 6 /* ONE ARGUMENT: const jx9_vfs *pVfs */
/*
* Call Context - Error Message Serverity Level.
*/
#define JX9_CTX_ERR UNQLITE_CTX_ERR /* Call context error such as unexpected number of arguments, invalid types and so on. */
#define JX9_CTX_WARNING UNQLITE_CTX_WARNING /* Call context Warning */
#define JX9_CTX_NOTICE UNQLITE_CTX_NOTICE /* Call context Notice */
/* Current VFS structure version*/
#define JX9_VFS_VERSION 2
/*
* JX9 Virtual File System (VFS).
*
* An instance of the jx9_vfs object defines the interface between the JX9 core
* and the underlying operating system. The "vfs" in the name of the object stands
* for "virtual file system". The vfs is used to implement JX9 system functions
* such as mkdir(), chdir(), stat(), get_user_name() and many more.
* The value of the iVersion field is initially 2 but may be larger in future versions
* of JX9.
* Additional fields may be appended to this object when the iVersion value is increased.
* Only a single vfs can be registered within the JX9 core. Vfs registration is done
* using the jx9_lib_config() interface with a configuration verb set to JX9_LIB_CONFIG_VFS.
* Note that Windows and UNIX (Linux, FreeBSD, Solaris, Mac OS X, etc.) users does not have to
* worry about registering and installing a vfs since JX9 come with a built-in vfs for these
* platforms which implement most the methods defined below.
* Host-application running on exotic systems (ie: Other than Windows and UNIX systems) must
* register their own vfs in order to be able to use and call JX9 system functions.
* Also note that the jx9_compile_file() interface depend on the xMmap() method of the underlying
* vfs which mean that this method must be available (Always the case using the built-in VFS)
* in order to use this interface.
* Developers wishing to implement their own vfs an contact symisc systems to obtain
* the JX9 VFS C/C++ Specification manual.
*/
struct jx9_vfs
{
const char *zName; /* Underlying VFS name [i.e: FreeBSD/Linux/Windows...] */
int iVersion; /* Current VFS structure version [default 2] */
/* Directory functions */
int (*xChdir)(const char *); /* Change directory */
int (*xChroot)(const char *); /* Change the root directory */
int (*xGetcwd)(jx9_context *); /* Get the current working directory */
int (*xMkdir)(const char *, int, int); /* Make directory */
int (*xRmdir)(const char *); /* Remove directory */
int (*xIsdir)(const char *); /* Tells whether the filename is a directory */
int (*xRename)(const char *, const char *); /* Renames a file or directory */
int (*xRealpath)(const char *, jx9_context *); /* Return canonicalized absolute pathname*/
/* Systems functions */
int (*xSleep)(unsigned int); /* Delay execution in microseconds */
int (*xUnlink)(const char *); /* Deletes a file */
int (*xFileExists)(const char *); /* Checks whether a file or directory exists */
int (*xChmod)(const char *, int); /* Changes file mode */
int (*xChown)(const char *, const char *); /* Changes file owner */
int (*xChgrp)(const char *, const char *); /* Changes file group */
jx9_int64 (*xFreeSpace)(const char *); /* Available space on filesystem or disk partition */
jx9_int64 (*xTotalSpace)(const char *); /* Total space on filesystem or disk partition */
jx9_int64 (*xFileSize)(const char *); /* Gets file size */
jx9_int64 (*xFileAtime)(const char *); /* Gets last access time of file */
jx9_int64 (*xFileMtime)(const char *); /* Gets file modification time */
jx9_int64 (*xFileCtime)(const char *); /* Gets inode change time of file */
int (*xStat)(const char *, jx9_value *, jx9_value *); /* Gives information about a file */
int (*xlStat)(const char *, jx9_value *, jx9_value *); /* Gives information about a file */
int (*xIsfile)(const char *); /* Tells whether the filename is a regular file */
int (*xIslink)(const char *); /* Tells whether the filename is a symbolic link */
int (*xReadable)(const char *); /* Tells whether a file exists and is readable */
int (*xWritable)(const char *); /* Tells whether the filename is writable */
int (*xExecutable)(const char *); /* Tells whether the filename is executable */
int (*xFiletype)(const char *, jx9_context *); /* Gets file type [i.e: fifo, dir, file..] */
int (*xGetenv)(const char *, jx9_context *); /* Gets the value of an environment variable */
int (*xSetenv)(const char *, const char *); /* Sets the value of an environment variable */
int (*xTouch)(const char *, jx9_int64, jx9_int64); /* Sets access and modification time of file */
int (*xMmap)(const char *, void **, jx9_int64 *); /* Read-only memory map of the whole file */
void (*xUnmap)(void *, jx9_int64); /* Unmap a memory view */
int (*xLink)(const char *, const char *, int); /* Create hard or symbolic link */
int (*xUmask)(int); /* Change the current umask */
void (*xTempDir)(jx9_context *); /* Get path of the temporary directory */
unsigned int (*xProcessId)(void); /* Get running process ID */
int (*xUid)(void); /* user ID of the process */
int (*xGid)(void); /* group ID of the process */
void (*xUsername)(jx9_context *); /* Running username */
int (*xExec)(const char *, jx9_context *); /* Execute an external program */
};
/* Current JX9 IO stream structure version. */
#define JX9_IO_STREAM_VERSION 1
/*
* Possible open mode flags that can be passed to the xOpen() routine
* of the underlying IO stream device .
* Refer to the JX9 IO Stream C/C++ specification manual (http://jx9.symisc.net/io_stream_spec.html)
* for additional information.
*/
#define JX9_IO_OPEN_RDONLY 0x001 /* Read-only open */
#define JX9_IO_OPEN_WRONLY 0x002 /* Write-only open */
#define JX9_IO_OPEN_RDWR 0x004 /* Read-write open. */
#define JX9_IO_OPEN_CREATE 0x008 /* If the file does not exist it will be created */
#define JX9_IO_OPEN_TRUNC 0x010 /* Truncate the file to zero length */
#define JX9_IO_OPEN_APPEND 0x020 /* Append mode.The file offset is positioned at the end of the file */
#define JX9_IO_OPEN_EXCL 0x040 /* Ensure that this call creates the file, the file must not exist before */
#define JX9_IO_OPEN_BINARY 0x080 /* Simple hint: Data is binary */
#define JX9_IO_OPEN_TEMP 0x100 /* Simple hint: Temporary file */
#define JX9_IO_OPEN_TEXT 0x200 /* Simple hint: Data is textual */
/*
* JX9 IO Stream Device.
*
* An instance of the jx9_io_stream object defines the interface between the JX9 core
* and the underlying stream device.
* A stream is a smart mechanism for generalizing file, network, data compression
* and other IO operations which share a common set of functions using an abstracted
* unified interface.
* A stream device is additional code which tells the stream how to handle specific
* protocols/encodings. For example, the http device knows how to translate a URL
* into an HTTP/1.1 request for a file on a remote server.
* JX9 come with two built-in IO streams device:
* The file:// stream which perform very efficient disk IO and the jx9:// stream
* which is a special stream that allow access various I/O streams (See the JX9 official
* documentation for more information on this stream).
* A stream is referenced as: scheme://target
* scheme(string) - The name of the wrapper to be used. Examples include: file, http, https, ftp,
* ftps, compress.zlib, compress.bz2, and jx9. If no wrapper is specified, the function default
* is used (typically file://).
* target - Depends on the device used. For filesystem related streams this is typically a path
* and filename of the desired file.For network related streams this is typically a hostname, often
* with a path appended.
* IO stream devices are registered using a call to jx9_vm_config() with a configuration verb
* set to JX9_VM_CONFIG_IO_STREAM.
* Currently the JX9 development team is working on the implementation of the http:// and ftp://
* IO stream protocols. These devices will be available in the next major release of the JX9 engine.
* Developers wishing to implement their own IO stream devices must understand and follow
* The JX9 IO Stream C/C++ specification manual (http://jx9.symisc.net/io_stream_spec.html).
*/
struct jx9_io_stream
{
const char *zName; /* Underlying stream name [i.e: file/http/zip/jx9, ..] */
int iVersion; /* IO stream structure version [default 1]*/
int (*xOpen)(const char *, int, jx9_value *, void **); /* Open handle*/
int (*xOpenDir)(const char *, jx9_value *, void **); /* Open directory handle */
void (*xClose)(void *); /* Close file handle */
void (*xCloseDir)(void *); /* Close directory handle */
jx9_int64 (*xRead)(void *, void *, jx9_int64); /* Read from the open stream */
int (*xReadDir)(void *, jx9_context *); /* Read entry from directory handle */
jx9_int64 (*xWrite)(void *, const void *, jx9_int64); /* Write to the open stream */
int (*xSeek)(void *, jx9_int64, int); /* Seek on the open stream */
int (*xLock)(void *, int); /* Lock/Unlock the open stream */
void (*xRewindDir)(void *); /* Rewind directory handle */
jx9_int64 (*xTell)(void *); /* Current position of the stream read/write pointer */
int (*xTrunc)(void *, jx9_int64); /* Truncates the open stream to a given length */
int (*xSync)(void *); /* Flush open stream data */
int (*xStat)(void *, jx9_value *, jx9_value *); /* Stat an open stream handle */
};
/*
* C-API-REF: Please refer to the official documentation for interfaces
* purpose and expected parameters.
*/
/* Engine Handling Interfaces */
JX9_PRIVATE int jx9_init(jx9 **ppEngine);
/*JX9_PRIVATE int jx9_config(jx9 *pEngine, int nConfigOp, ...);*/
JX9_PRIVATE int jx9_release(jx9 *pEngine);
/* Compile Interfaces */
JX9_PRIVATE int jx9_compile(jx9 *pEngine, const char *zSource, int nLen, jx9_vm **ppOutVm);
JX9_PRIVATE int jx9_compile_file(jx9 *pEngine, const char *zFilePath, jx9_vm **ppOutVm);
/* Virtual Machine Handling Interfaces */
JX9_PRIVATE int jx9_vm_config(jx9_vm *pVm, int iConfigOp, ...);
/*JX9_PRIVATE int jx9_vm_exec(jx9_vm *pVm, int *pExitStatus);*/
/*JX9_PRIVATE jx9_value * jx9_vm_extract_variable(jx9_vm *pVm,const char *zVarname);*/
/*JX9_PRIVATE int jx9_vm_reset(jx9_vm *pVm);*/
JX9_PRIVATE int jx9_vm_release(jx9_vm *pVm);
/*JX9_PRIVATE int jx9_vm_dump_v2(jx9_vm *pVm, int (*xConsumer)(const void *, unsigned int, void *), void *pUserData);*/
/* In-process Extending Interfaces */
JX9_PRIVATE int jx9_create_function(jx9_vm *pVm, const char *zName, int (*xFunc)(jx9_context *, int, jx9_value **), void *pUserData);
/*JX9_PRIVATE int jx9_delete_function(jx9_vm *pVm, const char *zName);*/
JX9_PRIVATE int jx9_create_constant(jx9_vm *pVm, const char *zName, void (*xExpand)(jx9_value *, void *), void *pUserData);
/*JX9_PRIVATE int jx9_delete_constant(jx9_vm *pVm, const char *zName);*/
/* Foreign Function Parameter Values */
JX9_PRIVATE int jx9_value_to_int(jx9_value *pValue);
JX9_PRIVATE int jx9_value_to_bool(jx9_value *pValue);
JX9_PRIVATE jx9_int64 jx9_value_to_int64(jx9_value *pValue);
JX9_PRIVATE double jx9_value_to_double(jx9_value *pValue);
JX9_PRIVATE const char * jx9_value_to_string(jx9_value *pValue, int *pLen);
JX9_PRIVATE void * jx9_value_to_resource(jx9_value *pValue);
JX9_PRIVATE int jx9_value_compare(jx9_value *pLeft, jx9_value *pRight, int bStrict);
/* Setting The Result Of A Foreign Function */
JX9_PRIVATE int jx9_result_int(jx9_context *pCtx, int iValue);
JX9_PRIVATE int jx9_result_int64(jx9_context *pCtx, jx9_int64 iValue);
JX9_PRIVATE int jx9_result_bool(jx9_context *pCtx, int iBool);
JX9_PRIVATE int jx9_result_double(jx9_context *pCtx, double Value);
JX9_PRIVATE int jx9_result_null(jx9_context *pCtx);
JX9_PRIVATE int jx9_result_string(jx9_context *pCtx, const char *zString, int nLen);
JX9_PRIVATE int jx9_result_string_format(jx9_context *pCtx, const char *zFormat, ...);
JX9_PRIVATE int jx9_result_value(jx9_context *pCtx, jx9_value *pValue);
JX9_PRIVATE int jx9_result_resource(jx9_context *pCtx, void *pUserData);
/* Call Context Handling Interfaces */
JX9_PRIVATE int jx9_context_output(jx9_context *pCtx, const char *zString, int nLen);
/*JX9_PRIVATE int jx9_context_output_format(jx9_context *pCtx, const char *zFormat, ...);*/
JX9_PRIVATE int jx9_context_throw_error(jx9_context *pCtx, int iErr, const char *zErr);
JX9_PRIVATE int jx9_context_throw_error_format(jx9_context *pCtx, int iErr, const char *zFormat, ...);
JX9_PRIVATE unsigned int jx9_context_random_num(jx9_context *pCtx);
JX9_PRIVATE int jx9_context_random_string(jx9_context *pCtx, char *zBuf, int nBuflen);
JX9_PRIVATE void * jx9_context_user_data(jx9_context *pCtx);
JX9_PRIVATE int jx9_context_push_aux_data(jx9_context *pCtx, void *pUserData);
JX9_PRIVATE void * jx9_context_peek_aux_data(jx9_context *pCtx);
JX9_PRIVATE void * jx9_context_pop_aux_data(jx9_context *pCtx);
JX9_PRIVATE unsigned int jx9_context_result_buf_length(jx9_context *pCtx);
JX9_PRIVATE const char * jx9_function_name(jx9_context *pCtx);
/* Call Context Memory Management Interfaces */
JX9_PRIVATE void * jx9_context_alloc_chunk(jx9_context *pCtx, unsigned int nByte, int ZeroChunk, int AutoRelease);
JX9_PRIVATE void * jx9_context_realloc_chunk(jx9_context *pCtx, void *pChunk, unsigned int nByte);
JX9_PRIVATE void jx9_context_free_chunk(jx9_context *pCtx, void *pChunk);
/* On Demand Dynamically Typed Value Object allocation interfaces */
JX9_PRIVATE jx9_value * jx9_new_scalar(jx9_vm *pVm);
JX9_PRIVATE jx9_value * jx9_new_array(jx9_vm *pVm);
JX9_PRIVATE int jx9_release_value(jx9_vm *pVm, jx9_value *pValue);
JX9_PRIVATE jx9_value * jx9_context_new_scalar(jx9_context *pCtx);
JX9_PRIVATE jx9_value * jx9_context_new_array(jx9_context *pCtx);
JX9_PRIVATE void jx9_context_release_value(jx9_context *pCtx, jx9_value *pValue);
/* Dynamically Typed Value Object Management Interfaces */
JX9_PRIVATE int jx9_value_int(jx9_value *pVal, int iValue);
JX9_PRIVATE int jx9_value_int64(jx9_value *pVal, jx9_int64 iValue);
JX9_PRIVATE int jx9_value_bool(jx9_value *pVal, int iBool);
JX9_PRIVATE int jx9_value_null(jx9_value *pVal);
JX9_PRIVATE int jx9_value_double(jx9_value *pVal, double Value);
JX9_PRIVATE int jx9_value_string(jx9_value *pVal, const char *zString, int nLen);
JX9_PRIVATE int jx9_value_string_format(jx9_value *pVal, const char *zFormat, ...);
JX9_PRIVATE int jx9_value_reset_string_cursor(jx9_value *pVal);
JX9_PRIVATE int jx9_value_resource(jx9_value *pVal, void *pUserData);
JX9_PRIVATE int jx9_value_release(jx9_value *pVal);
/* JSON Array/Object Management Interfaces */
JX9_PRIVATE jx9_value * jx9_array_fetch(jx9_value *pArray, const char *zKey, int nByte);
JX9_PRIVATE int jx9_array_walk(jx9_value *pArray, int (*xWalk)(jx9_value *, jx9_value *, void *), void *pUserData);
JX9_PRIVATE int jx9_array_add_elem(jx9_value *pArray, jx9_value *pKey, jx9_value *pValue);
JX9_PRIVATE int jx9_array_add_strkey_elem(jx9_value *pArray, const char *zKey, jx9_value *pValue);
JX9_PRIVATE unsigned int jx9_array_count(jx9_value *pArray);
/* Dynamically Typed Value Object Query Interfaces */
JX9_PRIVATE int jx9_value_is_int(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_float(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_bool(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_string(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_null(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_numeric(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_callable(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_scalar(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_json_array(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_json_object(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_resource(jx9_value *pVal);
JX9_PRIVATE int jx9_value_is_empty(jx9_value *pVal);
/* Global Library Management Interfaces */
/*JX9_PRIVATE int jx9_lib_init(void);*/
JX9_PRIVATE int jx9_lib_config(int nConfigOp, ...);
JX9_PRIVATE int jx9_lib_shutdown(void);
/*JX9_PRIVATE int jx9_lib_is_threadsafe(void);*/
/*JX9_PRIVATE const char * jx9_lib_version(void);*/
JX9_PRIVATE const char * jx9_lib_signature(void);
/*JX9_PRIVATE const char * jx9_lib_ident(void);*/
/*JX9_PRIVATE const char * jx9_lib_copyright(void);*/
#endif /* _JX9H_ */
/*
* ----------------------------------------------------------
* File: jx9Int.h
* MD5: fb8dffc8ba1425a139091aa145067e16
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: jx9Int.h v1.9 FreeBSD 2012-08-13 23:25 devel <chm@symisc.net> $ */
#ifndef __JX9INT_H__
#define __JX9INT_H__
/* Internal interface definitions for JX9. */
#ifdef JX9_AMALGAMATION
#ifndef JX9_PRIVATE
/* Marker for routines not intended for external use */
#define JX9_PRIVATE static
#endif /* JX9_PRIVATE */
#else
#define JX9_PRIVATE
#include "jx9.h"
#endif
#ifndef JX9_PI
/* Value of PI */
#define JX9_PI 3.1415926535898
#endif
/*
* Constants for the largest and smallest possible 64-bit signed integers.
* These macros are designed to work correctly on both 32-bit and 64-bit
* compilers.
*/
#ifndef LARGEST_INT64
#define LARGEST_INT64 (0xffffffff|(((sxi64)0x7fffffff)<<32))
#endif
#ifndef SMALLEST_INT64
#define SMALLEST_INT64 (((sxi64)-1) - LARGEST_INT64)
#endif
/* Forward declaration of private structures */
typedef struct jx9_foreach_info jx9_foreach_info;
typedef struct jx9_foreach_step jx9_foreach_step;
typedef struct jx9_hashmap_node jx9_hashmap_node;
typedef struct jx9_hashmap jx9_hashmap;
/* Symisc Standard types */
#if !defined(SYMISC_STD_TYPES)
#define SYMISC_STD_TYPES
#ifdef __WINNT__
/* Disable nuisance warnings on Borland compilers */
#if defined(__BORLANDC__)
#pragma warn -rch /* unreachable code */
#pragma warn -ccc /* Condition is always true or false */
#pragma warn -aus /* Assigned value is never used */
#pragma warn -csu /* Comparing signed and unsigned */
#pragma warn -spa /* Suspicious pointer arithmetic */
#endif
#endif
typedef signed char sxi8; /* signed char */
typedef unsigned char sxu8; /* unsigned char */
typedef signed short int sxi16; /* 16 bits(2 bytes) signed integer */
typedef unsigned short int sxu16; /* 16 bits(2 bytes) unsigned integer */
typedef int sxi32; /* 32 bits(4 bytes) integer */
typedef unsigned int sxu32; /* 32 bits(4 bytes) unsigned integer */
typedef long sxptr;
typedef unsigned long sxuptr;
typedef long sxlong;
typedef unsigned long sxulong;
typedef sxi32 sxofft;
typedef sxi64 sxofft64;
typedef long double sxlongreal;
typedef double sxreal;
#define SXI8_HIGH 0x7F
#define SXU8_HIGH 0xFF
#define SXI16_HIGH 0x7FFF
#define SXU16_HIGH 0xFFFF
#define SXI32_HIGH 0x7FFFFFFF
#define SXU32_HIGH 0xFFFFFFFF
#define SXI64_HIGH 0x7FFFFFFFFFFFFFFF
#define SXU64_HIGH 0xFFFFFFFFFFFFFFFF
#if !defined(TRUE)
#define TRUE 1
#endif
#if !defined(FALSE)
#define FALSE 0
#endif
/*
* The following macros are used to cast pointers to integers and
* integers to pointers.
*/
#if defined(__PTRDIFF_TYPE__)
# define SX_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
# define SX_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
#elif !defined(__GNUC__)
# define SX_INT_TO_PTR(X) ((void*)&((char*)0)[X])
# define SX_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
#else
# define SX_INT_TO_PTR(X) ((void*)(X))
# define SX_PTR_TO_INT(X) ((int)(X))
#endif
#define SXMIN(a, b) ((a < b) ? (a) : (b))
#define SXMAX(a, b) ((a < b) ? (b) : (a))
#endif /* SYMISC_STD_TYPES */
/* Symisc Run-time API private definitions */
#if !defined(SYMISC_PRIVATE_DEFS)
#define SYMISC_PRIVATE_DEFS
typedef sxi32 (*ProcRawStrCmp)(const SyString *, const SyString *);
#define SyStringData(RAW) ((RAW)->zString)
#define SyStringLength(RAW) ((RAW)->nByte)
#define SyStringInitFromBuf(RAW, ZBUF, NLEN){\
(RAW)->zString = (const char *)ZBUF;\
(RAW)->nByte = (sxu32)(NLEN);\
}
#define SyStringUpdatePtr(RAW, NBYTES){\
if( NBYTES > (RAW)->nByte ){\
(RAW)->nByte = 0;\
}else{\
(RAW)->zString += NBYTES;\
(RAW)->nByte -= NBYTES;\
}\
}
#define SyStringDupPtr(RAW1, RAW2)\
(RAW1)->zString = (RAW2)->zString;\
(RAW1)->nByte = (RAW2)->nByte;
#define SyStringTrimLeadingChar(RAW, CHAR)\
while((RAW)->nByte > 0 && (RAW)->zString[0] == CHAR ){\
(RAW)->zString++;\
(RAW)->nByte--;\
}
#define SyStringTrimTrailingChar(RAW, CHAR)\
while((RAW)->nByte > 0 && (RAW)->zString[(RAW)->nByte - 1] == CHAR){\
(RAW)->nByte--;\
}
#define SyStringCmp(RAW1, RAW2, xCMP)\
(((RAW1)->nByte == (RAW2)->nByte) ? xCMP((RAW1)->zString, (RAW2)->zString, (RAW2)->nByte) : (sxi32)((RAW1)->nByte - (RAW2)->nByte))
#define SyStringCmp2(RAW1, RAW2, xCMP)\
(((RAW1)->nByte >= (RAW2)->nByte) ? xCMP((RAW1)->zString, (RAW2)->zString, (RAW2)->nByte) : (sxi32)((RAW2)->nByte - (RAW1)->nByte))
#define SyStringCharCmp(RAW, CHAR) \
(((RAW)->nByte == sizeof(char)) ? ((RAW)->zString[0] == CHAR ? 0 : CHAR - (RAW)->zString[0]) : ((RAW)->zString[0] == CHAR ? 0 : (RAW)->nByte - sizeof(char)))
#define SX_ADDR(PTR) ((sxptr)PTR)
#define SX_ARRAYSIZE(X) (sizeof(X)/sizeof(X[0]))
#define SXUNUSED(P) (P = 0)
#define SX_EMPTY(PTR) (PTR == 0)
#define SX_EMPTY_STR(STR) (STR == 0 || STR[0] == 0 )
typedef struct SyMemBackend SyMemBackend;
typedef struct SyBlob SyBlob;
typedef struct SySet SySet;
/* Standard function signatures */
typedef sxi32 (*ProcCmp)(const void *, const void *, sxu32);
typedef sxi32 (*ProcPatternMatch)(const char *, sxu32, const char *, sxu32, sxu32 *);
typedef sxi32 (*ProcSearch)(const void *, sxu32, const void *, sxu32, ProcCmp, sxu32 *);
typedef sxu32 (*ProcHash)(const void *, sxu32);
typedef sxi32 (*ProcHashSum)(const void *, sxu32, unsigned char *, sxu32);
typedef sxi32 (*ProcSort)(void *, sxu32, sxu32, ProcCmp);
#define MACRO_LIST_PUSH(Head, Item)\
Item->pNext = Head;\
Head = Item;
#define MACRO_LD_PUSH(Head, Item)\
if( Head == 0 ){\
Head = Item;\
}else{\
Item->pNext = Head;\
Head->pPrev = Item;\
Head = Item;\
}
#define MACRO_LD_REMOVE(Head, Item)\
if( Head == Item ){\
Head = Head->pNext;\
}\
if( Item->pPrev ){ Item->pPrev->pNext = Item->pNext;}\
if( Item->pNext ){ Item->pNext->pPrev = Item->pPrev;}
/*
* A generic dynamic set.
*/
struct SySet
{
SyMemBackend *pAllocator; /* Memory backend */
void *pBase; /* Base pointer */
sxu32 nUsed; /* Total number of used slots */
sxu32 nSize; /* Total number of available slots */
sxu32 eSize; /* Size of a single slot */
sxu32 nCursor; /* Loop cursor */
void *pUserData; /* User private data associated with this container */
};
#define SySetBasePtr(S) ((S)->pBase)
#define SySetBasePtrJump(S, OFFT) (&((char *)(S)->pBase)[OFFT*(S)->eSize])
#define SySetUsed(S) ((S)->nUsed)
#define SySetSize(S) ((S)->nSize)
#define SySetElemSize(S) ((S)->eSize)
#define SySetCursor(S) ((S)->nCursor)
#define SySetGetAllocator(S) ((S)->pAllocator)
#define SySetSetUserData(S, DATA) ((S)->pUserData = DATA)
#define SySetGetUserData(S) ((S)->pUserData)
/*
* A variable length containers for generic data.
*/
struct SyBlob
{
SyMemBackend *pAllocator; /* Memory backend */
void *pBlob; /* Base pointer */
sxu32 nByte; /* Total number of used bytes */
sxu32 mByte; /* Total number of available bytes */
sxu32 nFlags; /* Blob internal flags, see below */
};
#define SXBLOB_LOCKED 0x01 /* Blob is locked [i.e: Cannot auto grow] */
#define SXBLOB_STATIC 0x02 /* Not allocated from heap */
#define SXBLOB_RDONLY 0x04 /* Read-Only data */
#define SyBlobFreeSpace(BLOB) ((BLOB)->mByte - (BLOB)->nByte)
#define SyBlobLength(BLOB) ((BLOB)->nByte)
#define SyBlobData(BLOB) ((BLOB)->pBlob)
#define SyBlobCurData(BLOB) ((void*)(&((char*)(BLOB)->pBlob)[(BLOB)->nByte]))
#define SyBlobDataAt(BLOB, OFFT) ((void *)(&((char *)(BLOB)->pBlob)[OFFT]))
#define SyBlobGetAllocator(BLOB) ((BLOB)->pAllocator)
#define SXMEM_POOL_INCR 3
#define SXMEM_POOL_NBUCKETS 12
#define SXMEM_BACKEND_MAGIC 0xBAC3E67D
#define SXMEM_BACKEND_CORRUPT(BACKEND) (BACKEND == 0 || BACKEND->nMagic != SXMEM_BACKEND_MAGIC)
#define SXMEM_BACKEND_RETRY 3
/* A memory backend subsystem is defined by an instance of the following structures */
typedef union SyMemHeader SyMemHeader;
typedef struct SyMemBlock SyMemBlock;
struct SyMemBlock
{
SyMemBlock *pNext, *pPrev; /* Chain of allocated memory blocks */
#ifdef UNTRUST
sxu32 nGuard; /* magic number associated with each valid block, so we
* can detect misuse.
*/
#endif
};
/*
* Header associated with each valid memory pool block.
*/
union SyMemHeader
{
SyMemHeader *pNext; /* Next chunk of size 1 << (nBucket + SXMEM_POOL_INCR) in the list */
sxu32 nBucket; /* Bucket index in aPool[] */
};
struct SyMemBackend
{
const SyMutexMethods *pMutexMethods; /* Mutex methods */
const SyMemMethods *pMethods; /* Memory allocation methods */
SyMemBlock *pBlocks; /* List of valid memory blocks */
sxu32 nBlock; /* Total number of memory blocks allocated so far */
ProcMemError xMemError; /* Out-of memory callback */
void *pUserData; /* First arg to xMemError() */
SyMutex *pMutex; /* Per instance mutex */
sxu32 nMagic; /* Sanity check against misuse */
SyMemHeader *apPool[SXMEM_POOL_NBUCKETS+SXMEM_POOL_INCR]; /* Pool of memory chunks */
};
/* Mutex types */
#define SXMUTEX_TYPE_FAST 1
#define SXMUTEX_TYPE_RECURSIVE 2
#define SXMUTEX_TYPE_STATIC_1 3
#define SXMUTEX_TYPE_STATIC_2 4
#define SXMUTEX_TYPE_STATIC_3 5
#define SXMUTEX_TYPE_STATIC_4 6
#define SXMUTEX_TYPE_STATIC_5 7
#define SXMUTEX_TYPE_STATIC_6 8
#define SyMutexGlobalInit(METHOD){\
if( (METHOD)->xGlobalInit ){\
(METHOD)->xGlobalInit();\
}\
}
#define SyMutexGlobalRelease(METHOD){\
if( (METHOD)->xGlobalRelease ){\
(METHOD)->xGlobalRelease();\
}\
}
#define SyMutexNew(METHOD, TYPE) (METHOD)->xNew(TYPE)
#define SyMutexRelease(METHOD, MUTEX){\
if( MUTEX && (METHOD)->xRelease ){\
(METHOD)->xRelease(MUTEX);\
}\
}
#define SyMutexEnter(METHOD, MUTEX){\
if( MUTEX ){\
(METHOD)->xEnter(MUTEX);\
}\
}
#define SyMutexTryEnter(METHOD, MUTEX){\
if( MUTEX && (METHOD)->xTryEnter ){\
(METHOD)->xTryEnter(MUTEX);\
}\
}
#define SyMutexLeave(METHOD, MUTEX){\
if( MUTEX ){\
(METHOD)->xLeave(MUTEX);\
}\
}
/* Comparison, byte swap, byte copy macros */
#define SX_MACRO_FAST_CMP(X1, X2, SIZE, RC){\
register unsigned char *r1 = (unsigned char *)X1;\
register unsigned char *r2 = (unsigned char *)X2;\
register sxu32 LEN = SIZE;\
for(;;){\
if( !LEN ){ break; }if( r1[0] != r2[0] ){ break; } r1++; r2++; LEN--;\
if( !LEN ){ break; }if( r1[0] != r2[0] ){ break; } r1++; r2++; LEN--;\
if( !LEN ){ break; }if( r1[0] != r2[0] ){ break; } r1++; r2++; LEN--;\
if( !LEN ){ break; }if( r1[0] != r2[0] ){ break; } r1++; r2++; LEN--;\
}\
RC = !LEN ? 0 : r1[0] - r2[0];\
}
#define SX_MACRO_FAST_MEMCPY(SRC, DST, SIZ){\
register unsigned char *xSrc = (unsigned char *)SRC;\
register unsigned char *xDst = (unsigned char *)DST;\
register sxu32 xLen = SIZ;\
for(;;){\
if( !xLen ){ break; }xDst[0] = xSrc[0]; xDst++; xSrc++; --xLen;\
if( !xLen ){ break; }xDst[0] = xSrc[0]; xDst++; xSrc++; --xLen;\
if( !xLen ){ break; }xDst[0] = xSrc[0]; xDst++; xSrc++; --xLen;\
if( !xLen ){ break; }xDst[0] = xSrc[0]; xDst++; xSrc++; --xLen;\
}\
}
#define SX_MACRO_BYTE_SWAP(X, Y, Z){\
register unsigned char *s = (unsigned char *)X;\
register unsigned char *d = (unsigned char *)Y;\
sxu32 ZLong = Z; \
sxi32 c; \
for(;;){\
if(!ZLong){ break; } c = s[0] ; s[0] = d[0]; d[0] = (unsigned char)c; s++; d++; --ZLong;\
if(!ZLong){ break; } c = s[0] ; s[0] = d[0]; d[0] = (unsigned char)c; s++; d++; --ZLong;\
if(!ZLong){ break; } c = s[0] ; s[0] = d[0]; d[0] = (unsigned char)c; s++; d++; --ZLong;\
if(!ZLong){ break; } c = s[0] ; s[0] = d[0]; d[0] = (unsigned char)c; s++; d++; --ZLong;\
}\
}
#define SX_MSEC_PER_SEC (1000) /* Millisec per seconds */
#define SX_USEC_PER_SEC (1000000) /* Microsec per seconds */
#define SX_NSEC_PER_SEC (1000000000) /* Nanosec per seconds */
#endif /* SYMISC_PRIVATE_DEFS */
/* Symisc Run-time API auxiliary definitions */
#if !defined(SYMISC_PRIVATE_AUX_DEFS)
#define SYMISC_PRIVATE_AUX_DEFS
typedef struct SyHashEntry_Pr SyHashEntry_Pr;
typedef struct SyHashEntry SyHashEntry;
typedef struct SyHash SyHash;
/*
* Each public hashtable entry is represented by an instance
* of the following structure.
*/
struct SyHashEntry
{
const void *pKey; /* Hash key */
sxu32 nKeyLen; /* Key length */
void *pUserData; /* User private data */
};
#define SyHashEntryGetUserData(ENTRY) ((ENTRY)->pUserData)
#define SyHashEntryGetKey(ENTRY) ((ENTRY)->pKey)
/* Each active hashtable is identified by an instance of the following structure */
struct SyHash
{
SyMemBackend *pAllocator; /* Memory backend */
ProcHash xHash; /* Hash function */
ProcCmp xCmp; /* Comparison function */
SyHashEntry_Pr *pList, *pCurrent; /* Linked list of hash entries user for linear traversal */
sxu32 nEntry; /* Total number of entries */
SyHashEntry_Pr **apBucket; /* Hash buckets */
sxu32 nBucketSize; /* Current bucket size */
};
#define SXHASH_BUCKET_SIZE 16 /* Initial bucket size: must be a power of two */
#define SXHASH_FILL_FACTOR 3
/* Hash access macro */
#define SyHashFunc(HASH) ((HASH)->xHash)
#define SyHashCmpFunc(HASH) ((HASH)->xCmp)
#define SyHashTotalEntry(HASH) ((HASH)->nEntry)
#define SyHashGetPool(HASH) ((HASH)->pAllocator)
/*
* An instance of the following structure define a single context
* for an Pseudo Random Number Generator.
*
* Nothing in this file or anywhere else in the library does any kind of
* encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
* number generator) not as an encryption device.
* This implementation is taken from the SQLite3 source tree.
*/
typedef struct SyPRNGCtx SyPRNGCtx;
struct SyPRNGCtx
{
sxu8 i, j; /* State variables */
unsigned char s[256]; /* State variables */
sxu16 nMagic; /* Sanity check */
};
typedef sxi32 (*ProcRandomSeed)(void *, unsigned int, void *);
/* High resolution timer.*/
typedef struct sytime sytime;
struct sytime
{
long tm_sec; /* seconds */
long tm_usec; /* microseconds */
};
/* Forward declaration */
typedef struct SyStream SyStream;
typedef struct SyToken SyToken;
typedef struct SyLex SyLex;
/*
* Tokenizer callback signature.
*/
typedef sxi32 (*ProcTokenizer)(SyStream *, SyToken *, void *, void *);
/*
* Each token in the input is represented by an instance
* of the following structure.
*/
struct SyToken
{
SyString sData; /* Token text and length */
sxu32 nType; /* Token type */
sxu32 nLine; /* Token line number */
void *pUserData; /* User private data associated with this token */
};
/*
* During tokenization, information about the state of the input
* stream is held in an instance of the following structure.
*/
struct SyStream
{
const unsigned char *zInput; /* Complete text of the input */
const unsigned char *zText; /* Current input we are processing */
const unsigned char *zEnd; /* End of input marker */
sxu32 nLine; /* Total number of processed lines */
sxu32 nIgn; /* Total number of ignored tokens */
SySet *pSet; /* Token containers */
};
/*
* Each lexer is represented by an instance of the following structure.
*/
struct SyLex
{
SyStream sStream; /* Input stream */
ProcTokenizer xTokenizer; /* Tokenizer callback */
void * pUserData; /* Third argument to xTokenizer() */
SySet *pTokenSet; /* Token set */
};
#define SyLexTotalToken(LEX) SySetTotalEntry(&(LEX)->aTokenSet)
#define SyLexTotalLines(LEX) ((LEX)->sStream.nLine)
#define SyLexTotalIgnored(LEX) ((LEX)->sStream.nIgn)
#define XLEX_IN_LEN(STREAM) (sxu32)(STREAM->zEnd - STREAM->zText)
#endif /* SYMISC_PRIVATE_AUX_DEFS */
/*
** Notes on UTF-8 (According to SQLite3 authors):
**
** Byte-0 Byte-1 Byte-2 Byte-3 Value
** 0xxxxxxx 00000000 00000000 0xxxxxxx
** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx
** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx
** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx
**
*/
/*
** Assuming zIn points to the first byte of a UTF-8 character,
** advance zIn to point to the first byte of the next UTF-8 character.
*/
#define SX_JMP_UTF8(zIn, zEnd)\
while(zIn < zEnd && (((unsigned char)zIn[0] & 0xc0) == 0x80) ){ zIn++; }
#define SX_WRITE_UTF8(zOut, c) { \
if( c<0x00080 ){ \
*zOut++ = (sxu8)(c&0xFF); \
}else if( c<0x00800 ){ \
*zOut++ = 0xC0 + (sxu8)((c>>6)&0x1F); \
*zOut++ = 0x80 + (sxu8)(c & 0x3F); \
}else if( c<0x10000 ){ \
*zOut++ = 0xE0 + (sxu8)((c>>12)&0x0F); \
*zOut++ = 0x80 + (sxu8)((c>>6) & 0x3F); \
*zOut++ = 0x80 + (sxu8)(c & 0x3F); \
}else{ \
*zOut++ = 0xF0 + (sxu8)((c>>18) & 0x07); \
*zOut++ = 0x80 + (sxu8)((c>>12) & 0x3F); \
*zOut++ = 0x80 + (sxu8)((c>>6) & 0x3F); \
*zOut++ = 0x80 + (sxu8)(c & 0x3F); \
} \
}
/* Rely on the standard ctype */
#include <ctype.h>
#define SyToUpper(c) toupper(c)
#define SyToLower(c) tolower(c)
#define SyisUpper(c) isupper(c)
#define SyisLower(c) islower(c)
#define SyisSpace(c) isspace(c)
#define SyisBlank(c) isspace(c)
#define SyisAlpha(c) isalpha(c)
#define SyisDigit(c) isdigit(c)
#define SyisHex(c) isxdigit(c)
#define SyisPrint(c) isprint(c)
#define SyisPunct(c) ispunct(c)
#define SyisSpec(c) iscntrl(c)
#define SyisCtrl(c) iscntrl(c)
#define SyisAscii(c) isascii(c)
#define SyisAlphaNum(c) isalnum(c)
#define SyisGraph(c) isgraph(c)
#define SyDigToHex(c) "0123456789ABCDEF"[c & 0x0F]
#define SyDigToInt(c) ((c < 0xc0 && SyisDigit(c))? (c - '0') : 0 )
#define SyCharToUpper(c) ((c < 0xc0 && SyisLower(c))? SyToUpper(c) : c)
#define SyCharToLower(c) ((c < 0xc0 && SyisUpper(c))? SyToLower(c) : c)
/* Remove white space/NUL byte from a raw string */
#define SyStringLeftTrim(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[0] < 0xc0 && SyisSpace((RAW)->zString[0])){\
(RAW)->nByte--;\
(RAW)->zString++;\
}
#define SyStringLeftTrimSafe(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[0] < 0xc0 && ((RAW)->zString[0] == 0 || SyisSpace((RAW)->zString[0]))){\
(RAW)->nByte--;\
(RAW)->zString++;\
}
#define SyStringRightTrim(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[(RAW)->nByte - 1] < 0xc0 && SyisSpace((RAW)->zString[(RAW)->nByte - 1])){\
(RAW)->nByte--;\
}
#define SyStringRightTrimSafe(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[(RAW)->nByte - 1] < 0xc0 && \
(( RAW)->zString[(RAW)->nByte - 1] == 0 || SyisSpace((RAW)->zString[(RAW)->nByte - 1]))){\
(RAW)->nByte--;\
}
#define SyStringFullTrim(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[0] < 0xc0 && SyisSpace((RAW)->zString[0])){\
(RAW)->nByte--;\
(RAW)->zString++;\
}\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[(RAW)->nByte - 1] < 0xc0 && SyisSpace((RAW)->zString[(RAW)->nByte - 1])){\
(RAW)->nByte--;\
}
#define SyStringFullTrimSafe(RAW)\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[0] < 0xc0 && \
( (RAW)->zString[0] == 0 || SyisSpace((RAW)->zString[0]))){\
(RAW)->nByte--;\
(RAW)->zString++;\
}\
while((RAW)->nByte > 0 && (unsigned char)(RAW)->zString[(RAW)->nByte - 1] < 0xc0 && \
( (RAW)->zString[(RAW)->nByte - 1] == 0 || SyisSpace((RAW)->zString[(RAW)->nByte - 1]))){\
(RAW)->nByte--;\
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
/*
* An XML raw text, CDATA, tag name and son is parsed out and stored
* in an instance of the following structure.
*/
typedef struct SyXMLRawStr SyXMLRawStr;
struct SyXMLRawStr
{
const char *zString; /* Raw text [UTF-8 ENCODED EXCEPT CDATA] [NOT NULL TERMINATED] */
sxu32 nByte; /* Text length */
sxu32 nLine; /* Line number this text occurs */
};
/*
* Event callback signatures.
*/
typedef sxi32 (*ProcXMLStartTagHandler)(SyXMLRawStr *, SyXMLRawStr *, sxu32, SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLTextHandler)(SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLEndTagHandler)(SyXMLRawStr *, SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLPIHandler)(SyXMLRawStr *, SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLDoctypeHandler)(SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLSyntaxErrorHandler)(const char *, int, SyToken *, void *);
typedef sxi32 (*ProcXMLStartDocument)(void *);
typedef sxi32 (*ProcXMLNameSpaceStart)(SyXMLRawStr *, SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLNameSpaceEnd)(SyXMLRawStr *, void *);
typedef sxi32 (*ProcXMLEndDocument)(void *);
/* XML processing control flags */
#define SXML_ENABLE_NAMESPACE 0x01 /* Parse XML with namespace support enbaled */
#define SXML_ENABLE_QUERY 0x02 /* Not used */
#define SXML_OPTION_CASE_FOLDING 0x04 /* Controls whether case-folding is enabled for this XML parser */
#define SXML_OPTION_SKIP_TAGSTART 0x08 /* Specify how many characters should be skipped in the beginning of a tag name.*/
#define SXML_OPTION_SKIP_WHITE 0x10 /* Whether to skip values consisting of whitespace characters. */
#define SXML_OPTION_TARGET_ENCODING 0x20 /* Default encoding: UTF-8 */
/* XML error codes */
enum xml_err_code{
SXML_ERROR_NONE = 1,
SXML_ERROR_NO_MEMORY,
SXML_ERROR_SYNTAX,
SXML_ERROR_NO_ELEMENTS,
SXML_ERROR_INVALID_TOKEN,
SXML_ERROR_UNCLOSED_TOKEN,
SXML_ERROR_PARTIAL_CHAR,
SXML_ERROR_TAG_MISMATCH,
SXML_ERROR_DUPLICATE_ATTRIBUTE,
SXML_ERROR_JUNK_AFTER_DOC_ELEMENT,
SXML_ERROR_PARAM_ENTITY_REF,
SXML_ERROR_UNDEFINED_ENTITY,
SXML_ERROR_RECURSIVE_ENTITY_REF,
SXML_ERROR_ASYNC_ENTITY,
SXML_ERROR_BAD_CHAR_REF,
SXML_ERROR_BINARY_ENTITY_REF,
SXML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
SXML_ERROR_MISPLACED_XML_PI,
SXML_ERROR_UNKNOWN_ENCODING,
SXML_ERROR_INCORRECT_ENCODING,
SXML_ERROR_UNCLOSED_CDATA_SECTION,
SXML_ERROR_EXTERNAL_ENTITY_HANDLING
};
/* Each active XML SAX parser is represented by an instance
* of the following structure.
*/
typedef struct SyXMLParser SyXMLParser;
struct SyXMLParser
{
SyMemBackend *pAllocator; /* Memory backend */
void *pUserData; /* User private data forwarded varbatim by the XML parser
* as the last argument to the users callbacks.
*/
SyHash hns; /* Namespace hashtable */
SySet sToken; /* XML tokens */
SyLex sLex; /* Lexical analyzer */
sxi32 nFlags; /* Control flags */
/* User callbacks */
ProcXMLStartTagHandler xStartTag; /* Start element handler */
ProcXMLEndTagHandler xEndTag; /* End element handler */
ProcXMLTextHandler xRaw; /* Raw text/CDATA handler */
ProcXMLDoctypeHandler xDoctype; /* DOCTYPE handler */
ProcXMLPIHandler xPi; /* Processing instruction (PI) handler*/
ProcXMLSyntaxErrorHandler xError; /* Error handler */
ProcXMLStartDocument xStartDoc; /* StartDoc handler */
ProcXMLEndDocument xEndDoc; /* EndDoc handler */
ProcXMLNameSpaceStart xNameSpace; /* Namespace declaration handler */
ProcXMLNameSpaceEnd xNameSpaceEnd; /* End namespace declaration handler */
};
/*
* --------------
* Archive extractor:
* --------------
* Each open ZIP/TAR archive is identified by an instance of the following structure.
* That is, a process can open one or more archives and manipulates them in thread safe
* way by simply working with pointers to the following structure.
* Each entry in the archive is remembered in a hashtable.
* Lookup is very fast and entry with the same name are chained together.
*/
typedef struct SyArchiveEntry SyArchiveEntry;
typedef struct SyArchive SyArchive;
struct SyArchive
{
SyMemBackend *pAllocator; /* Memory backend */
SyArchiveEntry *pCursor; /* Cursor for linear traversal of archive entries */
SyArchiveEntry *pList; /* Pointer to the List of the loaded archive */
SyArchiveEntry **apHash; /* Hashtable for archive entry */
ProcRawStrCmp xCmp; /* Hash comparison function */
ProcHash xHash; /* Hash Function */
sxu32 nSize; /* Hashtable size */
sxu32 nEntry; /* Total number of entries in the zip/tar archive */
sxu32 nLoaded; /* Total number of entries loaded in memory */
sxu32 nCentralOfft; /* Central directory offset(ZIP only. Otherwise Zero) */
sxu32 nCentralSize; /* Central directory size(ZIP only. Otherwise Zero) */
void *pUserData; /* Upper layer private data */
sxu32 nMagic; /* Sanity check */
};
#define SXARCH_MAGIC 0xDEAD635A
#define SXARCH_INVALID(ARCH) (ARCH == 0 || ARCH->nMagic != SXARCH_MAGIC)
#define SXARCH_ENTRY_INVALID(ENTRY) (ENTRY == 0 || ENTRY->nMagic != SXARCH_MAGIC)
#define SyArchiveHashFunc(ARCH) (ARCH)->xHash
#define SyArchiveCmpFunc(ARCH) (ARCH)->xCmp
#define SyArchiveUserData(ARCH) (ARCH)->pUserData
#define SyArchiveSetUserData(ARCH, DATA) (ARCH)->pUserData = DATA
/*
* Each loaded archive record is identified by an instance
* of the following structure.
*/
struct SyArchiveEntry
{
sxu32 nByte; /* Contents size before compression */
sxu32 nByteCompr; /* Contents size after compression */
sxu32 nReadCount; /* Read counter */
sxu32 nCrc; /* Contents CRC32 */
Sytm sFmt; /* Last-modification time */
sxu32 nOfft; /* Data offset. */
sxu16 nComprMeth; /* Compression method 0 == stored/8 == deflated and so on (see appnote.txt)*/
sxu16 nExtra; /* Extra size if any */
SyString sFileName; /* entry name & length */
sxu32 nDup; /* Total number of entries with the same name */
SyArchiveEntry *pNextHash, *pPrevHash; /* Hash collision chains */
SyArchiveEntry *pNextName; /* Next entry with the same name */
SyArchiveEntry *pNext, *pPrev; /* Next and previous entry in the list */
sxu32 nHash; /* Hash of the entry name */
void *pUserData; /* User data */
sxu32 nMagic; /* Sanity check */
};
/*
* Extra flags for extending the file local header
*/
#define SXZIP_EXTRA_TIMESTAMP 0x001 /* Extended UNIX timestamp */
#endif /* JX9_DISABLE_BUILTIN_FUNC */
#ifndef JX9_DISABLE_HASH_FUNC
/* MD5 context */
typedef struct MD5Context MD5Context;
struct MD5Context {
sxu32 buf[4];
sxu32 bits[2];
unsigned char in[64];
};
/* SHA1 context */
typedef struct SHA1Context SHA1Context;
struct SHA1Context {
unsigned int state[5];
unsigned int count[2];
unsigned char buffer[64];
};
#endif /* JX9_DISABLE_HASH_FUNC */
/* JX9 private declaration */
/*
* Memory Objects.
* Internally, the JX9 virtual machine manipulates nearly all JX9 values
* [i.e: string, int, float, resource, object, bool, null] as jx9_values structures.
* Each jx9_values struct may cache multiple representations (string, integer etc.)
* of the same value.
*/
struct jx9_value
{
union{
jx9_real rVal; /* Real value */
sxi64 iVal; /* Integer value */
void *pOther; /* Other values (Object, Array, Resource, Namespace, etc.) */
}x;
sxi32 iFlags; /* Control flags (see below) */
jx9_vm *pVm; /* VM this instance belong */
SyBlob sBlob; /* String values */
sxu32 nIdx; /* Object index in the global pool */
};
/* Allowed value types.
*/
#define MEMOBJ_STRING 0x001 /* Memory value is a UTF-8 string */
#define MEMOBJ_INT 0x002 /* Memory value is an integer */
#define MEMOBJ_REAL 0x004 /* Memory value is a real number */
#define MEMOBJ_BOOL 0x008 /* Memory value is a boolean */
#define MEMOBJ_NULL 0x020 /* Memory value is NULL */
#define MEMOBJ_HASHMAP 0x040 /* Memory value is a hashmap (JSON representation of Array and Objects) */
#define MEMOBJ_RES 0x100 /* Memory value is a resource [User private data] */
/* Mask of all known types */
#define MEMOBJ_ALL (MEMOBJ_STRING|MEMOBJ_INT|MEMOBJ_REAL|MEMOBJ_BOOL|MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES)
/* Scalar variables
* According to the JX9 language reference manual
* Scalar variables are those containing an integer, float, string or boolean.
* Types array, object and resource are not scalar.
*/
#define MEMOBJ_SCALAR (MEMOBJ_STRING|MEMOBJ_INT|MEMOBJ_REAL|MEMOBJ_BOOL|MEMOBJ_NULL)
/*
* The following macro clear the current jx9_value type and replace
* it with the given one.
*/
#define MemObjSetType(OBJ, TYPE) ((OBJ)->iFlags = ((OBJ)->iFlags&~MEMOBJ_ALL)|TYPE)
/* jx9_value cast method signature */
typedef sxi32 (*ProcMemObjCast)(jx9_value *);
/* Forward reference */
typedef struct jx9_output_consumer jx9_output_consumer;
typedef struct jx9_user_func jx9_user_func;
typedef struct jx9_conf jx9_conf;
/*
* An instance of the following structure store the default VM output
* consumer and it's private data.
* Client-programs can register their own output consumer callback
* via the [JX9_VM_CONFIG_OUTPUT] configuration directive.
* Please refer to the official documentation for more information
* on how to register an output consumer callback.
*/
struct jx9_output_consumer
{
ProcConsumer xConsumer; /* VM output consumer routine */
void *pUserData; /* Third argument to xConsumer() */
ProcConsumer xDef; /* Default output consumer routine */
void *pDefData; /* Third argument to xDef() */
};
/*
* JX9 engine [i.e: jx9 instance] configuration is stored in
* an instance of the following structure.
* Please refer to the official documentation for more information
* on how to configure your jx9 engine instance.
*/
struct jx9_conf
{
ProcConsumer xErr; /* Compile-time error consumer callback */
void *pErrData; /* Third argument to xErr() */
SyBlob sErrConsumer; /* Default error consumer */
};
/*
* Signature of the C function responsible of expanding constant values.
*/
typedef void (*ProcConstant)(jx9_value *, void *);
/*
* Each registered constant [i.e: __TIME__, __DATE__, JX9_OS, INT_MAX, etc.] is stored
* in an instance of the following structure.
* Please refer to the official documentation for more information
* on how to create/install foreign constants.
*/
typedef struct jx9_constant jx9_constant;
struct jx9_constant
{
SyString sName; /* Constant name */
ProcConstant xExpand; /* Function responsible of expanding constant value */
void *pUserData; /* Last argument to xExpand() */
};
typedef struct jx9_aux_data jx9_aux_data;
/*
* Auxiliary data associated with each foreign function is stored
* in a stack of the following structure.
* Note that automatic tracked chunks are also stored in an instance
* of this structure.
*/
struct jx9_aux_data
{
void *pAuxData; /* Aux data */
};
/* Foreign functions signature */
typedef int (*ProcHostFunction)(jx9_context *, int, jx9_value **);
/*
* Each installed foreign function is recored in an instance of the following
* structure.
* Please refer to the official documentation for more information on how
* to create/install foreign functions.
*/
struct jx9_user_func
{
jx9_vm *pVm; /* VM that own this instance */
SyString sName; /* Foreign function name */
ProcHostFunction xFunc; /* Implementation of the foreign function */
void *pUserData; /* User private data [Refer to the official documentation for more information]*/
SySet aAux; /* Stack of auxiliary data [Refer to the official documentation for more information]*/
};
/*
* The 'context' argument for an installable function. A pointer to an
* instance of this structure is the first argument to the routines used
* implement the foreign functions.
*/
struct jx9_context
{
jx9_user_func *pFunc; /* Function information. */
jx9_value *pRet; /* Return value is stored here. */
SySet sVar; /* Container of dynamically allocated jx9_values
* [i.e: Garbage collection purposes.]
*/
SySet sChunk; /* Track dynamically allocated chunks [jx9_aux_data instance].
* [i.e: Garbage collection purposes.]
*/
jx9_vm *pVm; /* Virtual machine that own this context */
sxi32 iFlags; /* Call flags */
};
/* Hashmap control flags */
#define HASHMAP_JSON_OBJECT 0x001 /* Hashmap represent JSON Object*/
/*
* Each hashmap entry [i.e: array(4, 5, 6)] is recorded in an instance
* of the following structure.
*/
struct jx9_hashmap_node
{
jx9_hashmap *pMap; /* Hashmap that own this instance */
sxi32 iType; /* Node type */
union{
sxi64 iKey; /* Int key */
SyBlob sKey; /* Blob key */
}xKey;
sxi32 iFlags; /* Control flags */
sxu32 nHash; /* Key hash value */
sxu32 nValIdx; /* Value stored in this node */
jx9_hashmap_node *pNext, *pPrev; /* Link to other entries [i.e: linear traversal] */
jx9_hashmap_node *pNextCollide, *pPrevCollide; /* Collision chain */
};
/*
* Each active hashmap aka array in the JX9 jargon is represented
* by an instance of the following structure.
*/
struct jx9_hashmap
{
jx9_vm *pVm; /* VM that own this instance */
jx9_hashmap_node **apBucket; /* Hash bucket */
jx9_hashmap_node *pFirst; /* First inserted entry */
jx9_hashmap_node *pLast; /* Last inserted entry */
jx9_hashmap_node *pCur; /* Current entry */
sxu32 nSize; /* Bucket size */
sxu32 nEntry; /* Total number of inserted entries */
sxu32 (*xIntHash)(sxi64); /* Hash function for int_keys */
sxu32 (*xBlobHash)(const void *, sxu32); /* Hash function for blob_keys */
sxi32 iFlags; /* Hashmap control flags */
sxi64 iNextIdx; /* Next available automatically assigned index */
sxi32 iRef; /* Reference count */
};
/* An instance of the following structure is the context
* for the FOREACH_STEP/FOREACH_INIT VM instructions.
* Those instructions are used to implement the 'foreach'
* statement.
* This structure is made available to these instructions
* as the P3 operand.
*/
struct jx9_foreach_info
{
SyString sKey; /* Key name. Empty otherwise*/
SyString sValue; /* Value name */
sxi32 iFlags; /* Control flags */
SySet aStep; /* Stack of steps [i.e: jx9_foreach_step instance] */
};
struct jx9_foreach_step
{
sxi32 iFlags; /* Control flags (see below) */
/* Iterate on this map*/
jx9_hashmap *pMap; /* Hashmap [i.e: array in the JX9 jargon] iteration
* Ex: foreach(array(1, 2, 3) as $key=>$value){}
*/
};
/* Foreach step control flags */
#define JX9_4EACH_STEP_KEY 0x001 /* Make Key available */
/*
* Each JX9 engine is identified by an instance of the following structure.
* Please refer to the official documentation for more information
* on how to configure your JX9 engine instance.
*/
struct jx9
{
SyMemBackend sAllocator; /* Low level memory allocation subsystem */
const jx9_vfs *pVfs; /* Underlying Virtual File System */
jx9_conf xConf; /* Configuration */
#if defined(JX9_ENABLE_THREADS)
SyMutex *pMutex; /* Per-engine mutex */
#endif
jx9_vm *pVms; /* List of active VM */
sxi32 iVm; /* Total number of active VM */
jx9 *pNext, *pPrev; /* List of active engines */
sxu32 nMagic; /* Sanity check against misuse */
};
/* Code generation data structures */
typedef sxi32 (*ProcErrorGen)(void *, sxi32, sxu32, const char *, ...);
typedef struct jx9_expr_node jx9_expr_node;
typedef struct jx9_expr_op jx9_expr_op;
typedef struct jx9_gen_state jx9_gen_state;
typedef struct GenBlock GenBlock;
typedef sxi32 (*ProcLangConstruct)(jx9_gen_state *);
typedef sxi32 (*ProcNodeConstruct)(jx9_gen_state *, sxi32);
/*
* Each supported operator [i.e: +, -, ==, *, %, >>, >=, new, etc.] is represented
* by an instance of the following structure.
* The JX9 parser does not use any external tools and is 100% handcoded.
* That is, the JX9 parser is thread-safe , full reentrant, produce consistant
* compile-time errrors and at least 7 times faster than the standard JX9 parser.
*/
struct jx9_expr_op
{
SyString sOp; /* String representation of the operator [i.e: "+", "*", "=="...] */
sxi32 iOp; /* Operator ID */
sxi32 iPrec; /* Operator precedence: 1 == Highest */
sxi32 iAssoc; /* Operator associativity (either left, right or non-associative) */
sxi32 iVmOp; /* VM OP code for this operator [i.e: JX9_OP_EQ, JX9_OP_LT, JX9_OP_MUL...]*/
};
/*
* Each expression node is parsed out and recorded
* in an instance of the following structure.
*/
struct jx9_expr_node
{
const jx9_expr_op *pOp; /* Operator ID or NULL if literal, constant, variable, function or object method call */
jx9_expr_node *pLeft; /* Left expression tree */
jx9_expr_node *pRight; /* Right expression tree */
SyToken *pStart; /* Stream of tokens that belong to this node */
SyToken *pEnd; /* End of token stream */
sxi32 iFlags; /* Node construct flags */
ProcNodeConstruct xCode; /* C routine responsible of compiling this node */
SySet aNodeArgs; /* Node arguments. Only used by postfix operators [i.e: function call]*/
jx9_expr_node *pCond; /* Condition: Only used by the ternary operator '?:' */
};
/* Node Construct flags */
#define EXPR_NODE_PRE_INCR 0x01 /* Pre-icrement/decrement [i.e: ++$i, --$j] node */
/*
* A block of instructions is recorded in an instance of the following structure.
* This structure is used only during compile-time and have no meaning
* during bytecode execution.
*/
struct GenBlock
{
jx9_gen_state *pGen; /* State of the code generator */
GenBlock *pParent; /* Upper block or NULL if global */
sxu32 nFirstInstr; /* First instruction to execute */
sxi32 iFlags; /* Block control flags (see below) */
SySet aJumpFix; /* Jump fixup (JumpFixup instance) */
void *pUserData; /* Upper layer private data */
/* The following two fields are used only when compiling
* the 'do..while()' language construct.
*/
sxu8 bPostContinue; /* TRUE when compiling the do..while() statement */
SySet aPostContFix; /* Post-continue jump fix */
};
/*
* Code generator state is remembered in an instance of the following
* structure. We put the information in this structure and pass around
* a pointer to this structure, rather than pass around all of the
* information separately. This helps reduce the number of arguments
* to generator functions.
* This structure is used only during compile-time and have no meaning
* during bytecode execution.
*/
struct jx9_gen_state
{
jx9_vm *pVm; /* VM that own this instance */
SyHash hLiteral; /* Constant string Literals table */
SyHash hNumLiteral; /* Numeric literals table */
SyHash hVar; /* Collected variable hashtable */
GenBlock *pCurrent; /* Current processed block */
GenBlock sGlobal; /* Global block */
ProcConsumer xErr; /* Error consumer callback */
void *pErrData; /* Third argument to xErr() */
SyToken *pIn; /* Current processed token */
SyToken *pEnd; /* Last token in the stream */
sxu32 nErr; /* Total number of compilation error */
};
/* Forward references */
typedef struct jx9_vm_func_static_var jx9_vm_func_static_var;
typedef struct jx9_vm_func_arg jx9_vm_func_arg;
typedef struct jx9_vm_func jx9_vm_func;
typedef struct VmFrame VmFrame;
/*
* Each collected function argument is recorded in an instance
* of the following structure.
* Note that as an extension, JX9 implements full type hinting
* which mean that any function can have it's own signature.
* Example:
* function foo(int $a, string $b, float $c, ClassInstance $d){}
* This is how the powerful function overloading mechanism is
* implemented.
* Note that as an extension, JX9 allow function arguments to have
* any complex default value associated with them unlike the standard
* JX9 engine.
* Example:
* function foo(int $a = rand() & 1023){}
* now, when foo is called without arguments [i.e: foo()] the
* $a variable (first parameter) will be set to a random number
* between 0 and 1023 inclusive.
* Refer to the official documentation for more information on this
* mechanism and other extension introduced by the JX9 engine.
*/
struct jx9_vm_func_arg
{
SyString sName; /* Argument name */
SySet aByteCode; /* Compiled default value associated with this argument */
sxu32 nType; /* Type of this argument [i.e: array, int, string, float, object, etc.] */
sxi32 iFlags; /* Configuration flags */
};
/*
* Each static variable is parsed out and remembered in an instance
* of the following structure.
* Note that as an extension, JX9 allow static variable have
* any complex default value associated with them unlike the standard
* JX9 engine.
* Example:
* static $rand_str = 'JX9'.rand_str(3); // Concatenate 'JX9' with
* // a random three characters(English alphabet)
* dump($rand_str);
* //You should see something like this
* string(6 'JX9awt');
*/
struct jx9_vm_func_static_var
{
SyString sName; /* Static variable name */
SySet aByteCode; /* Compiled initialization expression */
sxu32 nIdx; /* Object index in the global memory object container */
};
/* Function configuration flags */
#define VM_FUNC_ARG_HAS_DEF 0x001 /* Argument has default value associated with it */
#define VM_FUNC_ARG_IGNORE 0x002 /* Do not install argument in the current frame */
/*
* Each user defined function is parsed out and stored in an instance
* of the following structure.
* JX9 introduced some powerfull extensions to the JX9 5 programming
* language like function overloading, type hinting, complex default
* arguments values and many more.
* Please refer to the official documentation for more information.
*/
struct jx9_vm_func
{
SySet aArgs; /* Expected arguments (jx9_vm_func_arg instance) */
SySet aStatic; /* Static variable (jx9_vm_func_static_var instance) */
SyString sName; /* Function name */
SySet aByteCode; /* Compiled function body */
sxi32 iFlags; /* VM function configuration */
SyString sSignature; /* Function signature used to implement function overloading
* (Refer to the official docuemntation for more information
* on this powerfull feature)
*/
void *pUserData; /* Upper layer private data associated with this instance */
jx9_vm_func *pNextName; /* Next VM function with the same name as this one */
};
/* Forward reference */
typedef struct jx9_builtin_constant jx9_builtin_constant;
typedef struct jx9_builtin_func jx9_builtin_func;
/*
* Each built-in foreign function (C function) is stored in an
* instance of the following structure.
* Please refer to the official documentation for more information
* on how to create/install foreign functions.
*/
struct jx9_builtin_func
{
const char *zName; /* Function name [i.e: strlen(), rand(), array_merge(), etc.]*/
ProcHostFunction xFunc; /* C routine performing the computation */
};
/*
* Each built-in foreign constant is stored in an instance
* of the following structure.
* Please refer to the official documentation for more information
* on how to create/install foreign constants.
*/
struct jx9_builtin_constant
{
const char *zName; /* Constant name */
ProcConstant xExpand; /* C routine responsible of expanding constant value*/
};
/*
* A single instruction of the virtual machine has an opcode
* and as many as three operands.
* Each VM instruction resulting from compiling a JX9 script
* is stored in an instance of the following structure.
*/
typedef struct VmInstr VmInstr;
struct VmInstr
{
sxu8 iOp; /* Operation to preform */
sxi32 iP1; /* First operand */
sxu32 iP2; /* Second operand (Often the jump destination) */
void *p3; /* Third operand (Often Upper layer private data) */
};
/* Forward reference */
typedef struct jx9_case_expr jx9_case_expr;
typedef struct jx9_switch jx9_switch;
/*
* Each compiled case block in a swicth statement is compiled
* and stored in an instance of the following structure.
*/
struct jx9_case_expr
{
SySet aByteCode; /* Compiled body of the case block */
sxu32 nStart; /* First instruction to execute */
};
/*
* Each compiled switch statement is parsed out and stored
* in an instance of the following structure.
*/
struct jx9_switch
{
SySet aCaseExpr; /* Compile case block */
sxu32 nOut; /* First instruction to execute after this statement */
sxu32 nDefault; /* First instruction to execute in the default block */
};
/* Assertion flags */
#define JX9_ASSERT_DISABLE 0x01 /* Disable assertion */
#define JX9_ASSERT_WARNING 0x02 /* Issue a warning for each failed assertion */
#define JX9_ASSERT_BAIL 0x04 /* Terminate execution on failed assertions */
#define JX9_ASSERT_QUIET_EVAL 0x08 /* Not used */
#define JX9_ASSERT_CALLBACK 0x10 /* Callback to call on failed assertions */
/*
* An instance of the following structure hold the bytecode instructions
* resulting from compiling a JX9 script.
* This structure contains the complete state of the virtual machine.
*/
struct jx9_vm
{
SyMemBackend sAllocator; /* Memory backend */
#if defined(JX9_ENABLE_THREADS)
SyMutex *pMutex; /* Recursive mutex associated with this VM. */
#endif
jx9 *pEngine; /* Interpreter that own this VM */
SySet aByteCode; /* Default bytecode container */
SySet *pByteContainer; /* Current bytecode container */
VmFrame *pFrame; /* Stack of active frames */
SyPRNGCtx sPrng; /* PRNG context */
SySet aMemObj; /* Object allocation table */
SySet aLitObj; /* Literals allocation table */
jx9_value *aOps; /* Operand stack */
SySet aFreeObj; /* Stack of free memory objects */
SyHash hConstant; /* Host-application and user defined constants container */
SyHash hHostFunction; /* Host-application installable functions */
SyHash hFunction; /* Compiled functions */
SyHash hSuper; /* Global variable */
SyBlob sConsumer; /* Default VM consumer [i.e Redirect all VM output to this blob] */
SyBlob sWorker; /* General purpose working buffer */
SyBlob sArgv; /* $argv[] collector [refer to the [getopt()] implementation for more information] */
SySet aFiles; /* Stack of processed files */
SySet aPaths; /* Set of import paths */
SySet aIncluded; /* Set of included files */
SySet aIOstream; /* Installed IO stream container */
const jx9_io_stream *pDefStream; /* Default IO stream [i.e: typically this is the 'file://' stream] */
jx9_value sExec; /* Compiled script return value [Can be extracted via the JX9_VM_CONFIG_EXEC_VALUE directive]*/
void *pStdin; /* STDIN IO stream */
void *pStdout; /* STDOUT IO stream */
void *pStderr; /* STDERR IO stream */
int bErrReport; /* TRUE to report all runtime Error/Warning/Notice */
int nRecursionDepth; /* Current recursion depth */
int nMaxDepth; /* Maximum allowed recusion depth */
sxu32 nOutputLen; /* Total number of generated output */
jx9_output_consumer sVmConsumer; /* Registered output consumer callback */
int iAssertFlags; /* Assertion flags */
jx9_value sAssertCallback; /* Callback to call on failed assertions */
sxi32 iExitStatus; /* Script exit status */
jx9_gen_state sCodeGen; /* Code generator module */
jx9_vm *pNext, *pPrev; /* List of active VM's */
sxu32 nMagic; /* Sanity check against misuse */
};
/*
* Allowed value for jx9_vm.nMagic
*/
#define JX9_VM_INIT 0xEA12CD72 /* VM correctly initialized */
#define JX9_VM_RUN 0xBA851227 /* VM ready to execute JX9 bytecode */
#define JX9_VM_EXEC 0xCDFE1DAD /* VM executing JX9 bytecode */
#define JX9_VM_STALE 0xDEAD2BAD /* Stale VM */
/*
* Error codes according to the JX9 language reference manual.
*/
enum iErrCode
{
E_ABORT = -1, /* deadliness error， should halt script execution. */
E_ERROR = 1, /* Fatal run-time errors. These indicate errors that can not be recovered
* from, such as a memory allocation problem. Execution of the script is
* halted.
* The only fatal error under JX9 is an out-of-memory. All others erros
* even a call to undefined function will not halt script execution.
*/
E_WARNING , /* Run-time warnings (non-fatal errors). Execution of the script is not halted. */
E_PARSE , /* Compile-time parse errors. Parse errors should only be generated by the parser.*/
E_NOTICE , /* Run-time notices. Indicate that the script encountered something that could
* indicate an error, but could also happen in the normal course of running a script.
*/
};
/*
* Each VM instruction resulting from compiling a JX9 script is represented
* by one of the following OP codes.
* The program consists of a linear sequence of operations. Each operation
* has an opcode and 3 operands.Operands P1 is an integer.
* Operand P2 is an unsigned integer and operand P3 is a memory address.
* Few opcodes use all 3 operands.
*/
enum jx9_vm_op {
JX9_OP_DONE = 1, /* Done */
JX9_OP_HALT, /* Halt */
JX9_OP_LOAD, /* Load memory object */
JX9_OP_LOADC, /* Load constant */
JX9_OP_LOAD_IDX, /* Load array entry */
JX9_OP_LOAD_MAP, /* Load hashmap('array') */
JX9_OP_NOOP, /* NOOP */
JX9_OP_JMP, /* Unconditional jump */
JX9_OP_JZ, /* Jump on zero (FALSE jump) */
JX9_OP_JNZ, /* Jump on non-zero (TRUE jump) */
JX9_OP_POP, /* Stack POP */
JX9_OP_CAT, /* Concatenation */
JX9_OP_CVT_INT, /* Integer cast */
JX9_OP_CVT_STR, /* String cast */
JX9_OP_CVT_REAL, /* Float cast */
JX9_OP_CALL, /* Function call */
JX9_OP_UMINUS, /* Unary minus '-'*/
JX9_OP_UPLUS, /* Unary plus '+'*/
JX9_OP_BITNOT, /* Bitwise not '~' */
JX9_OP_LNOT, /* Logical not '!' */
JX9_OP_MUL, /* Multiplication '*' */
JX9_OP_DIV, /* Division '/' */
JX9_OP_MOD, /* Modulus '%' */
JX9_OP_ADD, /* Add '+' */
JX9_OP_SUB, /* Sub '-' */
JX9_OP_SHL, /* Left shift '<<' */
JX9_OP_SHR, /* Right shift '>>' */
JX9_OP_LT, /* Less than '<' */
JX9_OP_LE, /* Less or equal '<=' */
JX9_OP_GT, /* Greater than '>' */
JX9_OP_GE, /* Greater or equal '>=' */
JX9_OP_EQ, /* Equal '==' */
JX9_OP_NEQ, /* Not equal '!=' */
JX9_OP_TEQ, /* Type equal '===' */
JX9_OP_TNE, /* Type not equal '!==' */
JX9_OP_BAND, /* Bitwise and '&' */
JX9_OP_BXOR, /* Bitwise xor '^' */
JX9_OP_BOR, /* Bitwise or '|' */
JX9_OP_LAND, /* Logical and '&&','and' */
JX9_OP_LOR, /* Logical or '||','or' */
JX9_OP_LXOR, /* Logical xor 'xor' */
JX9_OP_STORE, /* Store Object */
JX9_OP_STORE_IDX, /* Store indexed object */
JX9_OP_PULL, /* Stack pull */
JX9_OP_SWAP, /* Stack swap */
JX9_OP_YIELD, /* Stack yield */
JX9_OP_CVT_BOOL, /* Boolean cast */
JX9_OP_CVT_NUMC, /* Numeric (integer, real or both) type cast */
JX9_OP_INCR, /* Increment ++ */
JX9_OP_DECR, /* Decrement -- */
JX9_OP_ADD_STORE, /* Add and store '+=' */
JX9_OP_SUB_STORE, /* Sub and store '-=' */
JX9_OP_MUL_STORE, /* Mul and store '*=' */
JX9_OP_DIV_STORE, /* Div and store '/=' */
JX9_OP_MOD_STORE, /* Mod and store '%=' */
JX9_OP_CAT_STORE, /* Cat and store '.=' */
JX9_OP_SHL_STORE, /* Shift left and store '>>=' */
JX9_OP_SHR_STORE, /* Shift right and store '<<=' */
JX9_OP_BAND_STORE, /* Bitand and store '&=' */
JX9_OP_BOR_STORE, /* Bitor and store '|=' */
JX9_OP_BXOR_STORE, /* Bitxor and store '^=' */
JX9_OP_CONSUME, /* Consume VM output */
JX9_OP_MEMBER, /* Object member run-time access */
JX9_OP_UPLINK, /* Run-Time frame link */
JX9_OP_CVT_NULL, /* NULL cast */
JX9_OP_CVT_ARRAY, /* Array cast */
JX9_OP_FOREACH_INIT, /* For each init */
JX9_OP_FOREACH_STEP, /* For each step */
JX9_OP_SWITCH /* Switch operation */
};
/* -- END-OF INSTRUCTIONS -- */
/*
* Expression Operators ID.
*/
enum jx9_expr_id {
EXPR_OP_DOT, /* Member access */
EXPR_OP_DC, /* :: */
EXPR_OP_SUBSCRIPT, /* []: Subscripting */
EXPR_OP_FUNC_CALL, /* func_call() */
EXPR_OP_INCR, /* ++ */
EXPR_OP_DECR, /* -- */
EXPR_OP_BITNOT, /* ~ */
EXPR_OP_UMINUS, /* Unary minus */
EXPR_OP_UPLUS, /* Unary plus */
EXPR_OP_TYPECAST, /* Type cast [i.e: (int), (float), (string)...] */
EXPR_OP_ALT, /* @ */
EXPR_OP_INSTOF, /* instanceof */
EXPR_OP_LOGNOT, /* logical not ! */
EXPR_OP_MUL, /* Multiplication */
EXPR_OP_DIV, /* division */
EXPR_OP_MOD, /* Modulus */
EXPR_OP_ADD, /* Addition */
EXPR_OP_SUB, /* Substraction */
EXPR_OP_DDOT, /* Concatenation */
EXPR_OP_SHL, /* Left shift */
EXPR_OP_SHR, /* Right shift */
EXPR_OP_LT, /* Less than */
EXPR_OP_LE, /* Less equal */
EXPR_OP_GT, /* Greater than */
EXPR_OP_GE, /* Greater equal */
EXPR_OP_EQ, /* Equal == */
EXPR_OP_NE, /* Not equal != <> */
EXPR_OP_TEQ, /* Type equal === */
EXPR_OP_TNE, /* Type not equal !== */
EXPR_OP_SEQ, /* String equal 'eq' */
EXPR_OP_SNE, /* String not equal 'ne' */
EXPR_OP_BAND, /* Biwise and '&' */
EXPR_OP_REF, /* Reference operator '&' */
EXPR_OP_XOR, /* bitwise xor '^' */
EXPR_OP_BOR, /* bitwise or '|' */
EXPR_OP_LAND, /* Logical and '&&','and' */
EXPR_OP_LOR, /* Logical or '||','or'*/
EXPR_OP_LXOR, /* Logical xor 'xor' */
EXPR_OP_QUESTY, /* Ternary operator '?' */
EXPR_OP_ASSIGN, /* Assignment '=' */
EXPR_OP_ADD_ASSIGN, /* Combined operator: += */
EXPR_OP_SUB_ASSIGN, /* Combined operator: -= */
EXPR_OP_MUL_ASSIGN, /* Combined operator: *= */
EXPR_OP_DIV_ASSIGN, /* Combined operator: /= */
EXPR_OP_MOD_ASSIGN, /* Combined operator: %= */
EXPR_OP_DOT_ASSIGN, /* Combined operator: .= */
EXPR_OP_AND_ASSIGN, /* Combined operator: &= */
EXPR_OP_OR_ASSIGN, /* Combined operator: |= */
EXPR_OP_XOR_ASSIGN, /* Combined operator: ^= */
EXPR_OP_SHL_ASSIGN, /* Combined operator: <<= */
EXPR_OP_SHR_ASSIGN, /* Combined operator: >>= */
EXPR_OP_COMMA /* Comma expression */
};
/*
* Lexer token codes
* The following set of constants are the tokens recognized
* by the lexer when processing JX9 input.
* Important: Token values MUST BE A POWER OF TWO.
*/
#define JX9_TK_INTEGER 0x0000001 /* Integer */
#define JX9_TK_REAL 0x0000002 /* Real number */
#define JX9_TK_NUM (JX9_TK_INTEGER|JX9_TK_REAL) /* Numeric token, either integer or real */
#define JX9_TK_KEYWORD 0x0000004 /* Keyword [i.e: while, for, if, foreach...] */
#define JX9_TK_ID 0x0000008 /* Alphanumeric or UTF-8 stream */
#define JX9_TK_DOLLAR 0x0000010 /* '$' Dollar sign */
#define JX9_TK_OP 0x0000020 /* Operator [i.e: +, *, /...] */
#define JX9_TK_OCB 0x0000040 /* Open curly brace'{' */
#define JX9_TK_CCB 0x0000080 /* Closing curly brace'}' */
#define JX9_TK_DOT 0x0000100 /* Dot . */
#define JX9_TK_LPAREN 0x0000200 /* Left parenthesis '(' */
#define JX9_TK_RPAREN 0x0000400 /* Right parenthesis ')' */
#define JX9_TK_OSB 0x0000800 /* Open square bracket '[' */
#define JX9_TK_CSB 0x0001000 /* Closing square bracket ']' */
#define JX9_TK_DSTR 0x0002000 /* Double quoted string "$str" */
#define JX9_TK_SSTR 0x0004000 /* Single quoted string 'str' */
#define JX9_TK_NOWDOC 0x0010000 /* Nowdoc <<< */
#define JX9_TK_COMMA 0x0020000 /* Comma ',' */
#define JX9_TK_SEMI 0x0040000 /* Semi-colon ";" */
#define JX9_TK_BSTR 0x0080000 /* Backtick quoted string [i.e: Shell command `date`] */
#define JX9_TK_COLON 0x0100000 /* single Colon ':' */
#define JX9_TK_AMPER 0x0200000 /* Ampersand '&' */
#define JX9_TK_EQUAL 0x0400000 /* Equal '=' */
#define JX9_TK_OTHER 0x1000000 /* Other symbols */
/*
* JX9 keyword.
* These words have special meaning in JX9. Some of them represent things which look like
* functions, some look like constants, and so on, but they're not, really: they are language constructs.
* You cannot use any of the following words as constants, object names, function or method names.
* Using them as variable names is generally OK, but could lead to confusion.
*/
#define JX9_TKWRD_SWITCH 1 /* switch */
#define JX9_TKWRD_PRINT 2 /* print */
#define JX9_TKWRD_ELIF 0x4000000 /* elseif: MUST BE A POWER OF TWO */
#define JX9_TKWRD_ELSE 0x8000000 /* else: MUST BE A POWER OF TWO */
#define JX9_TKWRD_IF 3 /* if */
#define JX9_TKWRD_STATIC 4 /* static */
#define JX9_TKWRD_CASE 5 /* case */
#define JX9_TKWRD_FUNCTION 6 /* function */
#define JX9_TKWRD_CONST 7 /* const */
/* The number '8' is reserved for JX9_TK_ID */
#define JX9_TKWRD_WHILE 9 /* while */
#define JX9_TKWRD_DEFAULT 10 /* default */
#define JX9_TKWRD_AS 11 /* as */
#define JX9_TKWRD_CONTINUE 12 /* continue */
#define JX9_TKWRD_EXIT 13 /* exit */
#define JX9_TKWRD_DIE 14 /* die */
#define JX9_TKWRD_IMPORT 15 /* import */
#define JX9_TKWRD_INCLUDE 16 /* include */
#define JX9_TKWRD_FOR 17 /* for */
#define JX9_TKWRD_FOREACH 18 /* foreach */
#define JX9_TKWRD_RETURN 19 /* return */
#define JX9_TKWRD_BREAK 20 /* break */
#define JX9_TKWRD_UPLINK 21 /* uplink */
#define JX9_TKWRD_BOOL 0x8000 /* bool: MUST BE A POWER OF TWO */
#define JX9_TKWRD_INT 0x10000 /* int: MUST BE A POWER OF TWO */
#define JX9_TKWRD_FLOAT 0x20000 /* float: MUST BE A POWER OF TWO */
#define JX9_TKWRD_STRING 0x40000 /* string: MUST BE A POWER OF TWO */
/* api.c */
JX9_PRIVATE sxi32 jx9EngineConfig(jx9 *pEngine, sxi32 nOp, va_list ap);
JX9_PRIVATE int jx9DeleteFunction(jx9_vm *pVm,const char *zName);
JX9_PRIVATE int Jx9DeleteConstant(jx9_vm *pVm,const char *zName);
/* json.c function prototypes */
JX9_PRIVATE int jx9JsonSerialize(jx9_value *pValue,SyBlob *pOut);
JX9_PRIVATE int jx9JsonDecode(jx9_context *pCtx,const char *zJSON,int nByte);
/* memobj.c function prototypes */
JX9_PRIVATE sxi32 jx9MemObjDump(SyBlob *pOut, jx9_value *pObj);
JX9_PRIVATE const char * jx9MemObjTypeDump(jx9_value *pVal);
JX9_PRIVATE sxi32 jx9MemObjAdd(jx9_value *pObj1, jx9_value *pObj2, int bAddStore);
JX9_PRIVATE sxi32 jx9MemObjCmp(jx9_value *pObj1, jx9_value *pObj2, int bStrict, int iNest);
JX9_PRIVATE sxi32 jx9MemObjInitFromString(jx9_vm *pVm, jx9_value *pObj, const SyString *pVal);
JX9_PRIVATE sxi32 jx9MemObjInitFromArray(jx9_vm *pVm, jx9_value *pObj, jx9_hashmap *pArray);
#if 0
/* Not used in the current release of the JX9 engine */
JX9_PRIVATE sxi32 jx9MemObjInitFromReal(jx9_vm *pVm, jx9_value *pObj, jx9_real rVal);
#endif
JX9_PRIVATE sxi32 jx9MemObjInitFromInt(jx9_vm *pVm, jx9_value *pObj, sxi64 iVal);
JX9_PRIVATE sxi32 jx9MemObjInitFromBool(jx9_vm *pVm, jx9_value *pObj, sxi32 iVal);
JX9_PRIVATE sxi32 jx9MemObjInit(jx9_vm *pVm, jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjStringAppend(jx9_value *pObj, const char *zData, sxu32 nLen);
#if 0
/* Not used in the current release of the JX9 engine */
JX9_PRIVATE sxi32 jx9MemObjStringFormat(jx9_value *pObj, const char *zFormat, va_list ap);
#endif
JX9_PRIVATE sxi32 jx9MemObjStore(jx9_value *pSrc, jx9_value *pDest);
JX9_PRIVATE sxi32 jx9MemObjLoad(jx9_value *pSrc, jx9_value *pDest);
JX9_PRIVATE sxi32 jx9MemObjRelease(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToNumeric(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjTryInteger(jx9_value *pObj);
JX9_PRIVATE ProcMemObjCast jx9MemObjCastMethod(sxi32 iFlags);
JX9_PRIVATE sxi32 jx9MemObjIsNumeric(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjIsEmpty(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToHashmap(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToString(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToNull(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToReal(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToInteger(jx9_value *pObj);
JX9_PRIVATE sxi32 jx9MemObjToBool(jx9_value *pObj);
JX9_PRIVATE sxi64 jx9TokenValueToInt64(SyString *pData);
/* lex.c function prototypes */
JX9_PRIVATE sxi32 jx9Tokenize(const char *zInput, sxu32 nLen, SySet *pOut);
/* vm.c function prototypes */
JX9_PRIVATE void jx9VmReleaseContextValue(jx9_context *pCtx, jx9_value *pValue);
JX9_PRIVATE sxi32 jx9VmInitFuncState(jx9_vm *pVm, jx9_vm_func *pFunc, const char *zName, sxu32 nByte,
sxi32 iFlags, void *pUserData);
JX9_PRIVATE sxi32 jx9VmInstallUserFunction(jx9_vm *pVm, jx9_vm_func *pFunc, SyString *pName);
JX9_PRIVATE sxi32 jx9VmRegisterConstant(jx9_vm *pVm, const SyString *pName, ProcConstant xExpand, void *pUserData);
JX9_PRIVATE sxi32 jx9VmInstallForeignFunction(jx9_vm *pVm, const SyString *pName, ProcHostFunction xFunc, void *pUserData);
JX9_PRIVATE sxi32 jx9VmBlobConsumer(const void *pSrc, unsigned int nLen, void *pUserData);
JX9_PRIVATE jx9_value * jx9VmReserveMemObj(jx9_vm *pVm,sxu32 *pIndex);
JX9_PRIVATE jx9_value * jx9VmReserveConstObj(jx9_vm *pVm, sxu32 *pIndex);
JX9_PRIVATE sxi32 jx9VmOutputConsume(jx9_vm *pVm, SyString *pString);
JX9_PRIVATE sxi32 jx9VmOutputConsumeAp(jx9_vm *pVm, const char *zFormat, va_list ap);
JX9_PRIVATE sxi32 jx9VmThrowErrorAp(jx9_vm *pVm, SyString *pFuncName, sxi32 iErr, const char *zFormat, va_list ap);
JX9_PRIVATE sxi32 jx9VmThrowError(jx9_vm *pVm, SyString *pFuncName, sxi32 iErr, const char *zMessage);
JX9_PRIVATE void jx9VmExpandConstantValue(jx9_value *pVal, void *pUserData);
JX9_PRIVATE sxi32 jx9VmDump(jx9_vm *pVm, ProcConsumer xConsumer, void *pUserData);
JX9_PRIVATE sxi32 jx9VmInit(jx9_vm *pVm, jx9 *pEngine);
JX9_PRIVATE sxi32 jx9VmConfigure(jx9_vm *pVm, sxi32 nOp, va_list ap);
JX9_PRIVATE sxi32 jx9VmByteCodeExec(jx9_vm *pVm);
JX9_PRIVATE jx9_value * jx9VmExtractVariable(jx9_vm *pVm,SyString *pVar);
JX9_PRIVATE sxi32 jx9VmRelease(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9VmReset(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9VmMakeReady(jx9_vm *pVm);
JX9_PRIVATE sxu32 jx9VmInstrLength(jx9_vm *pVm);
JX9_PRIVATE VmInstr * jx9VmPopInstr(jx9_vm *pVm);
JX9_PRIVATE VmInstr * jx9VmPeekInstr(jx9_vm *pVm);
JX9_PRIVATE VmInstr *jx9VmGetInstr(jx9_vm *pVm, sxu32 nIndex);
JX9_PRIVATE SySet * jx9VmGetByteCodeContainer(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9VmSetByteCodeContainer(jx9_vm *pVm, SySet *pContainer);
JX9_PRIVATE sxi32 jx9VmEmitInstr(jx9_vm *pVm, sxi32 iOp, sxi32 iP1, sxu32 iP2, void *p3, sxu32 *pIndex);
JX9_PRIVATE sxu32 jx9VmRandomNum(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9VmCallUserFunction(jx9_vm *pVm, jx9_value *pFunc, int nArg, jx9_value **apArg, jx9_value *pResult);
JX9_PRIVATE sxi32 jx9VmCallUserFunctionAp(jx9_vm *pVm, jx9_value *pFunc, jx9_value *pResult, ...);
JX9_PRIVATE sxi32 jx9VmUnsetMemObj(jx9_vm *pVm, sxu32 nObjIdx);
JX9_PRIVATE void jx9VmRandomString(jx9_vm *pVm, char *zBuf, int nLen);
JX9_PRIVATE int jx9VmIsCallable(jx9_vm *pVm, jx9_value *pValue);
JX9_PRIVATE sxi32 jx9VmPushFilePath(jx9_vm *pVm, const char *zPath, int nLen, sxu8 bMain, sxi32 *pNew);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE const jx9_io_stream * jx9VmGetStreamDevice(jx9_vm *pVm, const char **pzDevice, int nByte);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE int jx9Utf8Read(
const unsigned char *z, /* First byte of UTF-8 character */
const unsigned char *zTerm, /* Pretend this byte is 0x00 */
const unsigned char **pzNext /* Write first byte past UTF-8 char here */
);
/* parse.c function prototypes */
JX9_PRIVATE int jx9IsLangConstruct(sxu32 nKeyID);
JX9_PRIVATE sxi32 jx9ExprMakeTree(jx9_gen_state *pGen, SySet *pExprNode, jx9_expr_node **ppRoot);
JX9_PRIVATE sxi32 jx9GetNextExpr(SyToken *pStart, SyToken *pEnd, SyToken **ppNext);
JX9_PRIVATE void jx9DelimitNestedTokens(SyToken *pIn, SyToken *pEnd, sxu32 nTokStart, sxu32 nTokEnd, SyToken **ppEnd);
JX9_PRIVATE const jx9_expr_op * jx9ExprExtractOperator(SyString *pStr, SyToken *pLast);
JX9_PRIVATE sxi32 jx9ExprFreeTree(jx9_gen_state *pGen, SySet *pNodeSet);
/* compile.c function prototypes */
JX9_PRIVATE ProcNodeConstruct jx9GetNodeHandler(sxu32 nNodeType);
JX9_PRIVATE sxi32 jx9CompileLangConstruct(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileJsonArray(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileJsonObject(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileVariable(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileLiteral(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileSimpleString(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileString(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9CompileAnnonFunc(jx9_gen_state *pGen, sxi32 iCompileFlag);
JX9_PRIVATE sxi32 jx9InitCodeGenerator(jx9_vm *pVm, ProcConsumer xErr, void *pErrData);
JX9_PRIVATE sxi32 jx9ResetCodeGenerator(jx9_vm *pVm, ProcConsumer xErr, void *pErrData);
JX9_PRIVATE sxi32 jx9GenCompileError(jx9_gen_state *pGen, sxi32 nErrType, sxu32 nLine, const char *zFormat, ...);
JX9_PRIVATE sxi32 jx9CompileScript(jx9_vm *pVm, SyString *pScript, sxi32 iFlags);
/* constant.c function prototypes */
JX9_PRIVATE void jx9RegisterBuiltInConstant(jx9_vm *pVm);
/* builtin.c function prototypes */
JX9_PRIVATE void jx9RegisterBuiltInFunction(jx9_vm *pVm);
/* hashmap.c function prototypes */
JX9_PRIVATE jx9_hashmap * jx9NewHashmap(jx9_vm *pVm, sxu32 (*xIntHash)(sxi64), sxu32 (*xBlobHash)(const void *, sxu32));
JX9_PRIVATE sxi32 jx9HashmapLoadBuiltin(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9HashmapRelease(jx9_hashmap *pMap, int FreeDS);
JX9_PRIVATE void jx9HashmapUnref(jx9_hashmap *pMap);
JX9_PRIVATE sxi32 jx9HashmapLookup(jx9_hashmap *pMap, jx9_value *pKey, jx9_hashmap_node **ppNode);
JX9_PRIVATE sxi32 jx9HashmapInsert(jx9_hashmap *pMap, jx9_value *pKey, jx9_value *pVal);
JX9_PRIVATE sxi32 jx9HashmapUnion(jx9_hashmap *pLeft, jx9_hashmap *pRight);
JX9_PRIVATE sxi32 jx9HashmapDup(jx9_hashmap *pSrc, jx9_hashmap *pDest);
JX9_PRIVATE sxi32 jx9HashmapCmp(jx9_hashmap *pLeft, jx9_hashmap *pRight, int bStrict);
JX9_PRIVATE void jx9HashmapResetLoopCursor(jx9_hashmap *pMap);
JX9_PRIVATE jx9_hashmap_node * jx9HashmapGetNextEntry(jx9_hashmap *pMap);
JX9_PRIVATE jx9_value * jx9HashmapGetNodeValue(jx9_hashmap_node *pNode);
JX9_PRIVATE void jx9HashmapExtractNodeValue(jx9_hashmap_node *pNode, jx9_value *pValue, int bStore);
JX9_PRIVATE void jx9HashmapExtractNodeKey(jx9_hashmap_node *pNode, jx9_value *pKey);
JX9_PRIVATE void jx9RegisterHashmapFunctions(jx9_vm *pVm);
JX9_PRIVATE sxi32 jx9HashmapWalk(jx9_hashmap *pMap, int (*xWalk)(jx9_value *, jx9_value *, void *), void *pUserData);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE int jx9HashmapValuesToSet(jx9_hashmap *pMap, SySet *pOut);
/* builtin.c function prototypes */
JX9_PRIVATE sxi32 jx9InputFormat(int (*xConsumer)(jx9_context *, const char *, int, void *),
jx9_context *pCtx, const char *zIn, int nByte, int nArg, jx9_value **apArg, void *pUserData, int vf);
JX9_PRIVATE sxi32 jx9ProcessCsv(const char *zInput, int nByte, int delim, int encl,
int escape, sxi32 (*xConsumer)(const char *, int, void *), void *pUserData);
JX9_PRIVATE sxi32 jx9CsvConsumer(const char *zToken, int nTokenLen, void *pUserData);
JX9_PRIVATE sxi32 jx9StripTagsFromString(jx9_context *pCtx, const char *zIn, int nByte, const char *zTaglist, int nTaglen);
JX9_PRIVATE sxi32 jx9ParseIniString(jx9_context *pCtx, const char *zIn, sxu32 nByte, int bProcessSection);
#endif
/* vfs.c */
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE void * jx9StreamOpenHandle(jx9_vm *pVm, const jx9_io_stream *pStream, const char *zFile,
int iFlags, int use_include, jx9_value *pResource, int bPushInclude, int *pNew);
JX9_PRIVATE sxi32 jx9StreamReadWholeFile(void *pHandle, const jx9_io_stream *pStream, SyBlob *pOut);
JX9_PRIVATE void jx9StreamCloseHandle(const jx9_io_stream *pStream, void *pHandle);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE const char * jx9ExtractDirName(const char *zPath, int nByte, int *pLen);
JX9_PRIVATE sxi32 jx9RegisterIORoutine(jx9_vm *pVm);
JX9_PRIVATE const jx9_vfs * jx9ExportBuiltinVfs(void);
JX9_PRIVATE void * jx9ExportStdin(jx9_vm *pVm);
JX9_PRIVATE void * jx9ExportStdout(jx9_vm *pVm);
JX9_PRIVATE void * jx9ExportStderr(jx9_vm *pVm);
/* lib.c function prototypes */
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyArchiveInit(SyArchive *pArch, SyMemBackend *pAllocator, ProcHash xHash, ProcRawStrCmp xCmp);
JX9_PRIVATE sxi32 SyArchiveRelease(SyArchive *pArch);
JX9_PRIVATE sxi32 SyArchiveResetLoopCursor(SyArchive *pArch);
JX9_PRIVATE sxi32 SyArchiveGetNextEntry(SyArchive *pArch, SyArchiveEntry **ppEntry);
JX9_PRIVATE sxi32 SyZipExtractFromBuf(SyArchive *pArch, const char *zBuf, sxu32 nLen);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBinToHexConsumer(const void *pIn, sxu32 nLen, ProcConsumer xConsumer, void *pConsumerData);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_HASH_FUNC
JX9_PRIVATE sxu32 SyCrc32(const void *pSrc, sxu32 nLen);
JX9_PRIVATE void MD5Update(MD5Context *ctx, const unsigned char *buf, unsigned int len);
JX9_PRIVATE void MD5Final(unsigned char digest[16], MD5Context *ctx);
JX9_PRIVATE sxi32 MD5Init(MD5Context *pCtx);
JX9_PRIVATE sxi32 SyMD5Compute(const void *pIn, sxu32 nLen, unsigned char zDigest[16]);
JX9_PRIVATE void SHA1Init(SHA1Context *context);
JX9_PRIVATE void SHA1Update(SHA1Context *context, const unsigned char *data, unsigned int len);
JX9_PRIVATE void SHA1Final(SHA1Context *context, unsigned char digest[20]);
JX9_PRIVATE sxi32 SySha1Compute(const void *pIn, sxu32 nLen, unsigned char zDigest[20]);
#endif
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE sxi32 SyRandomness(SyPRNGCtx *pCtx, void *pBuf, sxu32 nLen);
JX9_PRIVATE sxi32 SyRandomnessInit(SyPRNGCtx *pCtx, ProcRandomSeed xSeed, void *pUserData);
JX9_PRIVATE sxu32 SyBufferFormat(char *zBuf, sxu32 nLen, const char *zFormat, ...);
JX9_PRIVATE sxu32 SyBlobFormatAp(SyBlob *pBlob, const char *zFormat, va_list ap);
JX9_PRIVATE sxu32 SyBlobFormat(SyBlob *pBlob, const char *zFormat, ...);
JX9_PRIVATE sxi32 SyProcFormat(ProcConsumer xConsumer, void *pData, const char *zFormat, ...);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE const char *SyTimeGetMonth(sxi32 iMonth);
JX9_PRIVATE const char *SyTimeGetDay(sxi32 iDay);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE sxi32 SyUriDecode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData, int bUTF8);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyUriEncode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData);
#endif
JX9_PRIVATE sxi32 SyLexRelease(SyLex *pLex);
JX9_PRIVATE sxi32 SyLexTokenizeInput(SyLex *pLex, const char *zInput, sxu32 nLen, void *pCtxData, ProcSort xSort, ProcCmp xCmp);
JX9_PRIVATE sxi32 SyLexInit(SyLex *pLex, SySet *pSet, ProcTokenizer xTokenizer, void *pUserData);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBase64Decode(const char *zB64, sxu32 nLen, ProcConsumer xConsumer, void *pUserData);
JX9_PRIVATE sxi32 SyBase64Encode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData);
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE sxu32 SyBinHash(const void *pSrc, sxu32 nLen);
JX9_PRIVATE sxi32 SyStrToReal(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyBinaryStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyOctalStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyHexStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyHexToint(sxi32 c);
JX9_PRIVATE sxi32 SyStrToInt64(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyStrToInt32(const char *zSrc, sxu32 nLen, void *pOutVal, const char **zRest);
JX9_PRIVATE sxi32 SyStrIsNumeric(const char *zSrc, sxu32 nLen, sxu8 *pReal, const char **pzTail);
JX9_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void *pUserData);
JX9_PRIVATE sxi32 SyHashForEach(SyHash *pHash, sxi32(*xStep)(SyHashEntry *, void *), void *pUserData);
JX9_PRIVATE sxi32 SyHashDeleteEntry(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void **ppUserData);
JX9_PRIVATE SyHashEntry *SyHashGet(SyHash *pHash, const void *pKey, sxu32 nKeyLen);
JX9_PRIVATE sxi32 SyHashRelease(SyHash *pHash);
JX9_PRIVATE sxi32 SyHashInit(SyHash *pHash, SyMemBackend *pAllocator, ProcHash xHash, ProcCmp xCmp);
JX9_PRIVATE void *SySetAt(SySet *pSet, sxu32 nIdx);
JX9_PRIVATE void *SySetPop(SySet *pSet);
JX9_PRIVATE void *SySetPeek(SySet *pSet);
JX9_PRIVATE sxi32 SySetRelease(SySet *pSet);
JX9_PRIVATE sxi32 SySetReset(SySet *pSet);
JX9_PRIVATE sxi32 SySetResetCursor(SySet *pSet);
JX9_PRIVATE sxi32 SySetGetNextEntry(SySet *pSet, void **ppEntry);
JX9_PRIVATE sxi32 SySetAlloc(SySet *pSet, sxi32 nItem);
JX9_PRIVATE sxi32 SySetPut(SySet *pSet, const void *pItem);
JX9_PRIVATE sxi32 SySetInit(SySet *pSet, SyMemBackend *pAllocator, sxu32 ElemSize);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBlobSearch(const void *pBlob, sxu32 nLen, const void *pPattern, sxu32 pLen, sxu32 *pOfft);
#endif
JX9_PRIVATE sxi32 SyBlobRelease(SyBlob *pBlob);
JX9_PRIVATE sxi32 SyBlobReset(SyBlob *pBlob);
JX9_PRIVATE sxi32 SyBlobTruncate(SyBlob *pBlob,sxu32 nNewLen);
JX9_PRIVATE sxi32 SyBlobDup(SyBlob *pSrc, SyBlob *pDest);
JX9_PRIVATE sxi32 SyBlobNullAppend(SyBlob *pBlob);
JX9_PRIVATE sxi32 SyBlobAppend(SyBlob *pBlob, const void *pData, sxu32 nSize);
JX9_PRIVATE sxi32 SyBlobReadOnly(SyBlob *pBlob, const void *pData, sxu32 nByte);
JX9_PRIVATE sxi32 SyBlobInit(SyBlob *pBlob, SyMemBackend *pAllocator);
JX9_PRIVATE sxi32 SyBlobInitFromBuf(SyBlob *pBlob, void *pBuffer, sxu32 nSize);
JX9_PRIVATE char *SyMemBackendStrDup(SyMemBackend *pBackend, const char *zSrc, sxu32 nSize);
JX9_PRIVATE void *SyMemBackendDup(SyMemBackend *pBackend, const void *pSrc, sxu32 nSize);
JX9_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend);
JX9_PRIVATE sxi32 SyMemBackendInitFromOthers(SyMemBackend *pBackend, const SyMemMethods *pMethods, ProcMemError xMemErr, void *pUserData);
JX9_PRIVATE sxi32 SyMemBackendInit(SyMemBackend *pBackend, ProcMemError xMemErr, void *pUserData);
JX9_PRIVATE sxi32 SyMemBackendInitFromParent(SyMemBackend *pBackend,const SyMemBackend *pParent);
#if 0
/* Not used in the current release of the JX9 engine */
JX9_PRIVATE void *SyMemBackendPoolRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nByte);
#endif
JX9_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void *pChunk);
JX9_PRIVATE void *SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte);
JX9_PRIVATE sxi32 SyMemBackendFree(SyMemBackend *pBackend, void *pChunk);
JX9_PRIVATE void *SyMemBackendRealloc(SyMemBackend *pBackend, void *pOld, sxu32 nByte);
JX9_PRIVATE void *SyMemBackendAlloc(SyMemBackend *pBackend, sxu32 nByte);
JX9_PRIVATE sxu32 SyMemcpy(const void *pSrc, void *pDest, sxu32 nLen);
JX9_PRIVATE sxi32 SyMemcmp(const void *pB1, const void *pB2, sxu32 nSize);
JX9_PRIVATE void SyZero(void *pSrc, sxu32 nSize);
JX9_PRIVATE sxi32 SyStrnicmp(const char *zLeft, const char *zRight, sxu32 SLen);
JX9_PRIVATE sxu32 Systrcpy(char *zDest, sxu32 nDestLen, const char *zSrc, sxu32 nLen);
#if !defined(JX9_DISABLE_BUILTIN_FUNC) || defined(__APPLE__)
JX9_PRIVATE sxi32 SyStrncmp(const char *zLeft, const char *zRight, sxu32 nLen);
#endif
JX9_PRIVATE sxi32 SyByteListFind(const char *zSrc, sxu32 nLen, const char *zList, sxu32 *pFirstPos);
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyByteFind2(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos);
#endif
JX9_PRIVATE sxi32 SyByteFind(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos);
JX9_PRIVATE sxu32 SyStrlen(const char *zSrc);
#if defined(JX9_ENABLE_THREADS)
JX9_PRIVATE const SyMutexMethods *SyMutexExportMethods(void);
JX9_PRIVATE sxi32 SyMemBackendMakeThreadSafe(SyMemBackend *pBackend, const SyMutexMethods *pMethods);
JX9_PRIVATE sxi32 SyMemBackendDisbaleMutexing(SyMemBackend *pBackend);
#endif
JX9_PRIVATE void SyBigEndianPack32(unsigned char *buf,sxu32 nb);
JX9_PRIVATE void SyBigEndianUnpack32(const unsigned char *buf,sxu32 *uNB);
JX9_PRIVATE void SyBigEndianPack16(unsigned char *buf,sxu16 nb);
JX9_PRIVATE void SyBigEndianUnpack16(const unsigned char *buf,sxu16 *uNB);
JX9_PRIVATE void SyBigEndianPack64(unsigned char *buf,sxu64 n64);
JX9_PRIVATE void SyBigEndianUnpack64(const unsigned char *buf,sxu64 *n64);
JX9_PRIVATE sxi32 SyBlobAppendBig64(SyBlob *pBlob,sxu64 n64);
JX9_PRIVATE sxi32 SyBlobAppendBig32(SyBlob *pBlob,sxu32 n32);
JX9_PRIVATE sxi32 SyBlobAppendBig16(SyBlob *pBlob,sxu16 n16);
JX9_PRIVATE void SyTimeFormatToDos(Sytm *pFmt,sxu32 *pOut);
JX9_PRIVATE void SyDosTimeFormat(sxu32 nDosDate, Sytm *pOut);
#endif /* __JX9INT_H__ */
/*
* ----------------------------------------------------------
* File: unqliteInt.h
* MD5: 325816ce05f6adbaab2c39a41875dedd
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: unqliteInt.h v1.7 FreeBSD 2012-11-02 11:25 devel <chm@symisc.net> $ */
#ifndef __UNQLITEINT_H__
#define __UNQLITEINT_H__
/* Internal interface definitions for UnQLite. */
#ifdef UNQLITE_AMALGAMATION
/* Marker for routines not intended for external use */
#define UNQLITE_PRIVATE static
#define JX9_AMALGAMATION
#else
#define UNQLITE_PRIVATE
#include "unqlite.h"
#include "jx9Int.h"
#endif
/* forward declaration */
typedef struct unqlite_db unqlite_db;
/*
** The following values may be passed as the second argument to
** UnqliteOsLock(). The various locks exhibit the following semantics:
**
** SHARED: Any number of processes may hold a SHARED lock simultaneously.
** RESERVED: A single process may hold a RESERVED lock on a file at
** any time. Other processes may hold and obtain new SHARED locks.
** PENDING: A single process may hold a PENDING lock on a file at
** any one time. Existing SHARED locks may persist, but no new
** SHARED locks may be obtained by other processes.
** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
**
** PENDING_LOCK may not be passed directly to UnqliteOsLock(). Instead, a
** process that requests an EXCLUSIVE lock may actually obtain a PENDING
** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
** UnqliteOsLock().
*/
#define NO_LOCK 0
#define SHARED_LOCK 1
#define RESERVED_LOCK 2
#define PENDING_LOCK 3
#define EXCLUSIVE_LOCK 4
/*
* UnQLite Locking Strategy (Same as SQLite3)
*
* The following #defines specify the range of bytes used for locking.
* SHARED_SIZE is the number of bytes available in the pool from which
* a random byte is selected for a shared lock. The pool of bytes for
* shared locks begins at SHARED_FIRST.
*
* The same locking strategy and byte ranges are used for Unix and Windows.
* This leaves open the possiblity of having clients on winNT, and
* unix all talking to the same shared file and all locking correctly.
* To do so would require that samba (or whatever
* tool is being used for file sharing) implements locks correctly between
* windows and unix. I'm guessing that isn't likely to happen, but by
* using the same locking range we are at least open to the possibility.
*
* Locking in windows is mandatory. For this reason, we cannot store
* actual data in the bytes used for locking. The pager never allocates
* the pages involved in locking therefore. SHARED_SIZE is selected so
* that all locks will fit on a single page even at the minimum page size.
* PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE
* is set high so that we don't have to allocate an unused page except
* for very large databases. But one should test the page skipping logic
* by setting PENDING_BYTE low and running the entire regression suite.
*
* Changing the value of PENDING_BYTE results in a subtly incompatible
* file format. Depending on how it is changed, you might not notice
* the incompatibility right away, even running a full regression test.
* The default location of PENDING_BYTE is the first byte past the
* 1GB boundary.
*/
#define PENDING_BYTE (0x40000000)
#define RESERVED_BYTE (PENDING_BYTE+1)
#define SHARED_FIRST (PENDING_BYTE+2)
#define SHARED_SIZE 510
/*
* The default size of a disk sector in bytes.
*/
#ifndef UNQLITE_DEFAULT_SECTOR_SIZE
#define UNQLITE_DEFAULT_SECTOR_SIZE 512
#endif
/*
* Each open database file is managed by a separate instance
* of the "Pager" structure.
*/
typedef struct Pager Pager;
/*
* Each database file to be accessed by the system is an instance
* of the following structure.
*/
struct unqlite_db
{
Pager *pPager; /* Pager and Transaction manager */
jx9 *pJx9; /* Jx9 Engine handle */
unqlite_kv_cursor *pCursor; /* Database cursor for common usage */
};
/*
* Each database connection is an instance of the following structure.
*/
struct unqlite
{
SyMemBackend sMem; /* Memory allocator subsystem */
SyBlob sErr; /* Error log */
unqlite_db sDB; /* Storage backend */
#if defined(UNQLITE_ENABLE_THREADS)
const SyMutexMethods *pMethods; /* Mutex methods */
SyMutex *pMutex; /* Per-handle mutex */
#endif
unqlite_vm *pVms; /* List of active VM */
sxi32 iVm; /* Total number of active VM */
sxi32 iFlags; /* Control flags (See below) */
unqlite *pNext,*pPrev; /* List of active DB handles */
sxu32 nMagic; /* Sanity check against misuse */
};
#define UNQLITE_FL_DISABLE_AUTO_COMMIT 0x001 /* Disable auto-commit on close */
/*
* VM control flags (Mostly related to collection handling).
*/
#define UNQLITE_VM_COLLECTION_CREATE 0x001 /* Create a new collection */
#define UNQLITE_VM_COLLECTION_EXISTS 0x002 /* Exists old collection */
#define UNQLITE_VM_AUTO_LOAD 0x004 /* Auto load a collection from the vfs */
/* Forward declaration */
typedef struct unqlite_col_record unqlite_col_record;
typedef struct unqlite_col unqlite_col;
/*
* Each an in-memory collection record is stored in an instance
* of the following structure.
*/
struct unqlite_col_record
{
unqlite_col *pCol; /* Collecion this record belong */
jx9_int64 nId; /* Unique record ID */
jx9_value sValue; /* In-memory value of the record */
unqlite_col_record *pNextCol,*pPrevCol; /* Collision chain */
unqlite_col_record *pNext,*pPrev; /* Linked list of records */
};
/*
* Magic number to identify a valid collection on disk.
*/
#define UNQLITE_COLLECTION_MAGIC 0x611E /* sizeof(unsigned short) 2 bytes */
/*
* A loaded collection is identified by an instance of the following structure.
*/
struct unqlite_col
{
unqlite_vm *pVm; /* VM that own this instance */
SyString sName; /* ID of the collection */
sxu32 nHash; /* sName hash */
jx9_value sSchema; /* Collection schema */
sxu32 nSchemaOfft; /* Shema offset in sHeader */
SyBlob sWorker; /* General purpose working buffer */
SyBlob sHeader; /* Collection binary header */
jx9_int64 nLastid; /* Last collection record ID */
jx9_int64 nCurid; /* Current record ID */
jx9_int64 nTotRec; /* Total number of records in the collection */
int iFlags; /* Control flags (see below) */
unqlite_col_record **apRecord; /* Hashtable of loaded records */
unqlite_col_record *pList; /* Linked list of records */
sxu32 nRec; /* Total number of records in apRecord[] */
sxu32 nRecSize; /* apRecord[] size */
Sytm sCreation; /* Colleation creation time */
unqlite_kv_cursor *pCursor; /* Cursor pointing to the raw binary data */
unqlite_col *pNext,*pPrev; /* Next and previous collection in the chain */
unqlite_col *pNextCol,*pPrevCol; /* Collision chain */
};
/*
* Each unQLite Virtual Machine resulting from successful compilation of
* a Jx9 script is represented by an instance of the following structure.
*/
struct unqlite_vm
{
unqlite *pDb; /* Database handle that own this instance */
SyMemBackend sAlloc; /* Private memory allocator */
#if defined(UNQLITE_ENABLE_THREADS)
SyMutex *pMutex; /* Recursive mutex associated with this VM. */
#endif
unqlite_col **apCol; /* Table of loaded collections */
unqlite_col *pCol; /* List of loaded collections */
sxu32 iCol; /* Total number of loaded collections */
sxu32 iColSize; /* apCol[] size */
jx9_vm *pJx9Vm; /* Compiled Jx9 script*/
unqlite_vm *pNext,*pPrev; /* Linked list of active unQLite VM */
sxu32 nMagic; /* Magic number to avoid misuse */
};
/*
* Database signature to identify a valid database image.
*/
#define UNQLITE_DB_SIG "unqlite"
/*
* Database magic number (4 bytes).
*/
#define UNQLITE_DB_MAGIC 0xDB7C2712
/*
* Maximum page size in bytes.
*/
#ifdef UNQLITE_MAX_PAGE_SIZE
# undef UNQLITE_MAX_PAGE_SIZE
#endif
#define UNQLITE_MAX_PAGE_SIZE 65536 /* 65K */
/*
* Minimum page size in bytes.
*/
#ifdef UNQLITE_MIN_PAGE_SIZE
# undef UNQLITE_MIN_PAGE_SIZE
#endif
#define UNQLITE_MIN_PAGE_SIZE 512
/*
* The default size of a database page.
*/
#ifndef UNQLITE_DEFAULT_PAGE_SIZE
# undef UNQLITE_DEFAULT_PAGE_SIZE
#endif
# define UNQLITE_DEFAULT_PAGE_SIZE 4096 /* 4K */
/* Forward declaration */
typedef struct Bitvec Bitvec;
/* Private library functions */
/* api.c */
UNQLITE_PRIVATE const SyMemBackend * unqliteExportMemBackend(void);
UNQLITE_PRIVATE int unqliteDataConsumer(
const void *pOut, /* Data to consume */
unsigned int nLen, /* Data length */
void *pUserData /* User private data */
);
UNQLITE_PRIVATE unqlite_kv_methods * unqliteFindKVStore(
const char *zName, /* Storage engine name [i.e. Hash, B+tree, LSM, etc.] */
sxu32 nByte /* zName length */
);
UNQLITE_PRIVATE int unqliteGetPageSize(void);
UNQLITE_PRIVATE int unqliteGenError(unqlite *pDb,const char *zErr);
UNQLITE_PRIVATE int unqliteGenErrorFormat(unqlite *pDb,const char *zFmt,...);
UNQLITE_PRIVATE int unqliteGenOutofMem(unqlite *pDb);
/* unql_vm.c */
UNQLITE_PRIVATE int unqliteExistsCollection(unqlite_vm *pVm, SyString *pName);
UNQLITE_PRIVATE int unqliteCreateCollection(unqlite_vm *pVm,SyString *pName);
UNQLITE_PRIVATE jx9_int64 unqliteCollectionLastRecordId(unqlite_col *pCol);
UNQLITE_PRIVATE jx9_int64 unqliteCollectionCurrentRecordId(unqlite_col *pCol);
UNQLITE_PRIVATE int unqliteCollectionCacheRemoveRecord(unqlite_col *pCol,jx9_int64 nId);
UNQLITE_PRIVATE jx9_int64 unqliteCollectionTotalRecords(unqlite_col *pCol);
UNQLITE_PRIVATE void unqliteCollectionResetRecordCursor(unqlite_col *pCol);
UNQLITE_PRIVATE int unqliteCollectionFetchNextRecord(unqlite_col *pCol,jx9_value *pValue);
UNQLITE_PRIVATE int unqliteCollectionFetchRecordById(unqlite_col *pCol,jx9_int64 nId,jx9_value *pValue);
UNQLITE_PRIVATE unqlite_col * unqliteCollectionFetch(unqlite_vm *pVm,SyString *pCol,int iFlag);
UNQLITE_PRIVATE int unqliteCollectionSetSchema(unqlite_col *pCol,jx9_value *pValue);
UNQLITE_PRIVATE int unqliteCollectionPut(unqlite_col *pCol,jx9_value *pValue,int iFlag);
UNQLITE_PRIVATE int unqliteCollectionDropRecord(unqlite_col *pCol,jx9_int64 nId,int wr_header,int log_err);
UNQLITE_PRIVATE int unqliteDropCollection(unqlite_col *pCol);
/* unql_jx9.c */
UNQLITE_PRIVATE int unqliteRegisterJx9Functions(unqlite_vm *pVm);
/* fastjson.c */
UNQLITE_PRIVATE sxi32 FastJsonEncode(
jx9_value *pValue, /* Value to encode */
SyBlob *pOut, /* Store encoded value here */
int iNest /* Nesting limit */
);
UNQLITE_PRIVATE sxi32 FastJsonDecode(
const void *pIn, /* Binary JSON */
sxu32 nByte, /* Chunk delimiter */
jx9_value *pOut, /* Decoded value */
const unsigned char **pzPtr,
int iNest /* Nesting limit */
);
/* vfs.c [io_win.c, io_unix.c ] */
UNQLITE_PRIVATE const unqlite_vfs * unqliteExportBuiltinVfs(void);
/* mem_kv.c */
UNQLITE_PRIVATE const unqlite_kv_methods * unqliteExportMemKvStorage(void);
/* lhash_kv.c */
UNQLITE_PRIVATE const unqlite_kv_methods * unqliteExportDiskKvStorage(void);
/* os.c */
UNQLITE_PRIVATE int unqliteOsRead(unqlite_file *id, void *pBuf, unqlite_int64 amt, unqlite_int64 offset);
UNQLITE_PRIVATE int unqliteOsWrite(unqlite_file *id, const void *pBuf, unqlite_int64 amt, unqlite_int64 offset);
UNQLITE_PRIVATE int unqliteOsTruncate(unqlite_file *id, unqlite_int64 size);
UNQLITE_PRIVATE int unqliteOsSync(unqlite_file *id, int flags);
UNQLITE_PRIVATE int unqliteOsFileSize(unqlite_file *id, unqlite_int64 *pSize);
UNQLITE_PRIVATE int unqliteOsLock(unqlite_file *id, int lockType);
UNQLITE_PRIVATE int unqliteOsUnlock(unqlite_file *id, int lockType);
UNQLITE_PRIVATE int unqliteOsCheckReservedLock(unqlite_file *id, int *pResOut);
UNQLITE_PRIVATE int unqliteOsSectorSize(unqlite_file *id);
UNQLITE_PRIVATE int unqliteOsOpen(
unqlite_vfs *pVfs,
SyMemBackend *pAlloc,
const char *zPath,
unqlite_file **ppOut,
unsigned int flags
);
UNQLITE_PRIVATE int unqliteOsCloseFree(SyMemBackend *pAlloc,unqlite_file *pId);
UNQLITE_PRIVATE int unqliteOsDelete(unqlite_vfs *pVfs, const char *zPath, int dirSync);
UNQLITE_PRIVATE int unqliteOsAccess(unqlite_vfs *pVfs,const char *zPath,int flags,int *pResOut);
/* bitmap.c */
UNQLITE_PRIVATE Bitvec *unqliteBitvecCreate(SyMemBackend *pAlloc,pgno iSize);
UNQLITE_PRIVATE int unqliteBitvecTest(Bitvec *p,pgno i);
UNQLITE_PRIVATE int unqliteBitvecSet(Bitvec *p,pgno i);
UNQLITE_PRIVATE void unqliteBitvecDestroy(Bitvec *p);
/* pager.c */
UNQLITE_PRIVATE int unqliteInitCursor(unqlite *pDb,unqlite_kv_cursor **ppOut);
UNQLITE_PRIVATE int unqliteReleaseCursor(unqlite *pDb,unqlite_kv_cursor *pCur);
UNQLITE_PRIVATE int unqlitePagerSetCachesize(Pager *pPager,int mxPage);
UNQLITE_PRIVATE int unqlitePagerClose(Pager *pPager);
UNQLITE_PRIVATE int unqlitePagerOpen(
unqlite_vfs *pVfs, /* The virtual file system to use */
unqlite *pDb, /* Database handle */
const char *zFilename, /* Name of the database file to open */
unsigned int iFlags /* flags controlling this file */
);
UNQLITE_PRIVATE int unqlitePagerRegisterKvEngine(Pager *pPager,unqlite_kv_methods *pMethods);
UNQLITE_PRIVATE unqlite_kv_engine * unqlitePagerGetKvEngine(unqlite *pDb);
UNQLITE_PRIVATE int unqlitePagerBegin(Pager *pPager);
UNQLITE_PRIVATE int unqlitePagerCommit(Pager *pPager);
UNQLITE_PRIVATE int unqlitePagerRollback(Pager *pPager,int bResetKvEngine);
UNQLITE_PRIVATE void unqlitePagerRandomString(Pager *pPager,char *zBuf,sxu32 nLen);
UNQLITE_PRIVATE sxu32 unqlitePagerRandomNum(Pager *pPager);
#endif /* __UNQLITEINT_H__ */
/*
* ----------------------------------------------------------
* File: api.c
* MD5: d79e8404e50dacd0ea75635c1ebe553a
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: api.c v2.0 FreeBSD 2012-11-08 23:07 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/* This file implement the public interfaces presented to host-applications.
* Routines in other files are for internal use by UnQLite and should not be
* accessed by users of the library.
*/
#define UNQLITE_DB_MISUSE(DB) (DB == 0 || DB->nMagic != UNQLITE_DB_MAGIC)
#define UNQLITE_VM_MISUSE(VM) (VM == 0 || VM->nMagic == JX9_VM_STALE)
/* If another thread have released a working instance, the following macros
* evaluates to true. These macros are only used when the library
* is built with threading support enabled.
*/
#define UNQLITE_THRD_DB_RELEASE(DB) (DB->nMagic != UNQLITE_DB_MAGIC)
#define UNQLITE_THRD_VM_RELEASE(VM) (VM->nMagic == JX9_VM_STALE)
/* IMPLEMENTATION: unqlite@embedded@symisc 118-09-4785 */
/*
* All global variables are collected in the structure named "sUnqlMPGlobal".
* That way it is clear in the code when we are using static variable because
* its name start with sUnqlMPGlobal.
*/
static struct unqlGlobal_Data
{
SyMemBackend sAllocator; /* Global low level memory allocator */
#if defined(UNQLITE_ENABLE_THREADS)
const SyMutexMethods *pMutexMethods; /* Mutex methods */
SyMutex *pMutex; /* Global mutex */
sxu32 nThreadingLevel; /* Threading level: 0 == Single threaded/1 == Multi-Threaded
* The threading level can be set using the [unqlite_lib_config()]
* interface with a configuration verb set to
* UNQLITE_LIB_CONFIG_THREAD_LEVEL_SINGLE or
* UNQLITE_LIB_CONFIG_THREAD_LEVEL_MULTI
*/
#endif
SySet kv_storage; /* Installed KV storage engines */
int iPageSize; /* Default Page size */
unqlite_vfs *pVfs; /* Underlying virtual file system (Vfs) */
sxi32 nDB; /* Total number of active DB handles */
unqlite *pDB; /* List of active DB handles */
sxu32 nMagic; /* Sanity check against library misuse */
}sUnqlMPGlobal = {
{0, 0, 0, 0, 0, 0, 0, 0, {0}},
#if defined(UNQLITE_ENABLE_THREADS)
0,
0,
0,
#endif
{0, 0, 0, 0, 0, 0, 0 },
UNQLITE_DEFAULT_PAGE_SIZE,
0,
0,
0,
0
};
#define UNQLITE_LIB_MAGIC 0xEA1495BA
#define UNQLITE_LIB_MISUSE (sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC)
/*
* Supported threading level.
* These options have meaning only when the library is compiled with multi-threading
* support. That is, the UNQLITE_ENABLE_THREADS compile time directive must be defined
* when UnQLite is built.
* UNQLITE_THREAD_LEVEL_SINGLE:
* In this mode, mutexing is disabled and the library can only be used by a single thread.
* UNQLITE_THREAD_LEVEL_MULTI
* In this mode, all mutexes including the recursive mutexes on [unqlite] objects
* are enabled so that the application is free to share the same database handle
* between different threads at the same time.
*/
#define UNQLITE_THREAD_LEVEL_SINGLE 1
#define UNQLITE_THREAD_LEVEL_MULTI 2
/*
* Find a Key Value storage engine from the set of installed engines.
* Return a pointer to the storage engine methods on success. NULL on failure.
*/
UNQLITE_PRIVATE unqlite_kv_methods * unqliteFindKVStore(
const char *zName, /* Storage engine name [i.e. Hash, B+tree, LSM, etc.] */
sxu32 nByte /* zName length */
)
{
unqlite_kv_methods **apStore,*pEntry;
sxu32 n,nMax;
/* Point to the set of installed engines */
apStore = (unqlite_kv_methods **)SySetBasePtr(&sUnqlMPGlobal.kv_storage);
nMax = SySetUsed(&sUnqlMPGlobal.kv_storage);
for( n = 0 ; n < nMax; ++n ){
pEntry = apStore[n];
if( nByte == SyStrlen(pEntry->zName) && SyStrnicmp(pEntry->zName,zName,nByte) == 0 ){
/* Storage engine found */
return pEntry;
}
}
/* No such entry, return NULL */
return 0;
}
/*
* Configure the UnQLite library.
* Return UNQLITE_OK on success. Any other return value indicates failure.
* Refer to [unqlite_lib_config()].
*/
static sxi32 unqliteCoreConfigure(sxi32 nOp, va_list ap)
{
int rc = UNQLITE_OK;
switch(nOp){
case UNQLITE_LIB_CONFIG_PAGE_SIZE: {
/* Default page size: Must be a power of two */
int iPage = va_arg(ap,int);
if( iPage >= UNQLITE_MIN_PAGE_SIZE && iPage <= UNQLITE_MAX_PAGE_SIZE ){
if( !(iPage & (iPage - 1)) ){
sUnqlMPGlobal.iPageSize = iPage;
}else{
/* Invalid page size */
rc = UNQLITE_INVALID;
}
}else{
/* Invalid page size */
rc = UNQLITE_INVALID;
}
break;
}
case UNQLITE_LIB_CONFIG_STORAGE_ENGINE: {
/* Install a key value storage engine */
unqlite_kv_methods *pMethods = va_arg(ap,unqlite_kv_methods *);
/* Make sure we are delaing with a valid methods */
if( pMethods == 0 || SX_EMPTY_STR(pMethods->zName) || pMethods->xSeek == 0 || pMethods->xData == 0
|| pMethods->xKey == 0 || pMethods->xDataLength == 0 || pMethods->xKeyLength == 0
|| pMethods->szKv < (int)sizeof(unqlite_kv_engine) ){
rc = UNQLITE_INVALID;
break;
}
/* Install it */
rc = SySetPut(&sUnqlMPGlobal.kv_storage,(const void *)&pMethods);
break;
}
case UNQLITE_LIB_CONFIG_VFS:{
/* Install a virtual file system */
unqlite_vfs *pVfs = va_arg(ap,unqlite_vfs *);
if( pVfs ){
sUnqlMPGlobal.pVfs = pVfs;
}
break;
}
case UNQLITE_LIB_CONFIG_USER_MALLOC: {
/* Use an alternative low-level memory allocation routines */
const SyMemMethods *pMethods = va_arg(ap, const SyMemMethods *);
/* Save the memory failure callback (if available) */
ProcMemError xMemErr = sUnqlMPGlobal.sAllocator.xMemError;
void *pMemErr = sUnqlMPGlobal.sAllocator.pUserData;
if( pMethods == 0 ){
/* Use the built-in memory allocation subsystem */
rc = SyMemBackendInit(&sUnqlMPGlobal.sAllocator, xMemErr, pMemErr);
}else{
rc = SyMemBackendInitFromOthers(&sUnqlMPGlobal.sAllocator, pMethods, xMemErr, pMemErr);
}
break;
}
case UNQLITE_LIB_CONFIG_MEM_ERR_CALLBACK: {
/* Memory failure callback */
ProcMemError xMemErr = va_arg(ap, ProcMemError);
void *pUserData = va_arg(ap, void *);
sUnqlMPGlobal.sAllocator.xMemError = xMemErr;
sUnqlMPGlobal.sAllocator.pUserData = pUserData;
break;
}
case UNQLITE_LIB_CONFIG_USER_MUTEX: {
#if defined(UNQLITE_ENABLE_THREADS)
/* Use an alternative low-level mutex subsystem */
const SyMutexMethods *pMethods = va_arg(ap, const SyMutexMethods *);
#if defined (UNTRUST)
if( pMethods == 0 ){
rc = UNQLITE_CORRUPT;
}
#endif
/* Sanity check */
if( pMethods->xEnter == 0 || pMethods->xLeave == 0 || pMethods->xNew == 0){
/* At least three criticial callbacks xEnter(), xLeave() and xNew() must be supplied */
rc = UNQLITE_CORRUPT;
break;
}
if( sUnqlMPGlobal.pMutexMethods ){
/* Overwrite the previous mutex subsystem */
SyMutexRelease(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex);
if( sUnqlMPGlobal.pMutexMethods->xGlobalRelease ){
sUnqlMPGlobal.pMutexMethods->xGlobalRelease();
}
sUnqlMPGlobal.pMutex = 0;
}
/* Initialize and install the new mutex subsystem */
if( pMethods->xGlobalInit ){
rc = pMethods->xGlobalInit();
if ( rc != UNQLITE_OK ){
break;
}
}
/* Create the global mutex */
sUnqlMPGlobal.pMutex = pMethods->xNew(SXMUTEX_TYPE_FAST);
if( sUnqlMPGlobal.pMutex == 0 ){
/*
* If the supplied mutex subsystem is so sick that we are unable to
* create a single mutex, there is no much we can do here.
*/
if( pMethods->xGlobalRelease ){
pMethods->xGlobalRelease();
}
rc = UNQLITE_CORRUPT;
break;
}
sUnqlMPGlobal.pMutexMethods = pMethods;
if( sUnqlMPGlobal.nThreadingLevel == 0 ){
/* Set a default threading level */
sUnqlMPGlobal.nThreadingLevel = UNQLITE_THREAD_LEVEL_MULTI;
}
#endif
break;
}
case UNQLITE_LIB_CONFIG_THREAD_LEVEL_SINGLE:
#if defined(UNQLITE_ENABLE_THREADS)
/* Single thread mode (Only one thread is allowed to play with the library) */
sUnqlMPGlobal.nThreadingLevel = UNQLITE_THREAD_LEVEL_SINGLE;
jx9_lib_config(JX9_LIB_CONFIG_THREAD_LEVEL_SINGLE);
#endif
break;
case UNQLITE_LIB_CONFIG_THREAD_LEVEL_MULTI:
#if defined(UNQLITE_ENABLE_THREADS)
/* Multi-threading mode (library is thread safe and database handles and virtual machines
* may be shared between multiple threads).
*/
sUnqlMPGlobal.nThreadingLevel = UNQLITE_THREAD_LEVEL_MULTI;
jx9_lib_config(JX9_LIB_CONFIG_THREAD_LEVEL_MULTI);
#endif
break;
default:
/* Unknown configuration option */
rc = UNQLITE_CORRUPT;
break;
}
return rc;
}
/*
* [CAPIREF: unqlite_lib_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_lib_config(int nConfigOp,...)
{
va_list ap;
int rc;
if( sUnqlMPGlobal.nMagic == UNQLITE_LIB_MAGIC ){
/* Library is already initialized, this operation is forbidden */
return UNQLITE_LOCKED;
}
va_start(ap,nConfigOp);
rc = unqliteCoreConfigure(nConfigOp,ap);
va_end(ap);
return rc;
}
/*
* Global library initialization
* Refer to [unqlite_lib_init()]
* This routine must be called to initialize the memory allocation subsystem, the mutex
* subsystem prior to doing any serious work with the library. The first thread to call
* this routine does the initialization process and set the magic number so no body later
* can re-initialize the library. If subsequent threads call this routine before the first
* thread have finished the initialization process, then the subsequent threads must block
* until the initialization process is done.
*/
static sxi32 unqliteCoreInitialize(void)
{
const unqlite_kv_methods *pMethods;
const unqlite_vfs *pVfs; /* Built-in vfs */
#if defined(UNQLITE_ENABLE_THREADS)
const SyMutexMethods *pMutexMethods = 0;
SyMutex *pMaster = 0;
#endif
int rc;
/*
* If the library is already initialized, then a call to this routine
* is a no-op.
*/
if( sUnqlMPGlobal.nMagic == UNQLITE_LIB_MAGIC ){
return UNQLITE_OK; /* Already initialized */
}
if( sUnqlMPGlobal.pVfs == 0 ){
/* Point to the built-in vfs */
pVfs = unqliteExportBuiltinVfs();
/* Install it */
unqlite_lib_config(UNQLITE_LIB_CONFIG_VFS, pVfs);
}
#if defined(UNQLITE_ENABLE_THREADS)
if( sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_SINGLE ){
pMutexMethods = sUnqlMPGlobal.pMutexMethods;
if( pMutexMethods == 0 ){
/* Use the built-in mutex subsystem */
pMutexMethods = SyMutexExportMethods();
if( pMutexMethods == 0 ){
return UNQLITE_CORRUPT; /* Can't happen */
}
/* Install the mutex subsystem */
rc = unqlite_lib_config(UNQLITE_LIB_CONFIG_USER_MUTEX, pMutexMethods);
if( rc != UNQLITE_OK ){
return rc;
}
}
/* Obtain a static mutex so we can initialize the library without calling malloc() */
pMaster = SyMutexNew(pMutexMethods, SXMUTEX_TYPE_STATIC_1);
if( pMaster == 0 ){
return UNQLITE_CORRUPT; /* Can't happen */
}
}
/* Lock the master mutex */
rc = UNQLITE_OK;
SyMutexEnter(pMutexMethods, pMaster); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
if( sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC ){
#endif
if( sUnqlMPGlobal.sAllocator.pMethods == 0 ){
/* Install a memory subsystem */
rc = unqlite_lib_config(UNQLITE_LIB_CONFIG_USER_MALLOC, 0); /* zero mean use the built-in memory backend */
if( rc != UNQLITE_OK ){
/* If we are unable to initialize the memory backend, there is no much we can do here.*/
goto End;
}
}
#if defined(UNQLITE_ENABLE_THREADS)
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE ){
/* Protect the memory allocation subsystem */
rc = SyMemBackendMakeThreadSafe(&sUnqlMPGlobal.sAllocator, sUnqlMPGlobal.pMutexMethods);
if( rc != UNQLITE_OK ){
goto End;
}
}
#endif
SySetInit(&sUnqlMPGlobal.kv_storage,&sUnqlMPGlobal.sAllocator,sizeof(unqlite_kv_methods *));
/* Install the built-in Key Value storage engines */
pMethods = unqliteExportMemKvStorage(); /* In-memory storage */
unqlite_lib_config(UNQLITE_LIB_CONFIG_STORAGE_ENGINE,pMethods);
/* Default disk key/value storage engine */
pMethods = unqliteExportDiskKvStorage(); /* Disk storage */
unqlite_lib_config(UNQLITE_LIB_CONFIG_STORAGE_ENGINE,pMethods);
/* Default page size */
if( sUnqlMPGlobal.iPageSize < UNQLITE_MIN_PAGE_SIZE ){
unqlite_lib_config(UNQLITE_LIB_CONFIG_PAGE_SIZE,UNQLITE_DEFAULT_PAGE_SIZE);
}
/* Our library is initialized, set the magic number */
sUnqlMPGlobal.nMagic = UNQLITE_LIB_MAGIC;
rc = UNQLITE_OK;
#if defined(UNQLITE_ENABLE_THREADS)
} /* sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC */
#endif
End:
#if defined(UNQLITE_ENABLE_THREADS)
/* Unlock the master mutex */
SyMutexLeave(pMutexMethods, pMaster); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
return rc;
}
/* Forward declaration */
static int unqliteVmRelease(unqlite_vm *pVm);
/*
* Release a single instance of an unqlite database handle.
*/
static int unqliteDbRelease(unqlite *pDb)
{
unqlite_db *pStore = &pDb->sDB;
unqlite_vm *pVm,*pNext;
int rc = UNQLITE_OK;
if( (pDb->iFlags & UNQLITE_FL_DISABLE_AUTO_COMMIT) == 0 ){
/* Commit any outstanding transaction */
rc = unqlitePagerCommit(pStore->pPager);
if( rc != UNQLITE_OK ){
/* Rollback the transaction */
rc = unqlitePagerRollback(pStore->pPager,FALSE);
}
}else{
/* Rollback any outstanding transaction */
rc = unqlitePagerRollback(pStore->pPager,FALSE);
}
/* Close the pager */
unqlitePagerClose(pStore->pPager);
/* Release any active VM's */
pVm = pDb->pVms;
for(;;){
if( pDb->iVm < 1 ){
break;
}
/* Point to the next entry */
pNext = pVm->pNext;
unqliteVmRelease(pVm);
pVm = pNext;
pDb->iVm--;
}
/* Release the Jx9 handle */
jx9_release(pStore->pJx9);
/* Set a dummy magic number */
pDb->nMagic = 0x7250;
/* Release the whole memory subsystem */
SyMemBackendRelease(&pDb->sMem);
/* Commit or rollback result */
return rc;
}
/*
* Release all resources consumed by the library.
* Note: This call is not thread safe. Refer to [unqlite_lib_shutdown()].
*/
static void unqliteCoreShutdown(void)
{
unqlite *pDb, *pNext;
/* Release all active databases handles */
pDb = sUnqlMPGlobal.pDB;
for(;;){
if( sUnqlMPGlobal.nDB < 1 ){
break;
}
pNext = pDb->pNext;
unqliteDbRelease(pDb);
pDb = pNext;
sUnqlMPGlobal.nDB--;
}
/* Release the storage methods container */
SySetRelease(&sUnqlMPGlobal.kv_storage);
#if defined(UNQLITE_ENABLE_THREADS)
/* Release the mutex subsystem */
if( sUnqlMPGlobal.pMutexMethods ){
if( sUnqlMPGlobal.pMutex ){
SyMutexRelease(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex);
sUnqlMPGlobal.pMutex = 0;
}
if( sUnqlMPGlobal.pMutexMethods->xGlobalRelease ){
sUnqlMPGlobal.pMutexMethods->xGlobalRelease();
}
sUnqlMPGlobal.pMutexMethods = 0;
}
sUnqlMPGlobal.nThreadingLevel = 0;
#endif
if( sUnqlMPGlobal.sAllocator.pMethods ){
/* Release the memory backend */
SyMemBackendRelease(&sUnqlMPGlobal.sAllocator);
}
sUnqlMPGlobal.nMagic = 0x1764;
/* Finally, shutdown the Jx9 library */
jx9_lib_shutdown();
}
/*
* [CAPIREF: unqlite_lib_init()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_lib_init(void)
{
int rc;
rc = unqliteCoreInitialize();
return rc;
}
/*
* [CAPIREF: unqlite_lib_shutdown()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_lib_shutdown(void)
{
if( sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC ){
/* Already shut */
return UNQLITE_OK;
}
unqliteCoreShutdown();
return UNQLITE_OK;
}
/*
* [CAPIREF: unqlite_lib_is_threadsafe()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_lib_is_threadsafe(void)
{
if( sUnqlMPGlobal.nMagic != UNQLITE_LIB_MAGIC ){
return 0;
}
#if defined(UNQLITE_ENABLE_THREADS)
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE ){
/* Muli-threading support is enabled */
return 1;
}else{
/* Single-threading */
return 0;
}
#else
return 0;
#endif
}
/*
*
* [CAPIREF: unqlite_lib_version()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_lib_version(void)
{
return UNQLITE_VERSION;
}
/*
*
* [CAPIREF: unqlite_lib_signature()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_lib_signature(void)
{
return UNQLITE_SIG;
}
/*
*
* [CAPIREF: unqlite_lib_ident()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_lib_ident(void)
{
return UNQLITE_IDENT;
}
/*
*
* [CAPIREF: unqlite_lib_copyright()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_lib_copyright(void)
{
return UNQLITE_COPYRIGHT;
}
/*
* Remove harmfull and/or stale flags passed to the [unqlite_open()] interface.
*/
static unsigned int unqliteSanityzeFlag(unsigned int iFlags)
{
iFlags &= ~UNQLITE_OPEN_EXCLUSIVE; /* Reserved flag */
if( iFlags & UNQLITE_OPEN_TEMP_DB ){
/* Omit journaling for temporary database */
iFlags |= UNQLITE_OPEN_OMIT_JOURNALING|UNQLITE_OPEN_CREATE;
}
if( (iFlags & (UNQLITE_OPEN_READONLY|UNQLITE_OPEN_READWRITE)) == 0 ){
/* Auto-append the R+W flag */
iFlags |= UNQLITE_OPEN_READWRITE;
}
if( iFlags & UNQLITE_OPEN_CREATE ){
iFlags &= ~(UNQLITE_OPEN_MMAP|UNQLITE_OPEN_READONLY);
/* Auto-append the R+W flag */
iFlags |= UNQLITE_OPEN_READWRITE;
}else{
if( iFlags & UNQLITE_OPEN_READONLY ){
iFlags &= ~UNQLITE_OPEN_READWRITE;
}else if( iFlags & UNQLITE_OPEN_READWRITE ){
iFlags &= ~UNQLITE_OPEN_MMAP;
}
}
return iFlags;
}
/*
* This routine does the work of initializing a database handle on behalf
* of [unqlite_open()].
*/
static int unqliteInitDatabase(
unqlite *pDB, /* Database handle */
SyMemBackend *pParent, /* Master memory backend */
const char *zFilename, /* Target database */
unsigned int iFlags /* Open flags */
)
{
unqlite_db *pStorage = &pDB->sDB;
int rc;
/* Initialiaze the memory subsystem */
SyMemBackendInitFromParent(&pDB->sMem,pParent);
//#if defined(UNQLITE_ENABLE_THREADS)
// /* No need for internal mutexes */
// SyMemBackendDisbaleMutexing(&pDB->sMem);
//#endif
SyBlobInit(&pDB->sErr,&pDB->sMem);
/* Sanityze flags */
iFlags = unqliteSanityzeFlag(iFlags);
/* Init the pager and the transaction manager */
rc = unqlitePagerOpen(sUnqlMPGlobal.pVfs,pDB,zFilename,iFlags);
if( rc != UNQLITE_OK ){
return rc;
}
/* Allocate a new Jx9 engine handle */
rc = jx9_init(&pStorage->pJx9);
if( rc != JX9_OK ){
return rc;
}
return UNQLITE_OK;
}
/*
* Allocate and initialize a new UnQLite Virtual Mahcine and attach it
* to the compiled Jx9 script.
*/
static int unqliteInitVm(unqlite *pDb,jx9_vm *pJx9Vm,unqlite_vm **ppOut)
{
unqlite_vm *pVm;
*ppOut = 0;
/* Allocate a new VM instance */
pVm = (unqlite_vm *)SyMemBackendPoolAlloc(&pDb->sMem,sizeof(unqlite_vm));
if( pVm == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pVm,sizeof(unqlite_vm));
/* Initialize */
SyMemBackendInitFromParent(&pVm->sAlloc,&pDb->sMem);
/* Allocate a new collection table */
pVm->apCol = (unqlite_col **)SyMemBackendAlloc(&pVm->sAlloc,32 * sizeof(unqlite_col *));
if( pVm->apCol == 0 ){
goto fail;
}
pVm->iColSize = 32; /* Must be a power of two */
/* Zero the table */
SyZero((void *)pVm->apCol,pVm->iColSize * sizeof(unqlite_col *));
#if defined(UNQLITE_ENABLE_THREADS)
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE ){
/* Associate a recursive mutex with this instance */
pVm->pMutex = SyMutexNew(sUnqlMPGlobal.pMutexMethods, SXMUTEX_TYPE_RECURSIVE);
if( pVm->pMutex == 0 ){
goto fail;
}
}
#endif
/* Link the VM to the list of active virtual machines */
pVm->pJx9Vm = pJx9Vm;
pVm->pDb = pDb;
MACRO_LD_PUSH(pDb->pVms,pVm);
pDb->iVm++;
/* Register Jx9 functions */
unqliteRegisterJx9Functions(pVm);
/* Set the magic number */
pVm->nMagic = JX9_VM_INIT; /* Same magic number as Jx9 */
/* All done */
*ppOut = pVm;
return UNQLITE_OK;
fail:
SyMemBackendRelease(&pVm->sAlloc);
SyMemBackendPoolFree(&pDb->sMem,pVm);
return UNQLITE_NOMEM;
}
/*
* Release an active VM.
*/
static int unqliteVmRelease(unqlite_vm *pVm)
{
/* Release the Jx9 VM */
jx9_vm_release(pVm->pJx9Vm);
/* Release the private memory backend */
SyMemBackendRelease(&pVm->sAlloc);
/* Upper layer will discard this VM from the list
* of active VM.
*/
return UNQLITE_OK;
}
/*
* Return the default page size.
*/
UNQLITE_PRIVATE int unqliteGetPageSize(void)
{
int iSize = sUnqlMPGlobal.iPageSize;
if( iSize < UNQLITE_MIN_PAGE_SIZE || iSize > UNQLITE_MAX_PAGE_SIZE ){
iSize = UNQLITE_DEFAULT_PAGE_SIZE;
}
return iSize;
}
/*
* Generate an error message.
*/
UNQLITE_PRIVATE int unqliteGenError(unqlite *pDb,const char *zErr)
{
int rc;
/* Append the error message */
rc = SyBlobAppend(&pDb->sErr,(const void *)zErr,SyStrlen(zErr));
/* Append a new line */
SyBlobAppend(&pDb->sErr,(const void *)"\n",sizeof(char));
return rc;
}
/*
* Generate an error message (Printf like).
*/
UNQLITE_PRIVATE int unqliteGenErrorFormat(unqlite *pDb,const char *zFmt,...)
{
va_list ap;
int rc;
va_start(ap,zFmt);
rc = SyBlobFormatAp(&pDb->sErr,zFmt,ap);
va_end(ap);
/* Append a new line */
SyBlobAppend(&pDb->sErr,(const void *)"\n",sizeof(char));
return rc;
}
/*
* Generate an error message (Out of memory).
*/
UNQLITE_PRIVATE int unqliteGenOutofMem(unqlite *pDb)
{
int rc;
rc = unqliteGenError(pDb,"unQLite is running out of memory");
return rc;
}
/*
* Configure a working UnQLite database handle.
*/
static int unqliteConfigure(unqlite *pDb,int nOp,va_list ap)
{
int rc = UNQLITE_OK;
switch(nOp){
case UNQLITE_CONFIG_JX9_ERR_LOG:
/* Jx9 compile-time error log */
rc = jx9EngineConfig(pDb->sDB.pJx9,JX9_CONFIG_ERR_LOG,ap);
break;
case UNQLITE_CONFIG_MAX_PAGE_CACHE: {
int max_page = va_arg(ap,int);
/* Maximum number of page to cache (Simple hint). */
rc = unqlitePagerSetCachesize(pDb->sDB.pPager,max_page);
break;
}
case UNQLITE_CONFIG_ERR_LOG: {
/* Database error log if any */
const char **pzPtr = va_arg(ap, const char **);
int *pLen = va_arg(ap, int *);
if( pzPtr == 0 ){
rc = JX9_CORRUPT;
break;
}
/* NULL terminate the error-log buffer */
SyBlobNullAppend(&pDb->sErr);
/* Point to the error-log buffer */
*pzPtr = (const char *)SyBlobData(&pDb->sErr);
if( pLen ){
if( SyBlobLength(&pDb->sErr) > 1 /* NULL '\0' terminator */ ){
*pLen = (int)SyBlobLength(&pDb->sErr);
}else{
*pLen = 0;
}
}
break;
}
case UNQLITE_CONFIG_DISABLE_AUTO_COMMIT:{
/* Disable auto-commit */
pDb->iFlags |= UNQLITE_FL_DISABLE_AUTO_COMMIT;
break;
}
case UNQLITE_CONFIG_GET_KV_NAME: {
/* Name of the underlying KV storage engine */
const char **pzPtr = va_arg(ap,const char **);
if( pzPtr ){
unqlite_kv_engine *pEngine;
pEngine = unqlitePagerGetKvEngine(pDb);
/* Point to the name */
*pzPtr = pEngine->pIo->pMethods->zName;
}
break;
}
default:
/* Unknown configuration option */
rc = UNQLITE_UNKNOWN;
break;
}
return rc;
}
/*
* Export the global (master) memory allocator to submodules.
*/
UNQLITE_PRIVATE const SyMemBackend * unqliteExportMemBackend(void)
{
return &sUnqlMPGlobal.sAllocator;
}
/*
* [CAPIREF: unqlite_open()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_open(unqlite **ppDB,const char *zFilename,unsigned int iMode)
{
unqlite *pHandle;
int rc;
#if defined(UNTRUST)
if( ppDB == 0 ){
return UNQLITE_CORRUPT;
}
#endif
*ppDB = 0;
/* One-time automatic library initialization */
rc = unqliteCoreInitialize();
if( rc != UNQLITE_OK ){
return rc;
}
/* Allocate a new database handle */
pHandle = (unqlite *)SyMemBackendPoolAlloc(&sUnqlMPGlobal.sAllocator, sizeof(unqlite));
if( pHandle == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pHandle,sizeof(unqlite));
if( iMode < 1 ){
/* Assume a read-only database */
iMode = UNQLITE_OPEN_READONLY|UNQLITE_OPEN_MMAP;
}
/* Init the database */
rc = unqliteInitDatabase(pHandle,&sUnqlMPGlobal.sAllocator,zFilename,iMode);
if( rc != UNQLITE_OK ){
goto Release;
}
#if defined(UNQLITE_ENABLE_THREADS)
if( !(iMode & UNQLITE_OPEN_NOMUTEX) && (sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE) ){
/* Associate a recursive mutex with this instance */
pHandle->pMutex = SyMutexNew(sUnqlMPGlobal.pMutexMethods, SXMUTEX_TYPE_RECURSIVE);
if( pHandle->pMutex == 0 ){
rc = UNQLITE_NOMEM;
goto Release;
}
}
#endif
/* Link to the list of active DB handles */
#if defined(UNQLITE_ENABLE_THREADS)
/* Enter the global mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
MACRO_LD_PUSH(sUnqlMPGlobal.pDB,pHandle);
sUnqlMPGlobal.nDB++;
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave the global mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
/* Set the magic number to identify a valid DB handle */
pHandle->nMagic = UNQLITE_DB_MAGIC;
/* Make the handle available to the caller */
*ppDB = pHandle;
return UNQLITE_OK;
Release:
SyMemBackendRelease(&pHandle->sMem);
SyMemBackendPoolFree(&sUnqlMPGlobal.sAllocator,pHandle);
return rc;
}
/*
* [CAPIREF: unqlite_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_config(unqlite *pDb,int nConfigOp,...)
{
va_list ap;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
va_start(ap, nConfigOp);
rc = unqliteConfigure(&(*pDb),nConfigOp, ap);
va_end(ap);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_close()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_close(unqlite *pDb)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Release the database handle */
rc = unqliteDbRelease(pDb);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
/* Release DB mutex */
SyMutexRelease(sUnqlMPGlobal.pMutexMethods, pDb->pMutex) /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
#if defined(UNQLITE_ENABLE_THREADS)
/* Enter the global mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
/* Unlink from the list of active database handles */
MACRO_LD_REMOVE(sUnqlMPGlobal.pDB, pDb);
sUnqlMPGlobal.nDB--;
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave the global mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods, sUnqlMPGlobal.pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel == UNQLITE_THREAD_LEVEL_SINGLE */
#endif
/* Release the memory chunk allocated to this handle */
SyMemBackendPoolFree(&sUnqlMPGlobal.sAllocator,pDb);
return rc;
}
/*
* [CAPIREF: unqlite_compile()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_compile(unqlite *pDb,const char *zJx9,int nByte,unqlite_vm **ppOut)
{
jx9_vm *pVm;
int rc;
if( UNQLITE_DB_MISUSE(pDb) || ppOut == 0){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT;
}
#endif
/* Compile the Jx9 script first */
rc = jx9_compile(pDb->sDB.pJx9,zJx9,nByte,&pVm);
if( rc == JX9_OK ){
/* Allocate a new unqlite VM instance */
rc = unqliteInitVm(pDb,pVm,ppOut);
if( rc != UNQLITE_OK ){
/* Release the Jx9 VM */
jx9_vm_release(pVm);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_compile_file()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_compile_file(unqlite *pDb,const char *zPath,unqlite_vm **ppOut)
{
jx9_vm *pVm;
int rc;
if( UNQLITE_DB_MISUSE(pDb) || ppOut == 0){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT;
}
#endif
/* Compile the Jx9 script first */
rc = jx9_compile_file(pDb->sDB.pJx9,zPath,&pVm);
if( rc == JX9_OK ){
/* Allocate a new unqlite VM instance */
rc = unqliteInitVm(pDb,pVm,ppOut);
if( rc != UNQLITE_OK ){
/* Release the Jx9 VM */
jx9_vm_release(pVm);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* Configure an unqlite virtual machine (Mostly Jx9 VM) instance.
*/
static int unqliteVmConfig(unqlite_vm *pVm,sxi32 iOp,va_list ap)
{
int rc;
rc = jx9VmConfigure(pVm->pJx9Vm,iOp,ap);
return rc;
}
/*
* [CAPIREF: unqlite_vm_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_config(unqlite_vm *pVm,int iOp,...)
{
va_list ap;
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
va_start(ap,iOp);
rc = unqliteVmConfig(pVm,iOp,ap);
va_end(ap);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_vm_exec()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_exec(unqlite_vm *pVm)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Execute the Jx9 bytecode program */
rc = jx9VmByteCodeExec(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_vm_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_release(unqlite_vm *pVm)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Release the VM */
rc = unqliteVmRelease(pVm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave VM mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
/* Release VM mutex */
SyMutexRelease(sUnqlMPGlobal.pMutexMethods,pVm->pMutex) /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
if( rc == UNQLITE_OK ){
unqlite *pDb = pVm->pDb;
/* Unlink from the list of active VM's */
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
MACRO_LD_REMOVE(pDb->pVms, pVm);
pDb->iVm--;
/* Release the memory chunk allocated to this instance */
SyMemBackendPoolFree(&pDb->sMem,pVm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
}
return rc;
}
/*
* [CAPIREF: unqlite_vm_reset()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_reset(unqlite_vm *pVm)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Reset the Jx9 VM */
rc = jx9VmReset(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_vm_dump()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_dump(unqlite_vm *pVm, int (*xConsumer)(const void *, unsigned int, void *), void *pUserData)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Dump the Jx9 VM */
rc = jx9VmDump(pVm->pJx9Vm,xConsumer,pUserData);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_vm_extract_variable()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_vm_extract_variable(unqlite_vm *pVm,const char *zVarname)
{
unqlite_value *pValue;
SyString sVariable;
if( UNQLITE_VM_MISUSE(pVm) ){
return 0;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return 0; /* Another thread have released this instance */
}
#endif
/* Extract the target variable */
SyStringInitFromBuf(&sVariable,zVarname,SyStrlen(zVarname));
pValue = jx9VmExtractVariable(pVm->pJx9Vm,&sVariable);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return pValue;
}
/*
* [CAPIREF: unqlite_create_function()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_create_function(unqlite_vm *pVm, const char *zName,int (*xFunc)(unqlite_context *,int,unqlite_value **),void *pUserData)
{
SyString sName;
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sName);
/* Ticket 1433-003: NULL values are not allowed */
if( sName.nByte < 1 || xFunc == 0 ){
return UNQLITE_INVALID;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Install the foreign function */
rc = jx9VmInstallForeignFunction(pVm->pJx9Vm,&sName,xFunc,pUserData);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_delete_function()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_delete_function(unqlite_vm *pVm, const char *zName)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Unlink the foreign function */
rc = jx9DeleteFunction(pVm->pJx9Vm,zName);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_create_constant()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_create_constant(unqlite_vm *pVm,const char *zName,void (*xExpand)(unqlite_value *, void *),void *pUserData)
{
SyString sName;
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sName);
if( sName.nByte < 1 ){
/* Empty constant name */
return UNQLITE_INVALID;
}
/* TICKET 1433-003: NULL pointer is harmless operation */
if( xExpand == 0 ){
return UNQLITE_INVALID;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Install the foreign constant */
rc = jx9VmRegisterConstant(pVm->pJx9Vm,&sName,xExpand,pUserData);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_delete_constant()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_delete_constant(unqlite_vm *pVm, const char *zName)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Unlink the foreign constant */
rc = Jx9DeleteConstant(pVm->pJx9Vm,zName);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_value_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_int(unqlite_value *pVal, int iValue)
{
return jx9_value_int(pVal,iValue);
}
/*
* [CAPIREF: unqlite_value_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_int64(unqlite_value *pVal,unqlite_int64 iValue)
{
return jx9_value_int64(pVal,iValue);
}
/*
* [CAPIREF: unqlite_value_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_bool(unqlite_value *pVal, int iBool)
{
return jx9_value_bool(pVal,iBool);
}
/*
* [CAPIREF: unqlite_value_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_null(unqlite_value *pVal)
{
return jx9_value_null(pVal);
}
/*
* [CAPIREF: unqlite_value_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_double(unqlite_value *pVal, double Value)
{
return jx9_value_double(pVal,Value);
}
/*
* [CAPIREF: unqlite_value_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_string(unqlite_value *pVal, const char *zString, int nLen)
{
return jx9_value_string(pVal,zString,nLen);
}
/*
* [CAPIREF: unqlite_value_string_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_string_format(unqlite_value *pVal, const char *zFormat,...)
{
va_list ap;
int rc;
if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
MemObjSetType(pVal, MEMOBJ_STRING);
}
va_start(ap, zFormat);
rc = SyBlobFormatAp(&pVal->sBlob, zFormat, ap);
va_end(ap);
return UNQLITE_OK;
}
/*
* [CAPIREF: unqlite_value_reset_string_cursor()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_reset_string_cursor(unqlite_value *pVal)
{
return jx9_value_reset_string_cursor(pVal);
}
/*
* [CAPIREF: unqlite_value_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_resource(unqlite_value *pVal,void *pUserData)
{
return jx9_value_resource(pVal,pUserData);
}
/*
* [CAPIREF: unqlite_value_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_release(unqlite_value *pVal)
{
return jx9_value_release(pVal);
}
/*
* [CAPIREF: unqlite_value_to_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_to_int(unqlite_value *pValue)
{
return jx9_value_to_int(pValue);
}
/*
* [CAPIREF: unqlite_value_to_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_to_bool(unqlite_value *pValue)
{
return jx9_value_to_bool(pValue);
}
/*
* [CAPIREF: unqlite_value_to_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_int64 unqlite_value_to_int64(unqlite_value *pValue)
{
return jx9_value_to_int64(pValue);
}
/*
* [CAPIREF: unqlite_value_to_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
double unqlite_value_to_double(unqlite_value *pValue)
{
return jx9_value_to_double(pValue);
}
/*
* [CAPIREF: unqlite_value_to_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_value_to_string(unqlite_value *pValue, int *pLen)
{
return jx9_value_to_string(pValue,pLen);
}
/*
* [CAPIREF: unqlite_value_to_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_value_to_resource(unqlite_value *pValue)
{
return jx9_value_to_resource(pValue);
}
/*
* [CAPIREF: unqlite_value_compare()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_compare(unqlite_value *pLeft, unqlite_value *pRight, int bStrict)
{
return jx9_value_compare(pLeft,pRight,bStrict);
}
/*
* [CAPIREF: unqlite_result_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_int(unqlite_context *pCtx, int iValue)
{
return jx9_result_int(pCtx,iValue);
}
/*
* [CAPIREF: unqlite_result_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_int64(unqlite_context *pCtx, unqlite_int64 iValue)
{
return jx9_result_int64(pCtx,iValue);
}
/*
* [CAPIREF: unqlite_result_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_bool(unqlite_context *pCtx, int iBool)
{
return jx9_result_bool(pCtx,iBool);
}
/*
* [CAPIREF: unqlite_result_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_double(unqlite_context *pCtx, double Value)
{
return jx9_result_double(pCtx,Value);
}
/*
* [CAPIREF: unqlite_result_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_null(unqlite_context *pCtx)
{
return jx9_result_null(pCtx);
}
/*
* [CAPIREF: unqlite_result_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_string(unqlite_context *pCtx, const char *zString, int nLen)
{
return jx9_result_string(pCtx,zString,nLen);
}
/*
* [CAPIREF: unqlite_result_string_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_string_format(unqlite_context *pCtx, const char *zFormat, ...)
{
jx9_value *p;
va_list ap;
int rc;
p = pCtx->pRet;
if( (p->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(p);
MemObjSetType(p, MEMOBJ_STRING);
}
/* Format the given string */
va_start(ap, zFormat);
rc = SyBlobFormatAp(&p->sBlob, zFormat, ap);
va_end(ap);
return rc;
}
/*
* [CAPIREF: unqlite_result_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_value(unqlite_context *pCtx, unqlite_value *pValue)
{
return jx9_result_value(pCtx,pValue);
}
/*
* [CAPIREF: unqlite_result_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_result_resource(unqlite_context *pCtx, void *pUserData)
{
return jx9_result_resource(pCtx,pUserData);
}
/*
* [CAPIREF: unqlite_value_is_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_int(unqlite_value *pVal)
{
return jx9_value_is_int(pVal);
}
/*
* [CAPIREF: unqlite_value_is_float()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_float(unqlite_value *pVal)
{
return jx9_value_is_float(pVal);
}
/*
* [CAPIREF: unqlite_value_is_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_bool(unqlite_value *pVal)
{
return jx9_value_is_bool(pVal);
}
/*
* [CAPIREF: unqlite_value_is_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_string(unqlite_value *pVal)
{
return jx9_value_is_string(pVal);
}
/*
* [CAPIREF: unqlite_value_is_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_null(unqlite_value *pVal)
{
return jx9_value_is_null(pVal);
}
/*
* [CAPIREF: unqlite_value_is_numeric()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_numeric(unqlite_value *pVal)
{
return jx9_value_is_numeric(pVal);
}
/*
* [CAPIREF: unqlite_value_is_callable()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_callable(unqlite_value *pVal)
{
return jx9_value_is_callable(pVal);
}
/*
* [CAPIREF: unqlite_value_is_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_scalar(unqlite_value *pVal)
{
return jx9_value_is_scalar(pVal);
}
/*
* [CAPIREF: unqlite_value_is_json_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_json_array(unqlite_value *pVal)
{
return jx9_value_is_json_array(pVal);
}
/*
* [CAPIREF: unqlite_value_is_json_object()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_json_object(unqlite_value *pVal)
{
return jx9_value_is_json_object(pVal);
}
/*
* [CAPIREF: unqlite_value_is_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_resource(unqlite_value *pVal)
{
return jx9_value_is_resource(pVal);
}
/*
* [CAPIREF: unqlite_value_is_empty()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_value_is_empty(unqlite_value *pVal)
{
return jx9_value_is_empty(pVal);
}
/*
* [CAPIREF: unqlite_array_fetch()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_array_fetch(unqlite_value *pArray, const char *zKey, int nByte)
{
return jx9_array_fetch(pArray,zKey,nByte);
}
/*
* [CAPIREF: unqlite_array_walk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_array_walk(unqlite_value *pArray, int (*xWalk)(unqlite_value *, unqlite_value *, void *), void *pUserData)
{
return jx9_array_walk(pArray,xWalk,pUserData);
}
/*
* [CAPIREF: unqlite_array_add_elem()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_array_add_elem(unqlite_value *pArray, unqlite_value *pKey, unqlite_value *pValue)
{
return jx9_array_add_elem(pArray,pKey,pValue);
}
/*
* [CAPIREF: unqlite_array_add_strkey_elem()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_array_add_strkey_elem(unqlite_value *pArray, const char *zKey, unqlite_value *pValue)
{
return jx9_array_add_strkey_elem(pArray,zKey,pValue);
}
/*
* [CAPIREF: unqlite_array_count()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_array_count(unqlite_value *pArray)
{
return (int)jx9_array_count(pArray);
}
/*
* [CAPIREF: unqlite_vm_new_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_vm_new_scalar(unqlite_vm *pVm)
{
unqlite_value *pValue;
if( UNQLITE_VM_MISUSE(pVm) ){
return 0;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return 0; /* Another thread have released this instance */
}
#endif
pValue = jx9_new_scalar(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return pValue;
}
/*
* [CAPIREF: unqlite_vm_new_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_vm_new_array(unqlite_vm *pVm)
{
unqlite_value *pValue;
if( UNQLITE_VM_MISUSE(pVm) ){
return 0;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return 0; /* Another thread have released this instance */
}
#endif
pValue = jx9_new_array(pVm->pJx9Vm);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return pValue;
}
/*
* [CAPIREF: unqlite_vm_release_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_vm_release_value(unqlite_vm *pVm,unqlite_value *pValue)
{
int rc;
if( UNQLITE_VM_MISUSE(pVm) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_VM_RELEASE(pVm) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
rc = jx9_release_value(pVm->pJx9Vm,pValue);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pVm->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_context_output()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_output(unqlite_context *pCtx, const char *zString, int nLen)
{
return jx9_context_output(pCtx,zString,nLen);
}
/*
* [CAPIREF: unqlite_context_output_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_output_format(unqlite_context *pCtx,const char *zFormat, ...)
{
va_list ap;
int rc;
va_start(ap, zFormat);
rc = jx9VmOutputConsumeAp(pCtx->pVm,zFormat, ap);
va_end(ap);
return rc;
}
/*
* [CAPIREF: unqlite_context_throw_error()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_throw_error(unqlite_context *pCtx, int iErr, const char *zErr)
{
return jx9_context_throw_error(pCtx,iErr,zErr);
}
/*
* [CAPIREF: unqlite_context_throw_error_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_throw_error_format(unqlite_context *pCtx, int iErr, const char *zFormat, ...)
{
va_list ap;
int rc;
if( zFormat == 0){
return JX9_OK;
}
va_start(ap, zFormat);
rc = jx9VmThrowErrorAp(pCtx->pVm, &pCtx->pFunc->sName, iErr, zFormat, ap);
va_end(ap);
return rc;
}
/*
* [CAPIREF: unqlite_context_random_num()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unsigned int unqlite_context_random_num(unqlite_context *pCtx)
{
return jx9_context_random_num(pCtx);
}
/*
* [CAPIREF: unqlite_context_random_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_random_string(unqlite_context *pCtx, char *zBuf, int nBuflen)
{
return jx9_context_random_string(pCtx,zBuf,nBuflen);
}
/*
* [CAPIREF: unqlite_context_user_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_context_user_data(unqlite_context *pCtx)
{
return jx9_context_user_data(pCtx);
}
/*
* [CAPIREF: unqlite_context_push_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_context_push_aux_data(unqlite_context *pCtx, void *pUserData)
{
return jx9_context_push_aux_data(pCtx,pUserData);
}
/*
* [CAPIREF: unqlite_context_peek_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_context_peek_aux_data(unqlite_context *pCtx)
{
return jx9_context_peek_aux_data(pCtx);
}
/*
* [CAPIREF: unqlite_context_pop_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_context_pop_aux_data(unqlite_context *pCtx)
{
return jx9_context_pop_aux_data(pCtx);
}
/*
* [CAPIREF: unqlite_context_result_buf_length()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unsigned int unqlite_context_result_buf_length(unqlite_context *pCtx)
{
return jx9_context_result_buf_length(pCtx);
}
/*
* [CAPIREF: unqlite_function_name()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
const char * unqlite_function_name(unqlite_context *pCtx)
{
return jx9_function_name(pCtx);
}
/*
* [CAPIREF: unqlite_context_new_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_context_new_scalar(unqlite_context *pCtx)
{
return jx9_context_new_scalar(pCtx);
}
/*
* [CAPIREF: unqlite_context_new_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
unqlite_value * unqlite_context_new_array(unqlite_context *pCtx)
{
return jx9_context_new_array(pCtx);
}
/*
* [CAPIREF: unqlite_context_release_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void unqlite_context_release_value(unqlite_context *pCtx,unqlite_value *pValue)
{
jx9_context_release_value(pCtx,pValue);
}
/*
* [CAPIREF: unqlite_context_alloc_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_context_alloc_chunk(unqlite_context *pCtx,unsigned int nByte,int ZeroChunk,int AutoRelease)
{
return jx9_context_alloc_chunk(pCtx,nByte,ZeroChunk,AutoRelease);
}
/*
* [CAPIREF: unqlite_context_realloc_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void * unqlite_context_realloc_chunk(unqlite_context *pCtx,void *pChunk,unsigned int nByte)
{
return jx9_context_realloc_chunk(pCtx,pChunk,nByte);
}
/*
* [CAPIREF: unqlite_context_free_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
void unqlite_context_free_chunk(unqlite_context *pCtx,void *pChunk)
{
jx9_context_free_chunk(pCtx,pChunk);
}
/*
* [CAPIREF: unqlite_kv_store()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_store(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen)
{
unqlite_kv_engine *pEngine;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
if( pEngine->pIo->pMethods->xReplace == 0 ){
/* Storage engine does not implement such method */
unqliteGenError(pDb,"xReplace() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
/* Perform the requested operation */
rc = pEngine->pIo->pMethods->xReplace(pEngine,pKey,nKeyLen,pData,nDataLen);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_store_fmt()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_store_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...)
{
unqlite_kv_engine *pEngine;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
if( pEngine->pIo->pMethods->xReplace == 0 ){
/* Storage engine does not implement such method */
unqliteGenError(pDb,"xReplace() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
SyBlob sWorker; /* Working buffer */
va_list ap;
SyBlobInit(&sWorker,&pDb->sMem);
/* Format the data */
va_start(ap,zFormat);
SyBlobFormatAp(&sWorker,zFormat,ap);
va_end(ap);
/* Perform the requested operation */
rc = pEngine->pIo->pMethods->xReplace(pEngine,pKey,nKeyLen,SyBlobData(&sWorker),SyBlobLength(&sWorker));
/* Clean up */
SyBlobRelease(&sWorker);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_append()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_append(unqlite *pDb,const void *pKey,int nKeyLen,const void *pData,unqlite_int64 nDataLen)
{
unqlite_kv_engine *pEngine;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
if( pEngine->pIo->pMethods->xAppend == 0 ){
/* Storage engine does not implement such method */
unqliteGenError(pDb,"xAppend() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
/* Perform the requested operation */
rc = pEngine->pIo->pMethods->xAppend(pEngine,pKey,nKeyLen,pData,nDataLen);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_append_fmt()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_append_fmt(unqlite *pDb,const void *pKey,int nKeyLen,const char *zFormat,...)
{
unqlite_kv_engine *pEngine;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
if( pEngine->pIo->pMethods->xAppend == 0 ){
/* Storage engine does not implement such method */
unqliteGenError(pDb,"xAppend() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
SyBlob sWorker; /* Working buffer */
va_list ap;
SyBlobInit(&sWorker,&pDb->sMem);
/* Format the data */
va_start(ap,zFormat);
SyBlobFormatAp(&sWorker,zFormat,ap);
va_end(ap);
/* Perform the requested operation */
rc = pEngine->pIo->pMethods->xAppend(pEngine,pKey,nKeyLen,SyBlobData(&sWorker),SyBlobLength(&sWorker));
/* Clean up */
SyBlobRelease(&sWorker);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_fetch()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_fetch(unqlite *pDb,const void *pKey,int nKeyLen,void *pBuf,unqlite_int64 *pBufLen)
{
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
unqlite_kv_cursor *pCur;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
pMethods = pEngine->pIo->pMethods;
pCur = pDb->sDB.pCursor;
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
/* Seek to the record position */
rc = pMethods->xSeek(pCur,pKey,nKeyLen,UNQLITE_CURSOR_MATCH_EXACT);
}
if( rc == UNQLITE_OK ){
if( pBuf == 0 ){
/* Data length only */
rc = pMethods->xDataLength(pCur,pBufLen);
}else{
SyBlob sBlob;
/* Initialize the data consumer */
SyBlobInitFromBuf(&sBlob,pBuf,(sxu32)*pBufLen);
/* Consume the data */
rc = pMethods->xData(pCur,unqliteDataConsumer,&sBlob);
/* Data length */
*pBufLen = (unqlite_int64)SyBlobLength(&sBlob);
/* Cleanup */
SyBlobRelease(&sBlob);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_fetch_callback()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_fetch_callback(unqlite *pDb,const void *pKey,int nKeyLen,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
unqlite_kv_cursor *pCur;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
pMethods = pEngine->pIo->pMethods;
pCur = pDb->sDB.pCursor;
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
/* Seek to the record position */
rc = pMethods->xSeek(pCur,pKey,nKeyLen,UNQLITE_CURSOR_MATCH_EXACT);
}
if( rc == UNQLITE_OK && xConsumer ){
/* Consume the data directly */
rc = pMethods->xData(pCur,xConsumer,pUserData);
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_delete()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_delete(unqlite *pDb,const void *pKey,int nKeyLen)
{
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
unqlite_kv_cursor *pCur;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
pMethods = pEngine->pIo->pMethods;
pCur = pDb->sDB.pCursor;
if( pMethods->xDelete == 0 ){
/* Storage engine does not implement such method */
unqliteGenError(pDb,"xDelete() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
unqliteGenError(pDb,"Empty key");
rc = UNQLITE_EMPTY;
}else{
/* Seek to the record position */
rc = pMethods->xSeek(pCur,pKey,nKeyLen,UNQLITE_CURSOR_MATCH_EXACT);
}
if( rc == UNQLITE_OK ){
/* Exact match found, delete the entry */
rc = pMethods->xDelete(pCur);
}
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_config(unqlite *pDb,int iOp,...)
{
unqlite_kv_engine *pEngine;
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Point to the underlying storage engine */
pEngine = unqlitePagerGetKvEngine(pDb);
if( pEngine->pIo->pMethods->xConfig == 0 ){
/* Storage engine does not implements such method */
unqliteGenError(pDb,"xConfig() method not implemented in the underlying storage engine");
rc = UNQLITE_NOTIMPLEMENTED;
}else{
va_list ap;
/* Configure the storage engine */
va_start(ap,iOp);
rc = pEngine->pIo->pMethods->xConfig(pEngine,iOp,ap);
va_end(ap);
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_init()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_init(unqlite *pDb,unqlite_kv_cursor **ppOut)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) || ppOut == 0 /* Noop */){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Allocate a new cursor */
rc = unqliteInitCursor(pDb,ppOut);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_release(unqlite *pDb,unqlite_kv_cursor *pCur)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) || pCur == 0 /* Noop */){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Release the cursor */
rc = unqliteReleaseCursor(pDb,pCur);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_first_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_first_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xFirst == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Seek to the first entry */
rc = pCursor->pStore->pIo->pMethods->xFirst(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_last_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_last_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xLast == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Seek to the last entry */
rc = pCursor->pStore->pIo->pMethods->xLast(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_valid_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_valid_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xValid == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
rc = pCursor->pStore->pIo->pMethods->xValid(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_next_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_next_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xNext == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Seek to the next entry */
rc = pCursor->pStore->pIo->pMethods->xNext(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_prev_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_prev_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xPrev == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Seek to the previous entry */
rc = pCursor->pStore->pIo->pMethods->xPrev(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_delete_entry()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_delete_entry(unqlite_kv_cursor *pCursor)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xDelete == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Delete the entry */
rc = pCursor->pStore->pIo->pMethods->xDelete(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_reset()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_reset(unqlite_kv_cursor *pCursor)
{
int rc = UNQLITE_OK;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Check if the requested method is implemented by the underlying storage engine */
if( pCursor->pStore->pIo->pMethods->xReset == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Reset */
pCursor->pStore->pIo->pMethods->xReset(pCursor);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_seek()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_seek(unqlite_kv_cursor *pCursor,const void *pKey,int nKeyLen,int iPos)
{
int rc = UNQLITE_OK;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
if( nKeyLen < 0 ){
/* Assume a null terminated string and compute it's length */
nKeyLen = SyStrlen((const char *)pKey);
}
if( !nKeyLen ){
rc = UNQLITE_EMPTY;
}else{
/* Seek to the desired location */
rc = pCursor->pStore->pIo->pMethods->xSeek(pCursor,pKey,nKeyLen,iPos);
}
return rc;
}
/*
* Default data consumer callback. That is, all retrieved is redirected to this
* routine which store the output in an internal blob.
*/
UNQLITE_PRIVATE int unqliteDataConsumer(
const void *pOut, /* Data to consume */
unsigned int nLen, /* Data length */
void *pUserData /* User private data */
)
{
sxi32 rc;
/* Store the output in an internal BLOB */
rc = SyBlobAppend((SyBlob *)pUserData, pOut, nLen);
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_data_callback()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_key_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Consume the key directly */
rc = pCursor->pStore->pIo->pMethods->xKey(pCursor,xConsumer,pUserData);
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_key()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_key(unqlite_kv_cursor *pCursor,void *pBuf,int *pnByte)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
if( pBuf == 0 ){
/* Key length only */
rc = pCursor->pStore->pIo->pMethods->xKeyLength(pCursor,pnByte);
}else{
SyBlob sBlob;
if( (*pnByte) < 0 ){
return UNQLITE_CORRUPT;
}
/* Initialize the data consumer */
SyBlobInitFromBuf(&sBlob,pBuf,(sxu32)(*pnByte));
/* Consume the key */
rc = pCursor->pStore->pIo->pMethods->xKey(pCursor,unqliteDataConsumer,&sBlob);
/* Key length */
*pnByte = SyBlobLength(&sBlob);
/* Cleanup */
SyBlobRelease(&sBlob);
}
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_data_callback()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_data_callback(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
/* Consume the data directly */
rc = pCursor->pStore->pIo->pMethods->xData(pCursor,xConsumer,pUserData);
return rc;
}
/*
* [CAPIREF: unqlite_kv_cursor_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_kv_cursor_data(unqlite_kv_cursor *pCursor,void *pBuf,unqlite_int64 *pnByte)
{
int rc;
#ifdef UNTRUST
if( pCursor == 0 ){
return UNQLITE_CORRUPT;
}
#endif
if( pBuf == 0 ){
/* Data length only */
rc = pCursor->pStore->pIo->pMethods->xDataLength(pCursor,pnByte);
}else{
SyBlob sBlob;
if( (*pnByte) < 0 ){
return UNQLITE_CORRUPT;
}
/* Initialize the data consumer */
SyBlobInitFromBuf(&sBlob,pBuf,(sxu32)(*pnByte));
/* Consume the data */
rc = pCursor->pStore->pIo->pMethods->xData(pCursor,unqliteDataConsumer,&sBlob);
/* Data length */
*pnByte = SyBlobLength(&sBlob);
/* Cleanup */
SyBlobRelease(&sBlob);
}
return rc;
}
/*
* [CAPIREF: unqlite_begin()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_begin(unqlite *pDb)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Begin the write transaction */
rc = unqlitePagerBegin(pDb->sDB.pPager);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_commit()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_commit(unqlite *pDb)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Commit the transaction */
rc = unqlitePagerCommit(pDb->sDB.pPager);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_rollback()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
int unqlite_rollback(unqlite *pDb)
{
int rc;
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Rollback the transaction */
rc = unqlitePagerRollback(pDb->sDB.pPager,TRUE);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: unqlite_util_load_mmaped_file()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
UNQLITE_APIEXPORT int unqlite_util_load_mmaped_file(const char *zFile,void **ppMap,unqlite_int64 *pFileSize)
{
const jx9_vfs *pVfs;
int rc;
if( SX_EMPTY_STR(zFile) || ppMap == 0 || pFileSize == 0){
/* Sanity check */
return UNQLITE_CORRUPT;
}
*ppMap = 0;
/* Extract the Jx9 Vfs */
pVfs = jx9ExportBuiltinVfs();
/*
* Check if the underlying vfs implement the memory map routines
* [i.e: mmap() under UNIX/MapViewOfFile() under windows].
*/
if( pVfs == 0 || pVfs->xMmap == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
/* Try to get a read-only memory view of the whole file */
rc = pVfs->xMmap(zFile,ppMap,pFileSize);
}
return rc;
}
/*
* [CAPIREF: unqlite_util_release_mmaped_file()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
UNQLITE_APIEXPORT int unqlite_util_release_mmaped_file(void *pMap,unqlite_int64 iFileSize)
{
const jx9_vfs *pVfs;
int rc = UNQLITE_OK;
if( pMap == 0 ){
return UNQLITE_OK;
}
/* Extract the Jx9 Vfs */
pVfs = jx9ExportBuiltinVfs();
if( pVfs == 0 || pVfs->xUnmap == 0 ){
rc = UNQLITE_NOTIMPLEMENTED;
}else{
pVfs->xUnmap(pMap,iFileSize);
}
return rc;
}
/*
* [CAPIREF: unqlite_util_random_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
UNQLITE_APIEXPORT int unqlite_util_random_string(unqlite *pDb,char *zBuf,unsigned int buf_size)
{
if( UNQLITE_DB_MISUSE(pDb) ){
return UNQLITE_CORRUPT;
}
if( zBuf == 0 || buf_size < 3 ){
/* Buffer must be long enough to hold three bytes */
return UNQLITE_INVALID;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return UNQLITE_ABORT; /* Another thread have released this instance */
}
#endif
/* Generate the random string */
unqlitePagerRandomString(pDb->sDB.pPager,zBuf,buf_size);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return UNQLITE_OK;
}
/*
* [CAPIREF: unqlite_util_random_num()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
UNQLITE_APIEXPORT unsigned int unqlite_util_random_num(unqlite *pDb)
{
sxu32 iNum;
if( UNQLITE_DB_MISUSE(pDb) ){
return 0;
}
#if defined(UNQLITE_ENABLE_THREADS)
/* Acquire DB mutex */
SyMutexEnter(sUnqlMPGlobal.pMutexMethods, pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
if( sUnqlMPGlobal.nThreadingLevel > UNQLITE_THREAD_LEVEL_SINGLE &&
UNQLITE_THRD_DB_RELEASE(pDb) ){
return 0; /* Another thread have released this instance */
}
#endif
/* Generate the random number */
iNum = unqlitePagerRandomNum(pDb->sDB.pPager);
#if defined(UNQLITE_ENABLE_THREADS)
/* Leave DB mutex */
SyMutexLeave(sUnqlMPGlobal.pMutexMethods,pDb->pMutex); /* NO-OP if sUnqlMPGlobal.nThreadingLevel != UNQLITE_THREAD_LEVEL_MULTI */
#endif
return iNum;
}
/*
* ----------------------------------------------------------
* File: bitvec.c
* MD5: 7e3376710d8454ebcf8c77baacca880f
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: bitvec.c v1.0 Win7 2013-02-27 15:16 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/** This file implements an object that represents a dynmaic
** bitmap.
**
** A bitmap is used to record which pages of a database file have been
** journalled during a transaction, or which pages have the "dont-write"
** property. Usually only a few pages are meet either condition.
** So the bitmap is usually sparse and has low cardinality.
*/
/*
* Actually, this is not a bitmap but a simple hashtable where page
* number (64-bit unsigned integers) are used as the lookup keys.
*/
typedef struct bitvec_rec bitvec_rec;
struct bitvec_rec
{
pgno iPage; /* Page number */
bitvec_rec *pNext,*pNextCol; /* Collison link */
};
struct Bitvec
{
SyMemBackend *pAlloc; /* Memory allocator */
sxu32 nRec; /* Total number of records */
sxu32 nSize; /* Table size */
bitvec_rec **apRec; /* Record table */
bitvec_rec *pList; /* List of records */
};
/*
* Allocate a new bitvec instance.
*/
UNQLITE_PRIVATE Bitvec * unqliteBitvecCreate(SyMemBackend *pAlloc,pgno iSize)
{
bitvec_rec **apNew;
Bitvec *p;
p = (Bitvec *)SyMemBackendAlloc(pAlloc,sizeof(*p) );
if( p == 0 ){
SXUNUSED(iSize); /* cc warning */
return 0;
}
/* Zero the structure */
SyZero(p,sizeof(Bitvec));
/* Allocate a new table */
p->nSize = 64; /* Must be a power of two */
apNew = (bitvec_rec **)SyMemBackendAlloc(pAlloc,p->nSize * sizeof(bitvec_rec *));
if( apNew == 0 ){
SyMemBackendFree(pAlloc,p);
return 0;
}
/* Zero the new table */
SyZero((void *)apNew,p->nSize * sizeof(bitvec_rec *));
/* Fill-in */
p->apRec = apNew;
p->pAlloc = pAlloc;
return p;
}
/*
* Check if the given page number is already installed in the table.
* Return true if installed. False otherwise.
*/
UNQLITE_PRIVATE int unqliteBitvecTest(Bitvec *p,pgno i)
{
bitvec_rec *pRec;
/* Point to the desired bucket */
pRec = p->apRec[i & (p->nSize - 1)];
for(;;){
if( pRec == 0 ){ break; }
if( pRec->iPage == i ){
/* Page found */
return 1;
}
/* Point to the next entry */
pRec = pRec->pNextCol;
if( pRec == 0 ){ break; }
if( pRec->iPage == i ){
/* Page found */
return 1;
}
/* Point to the next entry */
pRec = pRec->pNextCol;
if( pRec == 0 ){ break; }
if( pRec->iPage == i ){
/* Page found */
return 1;
}
/* Point to the next entry */
pRec = pRec->pNextCol;
if( pRec == 0 ){ break; }
if( pRec->iPage == i ){
/* Page found */
return 1;
}
/* Point to the next entry */
pRec = pRec->pNextCol;
}
/* No such entry */
return 0;
}
/*
* Install a given page number in our bitmap (Actually, our hashtable).
*/
UNQLITE_PRIVATE int unqliteBitvecSet(Bitvec *p,pgno i)
{
bitvec_rec *pRec;
sxi32 iBuck;
/* Allocate a new instance */
pRec = (bitvec_rec *)SyMemBackendPoolAlloc(p->pAlloc,sizeof(bitvec_rec));
if( pRec == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pRec,sizeof(bitvec_rec));
/* Fill-in */
pRec->iPage = i;
iBuck = i & (p->nSize - 1);
pRec->pNextCol = p->apRec[iBuck];
p->apRec[iBuck] = pRec;
pRec->pNext = p->pList;
p->pList = pRec;
p->nRec++;
if( p->nRec >= (p->nSize * 3) && p->nRec < 100000 ){
/* Grow the hashtable */
sxu32 nNewSize = p->nSize << 1;
bitvec_rec *pEntry,**apNew;
sxu32 n;
apNew = (bitvec_rec **)SyMemBackendAlloc(p->pAlloc, nNewSize * sizeof(bitvec_rec *));
if( apNew ){
sxu32 iBucket;
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(bitvec_rec *));
/* Rehash all entries */
n = 0;
pEntry = p->pList;
for(;;){
/* Loop one */
if( n >= p->nRec ){
break;
}
pEntry->pNextCol = 0;
/* Install in the new bucket */
iBucket = pEntry->iPage & (nNewSize - 1);
pEntry->pNextCol = apNew[iBucket];
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(p->pAlloc,(void *)p->apRec);
p->apRec = apNew;
p->nSize = nNewSize;
}
}
return UNQLITE_OK;
}
/*
* Destroy a bitvec instance. Reclaim all memory used.
*/
UNQLITE_PRIVATE void unqliteBitvecDestroy(Bitvec *p)
{
bitvec_rec *pNext,*pRec = p->pList;
SyMemBackend *pAlloc = p->pAlloc;
for(;;){
if( p->nRec < 1 ){
break;
}
pNext = pRec->pNext;
SyMemBackendPoolFree(pAlloc,(void *)pRec);
pRec = pNext;
p->nRec--;
if( p->nRec < 1 ){
break;
}
pNext = pRec->pNext;
SyMemBackendPoolFree(pAlloc,(void *)pRec);
pRec = pNext;
p->nRec--;
if( p->nRec < 1 ){
break;
}
pNext = pRec->pNext;
SyMemBackendPoolFree(pAlloc,(void *)pRec);
pRec = pNext;
p->nRec--;
if( p->nRec < 1 ){
break;
}
pNext = pRec->pNext;
SyMemBackendPoolFree(pAlloc,(void *)pRec);
pRec = pNext;
p->nRec--;
}
SyMemBackendFree(pAlloc,(void *)p->apRec);
SyMemBackendFree(pAlloc,p);
}
/*
* ----------------------------------------------------------
* File: fastjson.c
* MD5: 3693c0022edc7d37b65124d7aef68397
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: fastjson.c v1.1 FreeBSD 2012-12-05 22:52 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/* JSON binary encoding, decoding and stuff like that */
#ifndef UNQLITE_FAST_JSON_NEST_LIMIT
#if defined(__WINNT__) || defined(__UNIXES__)
#define UNQLITE_FAST_JSON_NEST_LIMIT 64 /* Nesting limit */
#else
#define UNQLITE_FAST_JSON_NEST_LIMIT 32 /* Nesting limit */
#endif
#endif /* UNQLITE_FAST_JSON_NEST_LIMIT */
/*
* JSON to Binary using the FastJSON implementation (BigEndian).
*/
/*
* FastJSON implemented binary token.
*/
#define FJSON_DOC_START 1 /* { */
#define FJSON_DOC_END 2 /* } */
#define FJSON_ARRAY_START 3 /* [ */
#define FJSON_ARRAY_END 4 /* ] */
#define FJSON_COLON 5 /* : */
#define FJSON_COMMA 6 /* , */
#define FJSON_ID 7 /* ID + 4 Bytes length */
#define FJSON_STRING 8 /* String + 4 bytes length */
#define FJSON_BYTE 9 /* Byte */
#define FJSON_INT64 10 /* Integer 64 + 8 bytes */
#define FJSON_REAL 18 /* Floating point value + 2 bytes */
#define FJSON_NULL 23 /* NULL */
#define FJSON_TRUE 24 /* TRUE */
#define FJSON_FALSE 25 /* FALSE */
/*
* Encode a Jx9 value to binary JSON.
*/
UNQLITE_PRIVATE sxi32 FastJsonEncode(
jx9_value *pValue, /* Value to encode */
SyBlob *pOut, /* Store encoded value here */
int iNest /* Nesting limit */
)
{
sxi32 iType = pValue ? pValue->iFlags : MEMOBJ_NULL;
sxi32 rc = SXRET_OK;
int c;
if( iNest >= UNQLITE_FAST_JSON_NEST_LIMIT ){
/* Nesting limit reached */
return SXERR_LIMIT;
}
if( iType & (MEMOBJ_NULL|MEMOBJ_RES) ){
/*
* Resources are encoded as null also.
*/
c = FJSON_NULL;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
}else if( iType & MEMOBJ_BOOL ){
c = pValue->x.iVal ? FJSON_TRUE : FJSON_FALSE;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
}else if( iType & MEMOBJ_STRING ){
unsigned char zBuf[sizeof(sxu32)]; /* String length */
c = FJSON_STRING;
SyBigEndianPack32(zBuf,SyBlobLength(&pValue->sBlob));
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc == SXRET_OK ){
rc = SyBlobAppend(pOut,(const void *)zBuf,sizeof(zBuf));
if( rc == SXRET_OK ){
rc = SyBlobAppend(pOut,SyBlobData(&pValue->sBlob),SyBlobLength(&pValue->sBlob));
}
}
}else if( iType & MEMOBJ_INT ){
unsigned char zBuf[8];
/* 64bit big endian integer */
c = FJSON_INT64;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc == SXRET_OK ){
SyBigEndianPack64(zBuf,(sxu64)pValue->x.iVal);
rc = SyBlobAppend(pOut,(const void *)zBuf,sizeof(zBuf));
}
}else if( iType & MEMOBJ_REAL ){
/* Real number */
c = FJSON_REAL;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc == SXRET_OK ){
sxu32 iOfft = SyBlobLength(pOut);
rc = SyBlobAppendBig16(pOut,0);
if( rc == SXRET_OK ){
unsigned char *zBlob;
SyBlobFormat(pOut,"%.15g",pValue->x.rVal);
zBlob = (unsigned char *)SyBlobDataAt(pOut,iOfft);
SyBigEndianPack16(zBlob,(sxu16)(SyBlobLength(pOut) - ( 2 + iOfft)));
}
}
}else if( iType & MEMOBJ_HASHMAP ){
/* A JSON object or array */
jx9_hashmap *pMap = (jx9_hashmap *)pValue->x.pOther;
jx9_hashmap_node *pNode;
jx9_value *pEntry;
/* Reset the hashmap loop cursor */
jx9HashmapResetLoopCursor(pMap);
if( pMap->iFlags & HASHMAP_JSON_OBJECT ){
jx9_value sKey;
/* A JSON object */
c = FJSON_DOC_START; /* { */
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc == SXRET_OK ){
jx9MemObjInit(pMap->pVm,&sKey);
/* Encode object entries */
while((pNode = jx9HashmapGetNextEntry(pMap)) != 0 ){
/* Extract the key */
jx9HashmapExtractNodeKey(pNode,&sKey);
/* Encode it */
rc = FastJsonEncode(&sKey,pOut,iNest+1);
if( rc != SXRET_OK ){
break;
}
c = FJSON_COLON;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc != SXRET_OK ){
break;
}
/* Extract the value */
pEntry = jx9HashmapGetNodeValue(pNode);
/* Encode it */
rc = FastJsonEncode(pEntry,pOut,iNest+1);
if( rc != SXRET_OK ){
break;
}
/* Delimit the entry */
c = FJSON_COMMA;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc != SXRET_OK ){
break;
}
}
jx9MemObjRelease(&sKey);
if( rc == SXRET_OK ){
c = FJSON_DOC_END; /* } */
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
}
}
}else{
/* A JSON array */
c = FJSON_ARRAY_START; /* [ */
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc == SXRET_OK ){
/* Encode array entries */
while( (pNode = jx9HashmapGetNextEntry(pMap)) != 0 ){
/* Extract the value */
pEntry = jx9HashmapGetNodeValue(pNode);
/* Encode it */
rc = FastJsonEncode(pEntry,pOut,iNest+1);
if( rc != SXRET_OK ){
break;
}
/* Delimit the entry */
c = FJSON_COMMA;
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
if( rc != SXRET_OK ){
break;
}
}
if( rc == SXRET_OK ){
c = FJSON_ARRAY_END; /* ] */
rc = SyBlobAppend(pOut,(const void *)&c,sizeof(char));
}
}
}
}
return rc;
}
/*
* Decode a FastJSON binary blob.
*/
UNQLITE_PRIVATE sxi32 FastJsonDecode(
const void *pIn, /* Binary JSON */
sxu32 nByte, /* Chunk delimiter */
jx9_value *pOut, /* Decoded value */
const unsigned char **pzPtr,
int iNest /* Nesting limit */
)
{
const unsigned char *zIn = (const unsigned char *)pIn;
const unsigned char *zEnd = &zIn[nByte];
sxi32 rc = SXRET_OK;
int c;
if( iNest >= UNQLITE_FAST_JSON_NEST_LIMIT ){
/* Nesting limit reached */
return SXERR_LIMIT;
}
c = zIn[0];
/* Advance the stream cursor */
zIn++;
/* Process the binary token */
switch(c){
case FJSON_NULL:
/* null */
jx9_value_null(pOut);
break;
case FJSON_FALSE:
/* Boolean FALSE */
jx9_value_bool(pOut,0);
break;
case FJSON_TRUE:
/* Boolean TRUE */
jx9_value_bool(pOut,1);
break;
case FJSON_INT64: {
/* 64Bit integer */
sxu64 iVal;
/* Sanity check */
if( &zIn[8] >= zEnd ){
/* Corrupt chunk */
rc = SXERR_CORRUPT;
break;
}
SyBigEndianUnpack64(zIn,&iVal);
/* Advance the pointer */
zIn += 8;
jx9_value_int64(pOut,(jx9_int64)iVal);
break;
}
case FJSON_REAL: {
/* Real number */
double iVal = 0; /* cc warning */
sxu16 iLen;
/* Sanity check */
if( &zIn[2] >= zEnd ){
/* Corrupt chunk */
rc = SXERR_CORRUPT;
break;
}
SyBigEndianUnpack16(zIn,&iLen);
if( &zIn[iLen] >= zEnd ){
/* Corrupt chunk */
rc = SXERR_CORRUPT;
break;
}
zIn += 2;
SyStrToReal((const char *)zIn,(sxu32)iLen,&iVal,0);
/* Advance the pointer */
zIn += iLen;
jx9_value_double(pOut,iVal);
break;
}
case FJSON_STRING: {
/* UTF-8/Binary chunk */
sxu32 iLength;
/* Sanity check */
if( &zIn[4] >= zEnd ){
/* Corrupt chunk */
rc = SXERR_CORRUPT;
break;
}
SyBigEndianUnpack32(zIn,&iLength);
if( &zIn[iLength] >= zEnd ){
/* Corrupt chunk */
rc = SXERR_CORRUPT;
break;
}
zIn += 4;
/* Invalidate any prior representation */
if( pOut->iFlags & MEMOBJ_STRING ){
/* Reset the string cursor */
SyBlobReset(&pOut->sBlob);
}
rc = jx9MemObjStringAppend(pOut,(const char *)zIn,iLength);
/* Update pointer */
zIn += iLength;
break;
}
case FJSON_ARRAY_START: {
/* Binary JSON array */
jx9_hashmap *pMap;
jx9_value sVal;
/* Allocate a new hashmap */
pMap = (jx9_hashmap *)jx9NewHashmap(pOut->pVm,0,0);
if( pMap == 0 ){
rc = SXERR_MEM;
break;
}
jx9MemObjInit(pOut->pVm,&sVal);
jx9MemObjRelease(pOut);
MemObjSetType(pOut,MEMOBJ_HASHMAP);
pOut->x.pOther = pMap;
rc = SXRET_OK;
for(;;){
/* Jump leading binary commas */
while (zIn < zEnd && zIn[0] == FJSON_COMMA ){
zIn++;
}
if( zIn >= zEnd || zIn[0] == FJSON_ARRAY_END ){
if( zIn < zEnd ){
zIn++; /* Jump the trailing binary ] */
}
break;
}
/* Decode the value */
rc = FastJsonDecode((const void *)zIn,(sxu32)(zEnd-zIn),&sVal,&zIn,iNest+1);
if( rc != SXRET_OK ){
break;
}
/* Insert the decoded value */
rc = jx9HashmapInsert(pMap,0,&sVal);
if( rc != UNQLITE_OK ){
break;
}
}
if( rc != SXRET_OK ){
jx9MemObjRelease(pOut);
}
jx9MemObjRelease(&sVal);
break;
}
case FJSON_DOC_START: {
/* Binary JSON object */
jx9_value sVal,sKey;
jx9_hashmap *pMap;
/* Allocate a new hashmap */
pMap = (jx9_hashmap *)jx9NewHashmap(pOut->pVm,0,0);
if( pMap == 0 ){
rc = SXERR_MEM;
break;
}
jx9MemObjInit(pOut->pVm,&sVal);
jx9MemObjInit(pOut->pVm,&sKey);
jx9MemObjRelease(pOut);
MemObjSetType(pOut,MEMOBJ_HASHMAP);
pOut->x.pOther = pMap;
rc = SXRET_OK;
for(;;){
/* Jump leading binary commas */
while (zIn < zEnd && zIn[0] == FJSON_COMMA ){
zIn++;
}
if( zIn >= zEnd || zIn[0] == FJSON_DOC_END ){
if( zIn < zEnd ){
zIn++; /* Jump the trailing binary } */
}
break;
}
/* Extract the key */
rc = FastJsonDecode((const void *)zIn,(sxu32)(zEnd-zIn),&sKey,&zIn,iNest+1);
if( rc != UNQLITE_OK ){
break;
}
if( zIn >= zEnd || zIn[0] != FJSON_COLON ){
rc = UNQLITE_CORRUPT;
break;
}
zIn++; /* Jump the binary colon ':' */
if( zIn >= zEnd ){
rc = UNQLITE_CORRUPT;
break;
}
/* Decode the value */
rc = FastJsonDecode((const void *)zIn,(sxu32)(zEnd-zIn),&sVal,&zIn,iNest+1);
if( rc != SXRET_OK ){
break;
}
/* Insert the key and its associated value */
rc = jx9HashmapInsert(pMap,&sKey,&sVal);
if( rc != UNQLITE_OK ){
break;
}
}
if( rc != SXRET_OK ){
jx9MemObjRelease(pOut);
}
jx9MemObjRelease(&sVal);
jx9MemObjRelease(&sKey);
break;
}
default:
/* Corrupt data */
rc = SXERR_CORRUPT;
break;
}
if( pzPtr ){
*pzPtr = zIn;
}
return rc;
}
/*
* ----------------------------------------------------------
* File: jx9_api.c
* MD5: 73cba599c009cee0ff878666d0543438
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: api.c v1.7 FreeBSD 2012-12-18 06:54 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file implement the public interfaces presented to host-applications.
* Routines in other files are for internal use by JX9 and should not be
* accessed by users of the library.
*/
#define JX9_ENGINE_MAGIC 0xF874BCD7
#define JX9_ENGINE_MISUSE(ENGINE) (ENGINE == 0 || ENGINE->nMagic != JX9_ENGINE_MAGIC)
#define JX9_VM_MISUSE(VM) (VM == 0 || VM->nMagic == JX9_VM_STALE)
/* If another thread have released a working instance, the following macros
* evaluates to true. These macros are only used when the library
* is built with threading support enabled which is not the case in
* the default built.
*/
#define JX9_THRD_ENGINE_RELEASE(ENGINE) (ENGINE->nMagic != JX9_ENGINE_MAGIC)
#define JX9_THRD_VM_RELEASE(VM) (VM->nMagic == JX9_VM_STALE)
/* IMPLEMENTATION: jx9@embedded@symisc 311-12-32 */
/*
* All global variables are collected in the structure named "sJx9MPGlobal".
* That way it is clear in the code when we are using static variable because
* its name start with sJx9MPGlobal.
*/
static struct Jx9Global_Data
{
SyMemBackend sAllocator; /* Global low level memory allocator */
#if defined(JX9_ENABLE_THREADS)
const SyMutexMethods *pMutexMethods; /* Mutex methods */
SyMutex *pMutex; /* Global mutex */
sxu32 nThreadingLevel; /* Threading level: 0 == Single threaded/1 == Multi-Threaded
* The threading level can be set using the [jx9_lib_config()]
* interface with a configuration verb set to
* JX9_LIB_CONFIG_THREAD_LEVEL_SINGLE or
* JX9_LIB_CONFIG_THREAD_LEVEL_MULTI
*/
#endif
const jx9_vfs *pVfs; /* Underlying virtual file system */
sxi32 nEngine; /* Total number of active engines */
jx9 *pEngines; /* List of active engine */
sxu32 nMagic; /* Sanity check against library misuse */
}sJx9MPGlobal = {
{0, 0, 0, 0, 0, 0, 0, 0, {0}},
#if defined(JX9_ENABLE_THREADS)
0,
0,
0,
#endif
0,
0,
0,
0
};
#define JX9_LIB_MAGIC 0xEA1495BA
#define JX9_LIB_MISUSE (sJx9MPGlobal.nMagic != JX9_LIB_MAGIC)
/*
* Supported threading level.
* These options have meaning only when the library is compiled with multi-threading
* support.That is, the JX9_ENABLE_THREADS compile time directive must be defined
* when JX9 is built.
* JX9_THREAD_LEVEL_SINGLE:
* In this mode, mutexing is disabled and the library can only be used by a single thread.
* JX9_THREAD_LEVEL_MULTI
* In this mode, all mutexes including the recursive mutexes on [jx9] objects
* are enabled so that the application is free to share the same engine
* between different threads at the same time.
*/
#define JX9_THREAD_LEVEL_SINGLE 1
#define JX9_THREAD_LEVEL_MULTI 2
/*
* Configure a running JX9 engine instance.
* return JX9_OK on success.Any other return
* value indicates failure.
* Refer to [jx9_config()].
*/
JX9_PRIVATE sxi32 jx9EngineConfig(jx9 *pEngine, sxi32 nOp, va_list ap)
{
jx9_conf *pConf = &pEngine->xConf;
int rc = JX9_OK;
/* Perform the requested operation */
switch(nOp){
case JX9_CONFIG_ERR_LOG:{
/* Extract compile-time error log if any */
const char **pzPtr = va_arg(ap, const char **);
int *pLen = va_arg(ap, int *);
if( pzPtr == 0 ){
rc = JX9_CORRUPT;
break;
}
/* NULL terminate the error-log buffer */
SyBlobNullAppend(&pConf->sErrConsumer);
/* Point to the error-log buffer */
*pzPtr = (const char *)SyBlobData(&pConf->sErrConsumer);
if( pLen ){
if( SyBlobLength(&pConf->sErrConsumer) > 1 /* NULL '\0' terminator */ ){
*pLen = (int)SyBlobLength(&pConf->sErrConsumer);
}else{
*pLen = 0;
}
}
break;
}
case JX9_CONFIG_ERR_ABORT:
/* Reserved for future use */
break;
default:
/* Unknown configuration verb */
rc = JX9_CORRUPT;
break;
} /* Switch() */
return rc;
}
/*
* Configure the JX9 library.
* Return JX9_OK on success. Any other return value indicates failure.
* Refer to [jx9_lib_config()].
*/
static sxi32 Jx9CoreConfigure(sxi32 nOp, va_list ap)
{
int rc = JX9_OK;
switch(nOp){
case JX9_LIB_CONFIG_VFS:{
/* Install a virtual file system */
const jx9_vfs *pVfs = va_arg(ap, const jx9_vfs *);
sJx9MPGlobal.pVfs = pVfs;
break;
}
case JX9_LIB_CONFIG_USER_MALLOC: {
/* Use an alternative low-level memory allocation routines */
const SyMemMethods *pMethods = va_arg(ap, const SyMemMethods *);
/* Save the memory failure callback (if available) */
ProcMemError xMemErr = sJx9MPGlobal.sAllocator.xMemError;
void *pMemErr = sJx9MPGlobal.sAllocator.pUserData;
if( pMethods == 0 ){
/* Use the built-in memory allocation subsystem */
rc = SyMemBackendInit(&sJx9MPGlobal.sAllocator, xMemErr, pMemErr);
}else{
rc = SyMemBackendInitFromOthers(&sJx9MPGlobal.sAllocator, pMethods, xMemErr, pMemErr);
}
break;
}
case JX9_LIB_CONFIG_MEM_ERR_CALLBACK: {
/* Memory failure callback */
ProcMemError xMemErr = va_arg(ap, ProcMemError);
void *pUserData = va_arg(ap, void *);
sJx9MPGlobal.sAllocator.xMemError = xMemErr;
sJx9MPGlobal.sAllocator.pUserData = pUserData;
break;
}
case JX9_LIB_CONFIG_USER_MUTEX: {
#if defined(JX9_ENABLE_THREADS)
/* Use an alternative low-level mutex subsystem */
const SyMutexMethods *pMethods = va_arg(ap, const SyMutexMethods *);
#if defined (UNTRUST)
if( pMethods == 0 ){
rc = JX9_CORRUPT;
}
#endif
/* Sanity check */
if( pMethods->xEnter == 0 || pMethods->xLeave == 0 || pMethods->xNew == 0){
/* At least three criticial callbacks xEnter(), xLeave() and xNew() must be supplied */
rc = JX9_CORRUPT;
break;
}
if( sJx9MPGlobal.pMutexMethods ){
/* Overwrite the previous mutex subsystem */
SyMutexRelease(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex);
if( sJx9MPGlobal.pMutexMethods->xGlobalRelease ){
sJx9MPGlobal.pMutexMethods->xGlobalRelease();
}
sJx9MPGlobal.pMutex = 0;
}
/* Initialize and install the new mutex subsystem */
if( pMethods->xGlobalInit ){
rc = pMethods->xGlobalInit();
if ( rc != JX9_OK ){
break;
}
}
/* Create the global mutex */
sJx9MPGlobal.pMutex = pMethods->xNew(SXMUTEX_TYPE_FAST);
if( sJx9MPGlobal.pMutex == 0 ){
/*
* If the supplied mutex subsystem is so sick that we are unable to
* create a single mutex, there is no much we can do here.
*/
if( pMethods->xGlobalRelease ){
pMethods->xGlobalRelease();
}
rc = JX9_CORRUPT;
break;
}
sJx9MPGlobal.pMutexMethods = pMethods;
if( sJx9MPGlobal.nThreadingLevel == 0 ){
/* Set a default threading level */
sJx9MPGlobal.nThreadingLevel = JX9_THREAD_LEVEL_MULTI;
}
#endif
break;
}
case JX9_LIB_CONFIG_THREAD_LEVEL_SINGLE:
#if defined(JX9_ENABLE_THREADS)
/* Single thread mode(Only one thread is allowed to play with the library) */
sJx9MPGlobal.nThreadingLevel = JX9_THREAD_LEVEL_SINGLE;
#endif
break;
case JX9_LIB_CONFIG_THREAD_LEVEL_MULTI:
#if defined(JX9_ENABLE_THREADS)
/* Multi-threading mode (library is thread safe and JX9 engines and virtual machines
* may be shared between multiple threads).
*/
sJx9MPGlobal.nThreadingLevel = JX9_THREAD_LEVEL_MULTI;
#endif
break;
default:
/* Unknown configuration option */
rc = JX9_CORRUPT;
break;
}
return rc;
}
/*
* [CAPIREF: jx9_lib_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_lib_config(int nConfigOp, ...)
{
va_list ap;
int rc;
if( sJx9MPGlobal.nMagic == JX9_LIB_MAGIC ){
/* Library is already initialized, this operation is forbidden */
return JX9_LOOKED;
}
va_start(ap, nConfigOp);
rc = Jx9CoreConfigure(nConfigOp, ap);
va_end(ap);
return rc;
}
/*
* Global library initialization
* Refer to [jx9_lib_init()]
* This routine must be called to initialize the memory allocation subsystem, the mutex
* subsystem prior to doing any serious work with the library.The first thread to call
* this routine does the initialization process and set the magic number so no body later
* can re-initialize the library.If subsequent threads call this routine before the first
* thread have finished the initialization process, then the subsequent threads must block
* until the initialization process is done.
*/
static sxi32 Jx9CoreInitialize(void)
{
const jx9_vfs *pVfs; /* Built-in vfs */
#if defined(JX9_ENABLE_THREADS)
const SyMutexMethods *pMutexMethods = 0;
SyMutex *pMaster = 0;
#endif
int rc;
/*
* If the library is already initialized, then a call to this routine
* is a no-op.
*/
if( sJx9MPGlobal.nMagic == JX9_LIB_MAGIC ){
return JX9_OK; /* Already initialized */
}
if( sJx9MPGlobal.pVfs == 0 ){
/* Point to the built-in vfs */
pVfs = jx9ExportBuiltinVfs();
/* Install it */
jx9_lib_config(JX9_LIB_CONFIG_VFS, pVfs);
}
#if defined(JX9_ENABLE_THREADS)
if( sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_SINGLE ){
pMutexMethods = sJx9MPGlobal.pMutexMethods;
if( pMutexMethods == 0 ){
/* Use the built-in mutex subsystem */
pMutexMethods = SyMutexExportMethods();
if( pMutexMethods == 0 ){
return JX9_CORRUPT; /* Can't happen */
}
/* Install the mutex subsystem */
rc = jx9_lib_config(JX9_LIB_CONFIG_USER_MUTEX, pMutexMethods);
if( rc != JX9_OK ){
return rc;
}
}
/* Obtain a static mutex so we can initialize the library without calling malloc() */
pMaster = SyMutexNew(pMutexMethods, SXMUTEX_TYPE_STATIC_1);
if( pMaster == 0 ){
return JX9_CORRUPT; /* Can't happen */
}
}
/* Lock the master mutex */
rc = JX9_OK;
SyMutexEnter(pMutexMethods, pMaster); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
if( sJx9MPGlobal.nMagic != JX9_LIB_MAGIC ){
#endif
if( sJx9MPGlobal.sAllocator.pMethods == 0 ){
/* Install a memory subsystem */
rc = jx9_lib_config(JX9_LIB_CONFIG_USER_MALLOC, 0); /* zero mean use the built-in memory backend */
if( rc != JX9_OK ){
/* If we are unable to initialize the memory backend, there is no much we can do here.*/
goto End;
}
}
#if defined(JX9_ENABLE_THREADS)
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE ){
/* Protect the memory allocation subsystem */
rc = SyMemBackendMakeThreadSafe(&sJx9MPGlobal.sAllocator, sJx9MPGlobal.pMutexMethods);
if( rc != JX9_OK ){
goto End;
}
}
#endif
/* Our library is initialized, set the magic number */
sJx9MPGlobal.nMagic = JX9_LIB_MAGIC;
rc = JX9_OK;
#if defined(JX9_ENABLE_THREADS)
} /* sJx9MPGlobal.nMagic != JX9_LIB_MAGIC */
#endif
End:
#if defined(JX9_ENABLE_THREADS)
/* Unlock the master mutex */
SyMutexLeave(pMutexMethods, pMaster); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
#endif
return rc;
}
/*
* Release an active JX9 engine and it's associated active virtual machines.
*/
static sxi32 EngineRelease(jx9 *pEngine)
{
jx9_vm *pVm, *pNext;
/* Release all active VM */
pVm = pEngine->pVms;
for(;;){
if( pEngine->iVm < 1 ){
break;
}
pNext = pVm->pNext;
jx9VmRelease(pVm);
pVm = pNext;
pEngine->iVm--;
}
/* Set a dummy magic number */
pEngine->nMagic = 0x7635;
/* Release the private memory subsystem */
SyMemBackendRelease(&pEngine->sAllocator);
return JX9_OK;
}
/*
* Release all resources consumed by the library.
* If JX9 is already shut when this routine is invoked then this
* routine is a harmless no-op.
* Note: This call is not thread safe. Refer to [jx9_lib_shutdown()].
*/
static void JX9CoreShutdown(void)
{
jx9 *pEngine, *pNext;
/* Release all active engines first */
pEngine = sJx9MPGlobal.pEngines;
for(;;){
if( sJx9MPGlobal.nEngine < 1 ){
break;
}
pNext = pEngine->pNext;
EngineRelease(pEngine);
pEngine = pNext;
sJx9MPGlobal.nEngine--;
}
#if defined(JX9_ENABLE_THREADS)
/* Release the mutex subsystem */
if( sJx9MPGlobal.pMutexMethods ){
if( sJx9MPGlobal.pMutex ){
SyMutexRelease(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex);
sJx9MPGlobal.pMutex = 0;
}
if( sJx9MPGlobal.pMutexMethods->xGlobalRelease ){
sJx9MPGlobal.pMutexMethods->xGlobalRelease();
}
sJx9MPGlobal.pMutexMethods = 0;
}
sJx9MPGlobal.nThreadingLevel = 0;
#endif
if( sJx9MPGlobal.sAllocator.pMethods ){
/* Release the memory backend */
SyMemBackendRelease(&sJx9MPGlobal.sAllocator);
}
sJx9MPGlobal.nMagic = 0x1928;
}
/*
* [CAPIREF: jx9_lib_shutdown()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_lib_shutdown(void)
{
if( sJx9MPGlobal.nMagic != JX9_LIB_MAGIC ){
/* Already shut */
return JX9_OK;
}
JX9CoreShutdown();
return JX9_OK;
}
/*
* [CAPIREF: jx9_lib_signature()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE const char * jx9_lib_signature(void)
{
return JX9_SIG;
}
/*
* [CAPIREF: jx9_init()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_init(jx9 **ppEngine)
{
jx9 *pEngine;
int rc;
#if defined(UNTRUST)
if( ppEngine == 0 ){
return JX9_CORRUPT;
}
#endif
*ppEngine = 0;
/* One-time automatic library initialization */
rc = Jx9CoreInitialize();
if( rc != JX9_OK ){
return rc;
}
/* Allocate a new engine */
pEngine = (jx9 *)SyMemBackendPoolAlloc(&sJx9MPGlobal.sAllocator, sizeof(jx9));
if( pEngine == 0 ){
return JX9_NOMEM;
}
/* Zero the structure */
SyZero(pEngine, sizeof(jx9));
/* Initialize engine fields */
pEngine->nMagic = JX9_ENGINE_MAGIC;
rc = SyMemBackendInitFromParent(&pEngine->sAllocator, &sJx9MPGlobal.sAllocator);
if( rc != JX9_OK ){
goto Release;
}
//#if defined(JX9_ENABLE_THREADS)
// SyMemBackendDisbaleMutexing(&pEngine->sAllocator);
//#endif
/* Default configuration */
SyBlobInit(&pEngine->xConf.sErrConsumer, &pEngine->sAllocator);
/* Install a default compile-time error consumer routine */
pEngine->xConf.xErr = jx9VmBlobConsumer;
pEngine->xConf.pErrData = &pEngine->xConf.sErrConsumer;
/* Built-in vfs */
pEngine->pVfs = sJx9MPGlobal.pVfs;
#if defined(JX9_ENABLE_THREADS)
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE ){
/* Associate a recursive mutex with this instance */
pEngine->pMutex = SyMutexNew(sJx9MPGlobal.pMutexMethods, SXMUTEX_TYPE_RECURSIVE);
if( pEngine->pMutex == 0 ){
rc = JX9_NOMEM;
goto Release;
}
}
#endif
/* Link to the list of active engines */
#if defined(JX9_ENABLE_THREADS)
/* Enter the global mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
#endif
MACRO_LD_PUSH(sJx9MPGlobal.pEngines, pEngine);
sJx9MPGlobal.nEngine++;
#if defined(JX9_ENABLE_THREADS)
/* Leave the global mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
#endif
/* Write a pointer to the new instance */
*ppEngine = pEngine;
return JX9_OK;
Release:
SyMemBackendRelease(&pEngine->sAllocator);
SyMemBackendPoolFree(&sJx9MPGlobal.sAllocator,pEngine);
return rc;
}
/*
* [CAPIREF: jx9_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_release(jx9 *pEngine)
{
int rc;
if( JX9_ENGINE_MISUSE(pEngine) ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire engine mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_ENGINE_RELEASE(pEngine) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/* Release the engine */
rc = EngineRelease(&(*pEngine));
#if defined(JX9_ENABLE_THREADS)
/* Leave engine mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
/* Release engine mutex */
SyMutexRelease(sJx9MPGlobal.pMutexMethods, pEngine->pMutex) /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
#if defined(JX9_ENABLE_THREADS)
/* Enter the global mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
#endif
/* Unlink from the list of active engines */
MACRO_LD_REMOVE(sJx9MPGlobal.pEngines, pEngine);
sJx9MPGlobal.nEngine--;
#if defined(JX9_ENABLE_THREADS)
/* Leave the global mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, sJx9MPGlobal.pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel == JX9_THREAD_LEVEL_SINGLE */
#endif
/* Release the memory chunk allocated to this engine */
SyMemBackendPoolFree(&sJx9MPGlobal.sAllocator, pEngine);
return rc;
}
/*
* Compile a raw JX9 script.
* To execute a JX9 code, it must first be compiled into a bytecode program using this routine.
* If something goes wrong [i.e: compile-time error], your error log [i.e: error consumer callback]
* should display the appropriate error message and this function set ppVm to null and return
* an error code that is different from JX9_OK. Otherwise when the script is successfully compiled
* ppVm should hold the JX9 bytecode and it's safe to call [jx9_vm_exec(), jx9_vm_reset(), etc.].
* This API does not actually evaluate the JX9 code. It merely compile and prepares the JX9 script
* for evaluation.
*/
static sxi32 ProcessScript(
jx9 *pEngine, /* Running JX9 engine */
jx9_vm **ppVm, /* OUT: A pointer to the virtual machine */
SyString *pScript, /* Raw JX9 script to compile */
sxi32 iFlags, /* Compile-time flags */
const char *zFilePath /* File path if script come from a file. NULL otherwise */
)
{
jx9_vm *pVm;
int rc;
/* Allocate a new virtual machine */
pVm = (jx9_vm *)SyMemBackendPoolAlloc(&pEngine->sAllocator, sizeof(jx9_vm));
if( pVm == 0 ){
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here. */
if( ppVm ){
*ppVm = 0;
}
return JX9_NOMEM;
}
if( iFlags < 0 ){
/* Default compile-time flags */
iFlags = 0;
}
/* Initialize the Virtual Machine */
rc = jx9VmInit(pVm, &(*pEngine));
if( rc != JX9_OK ){
SyMemBackendPoolFree(&pEngine->sAllocator, pVm);
if( ppVm ){
*ppVm = 0;
}
return JX9_VM_ERR;
}
if( zFilePath ){
/* Push processed file path */
jx9VmPushFilePath(pVm, zFilePath, -1, TRUE, 0);
}
/* Reset the error message consumer */
SyBlobReset(&pEngine->xConf.sErrConsumer);
/* Compile the script */
jx9CompileScript(pVm, &(*pScript), iFlags);
if( pVm->sCodeGen.nErr > 0 || pVm == 0){
sxu32 nErr = pVm->sCodeGen.nErr;
/* Compilation error or null ppVm pointer, release this VM */
SyMemBackendRelease(&pVm->sAllocator);
SyMemBackendPoolFree(&pEngine->sAllocator, pVm);
if( ppVm ){
*ppVm = 0;
}
return nErr > 0 ? JX9_COMPILE_ERR : JX9_OK;
}
/* Prepare the virtual machine for bytecode execution */
rc = jx9VmMakeReady(pVm);
if( rc != JX9_OK ){
goto Release;
}
/* Install local import path which is the current directory */
jx9_vm_config(pVm, JX9_VM_CONFIG_IMPORT_PATH, "./");
#if defined(JX9_ENABLE_THREADS)
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE ){
/* Associate a recursive mutex with this instance */
pVm->pMutex = SyMutexNew(sJx9MPGlobal.pMutexMethods, SXMUTEX_TYPE_RECURSIVE);
if( pVm->pMutex == 0 ){
goto Release;
}
}
#endif
/* Script successfully compiled, link to the list of active virtual machines */
MACRO_LD_PUSH(pEngine->pVms, pVm);
pEngine->iVm++;
/* Point to the freshly created VM */
*ppVm = pVm;
/* Ready to execute JX9 bytecode */
return JX9_OK;
Release:
SyMemBackendRelease(&pVm->sAllocator);
SyMemBackendPoolFree(&pEngine->sAllocator, pVm);
*ppVm = 0;
return JX9_VM_ERR;
}
/*
* [CAPIREF: jx9_compile()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_compile(jx9 *pEngine, const char *zSource, int nLen, jx9_vm **ppOutVm)
{
SyString sScript;
int rc;
if( JX9_ENGINE_MISUSE(pEngine) ){
return JX9_CORRUPT;
}
if( zSource == 0 ){
/* Empty Jx9 statement ';' */
zSource = ";";
nLen = (int)sizeof(char);
}
if( nLen < 0 ){
/* Compute input length automatically */
nLen = (int)SyStrlen(zSource);
}
SyStringInitFromBuf(&sScript, zSource, nLen);
#if defined(JX9_ENABLE_THREADS)
/* Acquire engine mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_ENGINE_RELEASE(pEngine) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/* Compile the script */
rc = ProcessScript(&(*pEngine),ppOutVm,&sScript,0,0);
#if defined(JX9_ENABLE_THREADS)
/* Leave engine mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
/* Compilation result */
return rc;
}
/*
* [CAPIREF: jx9_compile_file()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_compile_file(jx9 *pEngine, const char *zFilePath, jx9_vm **ppOutVm)
{
const jx9_vfs *pVfs;
int rc;
if( ppOutVm ){
*ppOutVm = 0;
}
rc = JX9_OK; /* cc warning */
if( JX9_ENGINE_MISUSE(pEngine) || SX_EMPTY_STR(zFilePath) ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire engine mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_ENGINE_RELEASE(pEngine) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/*
* Check if the underlying vfs implement the memory map
* [i.e: mmap() under UNIX/MapViewOfFile() under windows] function.
*/
pVfs = pEngine->pVfs;
if( pVfs == 0 || pVfs->xMmap == 0 ){
/* Memory map routine not implemented */
rc = JX9_IO_ERR;
}else{
void *pMapView = 0; /* cc warning */
jx9_int64 nSize = 0; /* cc warning */
SyString sScript;
/* Try to get a memory view of the whole file */
rc = pVfs->xMmap(zFilePath, &pMapView, &nSize);
if( rc != JX9_OK ){
/* Assume an IO error */
rc = JX9_IO_ERR;
}else{
/* Compile the file */
SyStringInitFromBuf(&sScript, pMapView, nSize);
rc = ProcessScript(&(*pEngine), ppOutVm, &sScript,0,zFilePath);
/* Release the memory view of the whole file */
if( pVfs->xUnmap ){
pVfs->xUnmap(pMapView, nSize);
}
}
}
#if defined(JX9_ENABLE_THREADS)
/* Leave engine mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
/* Compilation result */
return rc;
}
/*
* [CAPIREF: jx9_vm_config()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_vm_config(jx9_vm *pVm, int iConfigOp, ...)
{
va_list ap;
int rc;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_VM_RELEASE(pVm) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/* Confiugure the virtual machine */
va_start(ap, iConfigOp);
rc = jx9VmConfigure(&(*pVm), iConfigOp, ap);
va_end(ap);
#if defined(JX9_ENABLE_THREADS)
/* Leave VM mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
return rc;
}
/*
* [CAPIREF: jx9_vm_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_vm_release(jx9_vm *pVm)
{
jx9 *pEngine;
int rc;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_VM_RELEASE(pVm) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
pEngine = pVm->pEngine;
rc = jx9VmRelease(&(*pVm));
#if defined(JX9_ENABLE_THREADS)
/* Leave VM mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
/* Release VM mutex */
SyMutexRelease(sJx9MPGlobal.pMutexMethods, pVm->pMutex) /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
if( rc == JX9_OK ){
/* Unlink from the list of active VM */
#if defined(JX9_ENABLE_THREADS)
/* Acquire engine mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_ENGINE_RELEASE(pEngine) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
MACRO_LD_REMOVE(pEngine->pVms, pVm);
pEngine->iVm--;
/* Release the memory chunk allocated to this VM */
SyMemBackendPoolFree(&pEngine->sAllocator, pVm);
#if defined(JX9_ENABLE_THREADS)
/* Leave engine mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pEngine->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
}
return rc;
}
/*
* [CAPIREF: jx9_create_function()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_create_function(jx9_vm *pVm, const char *zName, int (*xFunc)(jx9_context *, int, jx9_value **), void *pUserData)
{
SyString sName;
int rc;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sName);
/* Ticket 1433-003: NULL values are not allowed */
if( sName.nByte < 1 || xFunc == 0 ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_VM_RELEASE(pVm) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/* Install the foreign function */
rc = jx9VmInstallForeignFunction(&(*pVm), &sName, xFunc, pUserData);
#if defined(JX9_ENABLE_THREADS)
/* Leave VM mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
return rc;
}
JX9_PRIVATE int jx9DeleteFunction(jx9_vm *pVm,const char *zName)
{
jx9_user_func *pFunc = 0; /* cc warning */
int rc;
/* Perform the deletion */
rc = SyHashDeleteEntry(&pVm->hHostFunction, (const void *)zName, SyStrlen(zName), (void **)&pFunc);
if( rc == JX9_OK ){
/* Release internal fields */
SySetRelease(&pFunc->aAux);
SyMemBackendFree(&pVm->sAllocator, (void *)SyStringData(&pFunc->sName));
SyMemBackendPoolFree(&pVm->sAllocator, pFunc);
}
return rc;
}
/*
* [CAPIREF: jx9_create_constant()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_create_constant(jx9_vm *pVm, const char *zName, void (*xExpand)(jx9_value *, void *), void *pUserData)
{
SyString sName;
int rc;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
SyStringInitFromBuf(&sName, zName, SyStrlen(zName));
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sName);
if( sName.nByte < 1 ){
/* Empty constant name */
return JX9_CORRUPT;
}
/* TICKET 1433-003: NULL pointer is harmless operation */
if( xExpand == 0 ){
return JX9_CORRUPT;
}
#if defined(JX9_ENABLE_THREADS)
/* Acquire VM mutex */
SyMutexEnter(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
if( sJx9MPGlobal.nThreadingLevel > JX9_THREAD_LEVEL_SINGLE &&
JX9_THRD_VM_RELEASE(pVm) ){
return JX9_ABORT; /* Another thread have released this instance */
}
#endif
/* Perform the registration */
rc = jx9VmRegisterConstant(&(*pVm), &sName, xExpand, pUserData);
#if defined(JX9_ENABLE_THREADS)
/* Leave VM mutex */
SyMutexLeave(sJx9MPGlobal.pMutexMethods, pVm->pMutex); /* NO-OP if sJx9MPGlobal.nThreadingLevel != JX9_THREAD_LEVEL_MULTI */
#endif
return rc;
}
JX9_PRIVATE int Jx9DeleteConstant(jx9_vm *pVm,const char *zName)
{
jx9_constant *pCons;
int rc;
/* Query the constant hashtable */
rc = SyHashDeleteEntry(&pVm->hConstant, (const void *)zName, SyStrlen(zName), (void **)&pCons);
if( rc == JX9_OK ){
/* Perform the deletion */
SyMemBackendFree(&pVm->sAllocator, (void *)SyStringData(&pCons->sName));
SyMemBackendPoolFree(&pVm->sAllocator, pCons);
}
return rc;
}
/*
* [CAPIREF: jx9_new_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_value * jx9_new_scalar(jx9_vm *pVm)
{
jx9_value *pObj;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return 0;
}
/* Allocate a new scalar variable */
pObj = (jx9_value *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_value));
if( pObj == 0 ){
return 0;
}
/* Nullify the new scalar */
jx9MemObjInit(pVm, pObj);
return pObj;
}
/*
* [CAPIREF: jx9_new_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_value * jx9_new_array(jx9_vm *pVm)
{
jx9_hashmap *pMap;
jx9_value *pObj;
/* Ticket 1433-002: NULL VM is harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return 0;
}
/* Create a new hashmap first */
pMap = jx9NewHashmap(&(*pVm), 0, 0);
if( pMap == 0 ){
return 0;
}
/* Associate a new jx9_value with this hashmap */
pObj = (jx9_value *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_value));
if( pObj == 0 ){
jx9HashmapRelease(pMap, TRUE);
return 0;
}
jx9MemObjInitFromArray(pVm, pObj, pMap);
return pObj;
}
/*
* [CAPIREF: jx9_release_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_release_value(jx9_vm *pVm, jx9_value *pValue)
{
/* Ticket 1433-002: NULL VM is a harmless operation */
if ( JX9_VM_MISUSE(pVm) ){
return JX9_CORRUPT;
}
if( pValue ){
/* Release the value */
jx9MemObjRelease(pValue);
SyMemBackendPoolFree(&pVm->sAllocator, pValue);
}
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_to_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_to_int(jx9_value *pValue)
{
int rc;
rc = jx9MemObjToInteger(pValue);
if( rc != JX9_OK ){
return 0;
}
return (int)pValue->x.iVal;
}
/*
* [CAPIREF: jx9_value_to_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_to_bool(jx9_value *pValue)
{
int rc;
rc = jx9MemObjToBool(pValue);
if( rc != JX9_OK ){
return 0;
}
return (int)pValue->x.iVal;
}
/*
* [CAPIREF: jx9_value_to_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_int64 jx9_value_to_int64(jx9_value *pValue)
{
int rc;
rc = jx9MemObjToInteger(pValue);
if( rc != JX9_OK ){
return 0;
}
return pValue->x.iVal;
}
/*
* [CAPIREF: jx9_value_to_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE double jx9_value_to_double(jx9_value *pValue)
{
int rc;
rc = jx9MemObjToReal(pValue);
if( rc != JX9_OK ){
return (double)0;
}
return (double)pValue->x.rVal;
}
/*
* [CAPIREF: jx9_value_to_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE const char * jx9_value_to_string(jx9_value *pValue, int *pLen)
{
jx9MemObjToString(pValue);
if( SyBlobLength(&pValue->sBlob) > 0 ){
SyBlobNullAppend(&pValue->sBlob);
if( pLen ){
*pLen = (int)SyBlobLength(&pValue->sBlob);
}
return (const char *)SyBlobData(&pValue->sBlob);
}else{
/* Return the empty string */
if( pLen ){
*pLen = 0;
}
return "";
}
}
/*
* [CAPIREF: jx9_value_to_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_value_to_resource(jx9_value *pValue)
{
if( (pValue->iFlags & MEMOBJ_RES) == 0 ){
/* Not a resource, return NULL */
return 0;
}
return pValue->x.pOther;
}
/*
* [CAPIREF: jx9_value_compare()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_compare(jx9_value *pLeft, jx9_value *pRight, int bStrict)
{
int rc;
if( pLeft == 0 || pRight == 0 ){
/* TICKET 1433-24: NULL values is harmless operation */
return 1;
}
/* Perform the comparison */
rc = jx9MemObjCmp(&(*pLeft), &(*pRight), bStrict, 0);
/* Comparison result */
return rc;
}
/*
* [CAPIREF: jx9_result_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_int(jx9_context *pCtx, int iValue)
{
return jx9_value_int(pCtx->pRet, iValue);
}
/*
* [CAPIREF: jx9_result_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_int64(jx9_context *pCtx, jx9_int64 iValue)
{
return jx9_value_int64(pCtx->pRet, iValue);
}
/*
* [CAPIREF: jx9_result_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_bool(jx9_context *pCtx, int iBool)
{
return jx9_value_bool(pCtx->pRet, iBool);
}
/*
* [CAPIREF: jx9_result_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_double(jx9_context *pCtx, double Value)
{
return jx9_value_double(pCtx->pRet, Value);
}
/*
* [CAPIREF: jx9_result_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_null(jx9_context *pCtx)
{
/* Invalidate any prior representation and set the NULL flag */
jx9MemObjRelease(pCtx->pRet);
return JX9_OK;
}
/*
* [CAPIREF: jx9_result_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_string(jx9_context *pCtx, const char *zString, int nLen)
{
return jx9_value_string(pCtx->pRet, zString, nLen);
}
/*
* [CAPIREF: jx9_result_string_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_string_format(jx9_context *pCtx, const char *zFormat, ...)
{
jx9_value *p;
va_list ap;
int rc;
p = pCtx->pRet;
if( (p->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(p);
MemObjSetType(p, MEMOBJ_STRING);
}
/* Format the given string */
va_start(ap, zFormat);
rc = SyBlobFormatAp(&p->sBlob, zFormat, ap);
va_end(ap);
return rc;
}
/*
* [CAPIREF: jx9_result_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_value(jx9_context *pCtx, jx9_value *pValue)
{
int rc = JX9_OK;
if( pValue == 0 ){
jx9MemObjRelease(pCtx->pRet);
}else{
rc = jx9MemObjStore(pValue, pCtx->pRet);
}
return rc;
}
/*
* [CAPIREF: jx9_result_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_result_resource(jx9_context *pCtx, void *pUserData)
{
return jx9_value_resource(pCtx->pRet, pUserData);
}
/*
* [CAPIREF: jx9_context_new_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_value * jx9_context_new_scalar(jx9_context *pCtx)
{
jx9_value *pVal;
pVal = jx9_new_scalar(pCtx->pVm);
if( pVal ){
/* Record value address so it can be freed automatically
* when the calling function returns.
*/
SySetPut(&pCtx->sVar, (const void *)&pVal);
}
return pVal;
}
/*
* [CAPIREF: jx9_context_new_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_value * jx9_context_new_array(jx9_context *pCtx)
{
jx9_value *pVal;
pVal = jx9_new_array(pCtx->pVm);
if( pVal ){
/* Record value address so it can be freed automatically
* when the calling function returns.
*/
SySetPut(&pCtx->sVar, (const void *)&pVal);
}
return pVal;
}
/*
* [CAPIREF: jx9_context_release_value()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void jx9_context_release_value(jx9_context *pCtx, jx9_value *pValue)
{
jx9VmReleaseContextValue(&(*pCtx), pValue);
}
/*
* [CAPIREF: jx9_context_alloc_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_context_alloc_chunk(jx9_context *pCtx, unsigned int nByte, int ZeroChunk, int AutoRelease)
{
void *pChunk;
pChunk = SyMemBackendAlloc(&pCtx->pVm->sAllocator, nByte);
if( pChunk ){
if( ZeroChunk ){
/* Zero the memory chunk */
SyZero(pChunk, nByte);
}
if( AutoRelease ){
jx9_aux_data sAux;
/* Track the chunk so that it can be released automatically
* upon this context is destroyed.
*/
sAux.pAuxData = pChunk;
SySetPut(&pCtx->sChunk, (const void *)&sAux);
}
}
return pChunk;
}
/*
* Check if the given chunk address is registered in the call context
* chunk container.
* Return TRUE if registered.FALSE otherwise.
* Refer to [jx9_context_realloc_chunk(), jx9_context_free_chunk()].
*/
static jx9_aux_data * ContextFindChunk(jx9_context *pCtx, void *pChunk)
{
jx9_aux_data *aAux, *pAux;
sxu32 n;
if( SySetUsed(&pCtx->sChunk) < 1 ){
/* Don't bother processing, the container is empty */
return 0;
}
/* Perform the lookup */
aAux = (jx9_aux_data *)SySetBasePtr(&pCtx->sChunk);
for( n = 0; n < SySetUsed(&pCtx->sChunk) ; ++n ){
pAux = &aAux[n];
if( pAux->pAuxData == pChunk ){
/* Chunk found */
return pAux;
}
}
/* No such allocated chunk */
return 0;
}
/*
* [CAPIREF: jx9_context_realloc_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_context_realloc_chunk(jx9_context *pCtx, void *pChunk, unsigned int nByte)
{
jx9_aux_data *pAux;
void *pNew;
pNew = SyMemBackendRealloc(&pCtx->pVm->sAllocator, pChunk, nByte);
if( pNew ){
pAux = ContextFindChunk(pCtx, pChunk);
if( pAux ){
pAux->pAuxData = pNew;
}
}
return pNew;
}
/*
* [CAPIREF: jx9_context_free_chunk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void jx9_context_free_chunk(jx9_context *pCtx, void *pChunk)
{
jx9_aux_data *pAux;
if( pChunk == 0 ){
/* TICKET-1433-93: NULL chunk is a harmless operation */
return;
}
pAux = ContextFindChunk(pCtx, pChunk);
if( pAux ){
/* Mark as destroyed */
pAux->pAuxData = 0;
}
SyMemBackendFree(&pCtx->pVm->sAllocator, pChunk);
}
/*
* [CAPIREF: jx9_array_fetch()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE jx9_value * jx9_array_fetch(jx9_value *pArray, const char *zKey, int nByte)
{
jx9_hashmap_node *pNode;
jx9_value *pValue;
jx9_value skey;
int rc;
/* Make sure we are dealing with a valid hashmap */
if( (pArray->iFlags & MEMOBJ_HASHMAP) == 0 ){
return 0;
}
if( nByte < 0 ){
nByte = (int)SyStrlen(zKey);
}
/* Convert the key to a jx9_value */
jx9MemObjInit(pArray->pVm, &skey);
jx9MemObjStringAppend(&skey, zKey, (sxu32)nByte);
/* Perform the lookup */
rc = jx9HashmapLookup((jx9_hashmap *)pArray->x.pOther, &skey, &pNode);
jx9MemObjRelease(&skey);
if( rc != JX9_OK ){
/* No such entry */
return 0;
}
/* Extract the target value */
pValue = (jx9_value *)SySetAt(&pArray->pVm->aMemObj, pNode->nValIdx);
return pValue;
}
/*
* [CAPIREF: jx9_array_walk()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_array_walk(jx9_value *pArray, int (*xWalk)(jx9_value *pValue, jx9_value *, void *), void *pUserData)
{
int rc;
if( xWalk == 0 ){
return JX9_CORRUPT;
}
/* Make sure we are dealing with a valid hashmap */
if( (pArray->iFlags & MEMOBJ_HASHMAP) == 0 ){
return JX9_CORRUPT;
}
/* Start the walk process */
rc = jx9HashmapWalk((jx9_hashmap *)pArray->x.pOther, xWalk, pUserData);
return rc != JX9_OK ? JX9_ABORT /* User callback request an operation abort*/ : JX9_OK;
}
/*
* [CAPIREF: jx9_array_add_elem()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_array_add_elem(jx9_value *pArray, jx9_value *pKey, jx9_value *pValue)
{
int rc;
/* Make sure we are dealing with a valid hashmap */
if( (pArray->iFlags & MEMOBJ_HASHMAP) == 0 ){
return JX9_CORRUPT;
}
/* Perform the insertion */
rc = jx9HashmapInsert((jx9_hashmap *)pArray->x.pOther, &(*pKey), &(*pValue));
return rc;
}
/*
* [CAPIREF: jx9_array_add_strkey_elem()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_array_add_strkey_elem(jx9_value *pArray, const char *zKey, jx9_value *pValue)
{
int rc;
/* Make sure we are dealing with a valid hashmap */
if( (pArray->iFlags & MEMOBJ_HASHMAP) == 0 ){
return JX9_CORRUPT;
}
/* Perform the insertion */
if( SX_EMPTY_STR(zKey) ){
/* Empty key, assign an automatic index */
rc = jx9HashmapInsert((jx9_hashmap *)pArray->x.pOther, 0, &(*pValue));
}else{
jx9_value sKey;
jx9MemObjInitFromString(pArray->pVm, &sKey, 0);
jx9MemObjStringAppend(&sKey, zKey, (sxu32)SyStrlen(zKey));
rc = jx9HashmapInsert((jx9_hashmap *)pArray->x.pOther, &sKey, &(*pValue));
jx9MemObjRelease(&sKey);
}
return rc;
}
/*
* [CAPIREF: jx9_array_count()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE unsigned int jx9_array_count(jx9_value *pArray)
{
jx9_hashmap *pMap;
/* Make sure we are dealing with a valid hashmap */
if( (pArray->iFlags & MEMOBJ_HASHMAP) == 0 ){
return 0;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)pArray->x.pOther;
return pMap->nEntry;
}
/*
* [CAPIREF: jx9_context_output()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_context_output(jx9_context *pCtx, const char *zString, int nLen)
{
SyString sData;
int rc;
if( nLen < 0 ){
nLen = (int)SyStrlen(zString);
}
SyStringInitFromBuf(&sData, zString, nLen);
rc = jx9VmOutputConsume(pCtx->pVm, &sData);
return rc;
}
/*
* [CAPIREF: jx9_context_throw_error()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_context_throw_error(jx9_context *pCtx, int iErr, const char *zErr)
{
int rc = JX9_OK;
if( zErr ){
rc = jx9VmThrowError(pCtx->pVm, &pCtx->pFunc->sName, iErr, zErr);
}
return rc;
}
/*
* [CAPIREF: jx9_context_throw_error_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_context_throw_error_format(jx9_context *pCtx, int iErr, const char *zFormat, ...)
{
va_list ap;
int rc;
if( zFormat == 0){
return JX9_OK;
}
va_start(ap, zFormat);
rc = jx9VmThrowErrorAp(pCtx->pVm, &pCtx->pFunc->sName, iErr, zFormat, ap);
va_end(ap);
return rc;
}
/*
* [CAPIREF: jx9_context_random_num()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE unsigned int jx9_context_random_num(jx9_context *pCtx)
{
sxu32 n;
n = jx9VmRandomNum(pCtx->pVm);
return n;
}
/*
* [CAPIREF: jx9_context_random_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_context_random_string(jx9_context *pCtx, char *zBuf, int nBuflen)
{
if( nBuflen < 3 ){
return JX9_CORRUPT;
}
jx9VmRandomString(pCtx->pVm, zBuf, nBuflen);
return JX9_OK;
}
/*
* [CAPIREF: jx9_context_user_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_context_user_data(jx9_context *pCtx)
{
return pCtx->pFunc->pUserData;
}
/*
* [CAPIREF: jx9_context_push_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_context_push_aux_data(jx9_context *pCtx, void *pUserData)
{
jx9_aux_data sAux;
int rc;
sAux.pAuxData = pUserData;
rc = SySetPut(&pCtx->pFunc->aAux, (const void *)&sAux);
return rc;
}
/*
* [CAPIREF: jx9_context_peek_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_context_peek_aux_data(jx9_context *pCtx)
{
jx9_aux_data *pAux;
pAux = (jx9_aux_data *)SySetPeek(&pCtx->pFunc->aAux);
return pAux ? pAux->pAuxData : 0;
}
/*
* [CAPIREF: jx9_context_pop_aux_data()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE void * jx9_context_pop_aux_data(jx9_context *pCtx)
{
jx9_aux_data *pAux;
pAux = (jx9_aux_data *)SySetPop(&pCtx->pFunc->aAux);
return pAux ? pAux->pAuxData : 0;
}
/*
* [CAPIREF: jx9_context_result_buf_length()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE unsigned int jx9_context_result_buf_length(jx9_context *pCtx)
{
return SyBlobLength(&pCtx->pRet->sBlob);
}
/*
* [CAPIREF: jx9_function_name()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE const char * jx9_function_name(jx9_context *pCtx)
{
SyString *pName;
pName = &pCtx->pFunc->sName;
return pName->zString;
}
/*
* [CAPIREF: jx9_value_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_int(jx9_value *pVal, int iValue)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
pVal->x.iVal = (jx9_int64)iValue;
MemObjSetType(pVal, MEMOBJ_INT);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_int64()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_int64(jx9_value *pVal, jx9_int64 iValue)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
pVal->x.iVal = iValue;
MemObjSetType(pVal, MEMOBJ_INT);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_bool(jx9_value *pVal, int iBool)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
pVal->x.iVal = iBool ? 1 : 0;
MemObjSetType(pVal, MEMOBJ_BOOL);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_null(jx9_value *pVal)
{
/* Invalidate any prior representation and set the NULL flag */
jx9MemObjRelease(pVal);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_double()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_double(jx9_value *pVal, double Value)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
pVal->x.rVal = (jx9_real)Value;
MemObjSetType(pVal, MEMOBJ_REAL);
/* Try to get an integer representation also */
jx9MemObjTryInteger(pVal);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_string(jx9_value *pVal, const char *zString, int nLen)
{
if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
MemObjSetType(pVal, MEMOBJ_STRING);
}
if( zString ){
if( nLen < 0 ){
/* Compute length automatically */
nLen = (int)SyStrlen(zString);
}
SyBlobAppend(&pVal->sBlob, (const void *)zString, (sxu32)nLen);
}
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_string_format()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_string_format(jx9_value *pVal, const char *zFormat, ...)
{
va_list ap;
int rc;
if((pVal->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
MemObjSetType(pVal, MEMOBJ_STRING);
}
va_start(ap, zFormat);
rc = SyBlobFormatAp(&pVal->sBlob, zFormat, ap);
va_end(ap);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_reset_string_cursor()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_reset_string_cursor(jx9_value *pVal)
{
/* Reset the string cursor */
SyBlobReset(&pVal->sBlob);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_resource(jx9_value *pVal, void *pUserData)
{
/* Invalidate any prior representation */
jx9MemObjRelease(pVal);
/* Reflect the new type */
pVal->x.pOther = pUserData;
MemObjSetType(pVal, MEMOBJ_RES);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_release()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_release(jx9_value *pVal)
{
jx9MemObjRelease(pVal);
return JX9_OK;
}
/*
* [CAPIREF: jx9_value_is_int()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_int(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_INT) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_float()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_float(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_REAL) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_bool()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_bool(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_BOOL) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_string()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_string(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_STRING) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_null()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_null(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_NULL) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_numeric()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_numeric(jx9_value *pVal)
{
int rc;
rc = jx9MemObjIsNumeric(pVal);
return rc;
}
/*
* [CAPIREF: jx9_value_is_callable()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_callable(jx9_value *pVal)
{
int rc;
rc = jx9VmIsCallable(pVal->pVm, pVal);
return rc;
}
/*
* [CAPIREF: jx9_value_is_scalar()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_scalar(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_SCALAR) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_json_array()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_json_array(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_HASHMAP) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_json_object()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_json_object(jx9_value *pVal)
{
jx9_hashmap *pMap;
if( (pVal->iFlags & MEMOBJ_HASHMAP) == 0 ){
return FALSE;
}
pMap = (jx9_hashmap *)pVal->x.pOther;
if( (pMap->iFlags & HASHMAP_JSON_OBJECT) == 0 ){
return FALSE;
}
return TRUE;
}
/*
* [CAPIREF: jx9_value_is_resource()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_resource(jx9_value *pVal)
{
return (pVal->iFlags & MEMOBJ_RES) ? TRUE : FALSE;
}
/*
* [CAPIREF: jx9_value_is_empty()]
* Please refer to the official documentation for function purpose and expected parameters.
*/
JX9_PRIVATE int jx9_value_is_empty(jx9_value *pVal)
{
int rc;
rc = jx9MemObjIsEmpty(pVal);
return rc;
}
/*
* ----------------------------------------------------------
* File: jx9_builtin.c
* MD5: 97ae6ddf8ded9fe14634060675e12f80
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: builtin.c v1.7 Win7 2012-12-13 00:01 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file implement built-in 'foreign' functions for the JX9 engine */
/*
* Section:
* Variable handling Functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* bool is_bool($var)
* Finds out whether a variable is a boolean.
* Parameters
* $var: The variable being evaluated.
* Return
* TRUE if var is a boolean. False otherwise.
*/
static int jx9Builtin_is_bool(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_bool(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_float($var)
* bool is_real($var)
* bool is_double($var)
* Finds out whether a variable is a float.
* Parameters
* $var: The variable being evaluated.
* Return
* TRUE if var is a float. False otherwise.
*/
static int jx9Builtin_is_float(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_float(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_int($var)
* bool is_integer($var)
* bool is_long($var)
* Finds out whether a variable is an integer.
* Parameters
* $var: The variable being evaluated.
* Return
* TRUE if var is an integer. False otherwise.
*/
static int jx9Builtin_is_int(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_int(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_string($var)
* Finds out whether a variable is a string.
* Parameters
* $var: The variable being evaluated.
* Return
* TRUE if var is string. False otherwise.
*/
static int jx9Builtin_is_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_string(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_null($var)
* Finds out whether a variable is NULL.
* Parameters
* $var: The variable being evaluated.
* Return
* TRUE if var is NULL. False otherwise.
*/
static int jx9Builtin_is_null(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_null(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_numeric($var)
* Find out whether a variable is NULL.
* Parameters
* $var: The variable being evaluated.
* Return
* True if var is numeric. False otherwise.
*/
static int jx9Builtin_is_numeric(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_numeric(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_scalar($var)
* Find out whether a variable is a scalar.
* Parameters
* $var: The variable being evaluated.
* Return
* True if var is scalar. False otherwise.
*/
static int jx9Builtin_is_scalar(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_scalar(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_array($var)
* Find out whether a variable is an array.
* Parameters
* $var: The variable being evaluated.
* Return
* True if var is an array. False otherwise.
*/
static int jx9Builtin_is_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_json_array(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_object($var)
* Find out whether a variable is an object.
* Parameters
* $var: The variable being evaluated.
* Return
* True if var is an object. False otherwise.
*/
static int jx9Builtin_is_object(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_json_object(apArg[0]);
}
/* Query result */
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* bool is_resource($var)
* Find out whether a variable is a resource.
* Parameters
* $var: The variable being evaluated.
* Return
* True if a resource. False otherwise.
*/
static int jx9Builtin_is_resource(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 0; /* Assume false by default */
if( nArg > 0 ){
res = jx9_value_is_resource(apArg[0]);
}
jx9_result_bool(pCtx, res);
return JX9_OK;
}
/*
* float floatval($var)
* Get float value of a variable.
* Parameter
* $var: The variable being processed.
* Return
* the float value of a variable.
*/
static int jx9Builtin_floatval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* return 0.0 */
jx9_result_double(pCtx, 0);
}else{
double dval;
/* Perform the cast */
dval = jx9_value_to_double(apArg[0]);
jx9_result_double(pCtx, dval);
}
return JX9_OK;
}
/*
* int intval($var)
* Get integer value of a variable.
* Parameter
* $var: The variable being processed.
* Return
* the int value of a variable.
*/
static int jx9Builtin_intval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* return 0 */
jx9_result_int(pCtx, 0);
}else{
sxi64 iVal;
/* Perform the cast */
iVal = jx9_value_to_int64(apArg[0]);
jx9_result_int64(pCtx, iVal);
}
return JX9_OK;
}
/*
* string strval($var)
* Get the string representation of a variable.
* Parameter
* $var: The variable being processed.
* Return
* the string value of a variable.
*/
static int jx9Builtin_strval(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* return NULL */
jx9_result_null(pCtx);
}else{
const char *zVal;
int iLen = 0; /* cc -O6 warning */
/* Perform the cast */
zVal = jx9_value_to_string(apArg[0], &iLen);
jx9_result_string(pCtx, zVal, iLen);
}
return JX9_OK;
}
/*
* bool empty($var)
* Determine whether a variable is empty.
* Parameters
* $var: The variable being checked.
* Return
* 0 if var has a non-empty and non-zero value.1 otherwise.
*/
static int jx9Builtin_empty(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int res = 1; /* Assume empty by default */
if( nArg > 0 ){
res = jx9_value_is_empty(apArg[0]);
}
jx9_result_bool(pCtx, res);
return JX9_OK;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifdef JX9_ENABLE_MATH_FUNC
/*
* Section:
* Math Functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
#include <stdlib.h> /* abs */
#include <math.h>
/*
* float sqrt(float $arg )
* Square root of the given number.
* Parameter
* The number to process.
* Return
* The square root of arg or the special value Nan of failure.
*/
static int jx9Builtin_sqrt(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = sqrt(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float exp(float $arg )
* Calculates the exponent of e.
* Parameter
* The number to process.
* Return
* 'e' raised to the power of arg.
*/
static int jx9Builtin_exp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = exp(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float floor(float $arg )
* Round fractions down.
* Parameter
* The number to process.
* Return
* Returns the next lowest integer value by rounding down value if necessary.
*/
static int jx9Builtin_floor(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = floor(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float cos(float $arg )
* Cosine.
* Parameter
* The number to process.
* Return
* The cosine of arg.
*/
static int jx9Builtin_cos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = cos(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float acos(float $arg )
* Arc cosine.
* Parameter
* The number to process.
* Return
* The arc cosine of arg.
*/
static int jx9Builtin_acos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = acos(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float cosh(float $arg )
* Hyperbolic cosine.
* Parameter
* The number to process.
* Return
* The hyperbolic cosine of arg.
*/
static int jx9Builtin_cosh(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = cosh(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float sin(float $arg )
* Sine.
* Parameter
* The number to process.
* Return
* The sine of arg.
*/
static int jx9Builtin_sin(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = sin(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float asin(float $arg )
* Arc sine.
* Parameter
* The number to process.
* Return
* The arc sine of arg.
*/
static int jx9Builtin_asin(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = asin(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float sinh(float $arg )
* Hyperbolic sine.
* Parameter
* The number to process.
* Return
* The hyperbolic sine of arg.
*/
static int jx9Builtin_sinh(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = sinh(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float ceil(float $arg )
* Round fractions up.
* Parameter
* The number to process.
* Return
* The next highest integer value by rounding up value if necessary.
*/
static int jx9Builtin_ceil(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = ceil(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float tan(float $arg )
* Tangent.
* Parameter
* The number to process.
* Return
* The tangent of arg.
*/
static int jx9Builtin_tan(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = tan(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float atan(float $arg )
* Arc tangent.
* Parameter
* The number to process.
* Return
* The arc tangent of arg.
*/
static int jx9Builtin_atan(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = atan(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float tanh(float $arg )
* Hyperbolic tangent.
* Parameter
* The number to process.
* Return
* The Hyperbolic tangent of arg.
*/
static int jx9Builtin_tanh(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = tanh(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float atan2(float $y, float $x)
* Arc tangent of two variable.
* Parameter
* $y = Dividend parameter.
* $x = Divisor parameter.
* Return
* The arc tangent of y/x in radian.
*/
static int jx9Builtin_atan2(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x, y;
if( nArg < 2 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
y = jx9_value_to_double(apArg[0]);
x = jx9_value_to_double(apArg[1]);
/* Perform the requested operation */
r = atan2(y, x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float/int64 abs(float/int64 $arg )
* Absolute value.
* Parameter
* The number to process.
* Return
* The absolute value of number.
*/
static int jx9Builtin_abs(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int is_float;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
is_float = jx9_value_is_float(apArg[0]);
if( is_float ){
double r, x;
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = fabs(x);
jx9_result_double(pCtx, r);
}else{
int r, x;
x = jx9_value_to_int(apArg[0]);
/* Perform the requested operation */
r = abs(x);
jx9_result_int(pCtx, r);
}
return JX9_OK;
}
/*
* float log(float $arg, [int/float $base])
* Natural logarithm.
* Parameter
* $arg: The number to process.
* $base: The optional logarithmic base to use. (only base-10 is supported)
* Return
* The logarithm of arg to base, if given, or the natural logarithm.
* Note:
* only Natural log and base-10 log are supported.
*/
static int jx9Builtin_log(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
if( nArg == 2 && jx9_value_is_numeric(apArg[1]) && jx9_value_to_int(apArg[1]) == 10 ){
/* Base-10 log */
r = log10(x);
}else{
r = log(x);
}
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float log10(float $arg )
* Base-10 logarithm.
* Parameter
* The number to process.
* Return
* The Base-10 logarithm of the given number.
*/
static int jx9Builtin_log10(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
/* Perform the requested operation */
r = log10(x);
/* store the result back */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* number pow(number $base, number $exp)
* Exponential expression.
* Parameter
* base
* The base to use.
* exp
* The exponent.
* Return
* base raised to the power of exp.
* If the result can be represented as integer it will be returned
* as type integer, else it will be returned as type float.
*/
static int jx9Builtin_pow(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double r, x, y;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
x = jx9_value_to_double(apArg[0]);
y = jx9_value_to_double(apArg[1]);
/* Perform the requested operation */
r = pow(x, y);
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float pi(void)
* Returns an approximation of pi.
* Note
* you can use the M_PI constant which yields identical results to pi().
* Return
* The value of pi as float.
*/
static int jx9Builtin_pi(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
jx9_result_double(pCtx, JX9_PI);
return JX9_OK;
}
/*
* float fmod(float $x, float $y)
* Returns the floating point remainder (modulo) of the division of the arguments.
* Parameters
* $x
* The dividend
* $y
* The divisor
* Return
* The floating point remainder of x/y.
*/
static int jx9Builtin_fmod(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double x, y, r;
if( nArg < 2 ){
/* Missing arguments */
jx9_result_double(pCtx, 0);
return JX9_OK;
}
/* Extract given arguments */
x = jx9_value_to_double(apArg[0]);
y = jx9_value_to_double(apArg[1]);
/* Perform the requested operation */
r = fmod(x, y);
/* Processing result */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* float hypot(float $x, float $y)
* Calculate the length of the hypotenuse of a right-angle triangle .
* Parameters
* $x
* Length of first side
* $y
* Length of first side
* Return
* Calculated length of the hypotenuse.
*/
static int jx9Builtin_hypot(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
double x, y, r;
if( nArg < 2 ){
/* Missing arguments */
jx9_result_double(pCtx, 0);
return JX9_OK;
}
/* Extract given arguments */
x = jx9_value_to_double(apArg[0]);
y = jx9_value_to_double(apArg[1]);
/* Perform the requested operation */
r = hypot(x, y);
/* Processing result */
jx9_result_double(pCtx, r);
return JX9_OK;
}
#endif /* JX9_ENABLE_MATH_FUNC */
/*
* float round ( float $val [, int $precision = 0 [, int $mode = JX9_ROUND_HALF_UP ]] )
* Exponential expression.
* Parameter
* $val
* The value to round.
* $precision
* The optional number of decimal digits to round to.
* $mode
* One of JX9_ROUND_HALF_UP, JX9_ROUND_HALF_DOWN, JX9_ROUND_HALF_EVEN, or JX9_ROUND_HALF_ODD.
* (not supported).
* Return
* The rounded value.
*/
static int jx9Builtin_round(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int n = 0;
double r;
if( nArg < 1 ){
/* Missing argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the precision if available */
if( nArg > 1 ){
n = jx9_value_to_int(apArg[1]);
if( n>30 ){
n = 30;
}
if( n<0 ){
n = 0;
}
}
r = jx9_value_to_double(apArg[0]);
/* If Y==0 and X will fit in a 64-bit int,
* handle the rounding directly.Otherwise
* use our own cutsom printf [i.e:SyBufferFormat()].
*/
if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
r = (double)((jx9_int64)(r+0.5));
}else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
r = -(double)((jx9_int64)((-r)+0.5));
}else{
char zBuf[256];
sxu32 nLen;
nLen = SyBufferFormat(zBuf, sizeof(zBuf), "%.*f", n, r);
/* Convert the string to real number */
SyStrToReal(zBuf, nLen, (void *)&r, 0);
}
/* Return thr rounded value */
jx9_result_double(pCtx, r);
return JX9_OK;
}
/*
* string dechex(int $number)
* Decimal to hexadecimal.
* Parameters
* $number
* Decimal value to convert
* Return
* Hexadecimal string representation of number
*/
static int jx9Builtin_dechex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iVal;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the given number */
iVal = jx9_value_to_int(apArg[0]);
/* Format */
jx9_result_string_format(pCtx, "%x", iVal);
return JX9_OK;
}
/*
* string decoct(int $number)
* Decimal to Octal.
* Parameters
* $number
* Decimal value to convert
* Return
* Octal string representation of number
*/
static int jx9Builtin_decoct(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iVal;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the given number */
iVal = jx9_value_to_int(apArg[0]);
/* Format */
jx9_result_string_format(pCtx, "%o", iVal);
return JX9_OK;
}
/*
* string decbin(int $number)
* Decimal to binary.
* Parameters
* $number
* Decimal value to convert
* Return
* Binary string representation of number
*/
static int jx9Builtin_decbin(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iVal;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the given number */
iVal = jx9_value_to_int(apArg[0]);
/* Format */
jx9_result_string_format(pCtx, "%B", iVal);
return JX9_OK;
}
/*
* int64 hexdec(string $hex_string)
* Hexadecimal to decimal.
* Parameters
* $hex_string
* The hexadecimal string to convert
* Return
* The decimal representation of hex_string
*/
static int jx9Builtin_hexdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zEnd;
jx9_int64 iVal;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
iVal = 0;
if( jx9_value_is_string(apArg[0]) ){
/* Extract the given string */
zString = jx9_value_to_string(apArg[0], &nLen);
/* Delimit the string */
zEnd = &zString[nLen];
/* Ignore non hex-stream */
while( zString < zEnd ){
if( (unsigned char)zString[0] >= 0xc0 ){
/* UTF-8 stream */
zString++;
while( zString < zEnd && (((unsigned char)zString[0] & 0xc0) == 0x80) ){
zString++;
}
}else{
if( SyisHex(zString[0]) ){
break;
}
/* Ignore */
zString++;
}
}
if( zString < zEnd ){
/* Cast */
SyHexStrToInt64(zString, (sxu32)(zEnd-zString), (void *)&iVal, 0);
}
}else{
/* Extract as a 64-bit integer */
iVal = jx9_value_to_int64(apArg[0]);
}
/* Return the number */
jx9_result_int64(pCtx, iVal);
return JX9_OK;
}
/*
* int64 bindec(string $bin_string)
* Binary to decimal.
* Parameters
* $bin_string
* The binary string to convert
* Return
* Returns the decimal equivalent of the binary number represented by the binary_string argument.
*/
static int jx9Builtin_bindec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
jx9_int64 iVal;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
iVal = 0;
if( jx9_value_is_string(apArg[0]) ){
/* Extract the given string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen > 0 ){
/* Perform a binary cast */
SyBinaryStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
}
}else{
/* Extract as a 64-bit integer */
iVal = jx9_value_to_int64(apArg[0]);
}
/* Return the number */
jx9_result_int64(pCtx, iVal);
return JX9_OK;
}
/*
* int64 octdec(string $oct_string)
* Octal to decimal.
* Parameters
* $oct_string
* The octal string to convert
* Return
* Returns the decimal equivalent of the octal number represented by the octal_string argument.
*/
static int jx9Builtin_octdec(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
jx9_int64 iVal;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
iVal = 0;
if( jx9_value_is_string(apArg[0]) ){
/* Extract the given string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen > 0 ){
/* Perform the cast */
SyOctalStrToInt64(zString, (sxu32)nLen, (void *)&iVal, 0);
}
}else{
/* Extract as a 64-bit integer */
iVal = jx9_value_to_int64(apArg[0]);
}
/* Return the number */
jx9_result_int64(pCtx, iVal);
return JX9_OK;
}
/*
* string base_convert(string $number, int $frombase, int $tobase)
* Convert a number between arbitrary bases.
* Parameters
* $number
* The number to convert
* $frombase
* The base number is in
* $tobase
* The base to convert number to
* Return
* Number converted to base tobase
*/
static int jx9Builtin_base_convert(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int nLen, iFbase, iTobase;
const char *zNum;
jx9_int64 iNum;
if( nArg < 3 ){
/* Return the empty string*/
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Base numbers */
iFbase = jx9_value_to_int(apArg[1]);
iTobase = jx9_value_to_int(apArg[2]);
if( jx9_value_is_string(apArg[0]) ){
/* Extract the target number */
zNum = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Return the empty string*/
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Base conversion */
switch(iFbase){
case 16:
/* Hex */
SyHexStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
break;
case 8:
/* Octal */
SyOctalStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
break;
case 2:
/* Binary */
SyBinaryStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
break;
default:
/* Decimal */
SyStrToInt64(zNum, (sxu32)nLen, (void *)&iNum, 0);
break;
}
}else{
iNum = jx9_value_to_int64(apArg[0]);
}
switch(iTobase){
case 16:
/* Hex */
jx9_result_string_format(pCtx, "%qx", iNum); /* Quad hex */
break;
case 8:
/* Octal */
jx9_result_string_format(pCtx, "%qo", iNum); /* Quad octal */
break;
case 2:
/* Binary */
jx9_result_string_format(pCtx, "%qB", iNum); /* Quad binary */
break;
default:
/* Decimal */
jx9_result_string_format(pCtx, "%qd", iNum); /* Quad decimal */
break;
}
return JX9_OK;
}
/*
* Section:
* String handling Functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* string substr(string $string, int $start[, int $length ])
* Return part of a string.
* Parameters
* $string
* The input string. Must be one character or longer.
* $start
* If start is non-negative, the returned string will start at the start'th position
* in string, counting from zero. For instance, in the string 'abcdef', the character
* at position 0 is 'a', the character at position 2 is 'c', and so forth.
* If start is negative, the returned string will start at the start'th character
* from the end of string.
* If string is less than or equal to start characters long, FALSE will be returned.
* $length
* If length is given and is positive, the string returned will contain at most length
* characters beginning from start (depending on the length of string).
* If length is given and is negative, then that many characters will be omitted from
* the end of string (after the start position has been calculated when a start is negative).
* If start denotes the position of this truncation or beyond, false will be returned.
* If length is given and is 0, FALSE or NULL an empty string will be returned.
* If length is omitted, the substring starting from start until the end of the string
* will be returned.
* Return
* Returns the extracted part of string, or FALSE on failure or an empty string.
*/
static int jx9Builtin_substr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zSource, *zOfft;
int nOfft, nLen, nSrcLen;
if( nArg < 2 ){
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zSource = jx9_value_to_string(apArg[0], &nSrcLen);
if( nSrcLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = nSrcLen; /* cc warning */
/* Extract the offset */
nOfft = jx9_value_to_int(apArg[1]);
if( nOfft < 0 ){
zOfft = &zSource[nSrcLen+nOfft];
if( zOfft < zSource ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = (int)(&zSource[nSrcLen]-zOfft);
nOfft = (int)(zOfft-zSource);
}else if( nOfft >= nSrcLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
zOfft = &zSource[nOfft];
nLen = nSrcLen - nOfft;
}
if( nArg > 2 ){
/* Extract the length */
nLen = jx9_value_to_int(apArg[2]);
if( nLen == 0 ){
/* Invalid length, return an empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}else if( nLen < 0 ){
nLen = nSrcLen + nLen - nOfft;
if( nLen < 1 ){
/* Invalid length */
nLen = nSrcLen - nOfft;
}
}
if( nLen + nOfft > nSrcLen ){
/* Invalid length */
nLen = nSrcLen - nOfft;
}
}
/* Return the substring */
jx9_result_string(pCtx, zOfft, nLen);
return JX9_OK;
}
/*
* int substr_compare(string $main_str, string $str , int $offset[, int $length[, bool $case_insensitivity = false ]])
* Binary safe comparison of two strings from an offset, up to length characters.
* Parameters
* $main_str
* The main string being compared.
* $str
* The secondary string being compared.
* $offset
* The start position for the comparison. If negative, it starts counting from
* the end of the string.
* $length
* The length of the comparison. The default value is the largest of the length
* of the str compared to the length of main_str less the offset.
* $case_insensitivity
* If case_insensitivity is TRUE, comparison is case insensitive.
* Return
* Returns < 0 if main_str from position offset is less than str, > 0 if it is greater than
* str, and 0 if they are equal. If offset is equal to or greater than the length of main_str
* or length is set and is less than 1, substr_compare() prints a warning and returns FALSE.
*/
static int jx9Builtin_substr_compare(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zSource, *zOfft, *zSub;
int nOfft, nLen, nSrcLen, nSublen;
int iCase = 0;
int rc;
if( nArg < 3 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zSource = jx9_value_to_string(apArg[0], &nSrcLen);
if( nSrcLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = nSrcLen; /* cc warning */
/* Extract the substring */
zSub = jx9_value_to_string(apArg[1], &nSublen);
if( nSublen < 1 || nSublen > nSrcLen){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the offset */
nOfft = jx9_value_to_int(apArg[2]);
if( nOfft < 0 ){
zOfft = &zSource[nSrcLen+nOfft];
if( zOfft < zSource ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = (int)(&zSource[nSrcLen]-zOfft);
nOfft = (int)(zOfft-zSource);
}else if( nOfft >= nSrcLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
zOfft = &zSource[nOfft];
nLen = nSrcLen - nOfft;
}
if( nArg > 3 ){
/* Extract the length */
nLen = jx9_value_to_int(apArg[3]);
if( nLen < 1 ){
/* Invalid length */
jx9_result_int(pCtx, 1);
return JX9_OK;
}else if( nLen + nOfft > nSrcLen ){
/* Invalid length */
nLen = nSrcLen - nOfft;
}
if( nArg > 4 ){
/* Case-sensitive or not */
iCase = jx9_value_to_bool(apArg[4]);
}
}
/* Perform the comparison */
if( iCase ){
rc = SyStrnicmp(zOfft, zSub, (sxu32)nLen);
}else{
rc = SyStrncmp(zOfft, zSub, (sxu32)nLen);
}
/* Comparison result */
jx9_result_int(pCtx, rc);
return JX9_OK;
}
/*
* int substr_count(string $haystack, string $needle[, int $offset = 0 [, int $length ]])
* Count the number of substring occurrences.
* Parameters
* $haystack
* The string to search in
* $needle
* The substring to search for
* $offset
* The offset where to start counting
* $length (NOT USED)
* The maximum length after the specified offset to search for the substring.
* It outputs a warning if the offset plus the length is greater than the haystack length.
* Return
* Toral number of substring occurrences.
*/
static int jx9Builtin_substr_count(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zText, *zPattern, *zEnd;
int nTextlen, nPatlen;
int iCount = 0;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the haystack */
zText = jx9_value_to_string(apArg[0], &nTextlen);
/* Point to the neddle */
zPattern = jx9_value_to_string(apArg[1], &nPatlen);
if( nTextlen < 1 || nPatlen < 1 || nPatlen > nTextlen ){
/* NOOP, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( nArg > 2 ){
int nOfft;
/* Extract the offset */
nOfft = jx9_value_to_int(apArg[2]);
if( nOfft < 0 || nOfft > nTextlen ){
/* Invalid offset, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the desired offset */
zText = &zText[nOfft];
/* Adjust length */
nTextlen -= nOfft;
}
/* Point to the end of the string */
zEnd = &zText[nTextlen];
if( nArg > 3 ){
int nLen;
/* Extract the length */
nLen = jx9_value_to_int(apArg[3]);
if( nLen < 0 || nLen > nTextlen ){
/* Invalid length, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Adjust pointer */
nTextlen = nLen;
zEnd = &zText[nTextlen];
}
/* Perform the search */
for(;;){
rc = SyBlobSearch((const void *)zText, (sxu32)(zEnd-zText), (const void *)zPattern, nPatlen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found, break immediately */
break;
}
/* Increment counter and update the offset */
iCount++;
zText += nOfft + nPatlen;
if( zText >= zEnd ){
break;
}
}
/* Pattern count */
jx9_result_int(pCtx, iCount);
return JX9_OK;
}
/*
* string chunk_split(string $body[, int $chunklen = 76 [, string $end = "\r\n" ]])
* Split a string into smaller chunks.
* Parameters
* $body
* The string to be chunked.
* $chunklen
* The chunk length.
* $end
* The line ending sequence.
* Return
* The chunked string or NULL on failure.
*/
static int jx9Builtin_chunk_split(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn, *zEnd, *zSep = "\r\n";
int nSepLen, nChunkLen, nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Nothing to split, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* initialize/Extract arguments */
nSepLen = (int)sizeof("\r\n") - 1;
nChunkLen = 76;
zIn = jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nArg > 1 ){
/* Chunk length */
nChunkLen = jx9_value_to_int(apArg[1]);
if( nChunkLen < 1 ){
/* Switch back to the default length */
nChunkLen = 76;
}
if( nArg > 2 ){
/* Separator */
zSep = jx9_value_to_string(apArg[2], &nSepLen);
if( nSepLen < 1 ){
/* Switch back to the default separator */
zSep = "\r\n";
nSepLen = (int)sizeof("\r\n") - 1;
}
}
}
/* Perform the requested operation */
if( nChunkLen > nLen ){
/* Nothing to split, return the string and the separator */
jx9_result_string_format(pCtx, "%.*s%.*s", nLen, zIn, nSepLen, zSep);
return JX9_OK;
}
while( zIn < zEnd ){
if( nChunkLen > (int)(zEnd-zIn) ){
nChunkLen = (int)(zEnd - zIn);
}
/* Append the chunk and the separator */
jx9_result_string_format(pCtx, "%.*s%.*s", nChunkLen, zIn, nSepLen, zSep);
/* Point beyond the chunk */
zIn += nChunkLen;
}
return JX9_OK;
}
/*
* string htmlspecialchars(string $string [, int $flags = ENT_COMPAT | ENT_HTML401 [, string $charset]])
* HTML escaping of special characters.
* The translations performed are:
* '&' (ampersand) ==> '&amp;'
* '"' (double quote) ==> '&quot;' when ENT_NOQUOTES is not set.
* "'" (single quote) ==> '&#039;' only when ENT_QUOTES is set.
* '<' (less than) ==> '&lt;'
* '>' (greater than) ==> '&gt;'
* Parameters
* $string
* The string being converted.
* $flags
* A bitmask of one or more of the following flags, which specify how to handle quotes.
* The default is ENT_COMPAT | ENT_HTML401.
* ENT_COMPAT Will convert double-quotes and leave single-quotes alone.
* ENT_QUOTES Will convert both double and single quotes.
* ENT_NOQUOTES Will leave both double and single quotes unconverted.
* ENT_IGNORE Silently discard invalid code unit sequences instead of returning an empty string.
* $charset
* Defines character set used in conversion. The default character set is ISO-8859-1. (Not used)
* Return
* The escaped string or NULL on failure.
*/
static int jx9Builtin_htmlspecialchars(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zCur, *zIn, *zEnd;
int iFlags = 0x01|0x40; /* ENT_COMPAT | ENT_HTML401 */
int nLen, c;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
/* Extract the flags if available */
if( nArg > 1 ){
iFlags = jx9_value_to_int(apArg[1]);
if( iFlags < 0 ){
iFlags = 0x01|0x40;
}
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
break;
}
zCur = zIn;
while( zIn < zEnd && zIn[0] != '&' && zIn[0] != '\'' && zIn[0] != '"' && zIn[0] != '<' && zIn[0] != '>' ){
zIn++;
}
if( zCur < zIn ){
/* Append the raw string verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
if( zIn >= zEnd ){
break;
}
c = zIn[0];
if( c == '&' ){
/* Expand '&amp;' */
jx9_result_string(pCtx, "&amp;", (int)sizeof("&amp;")-1);
}else if( c == '<' ){
/* Expand '&lt;' */
jx9_result_string(pCtx, "&lt;", (int)sizeof("&lt;")-1);
}else if( c == '>' ){
/* Expand '&gt;' */
jx9_result_string(pCtx, "&gt;", (int)sizeof("&gt;")-1);
}else if( c == '\'' ){
if( iFlags & 0x02 /*ENT_QUOTES*/ ){
/* Expand '&#039;' */
jx9_result_string(pCtx, "&#039;", (int)sizeof("&#039;")-1);
}else{
/* Leave the single quote untouched */
jx9_result_string(pCtx, "'", (int)sizeof(char));
}
}else if( c == '"' ){
if( (iFlags & 0x04) == 0 /*ENT_NOQUOTES*/ ){
/* Expand '&quot;' */
jx9_result_string(pCtx, "&quot;", (int)sizeof("&quot;")-1);
}else{
/* Leave the double quote untouched */
jx9_result_string(pCtx, "\"", (int)sizeof(char));
}
}
/* Ignore the unsafe HTML character */
zIn++;
}
return JX9_OK;
}
/*
* string htmlspecialchars_decode(string $string[, int $quote_style = ENT_COMPAT ])
* Unescape HTML entities.
* Parameters
* $string
* The string to decode
* $quote_style
* The quote style. One of the following constants:
* ENT_COMPAT Will convert double-quotes and leave single-quotes alone (default)
* ENT_QUOTES Will convert both double and single quotes
* ENT_NOQUOTES Will leave both double and single quotes unconverted
* Return
* The unescaped string or NULL on failure.
*/
static int jx9Builtin_htmlspecialchars_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zCur, *zIn, *zEnd;
int iFlags = 0x01; /* ENT_COMPAT */
int nLen, nJump;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
/* Extract the flags if available */
if( nArg > 1 ){
iFlags = jx9_value_to_int(apArg[1]);
if( iFlags < 0 ){
iFlags = 0x01;
}
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
break;
}
zCur = zIn;
while( zIn < zEnd && zIn[0] != '&' ){
zIn++;
}
if( zCur < zIn ){
/* Append the raw string verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
nLen = (int)(zEnd-zIn);
nJump = (int)sizeof(char);
if( nLen >= (int)sizeof("&amp;")-1 && SyStrnicmp(zIn, "&amp;", sizeof("&amp;")-1) == 0 ){
/* &amp; ==> '&' */
jx9_result_string(pCtx, "&", (int)sizeof(char));
nJump = (int)sizeof("&amp;")-1;
}else if( nLen >= (int)sizeof("&lt;")-1 && SyStrnicmp(zIn, "&lt;", sizeof("&lt;")-1) == 0 ){
/* &lt; ==> < */
jx9_result_string(pCtx, "<", (int)sizeof(char));
nJump = (int)sizeof("&lt;")-1;
}else if( nLen >= (int)sizeof("&gt;")-1 && SyStrnicmp(zIn, "&gt;", sizeof("&gt;")-1) == 0 ){
/* &gt; ==> '>' */
jx9_result_string(pCtx, ">", (int)sizeof(char));
nJump = (int)sizeof("&gt;")-1;
}else if( nLen >= (int)sizeof("&quot;")-1 && SyStrnicmp(zIn, "&quot;", sizeof("&quot;")-1) == 0 ){
/* &quot; ==> '"' */
if( (iFlags & 0x04) == 0 /*ENT_NOQUOTES*/ ){
jx9_result_string(pCtx, "\"", (int)sizeof(char));
}else{
/* Leave untouched */
jx9_result_string(pCtx, "&quot;", (int)sizeof("&quot;")-1);
}
nJump = (int)sizeof("&quot;")-1;
}else if( nLen >= (int)sizeof("&#039;")-1 && SyStrnicmp(zIn, "&#039;", sizeof("&#039;")-1) == 0 ){
/* &#039; ==> ''' */
if( iFlags & 0x02 /*ENT_QUOTES*/ ){
/* Expand ''' */
jx9_result_string(pCtx, "'", (int)sizeof(char));
}else{
/* Leave untouched */
jx9_result_string(pCtx, "&#039;", (int)sizeof("&#039;")-1);
}
nJump = (int)sizeof("&#039;")-1;
}else if( nLen >= (int)sizeof(char) ){
/* expand '&' */
jx9_result_string(pCtx, "&", (int)sizeof(char));
}else{
/* No more input to process */
break;
}
zIn += nJump;
}
return JX9_OK;
}
/* HTML encoding/Decoding table
* Source: Symisc RunTime API.[chm@symisc.net]
*/
static const char *azHtmlEscape[] = {
"&lt;", "<", "&gt;", ">", "&amp;", "&", "&quot;", "\"", "&#39;", "'",
"&#33;", "!", "&#36;", "$", "&#35;", "#", "&#37;", "%", "&#40;", "(",
"&#41;", ")", "&#123;", "{", "&#125;", "}", "&#61;", "=", "&#43;", "+",
"&#63;", "?", "&#91;", "[", "&#93;", "]", "&#64;", "@", "&#44;", ","
};
/*
* array get_html_translation_table(void)
* Returns the translation table used by htmlspecialchars() and htmlentities().
* Parameters
* None
* Return
* The translation table as an array or NULL on failure.
*/
static int jx9Builtin_get_html_translation_table(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray, *pValue;
sxu32 n;
/* Element value */
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Make the table */
for( n = 0 ; n < SX_ARRAYSIZE(azHtmlEscape) ; n += 2 ){
/* Prepare the value */
jx9_value_string(pValue, azHtmlEscape[n], -1 /* Compute length automatically */);
/* Insert the value */
jx9_array_add_strkey_elem(pArray, azHtmlEscape[n+1], pValue);
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
}
/*
* Return the array.
* Don't worry about freeing memory, everything will be automatically
* released upon we return from this function.
*/
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* string htmlentities( string $string [, int $flags = ENT_COMPAT | ENT_HTML401]);
* Convert all applicable characters to HTML entities
* Parameters
* $string
* The input string.
* $flags
* A bitmask of one or more of the flags (see block-comment on jx9Builtin_htmlspecialchars())
* Return
* The encoded string.
*/
static int jx9Builtin_htmlentities(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iFlags = 0x01; /* ENT_COMPAT */
const char *zIn, *zEnd;
int nLen, c;
sxu32 n;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
/* Extract the flags if available */
if( nArg > 1 ){
iFlags = jx9_value_to_int(apArg[1]);
if( iFlags < 0 ){
iFlags = 0x01;
}
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* No more input to process */
break;
}
c = zIn[0];
/* Perform a linear lookup on the decoding table */
for( n = 0 ; n < SX_ARRAYSIZE(azHtmlEscape) ; n += 2 ){
if( azHtmlEscape[n+1][0] == c ){
/* Got one */
break;
}
}
if( n < SX_ARRAYSIZE(azHtmlEscape) ){
/* Output the safe sequence [i.e: '<' ==> '&lt;"] */
if( c == '"' && (iFlags & 0x04) /*ENT_NOQUOTES*/ ){
/* Expand the double quote verbatim */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
}else if(c == '\'' && ((iFlags & 0x02 /*ENT_QUOTES*/) == 0 || (iFlags & 0x04) /*ENT_NOQUOTES*/) ){
/* expand single quote verbatim */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
}else{
jx9_result_string(pCtx, azHtmlEscape[n], -1/*Compute length automatically */);
}
}else{
/* Output character verbatim */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
}
zIn++;
}
return JX9_OK;
}
/*
* string html_entity_decode(string $string [, int $quote_style = ENT_COMPAT [, string $charset = 'UTF-8' ]])
* Perform the reverse operation of html_entity_decode().
* Parameters
* $string
* The input string.
* $flags
* A bitmask of one or more of the flags (see comment on jx9Builtin_htmlspecialchars())
* Return
* The decoded string.
*/
static int jx9Builtin_html_entity_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zCur, *zIn, *zEnd;
int iFlags = 0x01; /* ENT_COMPAT */
int nLen;
sxu32 n;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
/* Extract the flags if available */
if( nArg > 1 ){
iFlags = jx9_value_to_int(apArg[1]);
if( iFlags < 0 ){
iFlags = 0x01;
}
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* No more input to process */
break;
}
zCur = zIn;
while( zIn < zEnd && zIn[0] != '&' ){
zIn++;
}
if( zCur < zIn ){
/* Append raw string verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
if( zIn >= zEnd ){
break;
}
nLen = (int)(zEnd-zIn);
/* Find an encoded sequence */
for(n = 0 ; n < SX_ARRAYSIZE(azHtmlEscape) ; n += 2 ){
int iLen = (int)SyStrlen(azHtmlEscape[n]);
if( nLen >= iLen && SyStrnicmp(zIn, azHtmlEscape[n], (sxu32)iLen) == 0 ){
/* Got one */
zIn += iLen;
break;
}
}
if( n < SX_ARRAYSIZE(azHtmlEscape) ){
int c = azHtmlEscape[n+1][0];
/* Output the decoded character */
if( c == '\'' && ((iFlags & 0x02) == 0 /*ENT_QUOTES*/|| (iFlags & 0x04) /*ENT_NOQUOTES*/) ){
/* Do not process single quotes */
jx9_result_string(pCtx, azHtmlEscape[n], -1);
}else if( c == '"' && (iFlags & 0x04) /*ENT_NOQUOTES*/ ){
/* Do not process double quotes */
jx9_result_string(pCtx, azHtmlEscape[n], -1);
}else{
jx9_result_string(pCtx, azHtmlEscape[n+1], -1); /* Compute length automatically */
}
}else{
/* Append '&' */
jx9_result_string(pCtx, "&", (int)sizeof(char));
zIn++;
}
}
return JX9_OK;
}
/*
* int strlen($string)
* return the length of the given string.
* Parameter
* string: The string being measured for length.
* Return
* length of the given string.
*/
static int jx9Builtin_strlen(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iLen = 0;
if( nArg > 0 ){
jx9_value_to_string(apArg[0], &iLen);
}
/* String length */
jx9_result_int(pCtx, iLen);
return JX9_OK;
}
/*
* int strcmp(string $str1, string $str2)
* Perform a binary safe string comparison.
* Parameter
* str1: The first string
* str2: The second string
* Return
* Returns < 0 if str1 is less than str2; > 0 if str1 is greater
* than str2, and 0 if they are equal.
*/
static int jx9Builtin_strcmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *z1, *z2;
int n1, n2;
int res;
if( nArg < 2 ){
res = nArg == 0 ? 0 : 1;
jx9_result_int(pCtx, res);
return JX9_OK;
}
/* Perform the comparison */
z1 = jx9_value_to_string(apArg[0], &n1);
z2 = jx9_value_to_string(apArg[1], &n2);
res = SyStrncmp(z1, z2, (sxu32)(SXMAX(n1, n2)));
/* Comparison result */
jx9_result_int(pCtx, res);
return JX9_OK;
}
/*
* int strncmp(string $str1, string $str2, int n)
* Perform a binary safe string comparison of the first n characters.
* Parameter
* str1: The first string
* str2: The second string
* Return
* Returns < 0 if str1 is less than str2; > 0 if str1 is greater
* than str2, and 0 if they are equal.
*/
static int jx9Builtin_strncmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *z1, *z2;
int res;
int n;
if( nArg < 3 ){
/* Perform a standard comparison */
return jx9Builtin_strcmp(pCtx, nArg, apArg);
}
/* Desired comparison length */
n = jx9_value_to_int(apArg[2]);
if( n < 0 ){
/* Invalid length */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Perform the comparison */
z1 = jx9_value_to_string(apArg[0], 0);
z2 = jx9_value_to_string(apArg[1], 0);
res = SyStrncmp(z1, z2, (sxu32)n);
/* Comparison result */
jx9_result_int(pCtx, res);
return JX9_OK;
}
/*
* int strcasecmp(string $str1, string $str2, int n)
* Perform a binary safe case-insensitive string comparison.
* Parameter
* str1: The first string
* str2: The second string
* Return
* Returns < 0 if str1 is less than str2; > 0 if str1 is greater
* than str2, and 0 if they are equal.
*/
static int jx9Builtin_strcasecmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *z1, *z2;
int n1, n2;
int res;
if( nArg < 2 ){
res = nArg == 0 ? 0 : 1;
jx9_result_int(pCtx, res);
return JX9_OK;
}
/* Perform the comparison */
z1 = jx9_value_to_string(apArg[0], &n1);
z2 = jx9_value_to_string(apArg[1], &n2);
res = SyStrnicmp(z1, z2, (sxu32)(SXMAX(n1, n2)));
/* Comparison result */
jx9_result_int(pCtx, res);
return JX9_OK;
}
/*
* int strncasecmp(string $str1, string $str2, int n)
* Perform a binary safe case-insensitive string comparison of the first n characters.
* Parameter
* $str1: The first string
* $str2: The second string
* $len: The length of strings to be used in the comparison.
* Return
* Returns < 0 if str1 is less than str2; > 0 if str1 is greater
* than str2, and 0 if they are equal.
*/
static int jx9Builtin_strncasecmp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *z1, *z2;
int res;
int n;
if( nArg < 3 ){
/* Perform a standard comparison */
return jx9Builtin_strcasecmp(pCtx, nArg, apArg);
}
/* Desired comparison length */
n = jx9_value_to_int(apArg[2]);
if( n < 0 ){
/* Invalid length */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Perform the comparison */
z1 = jx9_value_to_string(apArg[0], 0);
z2 = jx9_value_to_string(apArg[1], 0);
res = SyStrnicmp(z1, z2, (sxu32)n);
/* Comparison result */
jx9_result_int(pCtx, res);
return JX9_OK;
}
/*
* Implode context [i.e: it's private data].
* A pointer to the following structure is forwarded
* verbatim to the array walker callback defined below.
*/
struct implode_data {
jx9_context *pCtx; /* Call context */
int bRecursive; /* TRUE if recursive implode [this is a symisc eXtension] */
const char *zSep; /* Arguments separator if any */
int nSeplen; /* Separator length */
int bFirst; /* TRUE if first call */
int nRecCount; /* Recursion count to avoid infinite loop */
};
/*
* Implode walker callback for the [jx9_array_walk()] interface.
* The following routine is invoked for each array entry passed
* to the implode() function.
*/
static int implode_callback(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
struct implode_data *pData = (struct implode_data *)pUserData;
const char *zData;
int nLen;
if( pData->bRecursive && jx9_value_is_json_array(pValue) && pData->nRecCount < 32 ){
if( pData->nSeplen > 0 ){
if( !pData->bFirst ){
/* append the separator first */
jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
}else{
pData->bFirst = 0;
}
}
/* Recurse */
pData->bFirst = 1;
pData->nRecCount++;
jx9HashmapWalk((jx9_hashmap *)pValue->x.pOther, implode_callback, pData);
pData->nRecCount--;
return JX9_OK;
}
/* Extract the string representation of the entry value */
zData = jx9_value_to_string(pValue, &nLen);
if( nLen > 0 ){
if( pData->nSeplen > 0 ){
if( !pData->bFirst ){
/* append the separator first */
jx9_result_string(pData->pCtx, pData->zSep, pData->nSeplen);
}else{
pData->bFirst = 0;
}
}
jx9_result_string(pData->pCtx, zData, nLen);
}else{
SXUNUSED(pKey); /* cc warning */
}
return JX9_OK;
}
/*
* string implode(string $glue, array $pieces, ...)
* string implode(array $pieces, ...)
* Join array elements with a string.
* $glue
* Defaults to an empty string. This is not the preferred usage of implode() as glue
* would be the second parameter and thus, the bad prototype would be used.
* $pieces
* The array of strings to implode.
* Return
* Returns a string containing a string representation of all the array elements in the same
* order, with the glue string between each element.
*/
static int jx9Builtin_implode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
struct implode_data imp_data;
int i = 1;
if( nArg < 1 ){
/* Missing argument, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Prepare the implode context */
imp_data.pCtx = pCtx;
imp_data.bRecursive = 0;
imp_data.bFirst = 1;
imp_data.nRecCount = 0;
if( !jx9_value_is_json_array(apArg[0]) ){
imp_data.zSep = jx9_value_to_string(apArg[0], &imp_data.nSeplen);
}else{
imp_data.zSep = 0;
imp_data.nSeplen = 0;
i = 0;
}
jx9_result_string(pCtx, "", 0); /* Set an empty stirng */
/* Start the 'join' process */
while( i < nArg ){
if( jx9_value_is_json_array(apArg[i]) ){
/* Iterate throw array entries */
jx9_array_walk(apArg[i], implode_callback, &imp_data);
}else{
const char *zData;
int nLen;
/* Extract the string representation of the jx9 value */
zData = jx9_value_to_string(apArg[i], &nLen);
if( nLen > 0 ){
if( imp_data.nSeplen > 0 ){
if( !imp_data.bFirst ){
/* append the separator first */
jx9_result_string(pCtx, imp_data.zSep, imp_data.nSeplen);
}else{
imp_data.bFirst = 0;
}
}
jx9_result_string(pCtx, zData, nLen);
}
}
i++;
}
return JX9_OK;
}
/*
* string implode_recursive(string $glue, array $pieces, ...)
* Purpose
* Same as implode() but recurse on arrays.
* Example:
* $a = array('usr', array('home', 'dean'));
* print implode_recursive("/", $a);
* Will output
* usr/home/dean.
* While the standard implode would produce.
* usr/Array.
* Parameter
* Refer to implode().
* Return
* Refer to implode().
*/
static int jx9Builtin_implode_recursive(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
struct implode_data imp_data;
int i = 1;
if( nArg < 1 ){
/* Missing argument, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Prepare the implode context */
imp_data.pCtx = pCtx;
imp_data.bRecursive = 1;
imp_data.bFirst = 1;
imp_data.nRecCount = 0;
if( !jx9_value_is_json_array(apArg[0]) ){
imp_data.zSep = jx9_value_to_string(apArg[0], &imp_data.nSeplen);
}else{
imp_data.zSep = 0;
imp_data.nSeplen = 0;
i = 0;
}
jx9_result_string(pCtx, "", 0); /* Set an empty stirng */
/* Start the 'join' process */
while( i < nArg ){
if( jx9_value_is_json_array(apArg[i]) ){
/* Iterate throw array entries */
jx9_array_walk(apArg[i], implode_callback, &imp_data);
}else{
const char *zData;
int nLen;
/* Extract the string representation of the jx9 value */
zData = jx9_value_to_string(apArg[i], &nLen);
if( nLen > 0 ){
if( imp_data.nSeplen > 0 ){
if( !imp_data.bFirst ){
/* append the separator first */
jx9_result_string(pCtx, imp_data.zSep, imp_data.nSeplen);
}else{
imp_data.bFirst = 0;
}
}
jx9_result_string(pCtx, zData, nLen);
}
}
i++;
}
return JX9_OK;
}
/*
* array explode(string $delimiter, string $string[, int $limit ])
* Returns an array of strings, each of which is a substring of string
* formed by splitting it on boundaries formed by the string delimiter.
* Parameters
* $delimiter
* The boundary string.
* $string
* The input string.
* $limit
* If limit is set and positive, the returned array will contain a maximum
* of limit elements with the last element containing the rest of string.
* If the limit parameter is negative, all fields except the last -limit are returned.
* If the limit parameter is zero, then this is treated as 1.
* Returns
* Returns an array of strings created by splitting the string parameter
* on boundaries formed by the delimiter.
* If delimiter is an empty string (""), explode() will return FALSE.
* If delimiter contains a value that is not contained in string and a negative
* limit is used, then an empty array will be returned, otherwise an array containing string
* will be returned.
* NOTE:
* Negative limit is not supported.
*/
static int jx9Builtin_explode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zDelim, *zString, *zCur, *zEnd;
int nDelim, nStrlen, iLimit;
jx9_value *pArray;
jx9_value *pValue;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the delimiter */
zDelim = jx9_value_to_string(apArg[0], &nDelim);
if( nDelim < 1 ){
/* Empty delimiter, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the string */
zString = jx9_value_to_string(apArg[1], &nStrlen);
if( nStrlen < 1 ){
/* Empty delimiter, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the end of the string */
zEnd = &zString[nStrlen];
/* Create the array */
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pValue == 0 ){
/* Out of memory, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Set a defualt limit */
iLimit = SXI32_HIGH;
if( nArg > 2 ){
iLimit = jx9_value_to_int(apArg[2]);
if( iLimit < 0 ){
iLimit = -iLimit;
}
if( iLimit == 0 ){
iLimit = 1;
}
iLimit--;
}
/* Start exploding */
for(;;){
if( zString >= zEnd ){
/* No more entry to process */
break;
}
rc = SyBlobSearch(zString, (sxu32)(zEnd-zString), zDelim, nDelim, &nOfft);
if( rc != SXRET_OK || iLimit <= (int)jx9_array_count(pArray) ){
/* Limit reached, insert the rest of the string and break */
if( zEnd > zString ){
jx9_value_string(pValue, zString, (int)(zEnd-zString));
jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pValue);
}
break;
}
/* Point to the desired offset */
zCur = &zString[nOfft];
if( zCur > zString ){
/* Perform the store operation */
jx9_value_string(pValue, zString, (int)(zCur-zString));
jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pValue);
}
/* Point beyond the delimiter */
zString = &zCur[nDelim];
/* Reset the cursor */
jx9_value_reset_string_cursor(pValue);
}
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
/* NOTE that every allocated jx9_value will be automatically
* released as soon we return from this foregin function.
*/
return JX9_OK;
}
/*
* string trim(string $str[, string $charlist ])
* Strip whitespace (or other characters) from the beginning and end of a string.
* Parameters
* $str
* The string that will be trimmed.
* $charlist
* Optionally, the stripped characters can also be specified using the charlist parameter.
* Simply list all characters that you want to be stripped.
* With .. you can specify a range of characters.
* Returns.
* Thr processed string.
*/
static int jx9Builtin_trim(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Start the trim process */
if( nArg < 2 ){
SyString sStr;
/* Remove white spaces and NUL bytes */
SyStringInitFromBuf(&sStr, zString, nLen);
SyStringFullTrimSafe(&sStr);
jx9_result_string(pCtx, sStr.zString, (int)sStr.nByte);
}else{
/* Char list */
const char *zList;
int nListlen;
zList = jx9_value_to_string(apArg[1], &nListlen);
if( nListlen < 1 ){
/* Return the string unchanged */
jx9_result_string(pCtx, zString, nLen);
}else{
const char *zEnd = &zString[nLen];
const char *zCur = zString;
const char *zPtr;
int i;
/* Left trim */
for(;;){
if( zCur >= zEnd ){
break;
}
zPtr = zCur;
for( i = 0 ; i < nListlen ; i++ ){
if( zCur < zEnd && zCur[0] == zList[i] ){
zCur++;
}
}
if( zCur == zPtr ){
/* No match, break immediately */
break;
}
}
/* Right trim */
zEnd--;
for(;;){
if( zEnd <= zCur ){
break;
}
zPtr = zEnd;
for( i = 0 ; i < nListlen ; i++ ){
if( zEnd > zCur && zEnd[0] == zList[i] ){
zEnd--;
}
}
if( zEnd == zPtr ){
break;
}
}
if( zCur >= zEnd ){
/* Return the empty string */
jx9_result_string(pCtx, "", 0);
}else{
zEnd++;
jx9_result_string(pCtx, zCur, (int)(zEnd-zCur));
}
}
}
return JX9_OK;
}
/*
* string rtrim(string $str[, string $charlist ])
* Strip whitespace (or other characters) from the end of a string.
* Parameters
* $str
* The string that will be trimmed.
* $charlist
* Optionally, the stripped characters can also be specified using the charlist parameter.
* Simply list all characters that you want to be stripped.
* With .. you can specify a range of characters.
* Returns.
* Thr processed string.
*/
static int jx9Builtin_rtrim(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Start the trim process */
if( nArg < 2 ){
SyString sStr;
/* Remove white spaces and NUL bytes*/
SyStringInitFromBuf(&sStr, zString, nLen);
SyStringRightTrimSafe(&sStr);
jx9_result_string(pCtx, sStr.zString, (int)sStr.nByte);
}else{
/* Char list */
const char *zList;
int nListlen;
zList = jx9_value_to_string(apArg[1], &nListlen);
if( nListlen < 1 ){
/* Return the string unchanged */
jx9_result_string(pCtx, zString, nLen);
}else{
const char *zEnd = &zString[nLen - 1];
const char *zCur = zString;
const char *zPtr;
int i;
/* Right trim */
for(;;){
if( zEnd <= zCur ){
break;
}
zPtr = zEnd;
for( i = 0 ; i < nListlen ; i++ ){
if( zEnd > zCur && zEnd[0] == zList[i] ){
zEnd--;
}
}
if( zEnd == zPtr ){
break;
}
}
if( zEnd <= zCur ){
/* Return the empty string */
jx9_result_string(pCtx, "", 0);
}else{
zEnd++;
jx9_result_string(pCtx, zCur, (int)(zEnd-zCur));
}
}
}
return JX9_OK;
}
/*
* string ltrim(string $str[, string $charlist ])
* Strip whitespace (or other characters) from the beginning and end of a string.
* Parameters
* $str
* The string that will be trimmed.
* $charlist
* Optionally, the stripped characters can also be specified using the charlist parameter.
* Simply list all characters that you want to be stripped.
* With .. you can specify a range of characters.
* Returns.
* The processed string.
*/
static int jx9Builtin_ltrim(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Start the trim process */
if( nArg < 2 ){
SyString sStr;
/* Remove white spaces and NUL byte */
SyStringInitFromBuf(&sStr, zString, nLen);
SyStringLeftTrimSafe(&sStr);
jx9_result_string(pCtx, sStr.zString, (int)sStr.nByte);
}else{
/* Char list */
const char *zList;
int nListlen;
zList = jx9_value_to_string(apArg[1], &nListlen);
if( nListlen < 1 ){
/* Return the string unchanged */
jx9_result_string(pCtx, zString, nLen);
}else{
const char *zEnd = &zString[nLen];
const char *zCur = zString;
const char *zPtr;
int i;
/* Left trim */
for(;;){
if( zCur >= zEnd ){
break;
}
zPtr = zCur;
for( i = 0 ; i < nListlen ; i++ ){
if( zCur < zEnd && zCur[0] == zList[i] ){
zCur++;
}
}
if( zCur == zPtr ){
/* No match, break immediately */
break;
}
}
if( zCur >= zEnd ){
/* Return the empty string */
jx9_result_string(pCtx, "", 0);
}else{
jx9_result_string(pCtx, zCur, (int)(zEnd-zCur));
}
}
}
return JX9_OK;
}
/*
* string strtolower(string $str)
* Make a string lowercase.
* Parameters
* $str
* The input string.
* Returns.
* The lowercased string.
*/
static int jx9Builtin_strtolower(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zCur, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Perform the requested operation */
zEnd = &zString[nLen];
for(;;){
if( zString >= zEnd ){
/* No more input, break immediately */
break;
}
if( (unsigned char)zString[0] >= 0xc0 ){
/* UTF-8 stream, output verbatim */
zCur = zString;
zString++;
while( zString < zEnd && ((unsigned char)zString[0] & 0xc0) == 0x80){
zString++;
}
/* Append UTF-8 stream */
jx9_result_string(pCtx, zCur, (int)(zString-zCur));
}else{
int c = zString[0];
if( SyisUpper(c) ){
c = SyToLower(zString[0]);
}
/* Append character */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
/* Advance the cursor */
zString++;
}
}
return JX9_OK;
}
/*
* string strtolower(string $str)
* Make a string uppercase.
* Parameters
* $str
* The input string.
* Returns.
* The uppercased string.
*/
static int jx9Builtin_strtoupper(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zCur, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Perform the requested operation */
zEnd = &zString[nLen];
for(;;){
if( zString >= zEnd ){
/* No more input, break immediately */
break;
}
if( (unsigned char)zString[0] >= 0xc0 ){
/* UTF-8 stream, output verbatim */
zCur = zString;
zString++;
while( zString < zEnd && ((unsigned char)zString[0] & 0xc0) == 0x80){
zString++;
}
/* Append UTF-8 stream */
jx9_result_string(pCtx, zCur, (int)(zString-zCur));
}else{
int c = zString[0];
if( SyisLower(c) ){
c = SyToUpper(zString[0]);
}
/* Append character */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
/* Advance the cursor */
zString++;
}
}
return JX9_OK;
}
/*
* int ord(string $string)
* Returns the ASCII value of the first character of string.
* Parameters
* $str
* The input string.
* Returns.
* The ASCII value as an integer.
*/
static int jx9Builtin_ord(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
int nLen, c;
if( nArg < 1 ){
/* Missing arguments, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Extract the ASCII value of the first character */
c = zString[0];
/* Return that value */
jx9_result_int(pCtx, c);
return JX9_OK;
}
/*
* string chr(int $ascii)
* Returns a one-character string containing the character specified by ascii.
* Parameters
* $ascii
* The ascii code.
* Returns.
* The specified character.
*/
static int jx9Builtin_chr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int c;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the ASCII value */
c = jx9_value_to_int(apArg[0]);
/* Return the specified character */
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
return JX9_OK;
}
/*
* Binary to hex consumer callback.
* This callback is the default consumer used by the hash functions
* [i.e: bin2hex(), md5(), sha1(), md5_file() ... ] defined below.
*/
static int HashConsumer(const void *pData, unsigned int nLen, void *pUserData)
{
/* Append hex chunk verbatim */
jx9_result_string((jx9_context *)pUserData, (const char *)pData, (int)nLen);
return SXRET_OK;
}
/*
* string bin2hex(string $str)
* Convert binary data into hexadecimal representation.
* Parameters
* $str
* The input string.
* Returns.
* Returns the hexadecimal representation of the given string.
*/
static int jx9Builtin_bin2hex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Perform the requested operation */
SyBinToHexConsumer((const void *)zString, (sxu32)nLen, HashConsumer, pCtx);
return JX9_OK;
}
/* Search callback signature */
typedef sxi32 (*ProcStringMatch)(const void *, sxu32, const void *, sxu32, sxu32 *);
/*
* Case-insensitive pattern match.
* Brute force is the default search method used here.
* This is due to the fact that brute-forcing works quite
* well for short/medium texts on modern hardware.
*/
static sxi32 iPatternMatch(const void *pText, sxu32 nLen, const void *pPattern, sxu32 iPatLen, sxu32 *pOfft)
{
const char *zpIn = (const char *)pPattern;
const char *zIn = (const char *)pText;
const char *zpEnd = &zpIn[iPatLen];
const char *zEnd = &zIn[nLen];
const char *zPtr, *zPtr2;
int c, d;
if( iPatLen > nLen ){
/* Don't bother processing */
return SXERR_NOTFOUND;
}
for(;;){
if( zIn >= zEnd ){
break;
}
c = SyToLower(zIn[0]);
d = SyToLower(zpIn[0]);
if( c == d ){
zPtr = &zIn[1];
zPtr2 = &zpIn[1];
for(;;){
if( zPtr2 >= zpEnd ){
/* Pattern found */
if( pOfft ){ *pOfft = (sxu32)(zIn-(const char *)pText); }
return SXRET_OK;
}
if( zPtr >= zEnd ){
break;
}
c = SyToLower(zPtr[0]);
d = SyToLower(zPtr2[0]);
if( c != d ){
break;
}
zPtr++; zPtr2++;
}
}
zIn++;
}
/* Pattern not found */
return SXERR_NOTFOUND;
}
/*
* string strstr(string $haystack, string $needle[, bool $before_needle = false ])
* Find the first occurrence of a string.
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $before_needle
* If TRUE, strstr() returns the part of the haystack before the first occurrence
* of the needle (excluding the needle).
* Return
* Returns the portion of string, or FALSE if needle is not found.
*/
static int jx9Builtin_strstr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
const char *zBlob, *zPattern;
int nLen, nPatLen;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
nOfft = 0; /* cc warning */
if( nLen > 0 && nPatLen > 0 ){
int before = 0;
/* Perform the lookup */
rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return the portion of the string */
if( nArg > 2 ){
before = jx9_value_to_int(apArg[2]);
}
if( before ){
jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
}else{
jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
}
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* string stristr(string $haystack, string $needle[, bool $before_needle = false ])
* Case-insensitive strstr().
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $before_needle
* If TRUE, strstr() returns the part of the haystack before the first occurrence
* of the needle (excluding the needle).
* Return
* Returns the portion of string, or FALSE if needle is not found.
*/
static int jx9Builtin_stristr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
const char *zBlob, *zPattern;
int nLen, nPatLen;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
nOfft = 0; /* cc warning */
if( nLen > 0 && nPatLen > 0 ){
int before = 0;
/* Perform the lookup */
rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return the portion of the string */
if( nArg > 2 ){
before = jx9_value_to_int(apArg[2]);
}
if( before ){
jx9_result_string(pCtx, zBlob, (int)(&zBlob[nOfft]-zBlob));
}else{
jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
}
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int strpos(string $haystack, string $needle [, int $offset = 0 ] )
* Returns the numeric position of the first occurrence of needle in the haystack string.
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $offset
* This optional offset parameter allows you to specify which character in haystack
* to start searching. The position returned is still relative to the beginning
* of haystack.
* Return
* Returns the position as an integer.If needle is not found, strpos() will return FALSE.
*/
static int jx9Builtin_strpos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
const char *zBlob, *zPattern;
int nLen, nPatLen, nStart;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
nOfft = 0; /* cc warning */
nStart = 0;
/* Peek the starting offset if available */
if( nArg > 2 ){
nStart = jx9_value_to_int(apArg[2]);
if( nStart < 0 ){
nStart = -nStart;
}
if( nStart >= nLen ){
/* Invalid offset */
nStart = 0;
}else{
zBlob += nStart;
nLen -= nStart;
}
}
if( nLen > 0 && nPatLen > 0 ){
/* Perform the lookup */
rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return the pattern position */
jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int stripos(string $haystack, string $needle [, int $offset = 0 ] )
* Case-insensitive strpos.
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $offset
* This optional offset parameter allows you to specify which character in haystack
* to start searching. The position returned is still relative to the beginning
* of haystack.
* Return
* Returns the position as an integer.If needle is not found, strpos() will return FALSE.
*/
static int jx9Builtin_stripos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
const char *zBlob, *zPattern;
int nLen, nPatLen, nStart;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
nOfft = 0; /* cc warning */
nStart = 0;
/* Peek the starting offset if available */
if( nArg > 2 ){
nStart = jx9_value_to_int(apArg[2]);
if( nStart < 0 ){
nStart = -nStart;
}
if( nStart >= nLen ){
/* Invalid offset */
nStart = 0;
}else{
zBlob += nStart;
nLen -= nStart;
}
}
if( nLen > 0 && nPatLen > 0 ){
/* Perform the lookup */
rc = xPatternMatch(zBlob, (sxu32)nLen, zPattern, (sxu32)nPatLen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return the pattern position */
jx9_result_int64(pCtx, (jx9_int64)(nOfft+nStart));
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int strrpos(string $haystack, string $needle [, int $offset = 0 ] )
* Find the numeric position of the last occurrence of needle in the haystack string.
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $offset
* If specified, search will start this number of characters counted from the beginning
* of the string. If the value is negative, search will instead start from that many
* characters from the end of the string, searching backwards.
* Return
* Returns the position as an integer.If needle is not found, strrpos() will return FALSE.
*/
static int jx9Builtin_strrpos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zStart, *zBlob, *zPattern, *zPtr, *zEnd;
ProcStringMatch xPatternMatch = SyBlobSearch; /* Case-sensitive pattern match */
int nLen, nPatLen;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
/* Point to the end of the pattern */
zPtr = &zBlob[nLen - 1];
zEnd = &zBlob[nLen];
/* Save the starting posistion */
zStart = zBlob;
nOfft = 0; /* cc warning */
/* Peek the starting offset if available */
if( nArg > 2 ){
int nStart;
nStart = jx9_value_to_int(apArg[2]);
if( nStart < 0 ){
nStart = -nStart;
if( nStart >= nLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
nLen -= nStart;
zPtr = &zBlob[nLen - 1];
zEnd = &zBlob[nLen];
}
}else{
if( nStart >= nLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
zBlob += nStart;
nLen -= nStart;
}
}
}
if( nLen > 0 && nPatLen > 0 ){
/* Perform the lookup */
for(;;){
if( zBlob >= zPtr ){
break;
}
rc = xPatternMatch((const void *)zPtr, (sxu32)(zEnd-zPtr), (const void *)zPattern, (sxu32)nPatLen, &nOfft);
if( rc == SXRET_OK ){
/* Pattern found, return it's position */
jx9_result_int64(pCtx, (jx9_int64)(&zPtr[nOfft] - zStart));
return JX9_OK;
}
zPtr--;
}
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int strripos(string $haystack, string $needle [, int $offset = 0 ] )
* Case-insensitive strrpos.
* Parameters
* $haystack
* The input string.
* $needle
* Search pattern (must be a string).
* $offset
* If specified, search will start this number of characters counted from the beginning
* of the string. If the value is negative, search will instead start from that many
* characters from the end of the string, searching backwards.
* Return
* Returns the position as an integer.If needle is not found, strrpos() will return FALSE.
*/
static int jx9Builtin_strripos(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zStart, *zBlob, *zPattern, *zPtr, *zEnd;
ProcStringMatch xPatternMatch = iPatternMatch; /* Case-insensitive pattern match */
int nLen, nPatLen;
sxu32 nOfft;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the needle and the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
zPattern = jx9_value_to_string(apArg[1], &nPatLen);
/* Point to the end of the pattern */
zPtr = &zBlob[nLen - 1];
zEnd = &zBlob[nLen];
/* Save the starting posistion */
zStart = zBlob;
nOfft = 0; /* cc warning */
/* Peek the starting offset if available */
if( nArg > 2 ){
int nStart;
nStart = jx9_value_to_int(apArg[2]);
if( nStart < 0 ){
nStart = -nStart;
if( nStart >= nLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
nLen -= nStart;
zPtr = &zBlob[nLen - 1];
zEnd = &zBlob[nLen];
}
}else{
if( nStart >= nLen ){
/* Invalid offset */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
zBlob += nStart;
nLen -= nStart;
}
}
}
if( nLen > 0 && nPatLen > 0 ){
/* Perform the lookup */
for(;;){
if( zBlob >= zPtr ){
break;
}
rc = xPatternMatch((const void *)zPtr, (sxu32)(zEnd-zPtr), (const void *)zPattern, (sxu32)nPatLen, &nOfft);
if( rc == SXRET_OK ){
/* Pattern found, return it's position */
jx9_result_int64(pCtx, (jx9_int64)(&zPtr[nOfft] - zStart));
return JX9_OK;
}
zPtr--;
}
/* Pattern not found, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int strrchr(string $haystack, mixed $needle)
* Find the last occurrence of a character in a string.
* Parameters
* $haystack
* The input string.
* $needle
* If needle contains more than one character, only the first is used.
* This behavior is different from that of strstr().
* If needle is not a string, it is converted to an integer and applied
* as the ordinal value of a character.
* Return
* This function returns the portion of string, or FALSE if needle is not found.
*/
static int jx9Builtin_strrchr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zBlob;
int nLen, c;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the haystack */
zBlob = jx9_value_to_string(apArg[0], &nLen);
c = 0; /* cc warning */
if( nLen > 0 ){
sxu32 nOfft;
sxi32 rc;
if( jx9_value_is_string(apArg[1]) ){
const char *zPattern;
zPattern = jx9_value_to_string(apArg[1], 0); /* Never fail, so there is no need to check
* for NULL pointer.
*/
c = zPattern[0];
}else{
/* Int cast */
c = jx9_value_to_int(apArg[1]);
}
/* Perform the lookup */
rc = SyByteFind2(zBlob, (sxu32)nLen, c, &nOfft);
if( rc != SXRET_OK ){
/* No such entry, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return the string portion */
jx9_result_string(pCtx, &zBlob[nOfft], (int)(&zBlob[nLen]-&zBlob[nOfft]));
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* string strrev(string $string)
* Reverse a string.
* Parameters
* $string
* String to be reversed.
* Return
* The reversed string.
*/
static int jx9Builtin_strrev(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn, *zEnd;
int nLen, c;
if( nArg < 1 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string Return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Perform the requested operation */
zEnd = &zIn[nLen - 1];
for(;;){
if( zEnd < zIn ){
/* No more input to process */
break;
}
/* Append current character */
c = zEnd[0];
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
zEnd--;
}
return JX9_OK;
}
/*
* string str_repeat(string $input, int $multiplier)
* Returns input repeated multiplier times.
* Parameters
* $string
* String to be repeated.
* $multiplier
* Number of time the input string should be repeated.
* multiplier has to be greater than or equal to 0. If the multiplier is set
* to 0, the function will return an empty string.
* Return
* The repeated string.
*/
static int jx9Builtin_str_repeat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen, nMul;
int rc;
if( nArg < 2 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string.Return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the multiplier */
nMul = jx9_value_to_int(apArg[1]);
if( nMul < 1 ){
/* Return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( nMul < 1 ){
break;
}
/* Append the copy */
rc = jx9_result_string(pCtx, zIn, nLen);
if( rc != JX9_OK ){
/* Out of memory, break immediately */
break;
}
nMul--;
}
return JX9_OK;
}
/*
* string nl2br(string $string[, bool $is_xhtml = true ])
* Inserts HTML line breaks before all newlines in a string.
* Parameters
* $string
* The input string.
* $is_xhtml
* Whenever to use XHTML compatible line breaks or not.
* Return
* The processed string.
*/
static int jx9Builtin_nl2br(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn, *zCur, *zEnd;
int is_xhtml = 0;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
if( nArg > 1 ){
is_xhtml = jx9_value_to_bool(apArg[1]);
}
zEnd = &zIn[nLen];
/* Perform the requested operation */
for(;;){
zCur = zIn;
/* Delimit the string */
while( zIn < zEnd && (zIn[0] != '\n'&& zIn[0] != '\r') ){
zIn++;
}
if( zCur < zIn ){
/* Output chunk verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
if( zIn >= zEnd ){
/* No more input to process */
break;
}
/* Output the HTML line break */
if( is_xhtml ){
jx9_result_string(pCtx, "<br>", (int)sizeof("<br>")-1);
}else{
jx9_result_string(pCtx, "<br/>", (int)sizeof("<br/>")-1);
}
zCur = zIn;
/* Append trailing line */
while( zIn < zEnd && (zIn[0] == '\n' || zIn[0] == '\r') ){
zIn++;
}
if( zCur < zIn ){
/* Output chunk verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
}
return JX9_OK;
}
/*
* Format a given string and invoke the given callback on each processed chunk.
* According to the JX9 reference manual.
* The format string is composed of zero or more directives: ordinary characters
* (excluding %) that are copied directly to the result, and conversion
* specifications, each of which results in fetching its own parameter.
* This applies to both sprintf() and printf().
* Each conversion specification consists of a percent sign (%), followed by one
* or more of these elements, in order:
* An optional sign specifier that forces a sign (- or +) to be used on a number.
* By default, only the - sign is used on a number if it's negative. This specifier forces
* positive numbers to have the + sign attached as well.
* An optional padding specifier that says what character will be used for padding
* the results to the right string size. This may be a space character or a 0 (zero character).
* The default is to pad with spaces. An alternate padding character can be specified by prefixing
* it with a single quote ('). See the examples below.
* An optional alignment specifier that says if the result should be left-justified or right-justified.
* The default is right-justified; a - character here will make it left-justified.
* An optional number, a width specifier that says how many characters (minimum) this conversion
* should result in.
* An optional precision specifier in the form of a period (`.') followed by an optional decimal
* digit string that says how many decimal digits should be displayed for floating-point numbers.
* When using this specifier on a string, it acts as a cutoff point, setting a maximum character
* limit to the string.
* A type specifier that says what type the argument data should be treated as. Possible types:
* % - a literal percent character. No argument is required.
* b - the argument is treated as an integer, and presented as a binary number.
* c - the argument is treated as an integer, and presented as the character with that ASCII value.
* d - the argument is treated as an integer, and presented as a (signed) decimal number.
* e - the argument is treated as scientific notation (e.g. 1.2e+2). The precision specifier stands
* for the number of digits after the decimal point.
* E - like %e but uses uppercase letter (e.g. 1.2E+2).
* u - the argument is treated as an integer, and presented as an unsigned decimal number.
* f - the argument is treated as a float, and presented as a floating-point number (locale aware).
* F - the argument is treated as a float, and presented as a floating-point number (non-locale aware).
* g - shorter of %e and %f.
* G - shorter of %E and %f.
* o - the argument is treated as an integer, and presented as an octal number.
* s - the argument is treated as and presented as a string.
* x - the argument is treated as an integer and presented as a hexadecimal number (with lowercase letters).
* X - the argument is treated as an integer and presented as a hexadecimal number (with uppercase letters).
*/
/*
* This implementation is based on the one found in the SQLite3 source tree.
*/
#define JX9_FMT_BUFSIZ 1024 /* Conversion buffer size */
/*
** Conversion types fall into various categories as defined by the
** following enumeration.
*/
#define JX9_FMT_RADIX 1 /* Integer types.%d, %x, %o, and so forth */
#define JX9_FMT_FLOAT 2 /* Floating point.%f */
#define JX9_FMT_EXP 3 /* Exponentional notation.%e and %E */
#define JX9_FMT_GENERIC 4 /* Floating or exponential, depending on exponent.%g */
#define JX9_FMT_SIZE 5 /* Total number of characters processed so far.%n */
#define JX9_FMT_STRING 6 /* Strings.%s */
#define JX9_FMT_PERCENT 7 /* Percent symbol.%% */
#define JX9_FMT_CHARX 8 /* Characters.%c */
#define JX9_FMT_ERROR 9 /* Used to indicate no such conversion type */
/*
** Allowed values for jx9_fmt_info.flags
*/
#define JX9_FMT_FLAG_SIGNED 0x01
#define JX9_FMT_FLAG_UNSIGNED 0x02
/*
** Each builtin conversion character (ex: the 'd' in "%d") is described
** by an instance of the following structure
*/
typedef struct jx9_fmt_info jx9_fmt_info;
struct jx9_fmt_info
{
char fmttype; /* The format field code letter [i.e: 'd', 's', 'x'] */
sxu8 base; /* The base for radix conversion */
int flags; /* One or more of JX9_FMT_FLAG_ constants below */
sxu8 type; /* Conversion paradigm */
char *charset; /* The character set for conversion */
char *prefix; /* Prefix on non-zero values in alt format */
};
#ifndef JX9_OMIT_FLOATING_POINT
/*
** "*val" is a double such that 0.1 <= *val < 10.0
** Return the ascii code for the leading digit of *val, then
** multiply "*val" by 10.0 to renormalize.
**
** Example:
** input: *val = 3.14159
** output: *val = 1.4159 function return = '3'
**
** The counter *cnt is incremented each time. After counter exceeds
** 16 (the number of significant digits in a 64-bit float) '0' is
** always returned.
*/
static int vxGetdigit(sxlongreal *val, int *cnt)
{
sxlongreal d;
int digit;
if( (*cnt)++ >= 16 ){
return '0';
}
digit = (int)*val;
d = digit;
*val = (*val - d)*10.0;
return digit + '0' ;
}
#endif /* JX9_OMIT_FLOATING_POINT */
/*
* The following table is searched linearly, so it is good to put the most frequently
* used conversion types first.
*/
static const jx9_fmt_info aFmt[] = {
{ 'd', 10, JX9_FMT_FLAG_SIGNED, JX9_FMT_RADIX, "0123456789", 0 },
{ 's', 0, 0, JX9_FMT_STRING, 0, 0 },
{ 'c', 0, 0, JX9_FMT_CHARX, 0, 0 },
{ 'x', 16, 0, JX9_FMT_RADIX, "0123456789abcdef", "x0" },
{ 'X', 16, 0, JX9_FMT_RADIX, "0123456789ABCDEF", "X0" },
{ 'b', 2, 0, JX9_FMT_RADIX, "01", "b0"},
{ 'o', 8, 0, JX9_FMT_RADIX, "01234567", "0" },
{ 'u', 10, 0, JX9_FMT_RADIX, "0123456789", 0 },
{ 'f', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_FLOAT, 0, 0 },
{ 'F', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_FLOAT, 0, 0 },
{ 'e', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_EXP, "e", 0 },
{ 'E', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_EXP, "E", 0 },
{ 'g', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_GENERIC, "e", 0 },
{ 'G', 0, JX9_FMT_FLAG_SIGNED, JX9_FMT_GENERIC, "E", 0 },
{ '%', 0, 0, JX9_FMT_PERCENT, 0, 0 }
};
/*
* Format a given string.
* The root program. All variations call this core.
* INPUTS:
* xConsumer This is a pointer to a function taking four arguments
* 1. A pointer to the call context.
* 2. A pointer to the list of characters to be output
* (Note, this list is NOT null terminated.)
* 3. An integer number of characters to be output.
* (Note: This number might be zero.)
* 4. Upper layer private data.
* zIn This is the format string, as in the usual print.
* apArg This is a pointer to a list of arguments.
*/
JX9_PRIVATE sxi32 jx9InputFormat(
int (*xConsumer)(jx9_context *, const char *, int, void *), /* Format consumer */
jx9_context *pCtx, /* call context */
const char *zIn, /* Format string */
int nByte, /* Format string length */
int nArg, /* Total argument of the given arguments */
jx9_value **apArg, /* User arguments */
void *pUserData, /* Last argument to xConsumer() */
int vf /* TRUE if called from vfprintf, vsprintf context */
)
{
char spaces[] = " ";
#define etSPACESIZE ((int)sizeof(spaces)-1)
const char *zCur, *zEnd = &zIn[nByte];
char *zBuf, zWorker[JX9_FMT_BUFSIZ]; /* Working buffer */
const jx9_fmt_info *pInfo; /* Pointer to the appropriate info structure */
int flag_alternateform; /* True if "#" flag is present */
int flag_leftjustify; /* True if "-" flag is present */
int flag_blanksign; /* True if " " flag is present */
int flag_plussign; /* True if "+" flag is present */
int flag_zeropad; /* True if field width constant starts with zero */
jx9_value *pArg; /* Current processed argument */
jx9_int64 iVal;
int precision; /* Precision of the current field */
char *zExtra;
int c, rc, n;
int length; /* Length of the field */
int prefix;
sxu8 xtype; /* Conversion paradigm */
int width; /* Width of the current field */
int idx;
n = (vf == TRUE) ? 0 : 1;
#define NEXT_ARG ( n < nArg ? apArg[n++] : 0 )
/* Start the format process */
for(;;){
zCur = zIn;
while( zIn < zEnd && zIn[0] != '%' ){
zIn++;
}
if( zCur < zIn ){
/* Consume chunk verbatim */
rc = xConsumer(pCtx, zCur, (int)(zIn-zCur), pUserData);
if( rc == SXERR_ABORT ){
/* Callback request an operation abort */
break;
}
}
if( zIn >= zEnd ){
/* No more input to process, break immediately */
break;
}
/* Find out what flags are present */
flag_leftjustify = flag_plussign = flag_blanksign =
flag_alternateform = flag_zeropad = 0;
zIn++; /* Jump the precent sign */
do{
c = zIn[0];
switch( c ){
case '-': flag_leftjustify = 1; c = 0; break;
case '+': flag_plussign = 1; c = 0; break;
case ' ': flag_blanksign = 1; c = 0; break;
case '#': flag_alternateform = 1; c = 0; break;
case '0': flag_zeropad = 1; c = 0; break;
case '\'':
zIn++;
if( zIn < zEnd ){
/* An alternate padding character can be specified by prefixing it with a single quote (') */
c = zIn[0];
for(idx = 0 ; idx < etSPACESIZE ; ++idx ){
spaces[idx] = (char)c;
}
c = 0;
}
break;
default: break;
}
}while( c==0 && (zIn++ < zEnd) );
/* Get the field width */
width = 0;
while( zIn < zEnd && ( zIn[0] >='0' && zIn[0] <='9') ){
width = width*10 + (zIn[0] - '0');
zIn++;
}
if( zIn < zEnd && zIn[0] == '$' ){
/* Position specifer */
if( width > 0 ){
n = width;
if( vf && n > 0 ){
n--;
}
}
zIn++;
width = 0;
if( zIn < zEnd && zIn[0] == '0' ){
flag_zeropad = 1;
zIn++;
}
while( zIn < zEnd && ( zIn[0] >='0' && zIn[0] <='9') ){
width = width*10 + (zIn[0] - '0');
zIn++;
}
}
if( width > JX9_FMT_BUFSIZ-10 ){
width = JX9_FMT_BUFSIZ-10;
}
/* Get the precision */
precision = -1;
if( zIn < zEnd && zIn[0] == '.' ){
precision = 0;
zIn++;
while( zIn < zEnd && ( zIn[0] >='0' && zIn[0] <='9') ){
precision = precision*10 + (zIn[0] - '0');
zIn++;
}
}
if( zIn >= zEnd ){
/* No more input */
break;
}
/* Fetch the info entry for the field */
pInfo = 0;
xtype = JX9_FMT_ERROR;
c = zIn[0];
zIn++; /* Jump the format specifer */
for(idx=0; idx< (int)SX_ARRAYSIZE(aFmt); idx++){
if( c==aFmt[idx].fmttype ){
pInfo = &aFmt[idx];
xtype = pInfo->type;
break;
}
}
zBuf = zWorker; /* Point to the working buffer */
length = 0;
zExtra = 0;
/*
** At this point, variables are initialized as follows:
**
** flag_alternateform TRUE if a '#' is present.
** flag_plussign TRUE if a '+' is present.
** flag_leftjustify TRUE if a '-' is present or if the
** field width was negative.
** flag_zeropad TRUE if the width began with 0.
** the conversion character.
** flag_blanksign TRUE if a ' ' is present.
** width The specified field width. This is
** always non-negative. Zero is the default.
** precision The specified precision. The default
** is -1.
*/
switch(xtype){
case JX9_FMT_PERCENT:
/* A literal percent character */
zWorker[0] = '%';
length = (int)sizeof(char);
break;
case JX9_FMT_CHARX:
/* The argument is treated as an integer, and presented as the character
* with that ASCII value
*/
pArg = NEXT_ARG;
if( pArg == 0 ){
c = 0;
}else{
c = jx9_value_to_int(pArg);
}
/* NUL byte is an acceptable value */
zWorker[0] = (char)c;
length = (int)sizeof(char);
break;
case JX9_FMT_STRING:
/* the argument is treated as and presented as a string */
pArg = NEXT_ARG;
if( pArg == 0 ){
length = 0;
}else{
zBuf = (char *)jx9_value_to_string(pArg, &length);
}
if( length < 1 ){
zBuf = " ";
length = (int)sizeof(char);
}
if( precision>=0 && precision<length ){
length = precision;
}
if( flag_zeropad ){
/* zero-padding works on strings too */
for(idx = 0 ; idx < etSPACESIZE ; ++idx ){
spaces[idx] = '0';
}
}
break;
case JX9_FMT_RADIX:
pArg = NEXT_ARG;
if( pArg == 0 ){
iVal = 0;
}else{
iVal = jx9_value_to_int64(pArg);
}
/* Limit the precision to prevent overflowing buf[] during conversion */
if( precision>JX9_FMT_BUFSIZ-40 ){
precision = JX9_FMT_BUFSIZ-40;
}
#if 1
/* For the format %#x, the value zero is printed "0" not "0x0".
** I think this is stupid.*/
if( iVal==0 ) flag_alternateform = 0;
#else
/* More sensible: turn off the prefix for octal (to prevent "00"),
** but leave the prefix for hex.*/
if( iVal==0 && pInfo->base==8 ) flag_alternateform = 0;
#endif
if( pInfo->flags & JX9_FMT_FLAG_SIGNED ){
if( iVal<0 ){
iVal = -iVal;
/* Ticket 1433-003 */
if( iVal < 0 ){
/* Overflow */
iVal= 0x7FFFFFFFFFFFFFFF;
}
prefix = '-';
}else if( flag_plussign ) prefix = '+';
else if( flag_blanksign ) prefix = ' ';
else prefix = 0;
}else{
if( iVal<0 ){
iVal = -iVal;
/* Ticket 1433-003 */
if( iVal < 0 ){
/* Overflow */
iVal= 0x7FFFFFFFFFFFFFFF;
}
}
prefix = 0;
}
if( flag_zeropad && precision<width-(prefix!=0) ){
precision = width-(prefix!=0);
}
zBuf = &zWorker[JX9_FMT_BUFSIZ-1];
{
register char *cset; /* Use registers for speed */
register int base;
cset = pInfo->charset;
base = pInfo->base;
do{ /* Convert to ascii */
*(--zBuf) = cset[iVal%base];
iVal = iVal/base;
}while( iVal>0 );
}
length = &zWorker[JX9_FMT_BUFSIZ-1]-zBuf;
for(idx=precision-length; idx>0; idx--){
*(--zBuf) = '0'; /* Zero pad */
}
if( prefix ) *(--zBuf) = (char)prefix; /* Add sign */
if( flag_alternateform && pInfo->prefix ){ /* Add "0" or "0x" */
char *pre, x;
pre = pInfo->prefix;
if( *zBuf!=pre[0] ){
for(pre=pInfo->prefix; (x=(*pre))!=0; pre++) *(--zBuf) = x;
}
}
length = &zWorker[JX9_FMT_BUFSIZ-1]-zBuf;
break;
case JX9_FMT_FLOAT:
case JX9_FMT_EXP:
case JX9_FMT_GENERIC:{
#ifndef JX9_OMIT_FLOATING_POINT
long double realvalue;
int exp; /* exponent of real numbers */
double rounder; /* Used for rounding floating point values */
int flag_dp; /* True if decimal point should be shown */
int flag_rtz; /* True if trailing zeros should be removed */
int flag_exp; /* True to force display of the exponent */
int nsd; /* Number of significant digits returned */
pArg = NEXT_ARG;
if( pArg == 0 ){
realvalue = 0;
}else{
realvalue = jx9_value_to_double(pArg);
}
if( precision<0 ) precision = 6; /* Set default precision */
if( precision>JX9_FMT_BUFSIZ-40) precision = JX9_FMT_BUFSIZ-40;
if( realvalue<0.0 ){
realvalue = -realvalue;
prefix = '-';
}else{
if( flag_plussign ) prefix = '+';
else if( flag_blanksign ) prefix = ' ';
else prefix = 0;
}
if( pInfo->type==JX9_FMT_GENERIC && precision>0 ) precision--;
rounder = 0.0;
#if 0
/* Rounding works like BSD when the constant 0.4999 is used.Wierd! */
for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
#else
/* It makes more sense to use 0.5 */
for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1);
#endif
if( pInfo->type==JX9_FMT_FLOAT ) realvalue += rounder;
/* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
exp = 0;
if( realvalue>0.0 ){
while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; }
while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; }
if( exp>350 || exp<-350 ){
zBuf = "NaN";
length = 3;
break;
}
}
zBuf = zWorker;
/*
** If the field type is etGENERIC, then convert to either etEXP
** or etFLOAT, as appropriate.
*/
flag_exp = xtype==JX9_FMT_EXP;
if( xtype!=JX9_FMT_FLOAT ){
realvalue += rounder;
if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
}
if( xtype==JX9_FMT_GENERIC ){
flag_rtz = !flag_alternateform;
if( exp<-4 || exp>precision ){
xtype = JX9_FMT_EXP;
}else{
precision = precision - exp;
xtype = JX9_FMT_FLOAT;
}
}else{
flag_rtz = 0;
}
/*
** The "exp+precision" test causes output to be of type etEXP if
** the precision is too large to fit in buf[].
*/
nsd = 0;
if( xtype==JX9_FMT_FLOAT && exp+precision<JX9_FMT_BUFSIZ-30 ){
flag_dp = (precision>0 || flag_alternateform);
if( prefix ) *(zBuf++) = (char)prefix; /* Sign */
if( exp<0 ) *(zBuf++) = '0'; /* Digits before "." */
else for(; exp>=0; exp--) *(zBuf++) = (char)vxGetdigit(&realvalue, &nsd);
if( flag_dp ) *(zBuf++) = '.'; /* The decimal point */
for(exp++; exp<0 && precision>0; precision--, exp++){
*(zBuf++) = '0';
}
while( (precision--)>0 ) *(zBuf++) = (char)vxGetdigit(&realvalue, &nsd);
*(zBuf--) = 0; /* Null terminate */
if( flag_rtz && flag_dp ){ /* Remove trailing zeros and "." */
while( zBuf>=zWorker && *zBuf=='0' ) *(zBuf--) = 0;
if( zBuf>=zWorker && *zBuf=='.' ) *(zBuf--) = 0;
}
zBuf++; /* point to next free slot */
}else{ /* etEXP or etGENERIC */
flag_dp = (precision>0 || flag_alternateform);
if( prefix ) *(zBuf++) = (char)prefix; /* Sign */
*(zBuf++) = (char)vxGetdigit(&realvalue, &nsd); /* First digit */
if( flag_dp ) *(zBuf++) = '.'; /* Decimal point */
while( (precision--)>0 ) *(zBuf++) = (char)vxGetdigit(&realvalue, &nsd);
zBuf--; /* point to last digit */
if( flag_rtz && flag_dp ){ /* Remove tail zeros */
while( zBuf>=zWorker && *zBuf=='0' ) *(zBuf--) = 0;
if( zBuf>=zWorker && *zBuf=='.' ) *(zBuf--) = 0;
}
zBuf++; /* point to next free slot */
if( exp || flag_exp ){
*(zBuf++) = pInfo->charset[0];
if( exp<0 ){ *(zBuf++) = '-'; exp = -exp; } /* sign of exp */
else { *(zBuf++) = '+'; }
if( exp>=100 ){
*(zBuf++) = (char)((exp/100)+'0'); /* 100's digit */
exp %= 100;
}
*(zBuf++) = (char)(exp/10+'0'); /* 10's digit */
*(zBuf++) = (char)(exp%10+'0'); /* 1's digit */
}
}
/* The converted number is in buf[] and zero terminated.Output it.
** Note that the number is in the usual order, not reversed as with
** integer conversions.*/
length = (int)(zBuf-zWorker);
zBuf = zWorker;
/* Special case: Add leading zeros if the flag_zeropad flag is
** set and we are not left justified */
if( flag_zeropad && !flag_leftjustify && length < width){
int i;
int nPad = width - length;
for(i=width; i>=nPad; i--){
zBuf[i] = zBuf[i-nPad];
}
i = prefix!=0;
while( nPad-- ) zBuf[i++] = '0';
length = width;
}
#else
zBuf = " ";
length = (int)sizeof(char);
#endif /* JX9_OMIT_FLOATING_POINT */
break;
}
default:
/* Invalid format specifer */
zWorker[0] = '?';
length = (int)sizeof(char);
break;
}
/*
** The text of the conversion is pointed to by "zBuf" and is
** "length" characters long.The field width is "width".Do
** the output.
*/
if( !flag_leftjustify ){
register int nspace;
nspace = width-length;
if( nspace>0 ){
while( nspace>=etSPACESIZE ){
rc = xConsumer(pCtx, spaces, etSPACESIZE, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
nspace -= etSPACESIZE;
}
if( nspace>0 ){
rc = xConsumer(pCtx, spaces, (unsigned int)nspace, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
}
}
if( length>0 ){
rc = xConsumer(pCtx, zBuf, (unsigned int)length, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
if( flag_leftjustify ){
register int nspace;
nspace = width-length;
if( nspace>0 ){
while( nspace>=etSPACESIZE ){
rc = xConsumer(pCtx, spaces, etSPACESIZE, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
nspace -= etSPACESIZE;
}
if( nspace>0 ){
rc = xConsumer(pCtx, spaces, (unsigned int)nspace, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
}
}
}/* for(;;) */
return SXRET_OK;
}
/*
* Callback [i.e: Formatted input consumer] of the sprintf function.
*/
static int sprintfConsumer(jx9_context *pCtx, const char *zInput, int nLen, void *pUserData)
{
/* Consume directly */
jx9_result_string(pCtx, zInput, nLen);
SXUNUSED(pUserData); /* cc warning */
return JX9_OK;
}
/*
* string sprintf(string $format[, mixed $args [, mixed $... ]])
* Return a formatted string.
* Parameters
* $format
* The format string (see block comment above)
* Return
* A string produced according to the formatting string format.
*/
static int jx9Builtin_sprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Format the string */
jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, nArg, apArg, 0, FALSE);
return JX9_OK;
}
/*
* Callback [i.e: Formatted input consumer] of the printf function.
*/
static int printfConsumer(jx9_context *pCtx, const char *zInput, int nLen, void *pUserData)
{
jx9_int64 *pCounter = (jx9_int64 *)pUserData;
/* Call the VM output consumer directly */
jx9_context_output(pCtx, zInput, nLen);
/* Increment counter */
*pCounter += nLen;
return JX9_OK;
}
/*
* int64 printf(string $format[, mixed $args[, mixed $... ]])
* Output a formatted string.
* Parameters
* $format
* See sprintf() for a description of format.
* Return
* The length of the outputted string.
*/
static int jx9Builtin_printf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_int64 nCounter = 0;
const char *zFormat;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Format the string */
jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, nArg, apArg, (void *)&nCounter, FALSE);
/* Return the length of the outputted string */
jx9_result_int64(pCtx, nCounter);
return JX9_OK;
}
/*
* int vprintf(string $format, array $args)
* Output a formatted string.
* Parameters
* $format
* See sprintf() for a description of format.
* Return
* The length of the outputted string.
*/
static int jx9Builtin_vprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_int64 nCounter = 0;
const char *zFormat;
jx9_hashmap *pMap;
SySet sArg;
int nLen, n;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
/* Missing/Invalid arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the hashmap */
pMap = (jx9_hashmap *)apArg[1]->x.pOther;
/* Extract arguments from the hashmap */
n = jx9HashmapValuesToSet(pMap, &sArg);
/* Format the string */
jx9InputFormat(printfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), (void *)&nCounter, TRUE);
/* Return the length of the outputted string */
jx9_result_int64(pCtx, nCounter);
/* Release the container */
SySetRelease(&sArg);
return JX9_OK;
}
/*
* int vsprintf(string $format, array $args)
* Output a formatted string.
* Parameters
* $format
* See sprintf() for a description of format.
* Return
* A string produced according to the formatting string format.
*/
static int jx9Builtin_vsprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
jx9_hashmap *pMap;
SySet sArg;
int nLen, n;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
/* Missing/Invalid arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Point to hashmap */
pMap = (jx9_hashmap *)apArg[1]->x.pOther;
/* Extract arguments from the hashmap */
n = jx9HashmapValuesToSet(pMap, &sArg);
/* Format the string */
jx9InputFormat(sprintfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), 0, TRUE);
/* Release the container */
SySetRelease(&sArg);
return JX9_OK;
}
/*
* string size_format(int64 $size)
* Return a smart string represenation of the given size [i.e: 64-bit integer]
* Example:
* print size_format(1*1024*1024*1024);// 1GB
* print size_format(512*1024*1024); // 512 MB
* print size_format(file_size(/path/to/my/file_8192)); //8KB
* Parameter
* $size
* Entity size in bytes.
* Return
* Formatted string representation of the given size.
*/
static int jx9Builtin_size_format(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
/*Kilo*/ /*Mega*/ /*Giga*/ /*Tera*/ /*Peta*/ /*Exa*/ /*Zeta*/
static const char zUnit[] = {"KMGTPEZ"};
sxi32 nRest, i_32;
jx9_int64 iSize;
int c = -1; /* index in zUnit[] */
if( nArg < 1 ){
/* Missing argument, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the given size */
iSize = jx9_value_to_int64(apArg[0]);
if( iSize < 100 /* Bytes */ ){
/* Don't bother formatting, return immediately */
jx9_result_string(pCtx, "0.1 KB", (int)sizeof("0.1 KB")-1);
return JX9_OK;
}
for(;;){
nRest = (sxi32)(iSize & 0x3FF);
iSize >>= 10;
c++;
if( (iSize & (~0 ^ 1023)) == 0 ){
break;
}
}
nRest /= 100;
if( nRest > 9 ){
nRest = 9;
}
if( iSize > 999 ){
c++;
nRest = 9;
iSize = 0;
}
i_32 = (sxi32)iSize;
/* Format */
jx9_result_string_format(pCtx, "%d.%d %cB", i_32, nRest, zUnit[c]);
return JX9_OK;
}
#if !defined(JX9_DISABLE_HASH_FUNC)
/*
* string md5(string $str[, bool $raw_output = false])
* Calculate the md5 hash of a string.
* Parameter
* $str
* Input string
* $raw_output
* If the optional raw_output is set to TRUE, then the md5 digest
* is instead returned in raw binary format with a length of 16.
* Return
* MD5 Hash as a 32-character hexadecimal string.
*/
static int jx9Builtin_md5(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
unsigned char zDigest[16];
int raw_output = FALSE;
const void *pIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the input string */
pIn = (const void *)jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
if( nArg > 1 && jx9_value_is_bool(apArg[1])){
raw_output = jx9_value_to_bool(apArg[1]);
}
/* Compute the MD5 digest */
SyMD5Compute(pIn, (sxu32)nLen, zDigest);
if( raw_output ){
/* Output raw digest */
jx9_result_string(pCtx, (const char *)zDigest, (int)sizeof(zDigest));
}else{
/* Perform a binary to hex conversion */
SyBinToHexConsumer((const void *)zDigest, sizeof(zDigest), HashConsumer, pCtx);
}
return JX9_OK;
}
/*
* string sha1(string $str[, bool $raw_output = false])
* Calculate the sha1 hash of a string.
* Parameter
* $str
* Input string
* $raw_output
* If the optional raw_output is set to TRUE, then the md5 digest
* is instead returned in raw binary format with a length of 16.
* Return
* SHA1 Hash as a 40-character hexadecimal string.
*/
static int jx9Builtin_sha1(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
unsigned char zDigest[20];
int raw_output = FALSE;
const void *pIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the input string */
pIn = (const void *)jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
if( nArg > 1 && jx9_value_is_bool(apArg[1])){
raw_output = jx9_value_to_bool(apArg[1]);
}
/* Compute the SHA1 digest */
SySha1Compute(pIn, (sxu32)nLen, zDigest);
if( raw_output ){
/* Output raw digest */
jx9_result_string(pCtx, (const char *)zDigest, (int)sizeof(zDigest));
}else{
/* Perform a binary to hex conversion */
SyBinToHexConsumer((const void *)zDigest, sizeof(zDigest), HashConsumer, pCtx);
}
return JX9_OK;
}
/*
* int64 crc32(string $str)
* Calculates the crc32 polynomial of a strin.
* Parameter
* $str
* Input string
* Return
* CRC32 checksum of the given input (64-bit integer).
*/
static int jx9Builtin_crc32(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const void *pIn;
sxu32 nCRC;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the input string */
pIn = (const void *)jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty string */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Calculate the sum */
nCRC = SyCrc32(pIn, (sxu32)nLen);
/* Return the CRC32 as 64-bit integer */
jx9_result_int64(pCtx, (jx9_int64)nCRC^ 0xFFFFFFFF);
return JX9_OK;
}
#endif /* JX9_DISABLE_HASH_FUNC */
/*
* Parse a CSV string and invoke the supplied callback for each processed xhunk.
*/
JX9_PRIVATE sxi32 jx9ProcessCsv(
const char *zInput, /* Raw input */
int nByte, /* Input length */
int delim, /* Delimiter */
int encl, /* Enclosure */
int escape, /* Escape character */
sxi32 (*xConsumer)(const char *, int, void *), /* User callback */
void *pUserData /* Last argument to xConsumer() */
)
{
const char *zEnd = &zInput[nByte];
const char *zIn = zInput;
const char *zPtr;
int isEnc;
/* Start processing */
for(;;){
if( zIn >= zEnd ){
/* No more input to process */
break;
}
isEnc = 0;
zPtr = zIn;
/* Find the first delimiter */
while( zIn < zEnd ){
if( zIn[0] == delim && !isEnc){
/* Delimiter found, break imediately */
break;
}else if( zIn[0] == encl ){
/* Inside enclosure? */
isEnc = !isEnc;
}else if( zIn[0] == escape ){
/* Escape sequence */
zIn++;
}
/* Advance the cursor */
zIn++;
}
if( zIn > zPtr ){
int nByte = (int)(zIn-zPtr);
sxi32 rc;
/* Invoke the supllied callback */
if( zPtr[0] == encl ){
zPtr++;
nByte-=2;
}
if( nByte > 0 ){
rc = xConsumer(zPtr, nByte, pUserData);
if( rc == SXERR_ABORT ){
/* User callback request an operation abort */
break;
}
}
}
/* Ignore trailing delimiter */
while( zIn < zEnd && zIn[0] == delim ){
zIn++;
}
}
return SXRET_OK;
}
/*
* Default consumer callback for the CSV parsing routine defined above.
* All the processed input is insereted into an array passed as the last
* argument to this callback.
*/
JX9_PRIVATE sxi32 jx9CsvConsumer(const char *zToken, int nTokenLen, void *pUserData)
{
jx9_value *pArray = (jx9_value *)pUserData;
jx9_value sEntry;
SyString sToken;
/* Insert the token in the given array */
SyStringInitFromBuf(&sToken, zToken, nTokenLen);
/* Remove trailing and leading white spcaces and null bytes */
SyStringFullTrimSafe(&sToken);
if( sToken.nByte < 1){
return SXRET_OK;
}
jx9MemObjInitFromString(pArray->pVm, &sEntry, &sToken);
jx9_array_add_elem(pArray, 0, &sEntry);
jx9MemObjRelease(&sEntry);
return SXRET_OK;
}
/*
* array str_getcsv(string $input[, string $delimiter = ', '[, string $enclosure = '"' [, string $escape='\\']]])
* Parse a CSV string into an array.
* Parameters
* $input
* The string to parse.
* $delimiter
* Set the field delimiter (one character only).
* $enclosure
* Set the field enclosure character (one character only).
* $escape
* Set the escape character (one character only). Defaults as a backslash (\)
* Return
* An indexed array containing the CSV fields or NULL on failure.
*/
static int jx9Builtin_str_getcsv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zInput, *zPtr;
jx9_value *pArray;
int delim = ','; /* Delimiter */
int encl = '"' ; /* Enclosure */
int escape = '\\'; /* Escape character */
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the raw input */
zInput = jx9_value_to_string(apArg[0], &nLen);
if( nArg > 1 ){
int i;
if( jx9_value_is_string(apArg[1]) ){
/* Extract the delimiter */
zPtr = jx9_value_to_string(apArg[1], &i);
if( i > 0 ){
delim = zPtr[0];
}
}
if( nArg > 2 ){
if( jx9_value_is_string(apArg[2]) ){
/* Extract the enclosure */
zPtr = jx9_value_to_string(apArg[2], &i);
if( i > 0 ){
encl = zPtr[0];
}
}
if( nArg > 3 ){
if( jx9_value_is_string(apArg[3]) ){
/* Extract the escape character */
zPtr = jx9_value_to_string(apArg[3], &i);
if( i > 0 ){
escape = zPtr[0];
}
}
}
}
}
/* Create our array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_null(pCtx);
return JX9_OK;
}
/* Parse the raw input */
jx9ProcessCsv(zInput, nLen, delim, encl, escape, jx9CsvConsumer, pArray);
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* Extract a tag name from a raw HTML input and insert it in the given
* container.
* Refer to [strip_tags()].
*/
static sxi32 AddTag(SySet *pSet, const char *zTag, int nByte)
{
const char *zEnd = &zTag[nByte];
const char *zPtr;
SyString sEntry;
/* Strip tags */
for(;;){
while( zTag < zEnd && (zTag[0] == '<' || zTag[0] == '/' || zTag[0] == '?'
|| zTag[0] == '!' || zTag[0] == '-' || ((unsigned char)zTag[0] < 0xc0 && SyisSpace(zTag[0]))) ){
zTag++;
}
if( zTag >= zEnd ){
break;
}
zPtr = zTag;
/* Delimit the tag */
while(zTag < zEnd ){
if( (unsigned char)zTag[0] >= 0xc0 ){
/* UTF-8 stream */
zTag++;
SX_JMP_UTF8(zTag, zEnd);
}else if( !SyisAlphaNum(zTag[0]) ){
break;
}else{
zTag++;
}
}
if( zTag > zPtr ){
/* Perform the insertion */
SyStringInitFromBuf(&sEntry, zPtr, (int)(zTag-zPtr));
SyStringFullTrim(&sEntry);
SySetPut(pSet, (const void *)&sEntry);
}
/* Jump the trailing '>' */
zTag++;
}
return SXRET_OK;
}
/*
* Check if the given HTML tag name is present in the given container.
* Return SXRET_OK if present.SXERR_NOTFOUND otherwise.
* Refer to [strip_tags()].
*/
static sxi32 FindTag(SySet *pSet, const char *zTag, int nByte)
{
if( SySetUsed(pSet) > 0 ){
const char *zCur, *zEnd = &zTag[nByte];
SyString sTag;
while( zTag < zEnd && (zTag[0] == '<' || zTag[0] == '/' || zTag[0] == '?' ||
((unsigned char)zTag[0] < 0xc0 && SyisSpace(zTag[0]))) ){
zTag++;
}
/* Delimit the tag */
zCur = zTag;
while(zTag < zEnd ){
if( (unsigned char)zTag[0] >= 0xc0 ){
/* UTF-8 stream */
zTag++;
SX_JMP_UTF8(zTag, zEnd);
}else if( !SyisAlphaNum(zTag[0]) ){
break;
}else{
zTag++;
}
}
SyStringInitFromBuf(&sTag, zCur, zTag-zCur);
/* Trim leading white spaces and null bytes */
SyStringLeftTrimSafe(&sTag);
if( sTag.nByte > 0 ){
SyString *aEntry, *pEntry;
sxi32 rc;
sxu32 n;
/* Perform the lookup */
aEntry = (SyString *)SySetBasePtr(pSet);
for( n = 0 ; n < SySetUsed(pSet) ; ++n ){
pEntry = &aEntry[n];
/* Do the comparison */
rc = SyStringCmp(pEntry, &sTag, SyStrnicmp);
if( !rc ){
return SXRET_OK;
}
}
}
}
/* No such tag */
return SXERR_NOTFOUND;
}
/*
* This function tries to return a string [i.e: in the call context result buffer]
* with all NUL bytes, HTML and JX9 tags stripped from a given string.
* Refer to [strip_tags()].
*/
JX9_PRIVATE sxi32 jx9StripTagsFromString(jx9_context *pCtx, const char *zIn, int nByte, const char *zTaglist, int nTaglen)
{
const char *zEnd = &zIn[nByte];
const char *zPtr, *zTag;
SySet sSet;
/* initialize the set of allowed tags */
SySetInit(&sSet, &pCtx->pVm->sAllocator, sizeof(SyString));
if( nTaglen > 0 ){
/* Set of allowed tags */
AddTag(&sSet, zTaglist, nTaglen);
}
/* Set the empty string */
jx9_result_string(pCtx, "", 0);
/* Start processing */
for(;;){
if(zIn >= zEnd){
/* No more input to process */
break;
}
zPtr = zIn;
/* Find a tag */
while( zIn < zEnd && zIn[0] != '<' && zIn[0] != 0 /* NUL byte */ ){
zIn++;
}
if( zIn > zPtr ){
/* Consume raw input */
jx9_result_string(pCtx, zPtr, (int)(zIn-zPtr));
}
/* Ignore trailing null bytes */
while( zIn < zEnd && zIn[0] == 0 ){
zIn++;
}
if(zIn >= zEnd){
/* No more input to process */
break;
}
if( zIn[0] == '<' ){
sxi32 rc;
zTag = zIn++;
/* Delimit the tag */
while( zIn < zEnd && zIn[0] != '>' ){
zIn++;
}
if( zIn < zEnd ){
zIn++; /* Ignore the trailing closing tag */
}
/* Query the set */
rc = FindTag(&sSet, zTag, (int)(zIn-zTag));
if( rc == SXRET_OK ){
/* Keep the tag */
jx9_result_string(pCtx, zTag, (int)(zIn-zTag));
}
}
}
/* Cleanup */
SySetRelease(&sSet);
return SXRET_OK;
}
/*
* string strip_tags(string $str[, string $allowable_tags])
* Strip HTML and JX9 tags from a string.
* Parameters
* $str
* The input string.
* $allowable_tags
* You can use the optional second parameter to specify tags which should not be stripped.
* Return
* Returns the stripped string.
*/
static int jx9Builtin_strip_tags(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zTaglist = 0;
const char *zString;
int nTaglen = 0;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Point to the raw string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nArg > 1 && jx9_value_is_string(apArg[1]) ){
/* Allowed tag */
zTaglist = jx9_value_to_string(apArg[1], &nTaglen);
}
/* Process input */
jx9StripTagsFromString(pCtx, zString, nLen, zTaglist, nTaglen);
return JX9_OK;
}
/*
* array str_split(string $string[, int $split_length = 1 ])
* Convert a string to an array.
* Parameters
* $str
* The input string.
* $split_length
* Maximum length of the chunk.
* Return
* If the optional split_length parameter is specified, the returned array
* will be broken down into chunks with each being split_length in length, otherwise
* each chunk will be one character in length. FALSE is returned if split_length is less than 1.
* If the split_length length exceeds the length of string, the entire string is returned
* as the first (and only) array element.
*/
static int jx9Builtin_str_split(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zEnd;
jx9_value *pArray, *pValue;
int split_len;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target string */
zString = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
split_len = (int)sizeof(char);
if( nArg > 1 ){
/* Split length */
split_len = jx9_value_to_int(apArg[1]);
if( split_len < 1 ){
/* Invalid length, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( split_len > nLen ){
split_len = nLen;
}
}
/* Create the array and the scalar value */
pArray = jx9_context_new_array(pCtx);
/*Chunk value */
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 || pArray == 0 ){
/* Return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the end of the string */
zEnd = &zString[nLen];
/* Perform the requested operation */
for(;;){
int nMax;
if( zString >= zEnd ){
/* No more input to process */
break;
}
nMax = (int)(zEnd-zString);
if( nMax < split_len ){
split_len = nMax;
}
/* Copy the current chunk */
jx9_value_string(pValue, zString, split_len);
/* Insert it */
jx9_array_add_elem(pArray, 0, pValue); /* Will make it's own copy */
/* reset the string cursor */
jx9_value_reset_string_cursor(pValue);
/* Update position */
zString += split_len;
}
/*
* Return the array.
* Don't worry about freeing memory, everything will be automatically released
* upon we return from this function.
*/
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* Tokenize a raw string and extract the first non-space token.
* Refer to [strspn()].
*/
static sxi32 ExtractNonSpaceToken(const char **pzIn, const char *zEnd, SyString *pOut)
{
const char *zIn = *pzIn;
const char *zPtr;
/* Ignore leading white spaces */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
zIn++;
}
if( zIn >= zEnd ){
/* End of input */
return SXERR_EOF;
}
zPtr = zIn;
/* Extract the token */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && !SyisSpace(zIn[0]) ){
zIn++;
}
SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
/* Synchronize pointers */
*pzIn = zIn;
/* Return to the caller */
return SXRET_OK;
}
/*
* Check if the given string contains only characters from the given mask.
* return the longest match.
* Refer to [strspn()].
*/
static int LongestStringMask(const char *zString, int nLen, const char *zMask, int nMaskLen)
{
const char *zEnd = &zString[nLen];
const char *zIn = zString;
int i, c;
for(;;){
if( zString >= zEnd ){
break;
}
/* Extract current character */
c = zString[0];
/* Perform the lookup */
for( i = 0 ; i < nMaskLen ; i++ ){
if( c == zMask[i] ){
/* Character found */
break;
}
}
if( i >= nMaskLen ){
/* Character not in the current mask, break immediately */
break;
}
/* Advance cursor */
zString++;
}
/* Longest match */
return (int)(zString-zIn);
}
/*
* Do the reverse operation of the previous function [i.e: LongestStringMask()].
* Refer to [strcspn()].
*/
static int LongestStringMask2(const char *zString, int nLen, const char *zMask, int nMaskLen)
{
const char *zEnd = &zString[nLen];
const char *zIn = zString;
int i, c;
for(;;){
if( zString >= zEnd ){
break;
}
/* Extract current character */
c = zString[0];
/* Perform the lookup */
for( i = 0 ; i < nMaskLen ; i++ ){
if( c == zMask[i] ){
break;
}
}
if( i < nMaskLen ){
/* Character in the current mask, break immediately */
break;
}
/* Advance cursor */
zString++;
}
/* Longest match */
return (int)(zString-zIn);
}
/*
* int strspn(string $str, string $mask[, int $start[, int $length]])
* Finds the length of the initial segment of a string consisting entirely
* of characters contained within a given mask.
* Parameters
* $str
* The input string.
* $mask
* The list of allowable characters.
* $start
* The position in subject to start searching.
* If start is given and is non-negative, then strspn() will begin examining
* subject at the start'th position. For instance, in the string 'abcdef', the character
* at position 0 is 'a', the character at position 2 is 'c', and so forth.
* If start is given and is negative, then strspn() will begin examining subject at the
* start'th position from the end of subject.
* $length
* The length of the segment from subject to examine.
* If length is given and is non-negative, then subject will be examined for length
* characters after the starting position.
* If lengthis given and is negative, then subject will be examined from the starting
* position up to length characters from the end of subject.
* Return
* Returns the length of the initial segment of subject which consists entirely of characters
* in mask.
*/
static int jx9Builtin_strspn(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zMask, *zEnd;
int iMasklen, iLen;
SyString sToken;
int iCount = 0;
int rc;
if( nArg < 2 ){
/* Missing agruments, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &iLen);
/* Extract the mask */
zMask = jx9_value_to_string(apArg[1], &iMasklen);
if( iLen < 1 || iMasklen < 1 ){
/* Nothing to process, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( nArg > 2 ){
int nOfft;
/* Extract the offset */
nOfft = jx9_value_to_int(apArg[2]);
if( nOfft < 0 ){
const char *zBase = &zString[iLen + nOfft];
if( zBase > zString ){
iLen = (int)(&zString[iLen]-zBase);
zString = zBase;
}else{
/* Invalid offset */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
}else{
if( nOfft >= iLen ){
/* Invalid offset */
jx9_result_int(pCtx, 0);
return JX9_OK;
}else{
/* Update offset */
zString += nOfft;
iLen -= nOfft;
}
}
if( nArg > 3 ){
int iUserlen;
/* Extract the desired length */
iUserlen = jx9_value_to_int(apArg[3]);
if( iUserlen > 0 && iUserlen < iLen ){
iLen = iUserlen;
}
}
}
/* Point to the end of the string */
zEnd = &zString[iLen];
/* Extract the first non-space token */
rc = ExtractNonSpaceToken(&zString, zEnd, &sToken);
if( rc == SXRET_OK && sToken.nByte > 0 ){
/* Compare against the current mask */
iCount = LongestStringMask(sToken.zString, (int)sToken.nByte, zMask, iMasklen);
}
/* Longest match */
jx9_result_int(pCtx, iCount);
return JX9_OK;
}
/*
* int strcspn(string $str, string $mask[, int $start[, int $length]])
* Find length of initial segment not matching mask.
* Parameters
* $str
* The input string.
* $mask
* The list of not allowed characters.
* $start
* The position in subject to start searching.
* If start is given and is non-negative, then strspn() will begin examining
* subject at the start'th position. For instance, in the string 'abcdef', the character
* at position 0 is 'a', the character at position 2 is 'c', and so forth.
* If start is given and is negative, then strspn() will begin examining subject at the
* start'th position from the end of subject.
* $length
* The length of the segment from subject to examine.
* If length is given and is non-negative, then subject will be examined for length
* characters after the starting position.
* If lengthis given and is negative, then subject will be examined from the starting
* position up to length characters from the end of subject.
* Return
* Returns the length of the segment as an integer.
*/
static int jx9Builtin_strcspn(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zMask, *zEnd;
int iMasklen, iLen;
SyString sToken;
int iCount = 0;
int rc;
if( nArg < 2 ){
/* Missing agruments, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zString = jx9_value_to_string(apArg[0], &iLen);
/* Extract the mask */
zMask = jx9_value_to_string(apArg[1], &iMasklen);
if( iLen < 1 ){
/* Nothing to process, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( iMasklen < 1 ){
/* No given mask, return the string length */
jx9_result_int(pCtx, iLen);
return JX9_OK;
}
if( nArg > 2 ){
int nOfft;
/* Extract the offset */
nOfft = jx9_value_to_int(apArg[2]);
if( nOfft < 0 ){
const char *zBase = &zString[iLen + nOfft];
if( zBase > zString ){
iLen = (int)(&zString[iLen]-zBase);
zString = zBase;
}else{
/* Invalid offset */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
}else{
if( nOfft >= iLen ){
/* Invalid offset */
jx9_result_int(pCtx, 0);
return JX9_OK;
}else{
/* Update offset */
zString += nOfft;
iLen -= nOfft;
}
}
if( nArg > 3 ){
int iUserlen;
/* Extract the desired length */
iUserlen = jx9_value_to_int(apArg[3]);
if( iUserlen > 0 && iUserlen < iLen ){
iLen = iUserlen;
}
}
}
/* Point to the end of the string */
zEnd = &zString[iLen];
/* Extract the first non-space token */
rc = ExtractNonSpaceToken(&zString, zEnd, &sToken);
if( rc == SXRET_OK && sToken.nByte > 0 ){
/* Compare against the current mask */
iCount = LongestStringMask2(sToken.zString, (int)sToken.nByte, zMask, iMasklen);
}
/* Longest match */
jx9_result_int(pCtx, iCount);
return JX9_OK;
}
/*
* string strpbrk(string $haystack, string $char_list)
* Search a string for any of a set of characters.
* Parameters
* $haystack
* The string where char_list is looked for.
* $char_list
* This parameter is case sensitive.
* Return
* Returns a string starting from the character found, or FALSE if it is not found.
*/
static int jx9Builtin_strpbrk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zList, *zEnd;
int iLen, iListLen, i, c;
sxu32 nOfft, nMax;
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the haystack and the char list */
zString = jx9_value_to_string(apArg[0], &iLen);
zList = jx9_value_to_string(apArg[1], &iListLen);
if( iLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the end of the string */
zEnd = &zString[iLen];
nOfft = nMax = SXU32_HIGH;
/* perform the requested operation */
for( i = 0 ; i < iListLen ; i++ ){
c = zList[i];
rc = SyByteFind(zString, (sxu32)iLen, c, &nMax);
if( rc == SXRET_OK ){
if( nMax < nOfft ){
nOfft = nMax;
}
}
}
if( nOfft == SXU32_HIGH ){
/* No such substring, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return the substring */
jx9_result_string(pCtx, &zString[nOfft], (int)(zEnd-&zString[nOfft]));
}
return JX9_OK;
}
/*
* string soundex(string $str)
* Calculate the soundex key of a string.
* Parameters
* $str
* The input string.
* Return
* Returns the soundex key as a string.
* Note:
* This implementation is based on the one found in the SQLite3
* source tree.
*/
static int jx9Builtin_soundex(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn;
char zResult[8];
int i, j;
static const unsigned char iCode[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
};
if( nArg < 1 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
zIn = (unsigned char *)jx9_value_to_string(apArg[0], 0);
for(i=0; zIn[i] && zIn[i] < 0xc0 && !SyisAlpha(zIn[i]); i++){}
if( zIn[i] ){
unsigned char prevcode = iCode[zIn[i]&0x7f];
zResult[0] = (char)SyToUpper(zIn[i]);
for(j=1; j<4 && zIn[i]; i++){
int code = iCode[zIn[i]&0x7f];
if( code>0 ){
if( code!=prevcode ){
prevcode = (unsigned char)code;
zResult[j++] = (char)code + '0';
}
}else{
prevcode = 0;
}
}
while( j<4 ){
zResult[j++] = '0';
}
jx9_result_string(pCtx, zResult, 4);
}else{
jx9_result_string(pCtx, "?000", 4);
}
return JX9_OK;
}
/*
* string wordwrap(string $str[, int $width = 75[, string $break = "\n"]])
* Wraps a string to a given number of characters.
* Parameters
* $str
* The input string.
* $width
* The column width.
* $break
* The line is broken using the optional break parameter.
* Return
* Returns the given string wrapped at the specified column.
*/
static int jx9Builtin_wordwrap(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn, *zEnd, *zBreak;
int iLen, iBreaklen, iChunk;
if( nArg < 1 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the input string */
zIn = jx9_value_to_string(apArg[0], &iLen);
if( iLen < 1 ){
/* Nothing to process, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Chunk length */
iChunk = 75;
iBreaklen = 0;
zBreak = ""; /* cc warning */
if( nArg > 1 ){
iChunk = jx9_value_to_int(apArg[1]);
if( iChunk < 1 ){
iChunk = 75;
}
if( nArg > 2 ){
zBreak = jx9_value_to_string(apArg[2], &iBreaklen);
}
}
if( iBreaklen < 1 ){
/* Set a default column break */
#ifdef __WINNT__
zBreak = "\r\n";
iBreaklen = (int)sizeof("\r\n")-1;
#else
zBreak = "\n";
iBreaklen = (int)sizeof(char);
#endif
}
/* Perform the requested operation */
zEnd = &zIn[iLen];
for(;;){
int nMax;
if( zIn >= zEnd ){
/* No more input to process */
break;
}
nMax = (int)(zEnd-zIn);
if( iChunk > nMax ){
iChunk = nMax;
}
/* Append the column first */
jx9_result_string(pCtx, zIn, iChunk); /* Will make it's own copy */
/* Advance the cursor */
zIn += iChunk;
if( zIn < zEnd ){
/* Append the line break */
jx9_result_string(pCtx, zBreak, iBreaklen);
}
}
return JX9_OK;
}
/*
* Check if the given character is a member of the given mask.
* Return TRUE on success. FALSE otherwise.
* Refer to [strtok()].
*/
static int CheckMask(int c, const char *zMask, int nMasklen, int *pOfft)
{
int i;
for( i = 0 ; i < nMasklen ; ++i ){
if( c == zMask[i] ){
if( pOfft ){
*pOfft = i;
}
return TRUE;
}
}
return FALSE;
}
/*
* Extract a single token from the input stream.
* Refer to [strtok()].
*/
static sxi32 ExtractToken(const char **pzIn, const char *zEnd, const char *zMask, int nMasklen, SyString *pOut)
{
const char *zIn = *pzIn;
const char *zPtr;
/* Ignore leading delimiter */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && CheckMask(zIn[0], zMask, nMasklen, 0) ){
zIn++;
}
if( zIn >= zEnd ){
/* End of input */
return SXERR_EOF;
}
zPtr = zIn;
/* Extract the token */
while( zIn < zEnd ){
if( (unsigned char)zIn[0] >= 0xc0 ){
/* UTF-8 stream */
zIn++;
SX_JMP_UTF8(zIn, zEnd);
}else{
if( CheckMask(zIn[0], zMask, nMasklen, 0) ){
break;
}
zIn++;
}
}
SyStringInitFromBuf(pOut, zPtr, zIn-zPtr);
/* Update the cursor */
*pzIn = zIn;
/* Return to the caller */
return SXRET_OK;
}
/* strtok auxiliary private data */
typedef struct strtok_aux_data strtok_aux_data;
struct strtok_aux_data
{
const char *zDup; /* Complete duplicate of the input */
const char *zIn; /* Current input stream */
const char *zEnd; /* End of input */
};
/*
* string strtok(string $str, string $token)
* string strtok(string $token)
* strtok() splits a string (str) into smaller strings (tokens), with each token
* being delimited by any character from token. That is, if you have a string like
* "This is an example string" you could tokenize this string into its individual
* words by using the space character as the token.
* Note that only the first call to strtok uses the string argument. Every subsequent
* call to strtok only needs the token to use, as it keeps track of where it is in
* the current string. To start over, or to tokenize a new string you simply call strtok
* with the string argument again to initialize it. Note that you may put multiple tokens
* in the token parameter. The string will be tokenized when any one of the characters in
* the argument are found.
* Parameters
* $str
* The string being split up into smaller strings (tokens).
* $token
* The delimiter used when splitting up str.
* Return
* Current token or FALSE on EOF.
*/
static int jx9Builtin_strtok(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
strtok_aux_data *pAux;
const char *zMask;
SyString sToken;
int nMasklen;
sxi32 rc;
if( nArg < 2 ){
/* Extract top aux data */
pAux = (strtok_aux_data *)jx9_context_peek_aux_data(pCtx);
if( pAux == 0 ){
/* No aux data, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nMasklen = 0;
zMask = ""; /* cc warning */
if( nArg > 0 ){
/* Extract the mask */
zMask = jx9_value_to_string(apArg[0], &nMasklen);
}
if( nMasklen < 1 ){
/* Invalid mask, return FALSE */
jx9_context_free_chunk(pCtx, (void *)pAux->zDup);
jx9_context_free_chunk(pCtx, pAux);
(void)jx9_context_pop_aux_data(pCtx);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the token */
rc = ExtractToken(&pAux->zIn, pAux->zEnd, zMask, nMasklen, &sToken);
if( rc != SXRET_OK ){
/* EOF , discard the aux data */
jx9_context_free_chunk(pCtx, (void *)pAux->zDup);
jx9_context_free_chunk(pCtx, pAux);
(void)jx9_context_pop_aux_data(pCtx);
jx9_result_bool(pCtx, 0);
}else{
/* Return the extracted token */
jx9_result_string(pCtx, sToken.zString, (int)sToken.nByte);
}
}else{
const char *zInput, *zCur;
char *zDup;
int nLen;
/* Extract the raw input */
zCur = zInput = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Empty input, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the mask */
zMask = jx9_value_to_string(apArg[1], &nMasklen);
if( nMasklen < 1 ){
/* Set a default mask */
#define TOK_MASK " \n\t\r\f"
zMask = TOK_MASK;
nMasklen = (int)sizeof(TOK_MASK) - 1;
#undef TOK_MASK
}
/* Extract a single token */
rc = ExtractToken(&zInput, &zInput[nLen], zMask, nMasklen, &sToken);
if( rc != SXRET_OK ){
/* Empty input */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}else{
/* Return the extracted token */
jx9_result_string(pCtx, sToken.zString, (int)sToken.nByte);
}
/* Create our auxilliary data and copy the input */
pAux = (strtok_aux_data *)jx9_context_alloc_chunk(pCtx, sizeof(strtok_aux_data), TRUE, FALSE);
if( pAux ){
nLen -= (int)(zInput-zCur);
if( nLen < 1 ){
jx9_context_free_chunk(pCtx, pAux);
return JX9_OK;
}
/* Duplicate input */
zDup = (char *)jx9_context_alloc_chunk(pCtx, (unsigned int)(nLen+1), TRUE, FALSE);
if( zDup ){
SyMemcpy(zInput, zDup, (sxu32)nLen);
/* Register the aux data */
pAux->zDup = pAux->zIn = zDup;
pAux->zEnd = &zDup[nLen];
jx9_context_push_aux_data(pCtx, pAux);
}
}
}
return JX9_OK;
}
/*
* string str_pad(string $input, int $pad_length[, string $pad_string = " " [, int $pad_type = STR_PAD_RIGHT]])
* Pad a string to a certain length with another string
* Parameters
* $input
* The input string.
* $pad_length
* If the value of pad_length is negative, less than, or equal to the length of the input
* string, no padding takes place.
* $pad_string
* Note:
* The pad_string WIIL NOT BE truncated if the required number of padding characters can't be evenly
* divided by the pad_string's length.
* $pad_type
* Optional argument pad_type can be STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH. If pad_type
* is not specified it is assumed to be STR_PAD_RIGHT.
* Return
* The padded string.
*/
static int jx9Builtin_str_pad(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iLen, iPadlen, iType, i, iDiv, iStrpad, iRealPad, jPad;
const char *zIn, *zPad;
if( nArg < 2 ){
/* Missing arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract the target string */
zIn = jx9_value_to_string(apArg[0], &iLen);
/* Padding length */
iRealPad = iPadlen = jx9_value_to_int(apArg[1]);
if( iPadlen > 0 ){
iPadlen -= iLen;
}
if( iPadlen < 1 ){
/* Return the string verbatim */
jx9_result_string(pCtx, zIn, iLen);
return JX9_OK;
}
zPad = " "; /* Whitespace padding */
iStrpad = (int)sizeof(char);
iType = 1 ; /* STR_PAD_RIGHT */
if( nArg > 2 ){
/* Padding string */
zPad = jx9_value_to_string(apArg[2], &iStrpad);
if( iStrpad < 1 ){
/* Empty string */
zPad = " "; /* Whitespace padding */
iStrpad = (int)sizeof(char);
}
if( nArg > 3 ){
/* Padd type */
iType = jx9_value_to_int(apArg[3]);
if( iType != 0 /* STR_PAD_LEFT */ && iType != 2 /* STR_PAD_BOTH */ ){
iType = 1 ; /* STR_PAD_RIGHT */
}
}
}
iDiv = 1;
if( iType == 2 ){
iDiv = 2; /* STR_PAD_BOTH */
}
/* Perform the requested operation */
if( iType == 0 /* STR_PAD_LEFT */ || iType == 2 /* STR_PAD_BOTH */ ){
jPad = iStrpad;
for( i = 0 ; i < iPadlen/iDiv ; i += jPad ){
/* Padding */
if( (int)jx9_context_result_buf_length(pCtx) + iLen + jPad >= iRealPad ){
break;
}
jx9_result_string(pCtx, zPad, jPad);
}
if( iType == 0 /* STR_PAD_LEFT */ ){
while( (int)jx9_context_result_buf_length(pCtx) + iLen < iRealPad ){
jPad = iRealPad - (iLen + (int)jx9_context_result_buf_length(pCtx) );
if( jPad > iStrpad ){
jPad = iStrpad;
}
if( jPad < 1){
break;
}
jx9_result_string(pCtx, zPad, jPad);
}
}
}
if( iLen > 0 ){
/* Append the input string */
jx9_result_string(pCtx, zIn, iLen);
}
if( iType == 1 /* STR_PAD_RIGHT */ || iType == 2 /* STR_PAD_BOTH */ ){
for( i = 0 ; i < iPadlen/iDiv ; i += iStrpad ){
/* Padding */
if( (int)jx9_context_result_buf_length(pCtx) + iStrpad >= iRealPad ){
break;
}
jx9_result_string(pCtx, zPad, iStrpad);
}
while( (int)jx9_context_result_buf_length(pCtx) < iRealPad ){
jPad = iRealPad - (int)jx9_context_result_buf_length(pCtx);
if( jPad > iStrpad ){
jPad = iStrpad;
}
if( jPad < 1){
break;
}
jx9_result_string(pCtx, zPad, jPad);
}
}
return JX9_OK;
}
/*
* String replacement private data.
*/
typedef struct str_replace_data str_replace_data;
struct str_replace_data
{
/* The following two fields are only used by the strtr function */
SyBlob *pWorker; /* Working buffer */
ProcStringMatch xMatch; /* Pattern match routine */
/* The following two fields are only used by the str_replace function */
SySet *pCollector; /* Argument collector*/
jx9_context *pCtx; /* Call context */
};
/*
* Remove a substring.
*/
#define STRDEL(SRC, SLEN, OFFT, ILEN){\
for(;;){\
if( OFFT + ILEN >= SLEN ) break; SRC[OFFT] = SRC[OFFT+ILEN]; ++OFFT;\
}\
}
/*
* Shift right and insert algorithm.
*/
#define SHIFTRANDINSERT(SRC, LEN, OFFT, ENTRY, ELEN){\
sxu32 INLEN = LEN - OFFT;\
for(;;){\
if( LEN > 0 ){ LEN--; } if(INLEN < 1 ) break; SRC[LEN + ELEN] = SRC[LEN] ; --INLEN; \
}\
for(;;){\
if(ELEN < 1)break; SRC[OFFT] = ENTRY[0]; OFFT++; ENTRY++; --ELEN;\
}\
}
/*
* Replace all occurrences of the search string at offset (nOfft) with the given
* replacement string [i.e: zReplace].
*/
static int StringReplace(SyBlob *pWorker, sxu32 nOfft, int nLen, const char *zReplace, int nReplen)
{
char *zInput = (char *)SyBlobData(pWorker);
sxu32 n, m;
n = SyBlobLength(pWorker);
m = nOfft;
/* Delete the old entry */
STRDEL(zInput, n, m, nLen);
SyBlobLength(pWorker) -= nLen;
if( nReplen > 0 ){
sxi32 iRep = nReplen;
sxi32 rc;
/*
* Make sure the working buffer is big enough to hold the replacement
* string.
*/
rc = SyBlobAppend(pWorker, 0/* Grow without an append operation*/, (sxu32)nReplen);
if( rc != SXRET_OK ){
/* Simply ignore any memory failure problem */
return SXRET_OK;
}
/* Perform the insertion now */
zInput = (char *)SyBlobData(pWorker);
n = SyBlobLength(pWorker);
SHIFTRANDINSERT(zInput, n, nOfft, zReplace, iRep);
SyBlobLength(pWorker) += nReplen;
}
return SXRET_OK;
}
/*
* String replacement walker callback.
* The following callback is invoked for each array entry that hold
* the replace string.
* Refer to the strtr() implementation for more information.
*/
static int StringReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
str_replace_data *pRepData = (str_replace_data *)pUserData;
const char *zTarget, *zReplace;
SyBlob *pWorker;
int tLen, nLen;
sxu32 nOfft;
sxi32 rc;
/* Point to the working buffer */
pWorker = pRepData->pWorker;
if( !jx9_value_is_string(pKey) ){
/* Target and replace must be a string */
return JX9_OK;
}
/* Extract the target and the replace */
zTarget = jx9_value_to_string(pKey, &tLen);
if( tLen < 1 ){
/* Empty target, return immediately */
return JX9_OK;
}
/* Perform a pattern search */
rc = pRepData->xMatch(SyBlobData(pWorker), SyBlobLength(pWorker), (const void *)zTarget, (sxu32)tLen, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found */
return JX9_OK;
}
/* Extract the replace string */
zReplace = jx9_value_to_string(pData, &nLen);
/* Perform the replace process */
StringReplace(pWorker, nOfft, tLen, zReplace, nLen);
/* All done */
return JX9_OK;
}
/*
* The following walker callback is invoked by the str_rplace() function inorder
* to collect search/replace string.
* This callback is invoked only if the given argument is of type array.
*/
static int StrReplaceWalker(jx9_value *pKey, jx9_value *pData, void *pUserData)
{
str_replace_data *pRep = (str_replace_data *)pUserData;
SyString sWorker;
const char *zIn;
int nByte;
/* Extract a string representation of the given argument */
zIn = jx9_value_to_string(pData, &nByte);
SyStringInitFromBuf(&sWorker, 0, 0);
if( nByte > 0 ){
char *zDup;
/* Duplicate the chunk */
zDup = (char *)jx9_context_alloc_chunk(pRep->pCtx, (unsigned int)nByte, FALSE,
TRUE /* Release the chunk automatically, upon this context is destroyd */
);
if( zDup == 0 ){
/* Ignore any memory failure problem */
jx9_context_throw_error(pRep->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
return JX9_OK;
}
SyMemcpy(zIn, zDup, (sxu32)nByte);
/* Save the chunk */
SyStringInitFromBuf(&sWorker, zDup, nByte);
}
/* Save for later processing */
SySetPut(pRep->pCollector, (const void *)&sWorker);
/* All done */
SXUNUSED(pKey); /* cc warning */
return JX9_OK;
}
/*
* mixed str_replace(mixed $search, mixed $replace, mixed $subject[, int &$count ])
* mixed str_ireplace(mixed $search, mixed $replace, mixed $subject[, int &$count ])
* Replace all occurrences of the search string with the replacement string.
* Parameters
* If search and replace are arrays, then str_replace() takes a value from each
* array and uses them to search and replace on subject. If replace has fewer values
* than search, then an empty string is used for the rest of replacement values.
* If search is an array and replace is a string, then this replacement string is used
* for every value of search. The converse would not make sense, though.
* If search or replace are arrays, their elements are processed first to last.
* $search
* The value being searched for, otherwise known as the needle. An array may be used
* to designate multiple needles.
* $replace
* The replacement value that replaces found search values. An array may be used
* to designate multiple replacements.
* $subject
* The string or array being searched and replaced on, otherwise known as the haystack.
* If subject is an array, then the search and replace is performed with every entry
* of subject, and the return value is an array as well.
* $count (Not used)
* If passed, this will be set to the number of replacements performed.
* Return
* This function returns a string or an array with the replaced values.
*/
static int jx9Builtin_str_replace(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyString sTemp, *pSearch, *pReplace;
ProcStringMatch xMatch;
const char *zIn, *zFunc;
str_replace_data sRep;
SyBlob sWorker;
SySet sReplace;
SySet sSearch;
int rep_str;
int nByte;
sxi32 rc;
if( nArg < 3 ){
/* Missing/Invalid arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Initialize fields */
SySetInit(&sSearch, &pCtx->pVm->sAllocator, sizeof(SyString));
SySetInit(&sReplace, &pCtx->pVm->sAllocator, sizeof(SyString));
SyBlobInit(&sWorker, &pCtx->pVm->sAllocator);
SyZero(&sRep, sizeof(str_replace_data));
sRep.pCtx = pCtx;
sRep.pCollector = &sSearch;
rep_str = 0;
/* Extract the subject */
zIn = jx9_value_to_string(apArg[2], &nByte);
if( nByte < 1 ){
/* Nothing to replace, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Copy the subject */
SyBlobAppend(&sWorker, (const void *)zIn, (sxu32)nByte);
/* Search string */
if( jx9_value_is_json_array(apArg[0]) ){
/* Collect search string */
jx9_array_walk(apArg[0], StrReplaceWalker, &sRep);
}else{
/* Single pattern */
zIn = jx9_value_to_string(apArg[0], &nByte);
if( nByte < 1 ){
/* Return the subject untouched since no search string is available */
jx9_result_value(pCtx, apArg[2]/* Subject as thrird argument*/);
return JX9_OK;
}
SyStringInitFromBuf(&sTemp, zIn, nByte);
/* Save for later processing */
SySetPut(&sSearch, (const void *)&sTemp);
}
/* Replace string */
if( jx9_value_is_json_array(apArg[1]) ){
/* Collect replace string */
sRep.pCollector = &sReplace;
jx9_array_walk(apArg[1], StrReplaceWalker, &sRep);
}else{
/* Single needle */
zIn = jx9_value_to_string(apArg[1], &nByte);
rep_str = 1;
SyStringInitFromBuf(&sTemp, zIn, nByte);
/* Save for later processing */
SySetPut(&sReplace, (const void *)&sTemp);
}
/* Reset loop cursors */
SySetResetCursor(&sSearch);
SySetResetCursor(&sReplace);
pReplace = pSearch = 0; /* cc warning */
SyStringInitFromBuf(&sTemp, "", 0);
/* Extract function name */
zFunc = jx9_function_name(pCtx);
/* Set the default pattern match routine */
xMatch = SyBlobSearch;
if( SyStrncmp(zFunc, "str_ireplace", sizeof("str_ireplace") - 1) == 0 ){
/* Case insensitive pattern match */
xMatch = iPatternMatch;
}
/* Start the replace process */
while( SXRET_OK == SySetGetNextEntry(&sSearch, (void **)&pSearch) ){
sxu32 nCount, nOfft;
if( pSearch->nByte < 1 ){
/* Empty string, ignore */
continue;
}
/* Extract the replace string */
if( rep_str ){
pReplace = (SyString *)SySetPeek(&sReplace);
}else{
if( SXRET_OK != SySetGetNextEntry(&sReplace, (void **)&pReplace) ){
/* Sepecial case when 'replace set' has fewer values than the search set.
* An empty string is used for the rest of replacement values
*/
pReplace = 0;
}
}
if( pReplace == 0 ){
/* Use an empty string instead */
pReplace = &sTemp;
}
nOfft = nCount = 0;
for(;;){
if( nCount >= SyBlobLength(&sWorker) ){
break;
}
/* Perform a pattern lookup */
rc = xMatch(SyBlobDataAt(&sWorker, nCount), SyBlobLength(&sWorker) - nCount, (const void *)pSearch->zString,
pSearch->nByte, &nOfft);
if( rc != SXRET_OK ){
/* Pattern not found */
break;
}
/* Perform the replace operation */
StringReplace(&sWorker, nCount+nOfft, (int)pSearch->nByte, pReplace->zString, (int)pReplace->nByte);
/* Increment offset counter */
nCount += nOfft + pReplace->nByte;
}
}
/* All done, clean-up the mess left behind */
jx9_result_string(pCtx, (const char *)SyBlobData(&sWorker), (int)SyBlobLength(&sWorker));
SySetRelease(&sSearch);
SySetRelease(&sReplace);
SyBlobRelease(&sWorker);
return JX9_OK;
}
/*
* string strtr(string $str, string $from, string $to)
* string strtr(string $str, array $replace_pairs)
* Translate characters or replace substrings.
* Parameters
* $str
* The string being translated.
* $from
* The string being translated to to.
* $to
* The string replacing from.
* $replace_pairs
* The replace_pairs parameter may be used instead of to and
* from, in which case it's an array in the form array('from' => 'to', ...).
* Return
* The translated string.
* If replace_pairs contains a key which is an empty string (""), FALSE will be returned.
*/
static int jx9Builtin_strtr(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen;
if( nArg < 1 ){
/* Nothing to replace, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 || nArg < 2 ){
/* Invalid arguments */
jx9_result_string(pCtx, zIn, nLen);
return JX9_OK;
}
if( nArg == 2 && jx9_value_is_json_array(apArg[1]) ){
str_replace_data sRepData;
SyBlob sWorker;
/* Initilaize the working buffer */
SyBlobInit(&sWorker, &pCtx->pVm->sAllocator);
/* Copy raw string */
SyBlobAppend(&sWorker, (const void *)zIn, (sxu32)nLen);
/* Init our replace data instance */
sRepData.pWorker = &sWorker;
sRepData.xMatch = SyBlobSearch;
/* Iterate throw array entries and perform the replace operation.*/
jx9_array_walk(apArg[1], StringReplaceWalker, &sRepData);
/* All done, return the result string */
jx9_result_string(pCtx, (const char *)SyBlobData(&sWorker),
(int)SyBlobLength(&sWorker)); /* Will make it's own copy */
/* Clean-up */
SyBlobRelease(&sWorker);
}else{
int i, flen, tlen, c, iOfft;
const char *zFrom, *zTo;
if( nArg < 3 ){
/* Nothing to replace */
jx9_result_string(pCtx, zIn, nLen);
return JX9_OK;
}
/* Extract given arguments */
zFrom = jx9_value_to_string(apArg[1], &flen);
zTo = jx9_value_to_string(apArg[2], &tlen);
if( flen < 1 || tlen < 1 ){
/* Nothing to replace */
jx9_result_string(pCtx, zIn, nLen);
return JX9_OK;
}
/* Start the replace process */
for( i = 0 ; i < nLen ; ++i ){
c = zIn[i];
if( CheckMask(c, zFrom, flen, &iOfft) ){
if ( iOfft < tlen ){
c = zTo[iOfft];
}
}
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
}
}
return JX9_OK;
}
/*
* Parse an INI string.
* According to wikipedia
* The INI file format is an informal standard for configuration files for some platforms or software.
* INI files are simple text files with a basic structure composed of "sections" and "properties".
* Format
* Properties
* The basic element contained in an INI file is the property. Every property has a name and a value
* delimited by an equals sign (=). The name appears to the left of the equals sign.
* Example:
* name=value
* Sections
* Properties may be grouped into arbitrarily named sections. The section name appears on a line by itself
* in square brackets ([ and ]). All properties after the section declaration are associated with that section.
* There is no explicit "end of section" delimiter; sections end at the next section declaration
* or the end of the file. Sections may not be nested.
* Example:
* [section]
* Comments
* Semicolons (;) at the beginning of the line indicate a comment. Comment lines are ignored.
* This function return an array holding parsed values on success.FALSE otherwise.
*/
JX9_PRIVATE sxi32 jx9ParseIniString(jx9_context *pCtx, const char *zIn, sxu32 nByte, int bProcessSection)
{
jx9_value *pCur, *pArray, *pSection, *pWorker, *pValue;
const char *zCur, *zEnd = &zIn[nByte];
SyHashEntry *pEntry;
SyString sEntry;
SyHash sHash;
int c;
/* Create an empty array and worker variables */
pArray = jx9_context_new_array(pCtx);
pWorker = jx9_context_new_scalar(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pWorker == 0 || pValue == 0){
/* Out of memory */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
/* Return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
SyHashInit(&sHash, &pCtx->pVm->sAllocator, 0, 0);
pCur = pArray;
/* Start the parse process */
for(;;){
/* Ignore leading white spaces */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0])){
zIn++;
}
if( zIn >= zEnd ){
/* No more input to process */
break;
}
if( zIn[0] == ';' || zIn[0] == '#' ){
/* Comment til the end of line */
zIn++;
while(zIn < zEnd && zIn[0] != '\n' ){
zIn++;
}
continue;
}
/* Reset the string cursor of the working variable */
jx9_value_reset_string_cursor(pWorker);
if( zIn[0] == '[' ){
/* Section: Extract the section name */
zIn++;
zCur = zIn;
while( zIn < zEnd && zIn[0] != ']' ){
zIn++;
}
if( zIn > zCur && bProcessSection ){
/* Save the section name */
SyStringInitFromBuf(&sEntry, zCur, (int)(zIn-zCur));
SyStringFullTrim(&sEntry);
jx9_value_string(pWorker, sEntry.zString, (int)sEntry.nByte);
if( sEntry.nByte > 0 ){
/* Associate an array with the section */
pSection = jx9_context_new_array(pCtx);
if( pSection ){
jx9_array_add_elem(pArray, pWorker/*Section name*/, pSection);
pCur = pSection;
}
}
}
zIn++; /* Trailing square brackets ']' */
}else{
jx9_value *pOldCur;
int is_array;
int iLen;
/* Properties */
is_array = 0;
zCur = zIn;
iLen = 0; /* cc warning */
pOldCur = pCur;
while( zIn < zEnd && zIn[0] != '=' ){
if( zIn[0] == '[' && !is_array ){
/* Array */
iLen = (int)(zIn-zCur);
is_array = 1;
if( iLen > 0 ){
jx9_value *pvArr = 0; /* cc warning */
/* Query the hashtable */
SyStringInitFromBuf(&sEntry, zCur, iLen);
SyStringFullTrim(&sEntry);
pEntry = SyHashGet(&sHash, (const void *)sEntry.zString, sEntry.nByte);
if( pEntry ){
pvArr = (jx9_value *)SyHashEntryGetUserData(pEntry);
}else{
/* Create an empty array */
pvArr = jx9_context_new_array(pCtx);
if( pvArr ){
/* Save the entry */
SyHashInsert(&sHash, (const void *)sEntry.zString, sEntry.nByte, pvArr);
/* Insert the entry */
jx9_value_reset_string_cursor(pWorker);
jx9_value_string(pWorker, sEntry.zString, (int)sEntry.nByte);
jx9_array_add_elem(pCur, pWorker, pvArr);
jx9_value_reset_string_cursor(pWorker);
}
}
if( pvArr ){
pCur = pvArr;
}
}
while ( zIn < zEnd && zIn[0] != ']' ){
zIn++;
}
}
zIn++;
}
if( !is_array ){
iLen = (int)(zIn-zCur);
}
/* Trim the key */
SyStringInitFromBuf(&sEntry, zCur, iLen);
SyStringFullTrim(&sEntry);
if( sEntry.nByte > 0 ){
if( !is_array ){
/* Save the key name */
jx9_value_string(pWorker, sEntry.zString, (int)sEntry.nByte);
}
/* extract key value */
jx9_value_reset_string_cursor(pValue);
zIn++; /* '=' */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
zIn++;
}
if( zIn < zEnd ){
zCur = zIn;
c = zIn[0];
if( c == '"' || c == '\'' ){
zIn++;
/* Delimit the value */
while( zIn < zEnd ){
if ( zIn[0] == c && zIn[-1] != '\\' ){
break;
}
zIn++;
}
if( zIn < zEnd ){
zIn++;
}
}else{
while( zIn < zEnd ){
if( zIn[0] == '\n' ){
if( zIn[-1] != '\\' ){
break;
}
}else if( zIn[0] == ';' || zIn[0] == '#' ){
/* Inline comments */
break;
}
zIn++;
}
}
/* Trim the value */
SyStringInitFromBuf(&sEntry, zCur, (int)(zIn-zCur));
SyStringFullTrim(&sEntry);
if( c == '"' || c == '\'' ){
SyStringTrimLeadingChar(&sEntry, c);
SyStringTrimTrailingChar(&sEntry, c);
}
if( sEntry.nByte > 0 ){
jx9_value_string(pValue, sEntry.zString, (int)sEntry.nByte);
}
/* Insert the key and it's value */
jx9_array_add_elem(pCur, is_array ? 0 /*Automatic index assign */: pWorker, pValue);
}
}else{
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && ( SyisSpace(zIn[0]) || zIn[0] == '=' ) ){
zIn++;
}
}
pCur = pOldCur;
}
}
SyHashRelease(&sHash);
/* Return the parse of the INI string */
jx9_result_value(pCtx, pArray);
return SXRET_OK;
}
/*
* array parse_ini_string(string $ini[, bool $process_sections = false[, int $scanner_mode = INI_SCANNER_NORMAL ]])
* Parse a configuration string.
* Parameters
* $ini
* The contents of the ini file being parsed.
* $process_sections
* By setting the process_sections parameter to TRUE, you get a multidimensional array, with the section names
* and settings included. The default for process_sections is FALSE.
* $scanner_mode (Not used)
* Can either be INI_SCANNER_NORMAL (default) or INI_SCANNER_RAW. If INI_SCANNER_RAW is supplied
* then option values will not be parsed.
* Return
* The settings are returned as an associative array on success, and FALSE on failure.
*/
static int jx9Builtin_parse_ini_string(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIni;
int nByte;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE*/
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the raw INI buffer */
zIni = jx9_value_to_string(apArg[0], &nByte);
/* Process the INI buffer*/
jx9ParseIniString(pCtx, zIni, (sxu32)nByte, (nArg > 1) ? jx9_value_to_bool(apArg[1]) : 0);
return JX9_OK;
}
/*
* Ctype Functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* bool ctype_alnum(string $text)
* Checks if all of the characters in the provided string, text, are alphanumeric.
* Parameters
* $text
* The tested string.
* Return
* TRUE if every character in text is either a letter or a digit, FALSE otherwise.
*/
static int jx9Builtin_ctype_alnum(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( !SyisAlphaNum(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_alpha(string $text)
* Checks if all of the characters in the provided string, text, are alphabetic.
* Parameters
* $text
* The tested string.
* Return
* TRUE if every character in text is a letter from the current locale, FALSE otherwise.
*/
static int jx9Builtin_ctype_alpha(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( !SyisAlpha(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_cntrl(string $text)
* Checks if all of the characters in the provided string, text, are control characters.
* Parameters
* $text
* The tested string.
* Return
* TRUE if every character in text is a control characters, FALSE otherwise.
*/
static int jx9Builtin_ctype_cntrl(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisCtrl(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_digit(string $text)
* Checks if all of the characters in the provided string, text, are numerical.
* Parameters
* $text
* The tested string.
* Return
* TRUE if every character in the string text is a decimal digit, FALSE otherwise.
*/
static int jx9Builtin_ctype_digit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisDigit(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_xdigit(string $text)
* Check for character(s) representing a hexadecimal digit.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text is a hexadecimal 'digit', that is
* a decimal digit or a character from [A-Fa-f] , FALSE otherwise.
*/
static int jx9Builtin_ctype_xdigit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisHex(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_graph(string $text)
* Checks if all of the characters in the provided string, text, creates visible output.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text is printable and actually creates visible output
* (no white space), FALSE otherwise.
*/
static int jx9Builtin_ctype_graph(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisGraph(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_print(string $text)
* Checks if all of the characters in the provided string, text, are printable.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text will actually create output (including blanks).
* Returns FALSE if text contains control characters or characters that do not have any output
* or control function at all.
*/
static int jx9Builtin_ctype_print(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisPrint(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_punct(string $text)
* Checks if all of the characters in the provided string, text, are punctuation character.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text is printable, but neither letter
* digit or blank, FALSE otherwise.
*/
static int jx9Builtin_ctype_punct(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisPunct(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_space(string $text)
* Checks if all of the characters in the provided string, text, creates whitespace.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text creates some sort of white space, FALSE otherwise.
* Besides the blank character this also includes tab, vertical tab, line feed, carriage return
* and form feed characters.
*/
static int jx9Builtin_ctype_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( zIn[0] >= 0xc0 ){
/* UTF-8 stream */
break;
}
if( !SyisSpace(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_lower(string $text)
* Checks if all of the characters in the provided string, text, are lowercase letters.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text is a lowercase letter in the current locale.
*/
static int jx9Builtin_ctype_lower(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( !SyisLower(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* bool ctype_upper(string $text)
* Checks if all of the characters in the provided string, text, are uppercase letters.
* Parameters
* $text
* The tested string.
* Return
* Returns TRUE if every character in text is a uppercase letter in the current locale.
*/
static int jx9Builtin_ctype_upper(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nLen);
zEnd = &zIn[nLen];
if( nLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
if( zIn >= zEnd ){
/* If we reach the end of the string, then the test succeeded. */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
if( !SyisUpper(zIn[0]) ){
break;
}
/* Point to the next character */
zIn++;
}
/* The test failed, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/*
* Date/Time functions
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Devel.
*/
#include <time.h>
#ifdef __WINNT__
/* GetSystemTime() */
#include <Windows.h>
#ifdef _WIN32_WCE
/*
** WindowsCE does not have a localtime() function. So create a
** substitute.
** Taken from the SQLite3 source tree.
** Status: Public domain
*/
struct tm *__cdecl localtime(const time_t *t)
{
static struct tm y;
FILETIME uTm, lTm;
SYSTEMTIME pTm;
jx9_int64 t64;
t64 = *t;
t64 = (t64 + 11644473600)*10000000;
uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
uTm.dwHighDateTime= (DWORD)(t64 >> 32);
FileTimeToLocalFileTime(&uTm, &lTm);
FileTimeToSystemTime(&lTm, &pTm);
y.tm_year = pTm.wYear - 1900;
y.tm_mon = pTm.wMonth - 1;
y.tm_wday = pTm.wDayOfWeek;
y.tm_mday = pTm.wDay;
y.tm_hour = pTm.wHour;
y.tm_min = pTm.wMinute;
y.tm_sec = pTm.wSecond;
return &y;
}
#endif /*_WIN32_WCE */
#elif defined(__UNIXES__)
#include <sys/time.h>
#endif /* __WINNT__*/
/*
* int64 time(void)
* Current Unix timestamp
* Parameters
* None.
* Return
* Returns the current time measured in the number of seconds
* since the Unix Epoch (January 1 1970 00:00:00 GMT).
*/
static int jx9Builtin_time(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
time_t tt;
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* Extract the current time */
time(&tt);
/* Return as 64-bit integer */
jx9_result_int64(pCtx, (jx9_int64)tt);
return JX9_OK;
}
/*
* string/float microtime([ bool $get_as_float = false ])
* microtime() returns the current Unix timestamp with microseconds.
* Parameters
* $get_as_float
* If used and set to TRUE, microtime() will return a float instead of a string
* as described in the return values section below.
* Return
* By default, microtime() returns a string in the form "msec sec", where sec
* is the current time measured in the number of seconds since the Unix
* epoch (0:00:00 January 1, 1970 GMT), and msec is the number of microseconds
* that have elapsed since sec expressed in seconds.
* If get_as_float is set to TRUE, then microtime() returns a float, which represents
* the current time in seconds since the Unix epoch accurate to the nearest microsecond.
*/
static int jx9Builtin_microtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int bFloat = 0;
sytime sTime;
#if defined(__UNIXES__)
struct timeval tv;
gettimeofday(&tv, 0);
sTime.tm_sec = (long)tv.tv_sec;
sTime.tm_usec = (long)tv.tv_usec;
#else
time_t tt;
time(&tt);
sTime.tm_sec = (long)tt;
sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
if( nArg > 0 ){
bFloat = jx9_value_to_bool(apArg[0]);
}
if( bFloat ){
/* Return as float */
jx9_result_double(pCtx, (double)sTime.tm_sec);
}else{
/* Return as string */
jx9_result_string_format(pCtx, "%ld %ld", sTime.tm_usec, sTime.tm_sec);
}
return JX9_OK;
}
/*
* array getdate ([ int $timestamp = time() ])
* Get date/time information.
* Parameter
* $timestamp: The optional timestamp parameter is an integer Unix timestamp
* that defaults to the current local time if a timestamp is not given.
* In other words, it defaults to the value of time().
* Returns
* Returns an associative array of information related to the timestamp.
* Elements from the returned associative array are as follows:
* KEY VALUE
* --------- -------
* "seconds" Numeric representation of seconds 0 to 59
* "minutes" Numeric representation of minutes 0 to 59
* "hours" Numeric representation of hours 0 to 23
* "mday" Numeric representation of the day of the month 1 to 31
* "wday" Numeric representation of the day of the week 0 (for Sunday) through 6 (for Saturday)
* "mon" Numeric representation of a month 1 through 12
* "year" A full numeric representation of a year, 4 digits Examples: 1999 or 2003
* "yday" Numeric representation of the day of the year 0 through 365
* "weekday" A full textual representation of the day of the week Sunday through Saturday
* "month" A full textual representation of a month, such as January or March January through December
* 0 Seconds since the Unix Epoch, similar to the values returned by time() and used by date().
* NOTE:
* NULL is returned on failure.
*/
static int jx9Builtin_getdate(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pValue, *pArray;
Sytm sTm;
if( nArg < 1 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
#ifdef __WINNT__
#ifdef _MSC_VER
#if _MSC_VER >= 1400 /* Visual Studio 2005 and up */
#pragma warning(disable:4996) /* _CRT_SECURE...*/
#endif
#endif
#endif
if( jx9_value_is_int(apArg[0]) ){
t = (time_t)jx9_value_to_int64(apArg[0]);
pTm = localtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Element value */
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Fill the array */
/* Seconds */
jx9_value_int(pValue, sTm.tm_sec);
jx9_array_add_strkey_elem(pArray, "seconds", pValue);
/* Minutes */
jx9_value_int(pValue, sTm.tm_min);
jx9_array_add_strkey_elem(pArray, "minutes", pValue);
/* Hours */
jx9_value_int(pValue, sTm.tm_hour);
jx9_array_add_strkey_elem(pArray, "hours", pValue);
/* mday */
jx9_value_int(pValue, sTm.tm_mday);
jx9_array_add_strkey_elem(pArray, "mday", pValue);
/* wday */
jx9_value_int(pValue, sTm.tm_wday);
jx9_array_add_strkey_elem(pArray, "wday", pValue);
/* mon */
jx9_value_int(pValue, sTm.tm_mon+1);
jx9_array_add_strkey_elem(pArray, "mon", pValue);
/* year */
jx9_value_int(pValue, sTm.tm_year);
jx9_array_add_strkey_elem(pArray, "year", pValue);
/* yday */
jx9_value_int(pValue, sTm.tm_yday);
jx9_array_add_strkey_elem(pArray, "yday", pValue);
/* Weekday */
jx9_value_string(pValue, SyTimeGetDay(sTm.tm_wday), -1);
jx9_array_add_strkey_elem(pArray, "weekday", pValue);
/* Month */
jx9_value_reset_string_cursor(pValue);
jx9_value_string(pValue, SyTimeGetMonth(sTm.tm_mon), -1);
jx9_array_add_strkey_elem(pArray, "month", pValue);
/* Seconds since the epoch */
jx9_value_int64(pValue, (jx9_int64)time(0));
jx9_array_add_elem(pArray, 0 /* Index zero */, pValue);
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* mixed gettimeofday([ bool $return_float = false ] )
* Returns an associative array containing the data returned from the system call.
* Parameters
* $return_float
* When set to TRUE, a float instead of an array is returned.
* Return
* By default an array is returned. If return_float is set, then
* a float is returned.
*/
static int jx9Builtin_gettimeofday(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int bFloat = 0;
sytime sTime;
#if defined(__UNIXES__)
struct timeval tv;
gettimeofday(&tv, 0);
sTime.tm_sec = (long)tv.tv_sec;
sTime.tm_usec = (long)tv.tv_usec;
#else
time_t tt;
time(&tt);
sTime.tm_sec = (long)tt;
sTime.tm_usec = (long)(tt%SX_USEC_PER_SEC);
#endif /* __UNIXES__ */
if( nArg > 0 ){
bFloat = jx9_value_to_bool(apArg[0]);
}
if( bFloat ){
/* Return as float */
jx9_result_double(pCtx, (double)sTime.tm_sec);
}else{
/* Return an associative array */
jx9_value *pValue, *pArray;
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
/* Element value */
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 || pArray == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Fill the array */
/* sec */
jx9_value_int64(pValue, sTime.tm_sec);
jx9_array_add_strkey_elem(pArray, "sec", pValue);
/* usec */
jx9_value_int64(pValue, sTime.tm_usec);
jx9_array_add_strkey_elem(pArray, "usec", pValue);
/* Return the array */
jx9_result_value(pCtx, pArray);
}
return JX9_OK;
}
/* Check if the given year is leap or not */
#define IS_LEAP_YEAR(YEAR) (YEAR % 400 ? ( YEAR % 100 ? ( YEAR % 4 ? 0 : 1 ) : 0 ) : 1)
/* ISO-8601 numeric representation of the day of the week */
static const int aISO8601[] = { 7 /* Sunday */, 1 /* Monday */, 2, 3, 4, 5, 6 };
/*
* Format a given date string.
* Supported format: (Taken from JX9 online docs)
* character Description
* d Day of the month
* D A textual representation of a days
* j Day of the month without leading zeros
* l A full textual representation of the day of the week
* N ISO-8601 numeric representation of the day of the week
* w Numeric representation of the day of the week
* z The day of the year (starting from 0)
* F A full textual representation of a month, such as January or March
* m Numeric representation of a month, with leading zeros 01 through 12
* M A short textual representation of a month, three letters Jan through Dec
* n Numeric representation of a month, without leading zeros 1 through 12
* t Number of days in the given month 28 through 31
* L Whether it's a leap year 1 if it is a leap year, 0 otherwise.
* o ISO-8601 year number. This has the same value as Y, except that if the ISO week number
* (W) belongs to the previous or next year, that year is used instead. (added in JX9 5.1.0) Examples: 1999 or 2003
* Y A full numeric representation of a year, 4 digits Examples: 1999 or 2003
* y A two digit representation of a year Examples: 99 or 03
* a Lowercase Ante meridiem and Post meridiem am or pm
* A Uppercase Ante meridiem and Post meridiem AM or PM
* g 12-hour format of an hour without leading zeros 1 through 12
* G 24-hour format of an hour without leading zeros 0 through 23
* h 12-hour format of an hour with leading zeros 01 through 12
* H 24-hour format of an hour with leading zeros 00 through 23
* i Minutes with leading zeros 00 to 59
* s Seconds, with leading zeros 00 through 59
* u Microseconds Example: 654321
* e Timezone identifier Examples: UTC, GMT, Atlantic/Azores
* I (capital i) Whether or not the date is in daylight saving time 1 if Daylight Saving Time, 0 otherwise.
* r RFC 2822 formatted date Example: Thu, 21 Dec 2000 16:01:07 +0200
* U Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)
* S English ordinal suffix for the day of the month, 2 characters
* O Difference to Greenwich time (GMT) in hours
* Z Timezone offset in seconds. The offset for timezones west of UTC is always negative, and for those
* east of UTC is always positive.
* c ISO 8601 date
*/
static sxi32 DateFormat(jx9_context *pCtx, const char *zIn, int nLen, Sytm *pTm)
{
const char *zEnd = &zIn[nLen];
const char *zCur;
/* Start the format process */
for(;;){
if( zIn >= zEnd ){
/* No more input to process */
break;
}
switch(zIn[0]){
case 'd':
/* Day of the month, 2 digits with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_mday);
break;
case 'D':
/*A textual representation of a day, three letters*/
zCur = SyTimeGetDay(pTm->tm_wday);
jx9_result_string(pCtx, zCur, 3);
break;
case 'j':
/* Day of the month without leading zeros */
jx9_result_string_format(pCtx, "%d", pTm->tm_mday);
break;
case 'l':
/* A full textual representation of the day of the week */
zCur = SyTimeGetDay(pTm->tm_wday);
jx9_result_string(pCtx, zCur, -1/*Compute length automatically*/);
break;
case 'N':{
/* ISO-8601 numeric representation of the day of the week */
jx9_result_string_format(pCtx, "%d", aISO8601[pTm->tm_wday % 7 ]);
break;
}
case 'w':
/*Numeric representation of the day of the week*/
jx9_result_string_format(pCtx, "%d", pTm->tm_wday);
break;
case 'z':
/*The day of the year*/
jx9_result_string_format(pCtx, "%d", pTm->tm_yday);
break;
case 'F':
/*A full textual representation of a month, such as January or March*/
zCur = SyTimeGetMonth(pTm->tm_mon);
jx9_result_string(pCtx, zCur, -1/*Compute length automatically*/);
break;
case 'm':
/*Numeric representation of a month, with leading zeros*/
jx9_result_string_format(pCtx, "%02d", pTm->tm_mon + 1);
break;
case 'M':
/*A short textual representation of a month, three letters*/
zCur = SyTimeGetMonth(pTm->tm_mon);
jx9_result_string(pCtx, zCur, 3);
break;
case 'n':
/*Numeric representation of a month, without leading zeros*/
jx9_result_string_format(pCtx, "%d", pTm->tm_mon + 1);
break;
case 't':{
static const int aMonDays[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int nDays = aMonDays[pTm->tm_mon % 12 ];
if( pTm->tm_mon == 1 /* 'February' */ && !IS_LEAP_YEAR(pTm->tm_year) ){
nDays = 28;
}
/*Number of days in the given month*/
jx9_result_string_format(pCtx, "%d", nDays);
break;
}
case 'L':{
int isLeap = IS_LEAP_YEAR(pTm->tm_year);
/* Whether it's a leap year */
jx9_result_string_format(pCtx, "%d", isLeap);
break;
}
case 'o':
/* ISO-8601 year number.*/
jx9_result_string_format(pCtx, "%4d", pTm->tm_year);
break;
case 'Y':
/* A full numeric representation of a year, 4 digits */
jx9_result_string_format(pCtx, "%4d", pTm->tm_year);
break;
case 'y':
/*A two digit representation of a year*/
jx9_result_string_format(pCtx, "%02d", pTm->tm_year%100);
break;
case 'a':
/* Lowercase Ante meridiem and Post meridiem */
jx9_result_string(pCtx, pTm->tm_hour > 12 ? "pm" : "am", 2);
break;
case 'A':
/* Uppercase Ante meridiem and Post meridiem */
jx9_result_string(pCtx, pTm->tm_hour > 12 ? "PM" : "AM", 2);
break;
case 'g':
/* 12-hour format of an hour without leading zeros*/
jx9_result_string_format(pCtx, "%d", 1+(pTm->tm_hour%12));
break;
case 'G':
/* 24-hour format of an hour without leading zeros */
jx9_result_string_format(pCtx, "%d", pTm->tm_hour);
break;
case 'h':
/* 12-hour format of an hour with leading zeros */
jx9_result_string_format(pCtx, "%02d", 1+(pTm->tm_hour%12));
break;
case 'H':
/* 24-hour format of an hour with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_hour);
break;
case 'i':
/* Minutes with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_min);
break;
case 's':
/* second with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_sec);
break;
case 'u':
/* Microseconds */
jx9_result_string_format(pCtx, "%u", pTm->tm_sec * SX_USEC_PER_SEC);
break;
case 'S':{
/* English ordinal suffix for the day of the month, 2 characters */
static const char zSuffix[] = "thstndrdthththththth";
int v = pTm->tm_mday;
jx9_result_string(pCtx, &zSuffix[2 * (int)(v / 10 % 10 != 1 ? v % 10 : 0)], (int)sizeof(char) * 2);
break;
}
case 'e':
/* Timezone identifier */
zCur = pTm->tm_zone;
if( zCur == 0 ){
/* Assume GMT */
zCur = "GMT";
}
jx9_result_string(pCtx, zCur, -1);
break;
case 'I':
/* Whether or not the date is in daylight saving time */
#ifdef __WINNT__
#ifdef _MSC_VER
#ifndef _WIN32_WCE
_get_daylight(&pTm->tm_isdst);
#endif
#endif
#endif
jx9_result_string_format(pCtx, "%d", pTm->tm_isdst == 1);
break;
case 'r':
/* RFC 2822 formatted date Example: Thu, 21 Dec 2000 16:01:07 */
jx9_result_string_format(pCtx, "%.3s, %02d %.3s %4d %02d:%02d:%02d",
SyTimeGetDay(pTm->tm_wday),
pTm->tm_mday,
SyTimeGetMonth(pTm->tm_mon),
pTm->tm_year,
pTm->tm_hour,
pTm->tm_min,
pTm->tm_sec
);
break;
case 'U':{
time_t tt;
/* Seconds since the Unix Epoch */
time(&tt);
jx9_result_string_format(pCtx, "%u", (unsigned int)tt);
break;
}
case 'O':
case 'P':
/* Difference to Greenwich time (GMT) in hours */
jx9_result_string_format(pCtx, "%+05d", pTm->tm_gmtoff);
break;
case 'Z':
/* Timezone offset in seconds. The offset for timezones west of UTC
* is always negative, and for those east of UTC is always positive.
*/
jx9_result_string_format(pCtx, "%+05d", pTm->tm_gmtoff);
break;
case 'c':
/* ISO 8601 date */
jx9_result_string_format(pCtx, "%4d-%02d-%02dT%02d:%02d:%02d%+05d",
pTm->tm_year,
pTm->tm_mon+1,
pTm->tm_mday,
pTm->tm_hour,
pTm->tm_min,
pTm->tm_sec,
pTm->tm_gmtoff
);
break;
case '\\':
zIn++;
/* Expand verbatim */
if( zIn < zEnd ){
jx9_result_string(pCtx, zIn, (int)sizeof(char));
}
break;
default:
/* Unknown format specifer, expand verbatim */
jx9_result_string(pCtx, zIn, (int)sizeof(char));
break;
}
/* Point to the next character */
zIn++;
}
return SXRET_OK;
}
/*
* JX9 implementation of the strftime() function.
* The following formats are supported:
* %a An abbreviated textual representation of the day
* %A A full textual representation of the day
* %d Two-digit day of the month (with leading zeros)
* %e Day of the month, with a space preceding single digits.
* %j Day of the year, 3 digits with leading zeros
* %u ISO-8601 numeric representation of the day of the week 1 (for Monday) though 7 (for Sunday)
* %w Numeric representation of the day of the week 0 (for Sunday) through 6 (for Saturday)
* %U Week number of the given year, starting with the first Sunday as the first week
* %V ISO-8601:1988 week number of the given year, starting with the first week of the year with at least
* 4 weekdays, with Monday being the start of the week.
* %W A numeric representation of the week of the year
* %b Abbreviated month name, based on the locale
* %B Full month name, based on the locale
* %h Abbreviated month name, based on the locale (an alias of %b)
* %m Two digit representation of the month
* %C Two digit representation of the century (year divided by 100, truncated to an integer)
* %g Two digit representation of the year going by ISO-8601:1988 standards (see %V)
* %G The full four-digit version of %g
* %y Two digit representation of the year
* %Y Four digit representation for the year
* %H Two digit representation of the hour in 24-hour format
* %I Two digit representation of the hour in 12-hour format
* %l (lower-case 'L') Hour in 12-hour format, with a space preceeding single digits
* %M Two digit representation of the minute
* %p UPPER-CASE 'AM' or 'PM' based on the given time
* %P lower-case 'am' or 'pm' based on the given time
* %r Same as "%I:%M:%S %p"
* %R Same as "%H:%M"
* %S Two digit representation of the second
* %T Same as "%H:%M:%S"
* %X Preferred time representation based on locale, without the date
* %z Either the time zone offset from UTC or the abbreviation
* %Z The time zone offset/abbreviation option NOT given by %z
* %c Preferred date and time stamp based on local
* %D Same as "%m/%d/%y"
* %F Same as "%Y-%m-%d"
* %s Unix Epoch Time timestamp (same as the time() function)
* %x Preferred date representation based on locale, without the time
* %n A newline character ("\n")
* %t A Tab character ("\t")
* %% A literal percentage character ("%")
*/
static int jx9Strftime(
jx9_context *pCtx, /* Call context */
const char *zIn, /* Input string */
int nLen, /* Input length */
Sytm *pTm /* Parse of the given time */
)
{
const char *zCur, *zEnd = &zIn[nLen];
int c;
/* Start the format process */
for(;;){
zCur = zIn;
while(zIn < zEnd && zIn[0] != '%' ){
zIn++;
}
if( zIn > zCur ){
/* Consume input verbatim */
jx9_result_string(pCtx, zCur, (int)(zIn-zCur));
}
zIn++; /* Jump the percent sign */
if( zIn >= zEnd ){
/* No more input to process */
break;
}
c = zIn[0];
/* Act according to the current specifer */
switch(c){
case '%':
/* A literal percentage character ("%") */
jx9_result_string(pCtx, "%", (int)sizeof(char));
break;
case 't':
/* A Tab character */
jx9_result_string(pCtx, "\t", (int)sizeof(char));
break;
case 'n':
/* A newline character */
jx9_result_string(pCtx, "\n", (int)sizeof(char));
break;
case 'a':
/* An abbreviated textual representation of the day */
jx9_result_string(pCtx, SyTimeGetDay(pTm->tm_wday), (int)sizeof(char)*3);
break;
case 'A':
/* A full textual representation of the day */
jx9_result_string(pCtx, SyTimeGetDay(pTm->tm_wday), -1/*Compute length automatically*/);
break;
case 'e':
/* Day of the month, 2 digits with leading space for single digit*/
jx9_result_string_format(pCtx, "%2d", pTm->tm_mday);
break;
case 'd':
/* Two-digit day of the month (with leading zeros) */
jx9_result_string_format(pCtx, "%02d", pTm->tm_mon+1);
break;
case 'j':
/*The day of the year, 3 digits with leading zeros*/
jx9_result_string_format(pCtx, "%03d", pTm->tm_yday);
break;
case 'u':
/* ISO-8601 numeric representation of the day of the week */
jx9_result_string_format(pCtx, "%d", aISO8601[pTm->tm_wday % 7 ]);
break;
case 'w':
/* Numeric representation of the day of the week */
jx9_result_string_format(pCtx, "%d", pTm->tm_wday);
break;
case 'b':
case 'h':
/*A short textual representation of a month, three letters (Not based on locale)*/
jx9_result_string(pCtx, SyTimeGetMonth(pTm->tm_mon), (int)sizeof(char)*3);
break;
case 'B':
/* Full month name (Not based on locale) */
jx9_result_string(pCtx, SyTimeGetMonth(pTm->tm_mon), -1/*Compute length automatically*/);
break;
case 'm':
/*Numeric representation of a month, with leading zeros*/
jx9_result_string_format(pCtx, "%02d", pTm->tm_mon + 1);
break;
case 'C':
/* Two digit representation of the century */
jx9_result_string_format(pCtx, "%2d", pTm->tm_year/100);
break;
case 'y':
case 'g':
/* Two digit representation of the year */
jx9_result_string_format(pCtx, "%2d", pTm->tm_year%100);
break;
case 'Y':
case 'G':
/* Four digit representation of the year */
jx9_result_string_format(pCtx, "%4d", pTm->tm_year);
break;
case 'I':
/* 12-hour format of an hour with leading zeros */
jx9_result_string_format(pCtx, "%02d", 1+(pTm->tm_hour%12));
break;
case 'l':
/* 12-hour format of an hour with leading space */
jx9_result_string_format(pCtx, "%2d", 1+(pTm->tm_hour%12));
break;
case 'H':
/* 24-hour format of an hour with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_hour);
break;
case 'M':
/* Minutes with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_min);
break;
case 'S':
/* Seconds with leading zeros */
jx9_result_string_format(pCtx, "%02d", pTm->tm_sec);
break;
case 'z':
case 'Z':
/* Timezone identifier */
zCur = pTm->tm_zone;
if( zCur == 0 ){
/* Assume GMT */
zCur = "GMT";
}
jx9_result_string(pCtx, zCur, -1);
break;
case 'T':
case 'X':
/* Same as "%H:%M:%S" */
jx9_result_string_format(pCtx, "%02d:%02d:%02d", pTm->tm_hour, pTm->tm_min, pTm->tm_sec);
break;
case 'R':
/* Same as "%H:%M" */
jx9_result_string_format(pCtx, "%02d:%02d", pTm->tm_hour, pTm->tm_min);
break;
case 'P':
/* Lowercase Ante meridiem and Post meridiem */
jx9_result_string(pCtx, pTm->tm_hour > 12 ? "pm" : "am", (int)sizeof(char)*2);
break;
case 'p':
/* Uppercase Ante meridiem and Post meridiem */
jx9_result_string(pCtx, pTm->tm_hour > 12 ? "PM" : "AM", (int)sizeof(char)*2);
break;
case 'r':
/* Same as "%I:%M:%S %p" */
jx9_result_string_format(pCtx, "%02d:%02d:%02d %s",
1+(pTm->tm_hour%12),
pTm->tm_min,
pTm->tm_sec,
pTm->tm_hour > 12 ? "PM" : "AM"
);
break;
case 'D':
case 'x':
/* Same as "%m/%d/%y" */
jx9_result_string_format(pCtx, "%02d/%02d/%02d",
pTm->tm_mon+1,
pTm->tm_mday,
pTm->tm_year%100
);
break;
case 'F':
/* Same as "%Y-%m-%d" */
jx9_result_string_format(pCtx, "%d-%02d-%02d",
pTm->tm_year,
pTm->tm_mon+1,
pTm->tm_mday
);
break;
case 'c':
jx9_result_string_format(pCtx, "%d-%02d-%02d %02d:%02d:%02d",
pTm->tm_year,
pTm->tm_mon+1,
pTm->tm_mday,
pTm->tm_hour,
pTm->tm_min,
pTm->tm_sec
);
break;
case 's':{
time_t tt;
/* Seconds since the Unix Epoch */
time(&tt);
jx9_result_string_format(pCtx, "%u", (unsigned int)tt);
break;
}
default:
/* unknown specifer, simply ignore*/
break;
}
/* Advance the cursor */
zIn++;
}
return SXRET_OK;
}
/*
* string date(string $format [, int $timestamp = time() ] )
* Returns a string formatted according to the given format string using
* the given integer timestamp or the current time if no timestamp is given.
* In other words, timestamp is optional and defaults to the value of time().
* Parameters
* $format
* The format of the outputted date string (See code above)
* $timestamp
* The optional timestamp parameter is an integer Unix timestamp
* that defaults to the current local time if a timestamp is not given.
* In other words, it defaults to the value of time().
* Return
* A formatted date string. If a non-numeric value is used for timestamp, FALSE is returned.
*/
static int jx9Builtin_date(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
int nLen;
Sytm sTm;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Don't bother processing return the empty string */
jx9_result_string(pCtx, "", 0);
}
if( nArg < 2 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
if( jx9_value_is_int(apArg[1]) ){
t = (time_t)jx9_value_to_int64(apArg[1]);
pTm = localtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Format the given string */
DateFormat(pCtx, zFormat, nLen, &sTm);
return JX9_OK;
}
/*
* string strftime(string $format [, int $timestamp = time() ] )
* Format a local time/date (PLATFORM INDEPENDANT IMPLEENTATION NOT BASED ON LOCALE)
* Parameters
* $format
* The format of the outputted date string (See code above)
* $timestamp
* The optional timestamp parameter is an integer Unix timestamp
* that defaults to the current local time if a timestamp is not given.
* In other words, it defaults to the value of time().
* Return
* Returns a string formatted according format using the given timestamp
* or the current local time if no timestamp is given.
*/
static int jx9Builtin_strftime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
int nLen;
Sytm sTm;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Don't bother processing return FALSE */
jx9_result_bool(pCtx, 0);
}
if( nArg < 2 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
if( jx9_value_is_int(apArg[1]) ){
t = (time_t)jx9_value_to_int64(apArg[1]);
pTm = localtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Format the given string */
jx9Strftime(pCtx, zFormat, nLen, &sTm);
if( jx9_context_result_buf_length(pCtx) < 1 ){
/* Nothing was formatted, return FALSE */
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* string gmdate(string $format [, int $timestamp = time() ] )
* Identical to the date() function except that the time returned
* is Greenwich Mean Time (GMT).
* Parameters
* $format
* The format of the outputted date string (See code above)
* $timestamp
* The optional timestamp parameter is an integer Unix timestamp
* that defaults to the current local time if a timestamp is not given.
* In other words, it defaults to the value of time().
* Return
* A formatted date string. If a non-numeric value is used for timestamp, FALSE is returned.
*/
static int jx9Builtin_gmdate(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
int nLen;
Sytm sTm;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Don't bother processing return the empty string */
jx9_result_string(pCtx, "", 0);
}
if( nArg < 2 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = gmtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
if( jx9_value_is_int(apArg[1]) ){
t = (time_t)jx9_value_to_int64(apArg[1]);
pTm = gmtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = gmtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Format the given string */
DateFormat(pCtx, zFormat, nLen, &sTm);
return JX9_OK;
}
/*
* array localtime([ int $timestamp = time() [, bool $is_associative = false ]])
* Return the local time.
* Parameter
* $timestamp: The optional timestamp parameter is an integer Unix timestamp
* that defaults to the current local time if a timestamp is not given.
* In other words, it defaults to the value of time().
* $is_associative
* If set to FALSE or not supplied then the array is returned as a regular, numerically
* indexed array. If the argument is set to TRUE then localtime() returns an associative
* array containing all the different elements of the structure returned by the C function
* call to localtime. The names of the different keys of the associative array are as follows:
* "tm_sec" - seconds, 0 to 59
* "tm_min" - minutes, 0 to 59
* "tm_hour" - hours, 0 to 23
* "tm_mday" - day of the month, 1 to 31
* "tm_mon" - month of the year, 0 (Jan) to 11 (Dec)
* "tm_year" - years since 1900
* "tm_wday" - day of the week, 0 (Sun) to 6 (Sat)
* "tm_yday" - day of the year, 0 to 365
* "tm_isdst" - is daylight savings time in effect? Positive if yes, 0 if not, negative if unknown.
* Returns
* An associative array of information related to the timestamp.
*/
static int jx9Builtin_localtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pValue, *pArray;
int isAssoc = 0;
Sytm sTm;
if( nArg < 1 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS); /* TODO(chems): GMT not local */
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
if( jx9_value_is_int(apArg[0]) ){
t = (time_t)jx9_value_to_int64(apArg[0]);
pTm = localtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Element value */
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
if( nArg > 1 ){
isAssoc = jx9_value_to_bool(apArg[1]);
}
/* Fill the array */
/* Seconds */
jx9_value_int(pValue, sTm.tm_sec);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_sec", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* Minutes */
jx9_value_int(pValue, sTm.tm_min);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_min", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* Hours */
jx9_value_int(pValue, sTm.tm_hour);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_hour", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* mday */
jx9_value_int(pValue, sTm.tm_mday);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_mday", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* mon */
jx9_value_int(pValue, sTm.tm_mon);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_mon", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* year since 1900 */
jx9_value_int(pValue, sTm.tm_year-1900);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_year", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* wday */
jx9_value_int(pValue, sTm.tm_wday);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_wday", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* yday */
jx9_value_int(pValue, sTm.tm_yday);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_yday", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* isdst */
#ifdef __WINNT__
#ifdef _MSC_VER
#ifndef _WIN32_WCE
_get_daylight(&sTm.tm_isdst);
#endif
#endif
#endif
jx9_value_int(pValue, sTm.tm_isdst);
if( isAssoc ){
jx9_array_add_strkey_elem(pArray, "tm_isdst", pValue);
}else{
jx9_array_add_elem(pArray, 0/* Automatic index */, pValue);
}
/* Return the array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* int idate(string $format [, int $timestamp = time() ])
* Returns a number formatted according to the given format string
* using the given integer timestamp or the current local time if
* no timestamp is given. In other words, timestamp is optional and defaults
* to the value of time().
* Unlike the function date(), idate() accepts just one char in the format
* parameter.
* $Parameters
* Supported format
* d Day of the month
* h Hour (12 hour format)
* H Hour (24 hour format)
* i Minutes
* I (uppercase i)1 if DST is activated, 0 otherwise
* L (uppercase l) returns 1 for leap year, 0 otherwise
* m Month number
* s Seconds
* t Days in current month
* U Seconds since the Unix Epoch - January 1 1970 00:00:00 UTC - this is the same as time()
* w Day of the week (0 on Sunday)
* W ISO-8601 week number of year, weeks starting on Monday
* y Year (1 or 2 digits - check note below)
* Y Year (4 digits)
* z Day of the year
* Z Timezone offset in seconds
* $timestamp
* The optional timestamp parameter is an integer Unix timestamp that defaults
* to the current local time if a timestamp is not given. In other words, it defaults
* to the value of time().
* Return
* An integer.
*/
static int jx9Builtin_idate(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFormat;
jx9_int64 iVal = 0;
int nLen;
Sytm sTm;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return -1 */
jx9_result_int(pCtx, -1);
return JX9_OK;
}
zFormat = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Don't bother processing return -1*/
jx9_result_int(pCtx, -1);
}
if( nArg < 2 ){
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
}else{
/* Use the given timestamp */
time_t t;
struct tm *pTm;
if( jx9_value_is_int(apArg[1]) ){
t = (time_t)jx9_value_to_int64(apArg[1]);
pTm = localtime(&t);
if( pTm == 0 ){
time(&t);
}
}else{
time(&t);
}
pTm = localtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
}
/* Perform the requested operation */
switch(zFormat[0]){
case 'd':
/* Day of the month */
iVal = sTm.tm_mday;
break;
case 'h':
/* Hour (12 hour format)*/
iVal = 1 + (sTm.tm_hour % 12);
break;
case 'H':
/* Hour (24 hour format)*/
iVal = sTm.tm_hour;
break;
case 'i':
/*Minutes*/
iVal = sTm.tm_min;
break;
case 'I':
/* returns 1 if DST is activated, 0 otherwise */
#ifdef __WINNT__
#ifdef _MSC_VER
#ifndef _WIN32_WCE
_get_daylight(&sTm.tm_isdst);
#endif
#endif
#endif
iVal = sTm.tm_isdst;
break;
case 'L':
/* returns 1 for leap year, 0 otherwise */
iVal = IS_LEAP_YEAR(sTm.tm_year);
break;
case 'm':
/* Month number*/
iVal = sTm.tm_mon;
break;
case 's':
/*Seconds*/
iVal = sTm.tm_sec;
break;
case 't':{
/*Days in current month*/
static const int aMonDays[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int nDays = aMonDays[sTm.tm_mon % 12 ];
if( sTm.tm_mon == 1 /* 'February' */ && !IS_LEAP_YEAR(sTm.tm_year) ){
nDays = 28;
}
iVal = nDays;
break;
}
case 'U':
/*Seconds since the Unix Epoch*/
iVal = (jx9_int64)time(0);
break;
case 'w':
/* Day of the week (0 on Sunday) */
iVal = sTm.tm_wday;
break;
case 'W': {
/* ISO-8601 week number of year, weeks starting on Monday */
static const int aISO8601[] = { 7 /* Sunday */, 1 /* Monday */, 2, 3, 4, 5, 6 };
iVal = aISO8601[sTm.tm_wday % 7 ];
break;
}
case 'y':
/* Year (2 digits) */
iVal = sTm.tm_year % 100;
break;
case 'Y':
/* Year (4 digits) */
iVal = sTm.tm_year;
break;
case 'z':
/* Day of the year */
iVal = sTm.tm_yday;
break;
case 'Z':
/*Timezone offset in seconds*/
iVal = sTm.tm_gmtoff;
break;
default:
/* unknown format, throw a warning */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Unknown date format token");
break;
}
/* Return the time value */
jx9_result_int64(pCtx, iVal);
return JX9_OK;
}
/*
* int mktime/gmmktime([ int $hour = date("H") [, int $minute = date("i") [, int $second = date("s")
* [, int $month = date("n") [, int $day = date("j") [, int $year = date("Y") [, int $is_dst = -1 ]]]]]]] )
* Returns the Unix timestamp corresponding to the arguments given. This timestamp is a 64bit integer
* containing the number of seconds between the Unix Epoch (January 1 1970 00:00:00 GMT) and the time
* specified.
* Arguments may be left out in order from right to left; any arguments thus omitted will be set to
* the current value according to the local date and time.
* Parameters
* $hour
* The number of the hour relevant to the start of the day determined by month, day and year.
* Negative values reference the hour before midnight of the day in question. Values greater
* than 23 reference the appropriate hour in the following day(s).
* $minute
* The number of the minute relevant to the start of the hour. Negative values reference
* the minute in the previous hour. Values greater than 59 reference the appropriate minute
* in the following hour(s).
* $second
* The number of seconds relevant to the start of the minute. Negative values reference
* the second in the previous minute. Values greater than 59 reference the appropriate
* second in the following minute(s).
* $month
* The number of the month relevant to the end of the previous year. Values 1 to 12 reference
* the normal calendar months of the year in question. Values less than 1 (including negative values)
* reference the months in the previous year in reverse order, so 0 is December, -1 is November)...
* $day
* The number of the day relevant to the end of the previous month. Values 1 to 28, 29, 30 or 31
* (depending upon the month) reference the normal days in the relevant month. Values less than 1
* (including negative values) reference the days in the previous month, so 0 is the last day
* of the previous month, -1 is the day before that, etc. Values greater than the number of days
* in the relevant month reference the appropriate day in the following month(s).
* $year
* The number of the year, may be a two or four digit value, with values between 0-69 mapping
* to 2000-2069 and 70-100 to 1970-2000. On systems where time_t is a 32bit signed integer, as
* most common today, the valid range for year is somewhere between 1901 and 2038.
* $is_dst
* This parameter can be set to 1 if the time is during daylight savings time (DST), 0 if it is not,
* or -1 (the default) if it is unknown whether the time is within daylight savings time or not.
* Return
* mktime() returns the Unix timestamp of the arguments given.
* If the arguments are invalid, the function returns FALSE
*/
static int jx9Builtin_mktime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFunction;
jx9_int64 iVal = 0;
struct tm *pTm;
time_t t;
/* Extract function name */
zFunction = jx9_function_name(pCtx);
/* Get the current time */
time(&t);
if( zFunction[0] == 'g' /* gmmktime */ ){
pTm = gmtime(&t);
}else{
/* localtime */
pTm = localtime(&t);
}
if( nArg > 0 ){
int iVal;
/* Hour */
iVal = jx9_value_to_int(apArg[0]);
pTm->tm_hour = iVal;
if( nArg > 1 ){
/* Minutes */
iVal = jx9_value_to_int(apArg[1]);
pTm->tm_min = iVal;
if( nArg > 2 ){
/* Seconds */
iVal = jx9_value_to_int(apArg[2]);
pTm->tm_sec = iVal;
if( nArg > 3 ){
/* Month */
iVal = jx9_value_to_int(apArg[3]);
pTm->tm_mon = iVal - 1;
if( nArg > 4 ){
/* mday */
iVal = jx9_value_to_int(apArg[4]);
pTm->tm_mday = iVal;
if( nArg > 5 ){
/* Year */
iVal = jx9_value_to_int(apArg[5]);
if( iVal > 1900 ){
iVal -= 1900;
}
pTm->tm_year = iVal;
if( nArg > 6 ){
/* is_dst */
iVal = jx9_value_to_bool(apArg[6]);
pTm->tm_isdst = iVal;
}
}
}
}
}
}
}
/* Make the time */
iVal = (jx9_int64)mktime(pTm);
/* Return the timesatmp as a 64bit integer */
jx9_result_int64(pCtx, iVal);
return JX9_OK;
}
/*
* Section:
* URL handling Functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* Output consumer callback for the standard Symisc routines.
* [i.e: SyBase64Encode(), SyBase64Decode(), SyUriEncode(), ...].
*/
static int Consumer(const void *pData, unsigned int nLen, void *pUserData)
{
/* Store in the call context result buffer */
jx9_result_string((jx9_context *)pUserData, (const char *)pData, (int)nLen);
return SXRET_OK;
}
/*
* string base64_encode(string $data)
* string convert_uuencode(string $data)
* Encodes data with MIME base64
* Parameter
* $data
* Data to encode
* Return
* Encoded data or FALSE on failure.
*/
static int jx9Builtin_base64_encode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the input string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the BASE64 encoding */
SyBase64Encode(zIn, (sxu32)nLen, Consumer, pCtx);
return JX9_OK;
}
/*
* string base64_decode(string $data)
* string convert_uudecode(string $data)
* Decodes data encoded with MIME base64
* Parameter
* $data
* Encoded data.
* Return
* Returns the original data or FALSE on failure.
*/
static int jx9Builtin_base64_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the input string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the BASE64 decoding */
SyBase64Decode(zIn, (sxu32)nLen, Consumer, pCtx);
return JX9_OK;
}
/*
* string urlencode(string $str)
* URL encoding
* Parameter
* $data
* Input string.
* Return
* Returns a string in which all non-alphanumeric characters except -_. have
* been replaced with a percent (%) sign followed by two hex digits and spaces
* encoded as plus (+) signs.
*/
static int jx9Builtin_urlencode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the input string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the URL encoding */
SyUriEncode(zIn, (sxu32)nLen, Consumer, pCtx);
return JX9_OK;
}
/*
* string urldecode(string $str)
* Decodes any %## encoding in the given string.
* Plus symbols ('+') are decoded to a space character.
* Parameter
* $data
* Input string.
* Return
* Decoded URL or FALSE on failure.
*/
static int jx9Builtin_urldecode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn;
int nLen;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the input string */
zIn = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the URL decoding */
SyUriDecode(zIn, (sxu32)nLen, Consumer, pCtx, TRUE);
return JX9_OK;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/* Table of the built-in functions */
static const jx9_builtin_func aBuiltInFunc[] = {
/* Variable handling functions */
{ "is_bool" , jx9Builtin_is_bool },
{ "is_float" , jx9Builtin_is_float },
{ "is_real" , jx9Builtin_is_float },
{ "is_double" , jx9Builtin_is_float },
{ "is_int" , jx9Builtin_is_int },
{ "is_integer" , jx9Builtin_is_int },
{ "is_long" , jx9Builtin_is_int },
{ "is_string" , jx9Builtin_is_string },
{ "is_null" , jx9Builtin_is_null },
{ "is_numeric" , jx9Builtin_is_numeric },
{ "is_scalar" , jx9Builtin_is_scalar },
{ "is_array" , jx9Builtin_is_array },
{ "is_object" , jx9Builtin_is_object },
{ "is_resource", jx9Builtin_is_resource },
{ "douleval" , jx9Builtin_floatval },
{ "floatval" , jx9Builtin_floatval },
{ "intval" , jx9Builtin_intval },
{ "strval" , jx9Builtin_strval },
{ "empty" , jx9Builtin_empty },
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifdef JX9_ENABLE_MATH_FUNC
/* Math functions */
{ "abs" , jx9Builtin_abs },
{ "sqrt" , jx9Builtin_sqrt },
{ "exp" , jx9Builtin_exp },
{ "floor", jx9Builtin_floor },
{ "cos" , jx9Builtin_cos },
{ "sin" , jx9Builtin_sin },
{ "acos" , jx9Builtin_acos },
{ "asin" , jx9Builtin_asin },
{ "cosh" , jx9Builtin_cosh },
{ "sinh" , jx9Builtin_sinh },
{ "ceil" , jx9Builtin_ceil },
{ "tan" , jx9Builtin_tan },
{ "tanh" , jx9Builtin_tanh },
{ "atan" , jx9Builtin_atan },
{ "atan2", jx9Builtin_atan2 },
{ "log" , jx9Builtin_log },
{ "log10" , jx9Builtin_log10 },
{ "pow" , jx9Builtin_pow },
{ "pi", jx9Builtin_pi },
{ "fmod", jx9Builtin_fmod },
{ "hypot", jx9Builtin_hypot },
#endif /* JX9_ENABLE_MATH_FUNC */
{ "round", jx9Builtin_round },
{ "dechex", jx9Builtin_dechex },
{ "decoct", jx9Builtin_decoct },
{ "decbin", jx9Builtin_decbin },
{ "hexdec", jx9Builtin_hexdec },
{ "bindec", jx9Builtin_bindec },
{ "octdec", jx9Builtin_octdec },
{ "base_convert", jx9Builtin_base_convert },
/* String handling functions */
{ "substr", jx9Builtin_substr },
{ "substr_compare", jx9Builtin_substr_compare },
{ "substr_count", jx9Builtin_substr_count },
{ "chunk_split", jx9Builtin_chunk_split},
{ "htmlspecialchars", jx9Builtin_htmlspecialchars },
{ "htmlspecialchars_decode", jx9Builtin_htmlspecialchars_decode },
{ "get_html_translation_table", jx9Builtin_get_html_translation_table },
{ "htmlentities", jx9Builtin_htmlentities},
{ "html_entity_decode", jx9Builtin_html_entity_decode},
{ "strlen" , jx9Builtin_strlen },
{ "strcmp" , jx9Builtin_strcmp },
{ "strcoll" , jx9Builtin_strcmp },
{ "strncmp" , jx9Builtin_strncmp },
{ "strcasecmp" , jx9Builtin_strcasecmp },
{ "strncasecmp", jx9Builtin_strncasecmp},
{ "implode" , jx9Builtin_implode },
{ "join" , jx9Builtin_implode },
{ "implode_recursive" , jx9Builtin_implode_recursive },
{ "join_recursive" , jx9Builtin_implode_recursive },
{ "explode" , jx9Builtin_explode },
{ "trim" , jx9Builtin_trim },
{ "rtrim" , jx9Builtin_rtrim },
{ "chop" , jx9Builtin_rtrim },
{ "ltrim" , jx9Builtin_ltrim },
{ "strtolower", jx9Builtin_strtolower },
{ "mb_strtolower", jx9Builtin_strtolower }, /* Only UTF-8 encoding is supported */
{ "strtoupper", jx9Builtin_strtoupper },
{ "mb_strtoupper", jx9Builtin_strtoupper }, /* Only UTF-8 encoding is supported */
{ "ord", jx9Builtin_ord },
{ "chr", jx9Builtin_chr },
{ "bin2hex", jx9Builtin_bin2hex },
{ "strstr", jx9Builtin_strstr },
{ "stristr", jx9Builtin_stristr },
{ "strchr", jx9Builtin_strstr },
{ "strpos", jx9Builtin_strpos },
{ "stripos", jx9Builtin_stripos },
{ "strrpos", jx9Builtin_strrpos },
{ "strripos", jx9Builtin_strripos },
{ "strrchr", jx9Builtin_strrchr },
{ "strrev", jx9Builtin_strrev },
{ "str_repeat", jx9Builtin_str_repeat },
{ "nl2br", jx9Builtin_nl2br },
{ "sprintf", jx9Builtin_sprintf },
{ "printf", jx9Builtin_printf },
{ "vprintf", jx9Builtin_vprintf },
{ "vsprintf", jx9Builtin_vsprintf },
{ "size_format", jx9Builtin_size_format},
#if !defined(JX9_DISABLE_HASH_FUNC)
{ "md5", jx9Builtin_md5 },
{ "sha1", jx9Builtin_sha1 },
{ "crc32", jx9Builtin_crc32 },
#endif /* JX9_DISABLE_HASH_FUNC */
{ "str_getcsv", jx9Builtin_str_getcsv },
{ "strip_tags", jx9Builtin_strip_tags },
{ "str_split", jx9Builtin_str_split },
{ "strspn", jx9Builtin_strspn },
{ "strcspn", jx9Builtin_strcspn },
{ "strpbrk", jx9Builtin_strpbrk },
{ "soundex", jx9Builtin_soundex },
{ "wordwrap", jx9Builtin_wordwrap },
{ "strtok", jx9Builtin_strtok },
{ "str_pad", jx9Builtin_str_pad },
{ "str_replace", jx9Builtin_str_replace},
{ "str_ireplace", jx9Builtin_str_replace},
{ "strtr", jx9Builtin_strtr },
{ "parse_ini_string", jx9Builtin_parse_ini_string},
/* Ctype functions */
{ "ctype_alnum", jx9Builtin_ctype_alnum },
{ "ctype_alpha", jx9Builtin_ctype_alpha },
{ "ctype_cntrl", jx9Builtin_ctype_cntrl },
{ "ctype_digit", jx9Builtin_ctype_digit },
{ "ctype_xdigit", jx9Builtin_ctype_xdigit},
{ "ctype_graph", jx9Builtin_ctype_graph },
{ "ctype_print", jx9Builtin_ctype_print },
{ "ctype_punct", jx9Builtin_ctype_punct },
{ "ctype_space", jx9Builtin_ctype_space },
{ "ctype_lower", jx9Builtin_ctype_lower },
{ "ctype_upper", jx9Builtin_ctype_upper },
/* Time functions */
{ "time" , jx9Builtin_time },
{ "microtime", jx9Builtin_microtime },
{ "getdate" , jx9Builtin_getdate },
{ "gettimeofday", jx9Builtin_gettimeofday },
{ "date", jx9Builtin_date },
{ "strftime", jx9Builtin_strftime },
{ "idate", jx9Builtin_idate },
{ "gmdate", jx9Builtin_gmdate },
{ "localtime", jx9Builtin_localtime },
{ "mktime", jx9Builtin_mktime },
{ "gmmktime", jx9Builtin_mktime },
/* URL functions */
{ "base64_encode", jx9Builtin_base64_encode },
{ "base64_decode", jx9Builtin_base64_decode },
{ "convert_uuencode", jx9Builtin_base64_encode },
{ "convert_uudecode", jx9Builtin_base64_decode },
{ "urlencode", jx9Builtin_urlencode },
{ "urldecode", jx9Builtin_urldecode },
{ "rawurlencode", jx9Builtin_urlencode },
{ "rawurldecode", jx9Builtin_urldecode },
#endif /* JX9_DISABLE_BUILTIN_FUNC */
};
/*
* Register the built-in functions defined above, the array functions
* defined in hashmap.c and the IO functions defined in vfs.c.
*/
JX9_PRIVATE void jx9RegisterBuiltInFunction(jx9_vm *pVm)
{
sxu32 n;
for( n = 0 ; n < SX_ARRAYSIZE(aBuiltInFunc) ; ++n ){
jx9_create_function(&(*pVm), aBuiltInFunc[n].zName, aBuiltInFunc[n].xFunc, 0);
}
/* Register hashmap functions [i.e: sort(), count(), array_diff(), ...] */
jx9RegisterHashmapFunctions(&(*pVm));
/* Register IO functions [i.e: fread(), fwrite(), chdir(), mkdir(), file(), ...] */
jx9RegisterIORoutine(&(*pVm));
}
/*
* ----------------------------------------------------------
* File: jx9_compile.c
* MD5: 562e73eb7214f890e71713c6b97a7863
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: compile.c v1.7 FreeBSD 2012-12-11 21:46 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/*
* This file implement a thread-safe and full-reentrant compiler for the JX9 engine.
* That is, routines defined in this file takes a stream of tokens and output
* JX9 bytecode instructions.
*/
/* Forward declaration */
typedef struct LangConstruct LangConstruct;
typedef struct JumpFixup JumpFixup;
/* Block [i.e: set of statements] control flags */
#define GEN_BLOCK_LOOP 0x001 /* Loop block [i.e: for, while, ...] */
#define GEN_BLOCK_PROTECTED 0x002 /* Protected block */
#define GEN_BLOCK_COND 0x004 /* Conditional block [i.e: if(condition){} ]*/
#define GEN_BLOCK_FUNC 0x008 /* Function body */
#define GEN_BLOCK_GLOBAL 0x010 /* Global block (always set)*/
#define GEN_BLOC_NESTED_FUNC 0x020 /* Nested function body */
#define GEN_BLOCK_EXPR 0x040 /* Expression */
#define GEN_BLOCK_STD 0x080 /* Standard block */
#define GEN_BLOCK_SWITCH 0x100 /* Switch statement */
/*
* Compilation of some JX9 constructs such as if, for, while, the logical or
* (||) and logical and (&&) operators in expressions requires the
* generation of forward jumps.
* Since the destination PC target of these jumps isn't known when the jumps
* are emitted, we record each forward jump in an instance of the following
* structure. Those jumps are fixed later when the jump destination is resolved.
*/
struct JumpFixup
{
sxi32 nJumpType; /* Jump type. Either TRUE jump, FALSE jump or Unconditional jump */
sxu32 nInstrIdx; /* Instruction index to fix later when the jump destination is resolved. */
};
/*
* Each language construct is represented by an instance
* of the following structure.
*/
struct LangConstruct
{
sxu32 nID; /* Language construct ID [i.e: JX9_TKWRD_WHILE, JX9_TKWRD_FOR, JX9_TKWRD_IF...] */
ProcLangConstruct xConstruct; /* C function implementing the language construct */
};
/* Compilation flags */
#define JX9_COMPILE_SINGLE_STMT 0x001 /* Compile a single statement */
/* Token stream synchronization macros */
#define SWAP_TOKEN_STREAM(GEN, START, END)\
pTmp = GEN->pEnd;\
pGen->pIn = START;\
pGen->pEnd = END
#define UPDATE_TOKEN_STREAM(GEN)\
if( GEN->pIn < pTmp ){\
GEN->pIn++;\
}\
GEN->pEnd = pTmp
#define SWAP_DELIMITER(GEN, START, END)\
pTmpIn = GEN->pIn;\
pTmpEnd = GEN->pEnd;\
GEN->pIn = START;\
GEN->pEnd = END
#define RE_SWAP_DELIMITER(GEN)\
GEN->pIn = pTmpIn;\
GEN->pEnd = pTmpEnd
/* Flags related to expression compilation */
#define EXPR_FLAG_LOAD_IDX_STORE 0x001 /* Set the iP2 flag when dealing with the LOAD_IDX instruction */
#define EXPR_FLAG_RDONLY_LOAD 0x002 /* Read-only load, refer to the 'JX9_OP_LOAD' VM instruction for more information */
#define EXPR_FLAG_COMMA_STATEMENT 0x004 /* Treat comma expression as a single statement (used by object attributes) */
/* Forward declaration */
static sxi32 jx9CompileExpr(
jx9_gen_state *pGen, /* Code generator state */
sxi32 iFlags, /* Control flags */
sxi32 (*xTreeValidator)(jx9_gen_state *, jx9_expr_node *) /* Node validator callback.NULL otherwise */
);
/*
* Recover from a compile-time error. In other words synchronize
* the token stream cursor with the first semi-colon seen.
*/
static sxi32 jx9ErrorRecover(jx9_gen_state *pGen)
{
/* Synchronize with the next-semi-colon and avoid compiling this erroneous statement */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI /*';'*/) == 0){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Check if the given identifier name is reserved or not.
* Return TRUE if reserved.FALSE otherwise.
*/
static int GenStateIsReservedID(SyString *pName)
{
if( pName->nByte == sizeof("null") - 1 ){
if( SyStrnicmp(pName->zString, "null", sizeof("null")-1) == 0 ){
return TRUE;
}else if( SyStrnicmp(pName->zString, "true", sizeof("true")-1) == 0 ){
return TRUE;
}
}else if( pName->nByte == sizeof("false") - 1 ){
if( SyStrnicmp(pName->zString, "false", sizeof("false")-1) == 0 ){
return TRUE;
}
}
/* Not a reserved constant */
return FALSE;
}
/*
* Check if a given token value is installed in the literal table.
*/
static sxi32 GenStateFindLiteral(jx9_gen_state *pGen, const SyString *pValue, sxu32 *pIdx)
{
SyHashEntry *pEntry;
pEntry = SyHashGet(&pGen->hLiteral, (const void *)pValue->zString, pValue->nByte);
if( pEntry == 0 ){
return SXERR_NOTFOUND;
}
*pIdx = (sxu32)SX_PTR_TO_INT(pEntry->pUserData);
return SXRET_OK;
}
/*
* Install a given constant index in the literal table.
* In order to be installed, the jx9_value must be of type string.
*/
static sxi32 GenStateInstallLiteral(jx9_gen_state *pGen,jx9_value *pObj, sxu32 nIdx)
{
if( SyBlobLength(&pObj->sBlob) > 0 ){
SyHashInsert(&pGen->hLiteral, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob), SX_INT_TO_PTR(nIdx));
}
return SXRET_OK;
}
/*
* Generate a fatal error.
*/
static sxi32 GenStateOutOfMem(jx9_gen_state *pGen)
{
jx9GenCompileError(pGen,E_ERROR,1,"Fatal, Jx9 compiler is running out of memory");
/* Abort compilation immediately */
return SXERR_ABORT;
}
/*
* Fetch a block that correspond to the given criteria from the stack of
* compiled blocks.
* Return a pointer to that block on success. NULL otherwise.
*/
static GenBlock * GenStateFetchBlock(GenBlock *pCurrent, sxi32 iBlockType, sxi32 iCount)
{
GenBlock *pBlock = pCurrent;
for(;;){
if( pBlock->iFlags & iBlockType ){
iCount--; /* Decrement nesting level */
if( iCount < 1 ){
/* Block meet with the desired criteria */
return pBlock;
}
}
/* Point to the upper block */
pBlock = pBlock->pParent;
if( pBlock == 0 || (pBlock->iFlags & (GEN_BLOCK_PROTECTED|GEN_BLOCK_FUNC)) ){
/* Forbidden */
break;
}
}
/* No such block */
return 0;
}
/*
* Initialize a freshly allocated block instance.
*/
static void GenStateInitBlock(
jx9_gen_state *pGen, /* Code generator state */
GenBlock *pBlock, /* Target block */
sxi32 iType, /* Block type [i.e: loop, conditional, function body, etc.]*/
sxu32 nFirstInstr, /* First instruction to compile */
void *pUserData /* Upper layer private data */
)
{
/* Initialize block fields */
pBlock->nFirstInstr = nFirstInstr;
pBlock->pUserData = pUserData;
pBlock->pGen = pGen;
pBlock->iFlags = iType;
pBlock->pParent = 0;
pBlock->bPostContinue = 0;
SySetInit(&pBlock->aJumpFix, &pGen->pVm->sAllocator, sizeof(JumpFixup));
SySetInit(&pBlock->aPostContFix, &pGen->pVm->sAllocator, sizeof(JumpFixup));
}
/*
* Allocate a new block instance.
* Return SXRET_OK and write a pointer to the new instantiated block
* on success.Otherwise generate a compile-time error and abort
* processing on failure.
*/
static sxi32 GenStateEnterBlock(
jx9_gen_state *pGen, /* Code generator state */
sxi32 iType, /* Block type [i.e: loop, conditional, function body, etc.]*/
sxu32 nFirstInstr, /* First instruction to compile */
void *pUserData, /* Upper layer private data */
GenBlock **ppBlock /* OUT: instantiated block */
)
{
GenBlock *pBlock;
/* Allocate a new block instance */
pBlock = (GenBlock *)SyMemBackendPoolAlloc(&pGen->pVm->sAllocator, sizeof(GenBlock));
if( pBlock == 0 ){
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here.
*/
return GenStateOutOfMem(pGen);
}
/* Zero the structure */
SyZero(pBlock, sizeof(GenBlock));
GenStateInitBlock(&(*pGen), pBlock, iType, nFirstInstr, pUserData);
/* Link to the parent block */
pBlock->pParent = pGen->pCurrent;
/* Mark as the current block */
pGen->pCurrent = pBlock;
if( ppBlock ){
/* Write a pointer to the new instance */
*ppBlock = pBlock;
}
return SXRET_OK;
}
/*
* Release block fields without freeing the whole instance.
*/
static void GenStateReleaseBlock(GenBlock *pBlock)
{
SySetRelease(&pBlock->aPostContFix);
SySetRelease(&pBlock->aJumpFix);
}
/*
* Release a block.
*/
static void GenStateFreeBlock(GenBlock *pBlock)
{
jx9_gen_state *pGen = pBlock->pGen;
GenStateReleaseBlock(&(*pBlock));
/* Free the instance */
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pBlock);
}
/*
* POP and release a block from the stack of compiled blocks.
*/
static sxi32 GenStateLeaveBlock(jx9_gen_state *pGen, GenBlock **ppBlock)
{
GenBlock *pBlock = pGen->pCurrent;
if( pBlock == 0 ){
/* No more block to pop */
return SXERR_EMPTY;
}
/* Point to the upper block */
pGen->pCurrent = pBlock->pParent;
if( ppBlock ){
/* Write a pointer to the popped block */
*ppBlock = pBlock;
}else{
/* Safely release the block */
GenStateFreeBlock(&(*pBlock));
}
return SXRET_OK;
}
/*
* Emit a forward jump.
* Notes on forward jumps
* Compilation of some JX9 constructs such as if, for, while and the logical or
* (||) and logical and (&&) operators in expressions requires the
* generation of forward jumps.
* Since the destination PC target of these jumps isn't known when the jumps
* are emitted, we record each forward jump in an instance of the following
* structure. Those jumps are fixed later when the jump destination is resolved.
*/
static sxi32 GenStateNewJumpFixup(GenBlock *pBlock, sxi32 nJumpType, sxu32 nInstrIdx)
{
JumpFixup sJumpFix;
sxi32 rc;
/* Init the JumpFixup structure */
sJumpFix.nJumpType = nJumpType;
sJumpFix.nInstrIdx = nInstrIdx;
/* Insert in the jump fixup table */
rc = SySetPut(&pBlock->aJumpFix,(const void *)&sJumpFix);
return rc;
}
/*
* Fix a forward jump now the jump destination is resolved.
* Return the total number of fixed jumps.
* Notes on forward jumps:
* Compilation of some JX9 constructs such as if, for, while and the logical or
* (||) and logical and (&&) operators in expressions requires the
* generation of forward jumps.
* Since the destination PC target of these jumps isn't known when the jumps
* are emitted, we record each forward jump in an instance of the following
* structure.Those jumps are fixed later when the jump destination is resolved.
*/
static sxu32 GenStateFixJumps(GenBlock *pBlock, sxi32 nJumpType, sxu32 nJumpDest)
{
JumpFixup *aFix;
VmInstr *pInstr;
sxu32 nFixed;
sxu32 n;
/* Point to the jump fixup table */
aFix = (JumpFixup *)SySetBasePtr(&pBlock->aJumpFix);
/* Fix the desired jumps */
for( nFixed = n = 0 ; n < SySetUsed(&pBlock->aJumpFix) ; ++n ){
if( aFix[n].nJumpType < 0 ){
/* Already fixed */
continue;
}
if( nJumpType > 0 && aFix[n].nJumpType != nJumpType ){
/* Not of our interest */
continue;
}
/* Point to the instruction to fix */
pInstr = jx9VmGetInstr(pBlock->pGen->pVm, aFix[n].nInstrIdx);
if( pInstr ){
pInstr->iP2 = nJumpDest;
nFixed++;
/* Mark as fixed */
aFix[n].nJumpType = -1;
}
}
/* Total number of fixed jumps */
return nFixed;
}
/*
* Reserve a room for a numeric constant [i.e: 64-bit integer or real number]
* in the constant table.
*/
static jx9_value * GenStateInstallNumLiteral(jx9_gen_state *pGen, sxu32 *pIdx)
{
jx9_value *pObj;
sxu32 nIdx = 0; /* cc warning */
/* Reserve a new constant */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
GenStateOutOfMem(pGen);
return 0;
}
*pIdx = nIdx;
/* TODO(chems): Create a numeric table (64bit int keys) same as
* the constant string iterals table [optimization purposes].
*/
return pObj;
}
/*
* Compile a numeric [i.e: integer or real] literal.
* Notes on the integer type.
* According to the JX9 language reference manual
* Integers can be specified in decimal (base 10), hexadecimal (base 16), octal (base 8)
* or binary (base 2) notation, optionally preceded by a sign (- or +).
* To use octal notation, precede the number with a 0 (zero). To use hexadecimal
* notation precede the number with 0x. To use binary notation precede the number with 0b.
*/
static sxi32 jx9CompileNumLiteral(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
SyToken *pToken = pGen->pIn; /* Raw token */
sxu32 nIdx = 0;
if( pToken->nType & JX9_TK_INTEGER ){
jx9_value *pObj;
sxi64 iValue;
iValue = jx9TokenValueToInt64(&pToken->sData);
pObj = GenStateInstallNumLiteral(&(*pGen), &nIdx);
if( pObj == 0 ){
SXUNUSED(iCompileFlag); /* cc warning */
return SXERR_ABORT;
}
jx9MemObjInitFromInt(pGen->pVm, pObj, iValue);
}else{
/* Real number */
jx9_value *pObj;
/* Reserve a new constant */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
return GenStateOutOfMem(pGen);
}
jx9MemObjInitFromString(pGen->pVm, pObj, &pToken->sData);
jx9MemObjToReal(pObj);
}
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile a nowdoc string.
* According to the JX9 language reference manual:
*
* Nowdocs are to single-quoted strings what heredocs are to double-quoted strings.
* A nowdoc is specified similarly to a heredoc, but no parsing is done inside a nowdoc.
* The construct is ideal for embedding JX9 code or other large blocks of text without the
* need for escaping. It shares some features in common with the SGML <![CDATA[ ]]>
* construct, in that it declares a block of text which is not for parsing.
* A nowdoc is identified with the same <<< sequence used for heredocs, but the identifier
* which follows is enclosed in single quotes, e.g. <<<'EOT'. All the rules for heredoc
* identifiers also apply to nowdoc identifiers, especially those regarding the appearance
* of the closing identifier.
*/
static sxi32 jx9CompileNowdoc(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
SyString *pStr = &pGen->pIn->sData; /* Constant string literal */
jx9_value *pObj;
sxu32 nIdx;
nIdx = 0; /* Prevent compiler warning */
if( pStr->nByte <= 0 ){
/* Empty string, load NULL */
jx9VmEmitInstr(pGen->pVm,JX9_OP_LOADC, 0, 0, 0, 0);
return SXRET_OK;
}
/* Reserve a new constant */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "JX9 engine is running out of memory");
SXUNUSED(iCompileFlag); /* cc warning */
return SXERR_ABORT;
}
/* No processing is done here, simply a memcpy() operation */
jx9MemObjInitFromString(pGen->pVm, pObj, pStr);
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile a single quoted string.
* According to the JX9 language reference manual:
*
* The simplest way to specify a string is to enclose it in single quotes (the character ' ).
* To specify a literal single quote, escape it with a backslash (\). To specify a literal
* backslash, double it (\\). All other instances of backslash will be treated as a literal
* backslash: this means that the other escape sequences you might be used to, such as \r
* or \n, will be output literally as specified rather than having any special meaning.
*
*/
JX9_PRIVATE sxi32 jx9CompileSimpleString(jx9_gen_state *pGen, sxi32 iCompileFlag)
{
SyString *pStr = &pGen->pIn->sData; /* Constant string literal */
const char *zIn, *zCur, *zEnd;
jx9_value *pObj;
sxu32 nIdx;
nIdx = 0; /* Prevent compiler warning */
/* Delimit the string */
zIn = pStr->zString;
zEnd = &zIn[pStr->nByte];
if( zIn > zEnd ){
/* Empty string, load NULL */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 0, 0, 0);
return SXRET_OK;
}
if( SXRET_OK == GenStateFindLiteral(&(*pGen), pStr, &nIdx) ){
/* Already processed, emit the load constant instruction
* and return.
*/
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
return SXRET_OK;
}
/* Reserve a new constant */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
jx9GenCompileError(&(*pGen), E_ERROR, 1, "JX9 engine is running out of memory");
SXUNUSED(iCompileFlag); /* cc warning */
return SXERR_ABORT;
}
jx9MemObjInitFromString(pGen->pVm, pObj, 0);
/* Compile the node */
for(;;){
if( zIn >= zEnd ){
/* End of input */
break;
}
zCur = zIn;
while( zIn < zEnd && zIn[0] != '\\' ){
zIn++;
}
if( zIn > zCur ){
/* Append raw contents*/
jx9MemObjStringAppend(pObj, zCur, (sxu32)(zIn-zCur));
}
else
{
jx9MemObjStringAppend(pObj, "", 0);
}
zIn++;
if( zIn < zEnd ){
if( zIn[0] == '\\' ){
/* A literal backslash */
jx9MemObjStringAppend(pObj, "\\", sizeof(char));
}else if( zIn[0] == '\'' ){
/* A single quote */
jx9MemObjStringAppend(pObj, "'", sizeof(char));
}else{
/* verbatim copy */
zIn--;
jx9MemObjStringAppend(pObj, zIn, sizeof(char)*2);
zIn++;
}
}
/* Advance the stream cursor */
zIn++;
}
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
if( pStr->nByte < 1024 ){
/* Install in the literal table */
GenStateInstallLiteral(pGen, pObj, nIdx);
}
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Process variable expression [i.e: "$var", "${var}"] embedded in a double quoted/heredoc string.
* According to the JX9 language reference manual
* When a string is specified in double quotes or with heredoc, variables are parsed within it.
* There are two types of syntax: a simple one and a complex one. The simple syntax is the most
* common and convenient. It provides a way to embed a variable, an array value, or an object
* property in a string with a minimum of effort.
* Simple syntax
* If a dollar sign ($) is encountered, the parser will greedily take as many tokens as possible
* to form a valid variable name. Enclose the variable name in curly braces to explicitly specify
* the end of the name.
* Similarly, an array index or an object property can be parsed. With array indices, the closing
* square bracket (]) marks the end of the index. The same rules apply to object properties
* as to simple variables.
* Complex (curly) syntax
* This isn't called complex because the syntax is complex, but because it allows for the use
* of complex expressions.
* Any scalar variable, array element or object property with a string representation can be
* included via this syntax. Simply write the expression the same way as it would appear outside
* the string, and then wrap it in { and }. Since { can not be escaped, this syntax will only
* be recognised when the $ immediately follows the {. Use {\$ to get a literal {$
*/
static sxi32 GenStateProcessStringExpression(
jx9_gen_state *pGen, /* Code generator state */
const char *zIn, /* Raw expression */
const char *zEnd /* End of the expression */
)
{
SyToken *pTmpIn, *pTmpEnd;
SySet sToken;
sxi32 rc;
/* Initialize the token set */
SySetInit(&sToken, &pGen->pVm->sAllocator, sizeof(SyToken));
/* Preallocate some slots */
SySetAlloc(&sToken, 0x08);
/* Tokenize the text */
jx9Tokenize(zIn,(sxu32)(zEnd-zIn),&sToken);
/* Swap delimiter */
pTmpIn = pGen->pIn;
pTmpEnd = pGen->pEnd;
pGen->pIn = (SyToken *)SySetBasePtr(&sToken);
pGen->pEnd = &pGen->pIn[SySetUsed(&sToken)];
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Restore token stream */
pGen->pIn = pTmpIn;
pGen->pEnd = pTmpEnd;
/* Release the token set */
SySetRelease(&sToken);
/* Compilation result */
return rc;
}
/*
* Reserve a new constant for a double quoted/heredoc string.
*/
static jx9_value * GenStateNewStrObj(jx9_gen_state *pGen,sxi32 *pCount)
{
jx9_value *pConstObj;
sxu32 nIdx = 0;
/* Reserve a new constant */
pConstObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pConstObj == 0 ){
GenStateOutOfMem(&(*pGen));
return 0;
}
(*pCount)++;
jx9MemObjInitFromString(pGen->pVm, pConstObj, 0);
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
return pConstObj;
}
/*
* Compile a double quoted/heredoc string.
* According to the JX9 language reference manual
* Heredoc
* A third way to delimit strings is the heredoc syntax: <<<. After this operator, an identifier
* is provided, then a newline. The string itself follows, and then the same identifier again
* to close the quotation.
* The closing identifier must begin in the first column of the line. Also, the identifier must
* follow the same naming rules as any other label in JX9: it must contain only alphanumeric
* characters and underscores, and must start with a non-digit character or underscore.
* Warning
* It is very important to note that the line with the closing identifier must contain
* no other characters, except possibly a semicolon (;). That means especially that the identifier
* may not be indented, and there may not be any spaces or tabs before or after the semicolon.
* It's also important to realize that the first character before the closing identifier must
* be a newline as defined by the local operating system. This is \n on UNIX systems, including Mac OS X.
* The closing delimiter (possibly followed by a semicolon) must also be followed by a newline.
* If this rule is broken and the closing identifier is not "clean", it will not be considered a closing
* identifier, and JX9 will continue looking for one. If a proper closing identifier is not found before
* the end of the current file, a parse error will result at the last line.
* Heredocs can not be used for initializing object properties.
* Double quoted
* If the string is enclosed in double-quotes ("), JX9 will interpret more escape sequences for special characters:
* Escaped characters Sequence Meaning
* \n linefeed (LF or 0x0A (10) in ASCII)
* \r carriage return (CR or 0x0D (13) in ASCII)
* \t horizontal tab (HT or 0x09 (9) in ASCII)
* \v vertical tab (VT or 0x0B (11) in ASCII)
* \f form feed (FF or 0x0C (12) in ASCII)
* \\ backslash
* \$ dollar sign
* \" double-quote
* \[0-7]{1, 3} the sequence of characters matching the regular expression is a character in octal notation
* \x[0-9A-Fa-f]{1, 2} the sequence of characters matching the regular expression is a character in hexadecimal notation
* As in single quoted strings, escaping any other character will result in the backslash being printed too.
* The most important feature of double-quoted strings is the fact that variable names will be expanded.
* See string parsing for details.
*/
static sxi32 GenStateCompileString(jx9_gen_state *pGen)
{
SyString *pStr = &pGen->pIn->sData; /* Raw token value */
const char *zIn, *zCur, *zEnd;
jx9_value *pObj = 0;
sxi32 iCons;
sxi32 rc;
/* Delimit the string */
zIn = pStr->zString;
zEnd = &zIn[pStr->nByte];
if( zIn > zEnd ){
/* Empty string, load NULL */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 0, 0, 0);
return SXRET_OK;
}
zCur = 0;
/* Compile the node */
iCons = 0;
for(;;){
zCur = zIn;
while( zIn < zEnd && zIn[0] != '\\' ){
if(zIn[0] == '$' && &zIn[1] < zEnd &&
(((unsigned char)zIn[1] >= 0xc0 || SyisAlpha(zIn[1]) || zIn[1] == '_')) ){
break;
}
zIn++;
}
if( zIn > zCur ){
if( pObj == 0 ){
pObj = GenStateNewStrObj(&(*pGen), &iCons);
if( pObj == 0 ){
return SXERR_ABORT;
}
}
jx9MemObjStringAppend(pObj, zCur, (sxu32)(zIn-zCur));
}
else
{
if( pObj == 0 ){
pObj = GenStateNewStrObj(&(*pGen), &iCons);
if( pObj == 0 ){
return SXERR_ABORT;
}
}
jx9MemObjStringAppend(pObj, "", 0);
}
if( zIn >= zEnd ){
break;
}
if( zIn[0] == '\\' ){
const char *zPtr = 0;
sxu32 n;
zIn++;
if( zIn >= zEnd ){
break;
}
if( pObj == 0 ){
pObj = GenStateNewStrObj(&(*pGen), &iCons);
if( pObj == 0 ){
return SXERR_ABORT;
}
}
n = sizeof(char); /* size of conversion */
switch( zIn[0] ){
case '$':
/* Dollar sign */
jx9MemObjStringAppend(pObj, "$", sizeof(char));
break;
case '\\':
/* A literal backslash */
jx9MemObjStringAppend(pObj, "\\", sizeof(char));
break;
case 'a':
/* The "alert" character (BEL)[ctrl+g] ASCII code 7 */
jx9MemObjStringAppend(pObj, "\a", sizeof(char));
break;
case 'b':
/* Backspace (BS)[ctrl+h] ASCII code 8 */
jx9MemObjStringAppend(pObj, "\b", sizeof(char));
break;
case 'f':
/* Form-feed (FF)[ctrl+l] ASCII code 12 */
jx9MemObjStringAppend(pObj, "\f", sizeof(char));
break;
case 'n':
/* Line feed(new line) (LF)[ctrl+j] ASCII code 10 */
jx9MemObjStringAppend(pObj, "\n", sizeof(char));
break;
case 'r':
/* Carriage return (CR)[ctrl+m] ASCII code 13 */
jx9MemObjStringAppend(pObj, "\r", sizeof(char));
break;
case 't':
/* Horizontal tab (HT)[ctrl+i] ASCII code 9 */
jx9MemObjStringAppend(pObj, "\t", sizeof(char));
break;
case 'v':
/* Vertical tab(VT)[ctrl+k] ASCII code 11 */
jx9MemObjStringAppend(pObj, "\v", sizeof(char));
break;
case '\'':
/* Single quote */
jx9MemObjStringAppend(pObj, "'", sizeof(char));
break;
case '"':
/* Double quote */
jx9MemObjStringAppend(pObj, "\"", sizeof(char));
break;
case '0':
/* NUL byte */
jx9MemObjStringAppend(pObj, "\0", sizeof(char));
break;
case 'x':
if((unsigned char)zIn[1] < 0xc0 && SyisHex(zIn[1]) ){
int c;
/* Hex digit */
c = SyHexToint(zIn[1]) << 4;
if( &zIn[2] < zEnd ){
c += SyHexToint(zIn[2]);
}
/* Output char */
jx9MemObjStringAppend(pObj, (const char *)&c, sizeof(char));
n += sizeof(char) * 2;
}else{
/* Output literal character */
jx9MemObjStringAppend(pObj, "x", sizeof(char));
}
break;
case 'o':
if( &zIn[1] < zEnd && (unsigned char)zIn[1] < 0xc0 && SyisDigit(zIn[1]) && (zIn[1] - '0') < 8 ){
/* Octal digit stream */
int c;
c = 0;
zIn++;
for( zPtr = zIn ; zPtr < &zIn[3*sizeof(char)] ; zPtr++ ){
if( zPtr >= zEnd || (unsigned char)zPtr[0] >= 0xc0 || !SyisDigit(zPtr[0]) || (zPtr[0] - '0') > 7 ){
break;
}
c = c * 8 + (zPtr[0] - '0');
}
if ( c > 0 ){
jx9MemObjStringAppend(pObj, (const char *)&c, sizeof(char));
}
n = (sxu32)(zPtr-zIn);
}else{
/* Output literal character */
jx9MemObjStringAppend(pObj, "o", sizeof(char));
}
break;
default:
/* Output without a slash */
jx9MemObjStringAppend(pObj, zIn, sizeof(char));
break;
}
/* Advance the stream cursor */
zIn += n;
continue;
}
if( zIn[0] == '{' ){
/* Curly syntax */
const char *zExpr;
sxi32 iNest = 1;
zIn++;
zExpr = zIn;
/* Synchronize with the next closing curly braces */
while( zIn < zEnd ){
if( zIn[0] == '{' ){
/* Increment nesting level */
iNest++;
}else if(zIn[0] == '}' ){
/* Decrement nesting level */
iNest--;
if( iNest <= 0 ){
break;
}
}
zIn++;
}
/* Process the expression */
rc = GenStateProcessStringExpression(&(*pGen),zExpr,zIn);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
if( rc != SXERR_EMPTY ){
++iCons;
}
if( zIn < zEnd ){
/* Jump the trailing curly */
zIn++;
}
}else{
/* Simple syntax */
const char *zExpr = zIn;
/* Assemble variable name */
for(;;){
/* Jump leading dollars */
while( zIn < zEnd && zIn[0] == '$' ){
zIn++;
}
for(;;){
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && (SyisAlphaNum(zIn[0]) || zIn[0] == '_' ) ){
zIn++;
}
if((unsigned char)zIn[0] >= 0xc0 ){
/* UTF-8 stream */
zIn++;
while( zIn < zEnd && (((unsigned char)zIn[0] & 0xc0) == 0x80) ){
zIn++;
}
continue;
}
break;
}
if( zIn >= zEnd ){
break;
}
if( zIn[0] == '[' ){
sxi32 iSquare = 1;
zIn++;
while( zIn < zEnd ){
if( zIn[0] == '[' ){
iSquare++;
}else if (zIn[0] == ']' ){
iSquare--;
if( iSquare <= 0 ){
break;
}
}
zIn++;
}
if( zIn < zEnd ){
zIn++;
}
break;
}else if( zIn[0] == '.' ){
/* Member access operator '.' */
zIn++;
}else{
break;
}
}
/* Process the expression */
rc = GenStateProcessStringExpression(&(*pGen),zExpr, zIn);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
if( rc != SXERR_EMPTY ){
++iCons;
}
}
/* Invalidate the previously used constant */
pObj = 0;
}/*for(;;)*/
if( iCons > 1 ){
/* Concatenate all compiled constants */
jx9VmEmitInstr(pGen->pVm, JX9_OP_CAT, iCons, 0, 0, 0);
}
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile a double quoted string.
* See the block-comment above for more information.
*/
JX9_PRIVATE sxi32 jx9CompileString(jx9_gen_state *pGen, sxi32 iCompileFlag)
{
sxi32 rc;
rc = GenStateCompileString(&(*pGen));
SXUNUSED(iCompileFlag); /* cc warning */
/* Compilation result */
return rc;
}
/*
* Compile a literal which is an identifier(name) for simple values.
*/
JX9_PRIVATE sxi32 jx9CompileLiteral(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
SyToken *pToken = pGen->pIn;
jx9_value *pObj;
SyString *pStr;
sxu32 nIdx;
/* Extract token value */
pStr = &pToken->sData;
/* Deal with the reserved literals [i.e: null, false, true, ...] first */
if( pStr->nByte == sizeof("NULL") - 1 ){
if( SyStrnicmp(pStr->zString, "null", sizeof("NULL")-1) == 0 ){
/* NULL constant are always indexed at 0 */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 0, 0, 0);
return SXRET_OK;
}else if( SyStrnicmp(pStr->zString, "true", sizeof("TRUE")-1) == 0 ){
/* TRUE constant are always indexed at 1 */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 1, 0, 0);
return SXRET_OK;
}
}else if (pStr->nByte == sizeof("FALSE") - 1 &&
SyStrnicmp(pStr->zString, "false", sizeof("FALSE")-1) == 0 ){
/* FALSE constant are always indexed at 2 */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 2, 0, 0);
return SXRET_OK;
}else if(pStr->nByte == sizeof("__LINE__") - 1 &&
SyMemcmp(pStr->zString, "__LINE__", sizeof("__LINE__")-1) == 0 ){
/* TICKET 1433-004: __LINE__ constant must be resolved at compile time, not run time */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
SXUNUSED(iCompileFlag); /* cc warning */
return GenStateOutOfMem(pGen);
}
jx9MemObjInitFromInt(pGen->pVm, pObj, pToken->nLine);
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
return SXRET_OK;
}else if( pStr->nByte == sizeof("__FUNCTION__") - 1 &&
SyMemcmp(pStr->zString, "__FUNCTION__", sizeof("__FUNCTION__")-1) == 0 ){
GenBlock *pBlock = pGen->pCurrent;
/* TICKET 1433-004: __FUNCTION__/__METHOD__ constants must be resolved at compile time, not run time */
while( pBlock && (pBlock->iFlags & GEN_BLOCK_FUNC) == 0 ){
/* Point to the upper block */
pBlock = pBlock->pParent;
}
if( pBlock == 0 ){
/* Called in the global scope, load NULL */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 0, 0, 0);
}else{
/* Extract the target function/method */
jx9_vm_func *pFunc = (jx9_vm_func *)pBlock->pUserData;
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
return GenStateOutOfMem(pGen);
}
jx9MemObjInitFromString(pGen->pVm, pObj, &pFunc->sName);
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
}
return SXRET_OK;
}
/* Query literal table */
if( SXRET_OK != GenStateFindLiteral(&(*pGen), &pToken->sData, &nIdx) ){
jx9_value *pObj;
/* Unknown literal, install it in the literal table */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
return GenStateOutOfMem(pGen);
}
jx9MemObjInitFromString(pGen->pVm, pObj, &pToken->sData);
GenStateInstallLiteral(&(*pGen), pObj, nIdx);
}
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm,JX9_OP_LOADC,1,nIdx, 0, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile an array entry whether it is a key or a value.
*/
static sxi32 GenStateCompileJSONEntry(
jx9_gen_state *pGen, /* Code generator state */
SyToken *pIn, /* Token stream */
SyToken *pEnd, /* End of the token stream */
sxi32 iFlags, /* Compilation flags */
sxi32 (*xValidator)(jx9_gen_state *,jx9_expr_node *) /* Expression tree validator callback */
)
{
SyToken *pTmpIn, *pTmpEnd;
sxi32 rc;
/* Swap token stream */
SWAP_DELIMITER(pGen, pIn, pEnd);
/* Compile the expression*/
rc = jx9CompileExpr(&(*pGen), iFlags, xValidator);
/* Restore token stream */
RE_SWAP_DELIMITER(pGen);
return rc;
}
/*
* Compile a Jx9 JSON Array.
*/
JX9_PRIVATE sxi32 jx9CompileJsonArray(jx9_gen_state *pGen, sxi32 iCompileFlag)
{
sxi32 nPair = 0;
SyToken *pCur;
sxi32 rc;
pGen->pIn++; /* Jump the open square bracket '['*/
pGen->pEnd--;
SXUNUSED(iCompileFlag); /* cc warning */
for(;;){
/* Jump leading commas */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_COMMA) ){
pGen->pIn++;
}
pCur = pGen->pIn;
if( SXRET_OK != jx9GetNextExpr(pGen->pIn, pGen->pEnd, &pGen->pIn) ){
/* No more entry to process */
break;
}
/* Compile entry */
rc = GenStateCompileJSONEntry(&(*pGen),pCur,pGen->pIn,EXPR_FLAG_RDONLY_LOAD/*Do not create the variable if inexistant*/,0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
nPair++;
}
/* Emit the load map instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOAD_MAP,nPair,0,0,0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Node validator for a given JSON key.
*/
static sxi32 GenStateJSONObjectKeyNodeValidator(jx9_gen_state *pGen,jx9_expr_node *pRoot)
{
sxi32 rc = SXRET_OK;
if( pRoot->xCode != jx9CompileVariable && pRoot->xCode != jx9CompileString
&& pRoot->xCode != jx9CompileSimpleString && pRoot->xCode != jx9CompileLiteral ){
/* Unexpected expression */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pRoot->pStart? pRoot->pStart->nLine : 0,
"JSON Object: Unexpected expression, key must be of type string, literal or simple variable");
if( rc != SXERR_ABORT ){
rc = SXERR_INVALID;
}
}
return rc;
}
/*
* Compile a Jx9 JSON Object
*/
JX9_PRIVATE sxi32 jx9CompileJsonObject(jx9_gen_state *pGen, sxi32 iCompileFlag)
{
SyToken *pKey, *pCur;
sxi32 nPair = 0;
sxi32 rc;
pGen->pIn++; /* Jump the open querly braces '{'*/
pGen->pEnd--;
SXUNUSED(iCompileFlag); /* cc warning */
for(;;){
/* Jump leading commas */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_COMMA) ){
pGen->pIn++;
}
pCur = pGen->pIn;
if( SXRET_OK != jx9GetNextExpr(pGen->pIn, pGen->pEnd, &pGen->pIn) ){
/* No more entry to process */
break;
}
/* Compile the key */
pKey = pCur;
while( pCur < pGen->pIn ){
if( pCur->nType & JX9_TK_COLON /*':'*/ ){
break;
}
pCur++;
}
rc = SXERR_EMPTY;
if( (pCur->nType & JX9_TK_COLON) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ABORT, pCur->nLine, "JSON Object: Missing colon string \":\"");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
return SXRET_OK;
}
if( pCur < pGen->pIn ){
if( &pCur[1] >= pGen->pIn ){
/* Missing value */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pCur->nLine, "JSON Object: Missing entry value");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
return SXRET_OK;
}
/* Compile the expression holding the key */
rc = GenStateCompileJSONEntry(&(*pGen), pKey, pCur,
EXPR_FLAG_RDONLY_LOAD /* Do not create the variable if inexistant */,
GenStateJSONObjectKeyNodeValidator /* Node validator callback */
);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
pCur++; /* Jump the double colon ':' */
}else if( pKey == pCur ){
/* Key is omitted, emit an error */
jx9GenCompileError(&(*pGen),E_ERROR, pCur->nLine, "JSON Object: Missing entry key");
pCur++; /* Jump the double colon ':' */
}else{
/* Reset back the cursor and point to the entry value */
pCur = pKey;
}
/* Compile indice value */
rc = GenStateCompileJSONEntry(&(*pGen), pCur, pGen->pIn, EXPR_FLAG_RDONLY_LOAD/*Do not create the variable if inexistant*/,0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
nPair++;
}
/* Emit the load map instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOAD_MAP, nPair * 2, 1, 0, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile a function [i.e: print, exit(), include(), ...] which is a langauge
* construct.
*/
JX9_PRIVATE sxi32 jx9CompileLangConstruct(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
SyString *pName;
sxu32 nKeyID;
sxi32 rc;
/* Name of the language construct [i.e: print, die...]*/
pName = &pGen->pIn->sData;
nKeyID = (sxu32)SX_PTR_TO_INT(pGen->pIn->pUserData);
pGen->pIn++; /* Jump the language construct keyword */
if( nKeyID == JX9_TKWRD_PRINT ){
SyToken *pTmp, *pNext = 0;
/* Compile arguments one after one */
pTmp = pGen->pEnd;
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, 1 /* Boolean true index */, 0, 0);
while( SXRET_OK == jx9GetNextExpr(pGen->pIn, pTmp, &pNext) ){
if( pGen->pIn < pNext ){
pGen->pEnd = pNext;
rc = jx9CompileExpr(&(*pGen), EXPR_FLAG_RDONLY_LOAD/* Do not create variable if inexistant */, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
if( rc != SXERR_EMPTY ){
/* Ticket 1433-008: Optimization #1: Consume input directly
* without the overhead of a function call.
* This is a very powerful optimization that improve
* performance greatly.
*/
jx9VmEmitInstr(pGen->pVm,JX9_OP_CONSUME,1,0,0,0);
}
}
/* Jump trailing commas */
while( pNext < pTmp && (pNext->nType & JX9_TK_COMMA) ){
pNext++;
}
pGen->pIn = pNext;
}
/* Restore token stream */
pGen->pEnd = pTmp;
}else{
sxi32 nArg = 0;
sxu32 nIdx = 0;
rc = jx9CompileExpr(&(*pGen), EXPR_FLAG_RDONLY_LOAD/* Do not create variable if inexistant */, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}else if(rc != SXERR_EMPTY ){
nArg = 1;
}
if( SXRET_OK != GenStateFindLiteral(&(*pGen), pName, &nIdx) ){
jx9_value *pObj;
/* Emit the call instruction */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
SXUNUSED(iCompileFlag); /* cc warning */
return GenStateOutOfMem(pGen);
}
jx9MemObjInitFromString(pGen->pVm, pObj, pName);
/* Install in the literal table */
GenStateInstallLiteral(&(*pGen), pObj, nIdx);
}
/* Emit the call instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
jx9VmEmitInstr(pGen->pVm, JX9_OP_CALL, nArg, 0, 0, 0);
}
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile a node holding a variable declaration.
* According to the J9X language reference
* Variables in JX9 are represented by a dollar sign followed by the name of the variable.
* The variable name is case-sensitive.
* Variable names follow the same rules as other labels in JX9. A valid variable name
* starts with a letter, underscore or any UTF-8 stream, followed by any number of letters
* numbers, or underscores.
* By default, variables are always assigned by value unless the target value is a JSON
* array or a JSON object which is passed by reference.
*/
JX9_PRIVATE sxi32 jx9CompileVariable(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
sxu32 nLine = pGen->pIn->nLine;
SyHashEntry *pEntry;
SyString *pName;
char *zName = 0;
sxi32 iP1;
void *p3;
sxi32 rc;
pGen->pIn++; /* Jump the dollar sign '$' */
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
/* Invalid variable name */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Invalid variable name");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
return SXRET_OK;
}
/* Extract variable name */
pName = &pGen->pIn->sData;
/* Advance the stream cursor */
pGen->pIn++;
pEntry = SyHashGet(&pGen->hVar, (const void *)pName->zString, pName->nByte);
if( pEntry == 0 ){
/* Duplicate name */
zName = SyMemBackendStrDup(&pGen->pVm->sAllocator, pName->zString, pName->nByte);
if( zName == 0 ){
return GenStateOutOfMem(pGen);
}
/* Install in the hashtable */
SyHashInsert(&pGen->hVar, zName, pName->nByte, zName);
}else{
/* Name already available */
zName = (char *)pEntry->pUserData;
}
p3 = (void *)zName;
iP1 = 0;
if( iCompileFlag & EXPR_FLAG_RDONLY_LOAD ){
if( (iCompileFlag & EXPR_FLAG_LOAD_IDX_STORE) == 0 ){
/* Read-only load.In other words do not create the variable if inexistant */
iP1 = 1;
}
}
/* Emit the load instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOAD, iP1, 0, p3, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/* Forward declaration */
static sxi32 GenStateCompileFunc(jx9_gen_state *pGen,SyString *pName,sxi32 iFlags,jx9_vm_func **ppFunc);
/*
* Compile an annoynmous function or a closure.
* According to the JX9 language reference
* Anonymous functions, also known as closures, allow the creation of functions
* which have no specified name. They are most useful as the value of callback
* parameters, but they have many other uses. Closures can also be used as
* the values of variables; Assigning a closure to a variable uses the same
* syntax as any other assignment, including the trailing semicolon:
* Example Anonymous function variable assignment example
* $greet = function($name)
* {
* printf("Hello %s\r\n", $name);
* };
* $greet('World');
* $greet('JX9');
* Note that the implementation of annoynmous function and closure under
* JX9 is completely different from the one used by the engine.
*/
JX9_PRIVATE sxi32 jx9CompileAnnonFunc(jx9_gen_state *pGen,sxi32 iCompileFlag)
{
jx9_vm_func *pAnnonFunc; /* Annonymous function body */
char zName[512]; /* Unique lambda name */
static int iCnt = 1; /* There is no worry about thread-safety here, because only
* one thread is allowed to compile the script.
*/
jx9_value *pObj;
SyString sName;
sxu32 nIdx;
sxu32 nLen;
sxi32 rc;
pGen->pIn++; /* Jump the 'function' keyword */
if( pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD) ){
pGen->pIn++;
}
/* Reserve a constant for the lambda */
pObj = jx9VmReserveConstObj(pGen->pVm, &nIdx);
if( pObj == 0 ){
GenStateOutOfMem(pGen);
SXUNUSED(iCompileFlag); /* cc warning */
return SXERR_ABORT;
}
/* Generate a unique name */
nLen = SyBufferFormat(zName, sizeof(zName), "[lambda_%d]", iCnt++);
/* Make sure the generated name is unique */
while( SyHashGet(&pGen->pVm->hFunction, zName, nLen) != 0 && nLen < sizeof(zName) - 2 ){
nLen = SyBufferFormat(zName, sizeof(zName), "[lambda_%d]", iCnt++);
}
SyStringInitFromBuf(&sName, zName, nLen);
jx9MemObjInitFromString(pGen->pVm, pObj, &sName);
/* Compile the lambda body */
rc = GenStateCompileFunc(&(*pGen),&sName,0,&pAnnonFunc);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* Emit the load constant instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_LOADC, 0, nIdx, 0, 0);
/* Node successfully compiled */
return SXRET_OK;
}
/*
* Compile the 'continue' statement.
* According to the JX9 language reference
* continue is used within looping structures to skip the rest of the current loop iteration
* and continue execution at the condition evaluation and then the beginning of the next
* iteration.
* Note: Note that in JX9 the switch statement is considered a looping structure for
* the purposes of continue.
* continue accepts an optional numeric argument which tells it how many levels
* of enclosing loops it should skip to the end of.
* Note:
* continue 0; and continue 1; is the same as running continue;.
*/
static sxi32 jx9CompileContinue(jx9_gen_state *pGen)
{
GenBlock *pLoop; /* Target loop */
sxi32 iLevel; /* How many nesting loop to skip */
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
iLevel = 0;
/* Jump the 'continue' keyword */
pGen->pIn++;
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_NUM) ){
/* optional numeric argument which tells us how many levels
* of enclosing loops we should skip to the end of.
*/
iLevel = (sxi32)jx9TokenValueToInt64(&pGen->pIn->sData);
if( iLevel < 2 ){
iLevel = 0;
}
pGen->pIn++; /* Jump the optional numeric argument */
}
/* Point to the target loop */
pLoop = GenStateFetchBlock(pGen->pCurrent, GEN_BLOCK_LOOP, iLevel);
if( pLoop == 0 ){
/* Illegal continue */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "A 'continue' statement may only be used within a loop or switch");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
}else{
sxu32 nInstrIdx = 0;
/* Emit the unconditional jump to the beginning of the target loop */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, pLoop->nFirstInstr, 0, &nInstrIdx);
if( pLoop->bPostContinue == TRUE ){
JumpFixup sJumpFix;
/* Post-continue */
sJumpFix.nJumpType = JX9_OP_JMP;
sJumpFix.nInstrIdx = nInstrIdx;
SySetPut(&pLoop->aPostContFix, (const void *)&sJumpFix);
}
}
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Not so fatal, emit a warning only */
jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine, "Expected semi-colon ';' after 'continue' statement");
}
/* Statement successfully compiled */
return SXRET_OK;
}
/*
* Compile the 'break' statement.
* According to the JX9 language reference
* break ends execution of the current for, foreach, while, do-while or switch
* structure.
* break accepts an optional numeric argument which tells it how many nested
* enclosing structures are to be broken out of.
*/
static sxi32 jx9CompileBreak(jx9_gen_state *pGen)
{
GenBlock *pLoop; /* Target loop */
sxi32 iLevel; /* How many nesting loop to skip */
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
iLevel = 0;
/* Jump the 'break' keyword */
pGen->pIn++;
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_NUM) ){
/* optional numeric argument which tells us how many levels
* of enclosing loops we should skip to the end of.
*/
iLevel = (sxi32)jx9TokenValueToInt64(&pGen->pIn->sData);
if( iLevel < 2 ){
iLevel = 0;
}
pGen->pIn++; /* Jump the optional numeric argument */
}
/* Extract the target loop */
pLoop = GenStateFetchBlock(pGen->pCurrent, GEN_BLOCK_LOOP, iLevel);
if( pLoop == 0 ){
/* Illegal break */
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine, "A 'break' statement may only be used within a loop or switch");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
}else{
sxu32 nInstrIdx;
rc = jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, 0, 0, &nInstrIdx);
if( rc == SXRET_OK ){
/* Fix the jump later when the jump destination is resolved */
GenStateNewJumpFixup(pLoop, JX9_OP_JMP, nInstrIdx);
}
}
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Not so fatal, emit a warning only */
jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine, "Expected semi-colon ';' after 'break' statement");
}
/* Statement successfully compiled */
return SXRET_OK;
}
/* Forward declaration */
static sxi32 GenStateCompileChunk(jx9_gen_state *pGen,sxi32 iFlags);
/*
* Compile a JX9 block.
* A block is simply one or more JX9 statements and expressions to compile
* optionally delimited by braces {}.
* Return SXRET_OK on success. Any other return value indicates failure
* and this function takes care of generating the appropriate error
* message.
*/
static sxi32 jx9CompileBlock(
jx9_gen_state *pGen /* Code generator state */
)
{
sxi32 rc;
if( pGen->pIn->nType & JX9_TK_OCB /* '{' */ ){
sxu32 nLine = pGen->pIn->nLine;
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_STD, jx9VmInstrLength(pGen->pVm), 0, 0);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
pGen->pIn++;
/* Compile until we hit the closing braces '}' */
for(;;){
if( pGen->pIn >= pGen->pEnd ){
/* No more token to process. Missing closing braces */
jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Missing closing braces '}'");
break;
}
if( pGen->pIn->nType & JX9_TK_CCB/*'}'*/ ){
/* Closing braces found, break immediately*/
pGen->pIn++;
break;
}
/* Compile a single statement */
rc = GenStateCompileChunk(&(*pGen),JX9_COMPILE_SINGLE_STMT);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
GenStateLeaveBlock(&(*pGen), 0);
}else{
/* Compile a single statement */
rc = GenStateCompileChunk(&(*pGen),JX9_COMPILE_SINGLE_STMT);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
/* Jump trailing semi-colons ';' */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the gentle 'while' statement.
* According to the JX9 language reference
* while loops are the simplest type of loop in JX9.They behave just like their C counterparts.
* The basic form of a while statement is:
* while (expr)
* statement
* The meaning of a while statement is simple. It tells JX9 to execute the nested statement(s)
* repeatedly, as long as the while expression evaluates to TRUE. The value of the expression
* is checked each time at the beginning of the loop, so even if this value changes during
* the execution of the nested statement(s), execution will not stop until the end of the iteration
* (each time JX9 runs the statements in the loop is one iteration). Sometimes, if the while
* expression evaluates to FALSE from the very beginning, the nested statement(s) won't even be run once.
* Like with the if statement, you can group multiple statements within the same while loop by surrounding
* a group of statements with curly braces, or by using the alternate syntax:
* while (expr):
* statement
* endwhile;
*/
static sxi32 jx9CompileWhile(jx9_gen_state *pGen)
{
GenBlock *pWhileBlock = 0;
SyToken *pTmp, *pEnd = 0;
sxu32 nFalseJump;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
/* Jump the 'while' keyword */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected '(' after 'while' keyword");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Jump the left parenthesis '(' */
pGen->pIn++;
/* Create the loop block */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_LOOP, jx9VmInstrLength(pGen->pVm), 0, &pWhileBlock);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
/* Delimit the condition */
jx9DelimitNestedTokens(pGen->pIn, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pGen->pIn == pEnd || pEnd >= pGen->pEnd ){
/* Empty expression */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected expression after 'while' keyword");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
}
/* Swap token streams */
pTmp = pGen->pEnd;
pGen->pEnd = pEnd;
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}
/* Update token stream */
while(pGen->pIn < pEnd ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Unexpected token '%z'", &pGen->pIn->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
pGen->pIn++;
}
/* Synchronize pointers */
pGen->pIn = &pEnd[1];
pGen->pEnd = pTmp;
/* Emit the false jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JZ, 0, 0, 0, &nFalseJump);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pWhileBlock, JX9_OP_JZ, nFalseJump);
/* Compile the loop body */
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* Emit the unconditional jump to the start of the loop */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, pWhileBlock->nFirstInstr, 0, 0);
/* Fix all jumps now the destination is resolved */
GenStateFixJumps(pWhileBlock, -1, jx9VmInstrLength(pGen->pVm));
/* Release the loop block */
GenStateLeaveBlock(pGen, 0);
/* Statement successfully compiled */
return SXRET_OK;
Synchronize:
/* Synchronize with the first semi-colon ';' so we can avoid
* compiling this erroneous block.
*/
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the complex and powerful 'for' statement.
* According to the JX9 language reference
* for loops are the most complex loops in JX9. They behave like their C counterparts.
* The syntax of a for loop is:
* for (expr1; expr2; expr3)
* statement
* The first expression (expr1) is evaluated (executed) once unconditionally at
* the beginning of the loop.
* In the beginning of each iteration, expr2 is evaluated. If it evaluates to
* TRUE, the loop continues and the nested statement(s) are executed. If it evaluates
* to FALSE, the execution of the loop ends.
* At the end of each iteration, expr3 is evaluated (executed).
* Each of the expressions can be empty or contain multiple expressions separated by commas.
* In expr2, all expressions separated by a comma are evaluated but the result is taken
* from the last part. expr2 being empty means the loop should be run indefinitely
* (JX9 implicitly considers it as TRUE, like C). This may not be as useless as you might
* think, since often you'd want to end the loop using a conditional break statement instead
* of using the for truth expression.
*/
static sxi32 jx9CompileFor(jx9_gen_state *pGen)
{
SyToken *pTmp, *pPostStart, *pEnd = 0;
GenBlock *pForBlock = 0;
sxu32 nFalseJump;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
/* Jump the 'for' keyword */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected '(' after 'for' keyword");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
return SXRET_OK;
}
/* Jump the left parenthesis '(' */
pGen->pIn++;
/* Delimit the init-expr;condition;post-expr */
jx9DelimitNestedTokens(pGen->pIn, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pGen->pIn == pEnd || pEnd >= pGen->pEnd ){
/* Empty expression */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "for: Invalid expression");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
/* Synchronize */
pGen->pIn = pEnd;
if( pGen->pIn < pGen->pEnd ){
pGen->pIn++;
}
return SXRET_OK;
}
/* Swap token streams */
pTmp = pGen->pEnd;
pGen->pEnd = pEnd;
/* Compile initialization expressions if available */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Pop operand lvalues */
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}else if( rc != SXERR_EMPTY ){
jx9VmEmitInstr(pGen->pVm, JX9_OP_POP, 1, 0, 0, 0);
}
if( (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine,
"for: Expected ';' after initialization expressions");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
return SXRET_OK;
}
/* Jump the trailing ';' */
pGen->pIn++;
/* Create the loop block */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_LOOP, jx9VmInstrLength(pGen->pVm), 0, &pForBlock);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
/* Deffer continue jumps */
pForBlock->bPostContinue = TRUE;
/* Compile the condition */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}else if( rc != SXERR_EMPTY ){
/* Emit the false jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JZ, 0, 0, 0, &nFalseJump);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pForBlock, JX9_OP_JZ, nFalseJump);
}
if( (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine,
"for: Expected ';' after conditionals expressions");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
return SXRET_OK;
}
/* Jump the trailing ';' */
pGen->pIn++;
/* Save the post condition stream */
pPostStart = pGen->pIn;
/* Compile the loop body */
pGen->pIn = &pEnd[1]; /* Jump the trailing parenthesis ')' */
pGen->pEnd = pTmp;
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* Fix post-continue jumps */
if( SySetUsed(&pForBlock->aPostContFix) > 0 ){
JumpFixup *aPost;
VmInstr *pInstr;
sxu32 nJumpDest;
sxu32 n;
aPost = (JumpFixup *)SySetBasePtr(&pForBlock->aPostContFix);
nJumpDest = jx9VmInstrLength(pGen->pVm);
for( n = 0 ; n < SySetUsed(&pForBlock->aPostContFix) ; ++n ){
pInstr = jx9VmGetInstr(pGen->pVm, aPost[n].nInstrIdx);
if( pInstr ){
/* Fix jump */
pInstr->iP2 = nJumpDest;
}
}
}
/* compile the post-expressions if available */
while( pPostStart < pEnd && (pPostStart->nType & JX9_TK_SEMI) ){
pPostStart++;
}
if( pPostStart < pEnd ){
SyToken *pTmpIn, *pTmpEnd;
SWAP_DELIMITER(pGen, pPostStart, pEnd);
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( pGen->pIn < pGen->pEnd ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine, "for: Expected ')' after post-expressions");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
return SXRET_OK;
}
RE_SWAP_DELIMITER(pGen);
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}else if( rc != SXERR_EMPTY){
/* Pop operand lvalue */
jx9VmEmitInstr(pGen->pVm, JX9_OP_POP, 1, 0, 0, 0);
}
}
/* Emit the unconditional jump to the start of the loop */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, pForBlock->nFirstInstr, 0, 0);
/* Fix all jumps now the destination is resolved */
GenStateFixJumps(pForBlock, -1, jx9VmInstrLength(pGen->pVm));
/* Release the loop block */
GenStateLeaveBlock(pGen, 0);
/* Statement successfully compiled */
return SXRET_OK;
}
/* Expression tree validator callback used by the 'foreach' statement.
* Note that only variable expression [i.e: $x; ${'My'.'Var'}; ${$a['key]};...]
* are allowed.
*/
static sxi32 GenStateForEachNodeValidator(jx9_gen_state *pGen,jx9_expr_node *pRoot)
{
sxi32 rc = SXRET_OK; /* Assume a valid expression tree */
if( pRoot->xCode != jx9CompileVariable ){
/* Unexpected expression */
rc = jx9GenCompileError(&(*pGen),
E_ERROR,
pRoot->pStart? pRoot->pStart->nLine : 0,
"foreach: Expecting a variable name"
);
if( rc != SXERR_ABORT ){
rc = SXERR_INVALID;
}
}
return rc;
}
/*
* Compile the 'foreach' statement.
* According to the JX9 language reference
* The foreach construct simply gives an easy way to iterate over arrays. foreach works
* only on arrays (and objects), and will issue an error when you try to use it on a variable
* with a different data type or an uninitialized variable. There are two syntaxes; the second
* is a minor but useful extension of the first:
* foreach (json_array_json_object as $value)
* statement
* foreach (json_array_json_objec as $key,$value)
* statement
* The first form loops over the array given by array_expression. On each loop, the value
* of the current element is assigned to $value and the internal array pointer is advanced
* by one (so on the next loop, you'll be looking at the next element).
* The second form does the same thing, except that the current element's key will be assigned
* to the variable $key on each loop.
* Note:
* When foreach first starts executing, the internal array pointer is automatically reset to the
* first element of the array. This means that you do not need to call reset() before a foreach loop.
*/
static sxi32 jx9CompileForeach(jx9_gen_state *pGen)
{
SyToken *pCur, *pTmp, *pEnd = 0;
GenBlock *pForeachBlock = 0;
jx9_foreach_info *pInfo;
sxu32 nFalseJump;
VmInstr *pInstr;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
/* Jump the 'foreach' keyword */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "foreach: Expected '('");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Jump the left parenthesis '(' */
pGen->pIn++;
/* Create the loop block */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_LOOP, jx9VmInstrLength(pGen->pVm), 0, &pForeachBlock);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
/* Delimit the expression */
jx9DelimitNestedTokens(pGen->pIn, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pGen->pIn == pEnd || pEnd >= pGen->pEnd ){
/* Empty expression */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "foreach: Missing expression");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
/* Synchronize */
pGen->pIn = pEnd;
if( pGen->pIn < pGen->pEnd ){
pGen->pIn++;
}
return SXRET_OK;
}
/* Compile the array expression */
pCur = pGen->pIn;
while( pCur < pEnd ){
if( pCur->nType & JX9_TK_KEYWORD ){
sxi32 nKeywrd = SX_PTR_TO_INT(pCur->pUserData);
if( nKeywrd == JX9_TKWRD_AS ){
/* Break with the first 'as' found */
break;
}
}
/* Advance the stream cursor */
pCur++;
}
if( pCur <= pGen->pIn ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine,
"foreach: Missing array/object expression");
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Swap token streams */
pTmp = pGen->pEnd;
pGen->pEnd = pCur;
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}
/* Update token stream */
while(pGen->pIn < pCur ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "foreach: Unexpected token '%z'", &pGen->pIn->sData);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
pGen->pIn++;
}
pCur++; /* Jump the 'as' keyword */
pGen->pIn = pCur;
if( pGen->pIn >= pEnd ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "foreach: Missing $key => $value pair");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
/* Create the foreach context */
pInfo = (jx9_foreach_info *)SyMemBackendAlloc(&pGen->pVm->sAllocator, sizeof(jx9_foreach_info));
if( pInfo == 0 ){
jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Fatal, JX9 engine is running out-of-memory");
return SXERR_ABORT;
}
/* Zero the structure */
SyZero(pInfo, sizeof(jx9_foreach_info));
/* Initialize structure fields */
SySetInit(&pInfo->aStep, &pGen->pVm->sAllocator, sizeof(jx9_foreach_step *));
/* Check if we have a key field */
while( pCur < pEnd && (pCur->nType & JX9_TK_COMMA) == 0 ){
pCur++;
}
if( pCur < pEnd ){
/* Compile the expression holding the key name */
if( pGen->pIn >= pCur ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "foreach: Missing $key");
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
}else{
pGen->pEnd = pCur;
rc = jx9CompileExpr(&(*pGen), 0, GenStateForEachNodeValidator);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
pInstr = jx9VmPopInstr(pGen->pVm);
if( pInstr->p3 ){
/* Record key name */
SyStringInitFromBuf(&pInfo->sKey, pInstr->p3, SyStrlen((const char *)pInstr->p3));
}
pInfo->iFlags |= JX9_4EACH_STEP_KEY;
}
pGen->pIn = &pCur[1]; /* Jump the arrow */
}
pGen->pEnd = pEnd;
if( pGen->pIn >= pEnd ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "foreach: Missing $value");
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Compile the expression holding the value name */
rc = jx9CompileExpr(&(*pGen), 0, GenStateForEachNodeValidator);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
pInstr = jx9VmPopInstr(pGen->pVm);
if( pInstr->p3 ){
/* Record value name */
SyStringInitFromBuf(&pInfo->sValue, pInstr->p3, SyStrlen((const char *)pInstr->p3));
}
/* Emit the 'FOREACH_INIT' instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_FOREACH_INIT, 0, 0, pInfo, &nFalseJump);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pForeachBlock, JX9_OP_FOREACH_INIT, nFalseJump);
/* Record the first instruction to execute */
pForeachBlock->nFirstInstr = jx9VmInstrLength(pGen->pVm);
/* Emit the FOREACH_STEP instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_FOREACH_STEP, 0, 0, pInfo, &nFalseJump);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pForeachBlock, JX9_OP_FOREACH_STEP, nFalseJump);
/* Compile the loop body */
pGen->pIn = &pEnd[1];
pGen->pEnd = pTmp;
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
/* Emit the unconditional jump to the start of the loop */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, pForeachBlock->nFirstInstr, 0, 0);
/* Fix all jumps now the destination is resolved */
GenStateFixJumps(pForeachBlock, -1,jx9VmInstrLength(pGen->pVm));
/* Release the loop block */
GenStateLeaveBlock(pGen, 0);
/* Statement successfully compiled */
return SXRET_OK;
Synchronize:
/* Synchronize with the first semi-colon ';' so we can avoid
* compiling this erroneous block.
*/
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the infamous if/elseif/else if/else statements.
* According to the JX9 language reference
* The if construct is one of the most important features of many languages JX9 included.
* It allows for conditional execution of code fragments. JX9 features an if structure
* that is similar to that of C:
* if (expr)
* statement
* else construct:
* Often you'd want to execute a statement if a certain condition is met, and a different
* statement if the condition is not met. This is what else is for. else extends an if statement
* to execute a statement in case the expression in the if statement evaluates to FALSE.
* For example, the following code would display a is greater than b if $a is greater than
* $b, and a is NOT greater than b otherwise.
* The else statement is only executed if the if expression evaluated to FALSE, and if there
* were any elseif expressions - only if they evaluated to FALSE as well
* elseif
* elseif, as its name suggests, is a combination of if and else. Like else, it extends
* an if statement to execute a different statement in case the original if expression evaluates
* to FALSE. However, unlike else, it will execute that alternative expression only if the elseif
* conditional expression evaluates to TRUE. For example, the following code would display a is bigger
* than b, a equal to b or a is smaller than b:
* if ($a > $b) {
* print "a is bigger than b";
* } elseif ($a == $b) {
* print "a is equal to b";
* } else {
* print "a is smaller than b";
* }
*/
static sxi32 jx9CompileIf(jx9_gen_state *pGen)
{
SyToken *pToken, *pTmp, *pEnd = 0;
GenBlock *pCondBlock = 0;
sxu32 nJumpIdx;
sxu32 nKeyID;
sxi32 rc;
/* Jump the 'if' keyword */
pGen->pIn++;
pToken = pGen->pIn;
/* Create the conditional block */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_COND, jx9VmInstrLength(pGen->pVm), 0, &pCondBlock);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
/* Process as many [if/else if/elseif/else] blocks as we can */
for(;;){
if( pToken >= pGen->pEnd || (pToken->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
if( pToken >= pGen->pEnd ){
pToken--;
}
rc = jx9GenCompileError(pGen, E_ERROR, pToken->nLine, "if/else/elseif: Missing '('");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Jump the left parenthesis '(' */
pToken++;
/* Delimit the condition */
jx9DelimitNestedTokens(pToken, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pToken >= pEnd || (pEnd->nType & JX9_TK_RPAREN) == 0 ){
/* Syntax error */
if( pToken >= pGen->pEnd ){
pToken--;
}
rc = jx9GenCompileError(pGen, E_ERROR, pToken->nLine, "if/else/elseif: Missing ')'");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Swap token streams */
SWAP_TOKEN_STREAM(pGen, pToken, pEnd);
/* Compile the condition */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Update token stream */
while(pGen->pIn < pEnd ){
jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Unexpected token '%z'", &pGen->pIn->sData);
pGen->pIn++;
}
pGen->pIn = &pEnd[1];
pGen->pEnd = pTmp;
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}
/* Emit the false jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JZ, 0, 0, 0, &nJumpIdx);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pCondBlock, JX9_OP_JZ, nJumpIdx);
/* Compile the body */
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_KEYWORD) == 0 ){
break;
}
/* Ensure that the keyword ID is 'else if' or 'else' */
nKeyID = (sxu32)SX_PTR_TO_INT(pGen->pIn->pUserData);
if( (nKeyID & (JX9_TKWRD_ELSE|JX9_TKWRD_ELIF)) == 0 ){
break;
}
/* Emit the unconditional jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, 0, 0, &nJumpIdx);
/* Save the instruction index so we can fix it later when the jump destination is resolved */
GenStateNewJumpFixup(pCondBlock, JX9_OP_JMP, nJumpIdx);
if( nKeyID & JX9_TKWRD_ELSE ){
pToken = &pGen->pIn[1];
if( pToken >= pGen->pEnd || (pToken->nType & JX9_TK_KEYWORD) == 0 ||
SX_PTR_TO_INT(pToken->pUserData) != JX9_TKWRD_IF ){
break;
}
pGen->pIn++; /* Jump the 'else' keyword */
}
pGen->pIn++; /* Jump the 'elseif/if' keyword */
/* Synchronize cursors */
pToken = pGen->pIn;
/* Fix the false jump */
GenStateFixJumps(pCondBlock, JX9_OP_JZ, jx9VmInstrLength(pGen->pVm));
} /* For(;;) */
/* Fix the false jump */
GenStateFixJumps(pCondBlock, JX9_OP_JZ, jx9VmInstrLength(pGen->pVm));
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_KEYWORD) &&
(SX_PTR_TO_INT(pGen->pIn->pUserData) & JX9_TKWRD_ELSE) ){
/* Compile the else block */
pGen->pIn++;
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
nJumpIdx = jx9VmInstrLength(pGen->pVm);
/* Fix all unconditional jumps now the destination is resolved */
GenStateFixJumps(pCondBlock, JX9_OP_JMP, nJumpIdx);
/* Release the conditional block */
GenStateLeaveBlock(pGen, 0);
/* Statement successfully compiled */
return SXRET_OK;
Synchronize:
/* Synchronize with the first semi-colon ';' so we can avoid compiling this erroneous block.
*/
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the return statement.
* According to the JX9 language reference
* If called from within a function, the return() statement immediately ends execution
* of the current function, and returns its argument as the value of the function call.
* return() will also end the execution of an eval() statement or script file.
* If called from the global scope, then execution of the current script file is ended.
* If the current script file was include()ed or require()ed, then control is passed back
* to the calling file. Furthermore, if the current script file was include()ed, then the value
* given to return() will be returned as the value of the include() call. If return() is called
* from within the main script file, then script execution end.
* Note that since return() is a language construct and not a function, the parentheses
* surrounding its arguments are not required. It is common to leave them out, and you actually
* should do so as JX9 has less work to do in this case.
* Note: If no parameter is supplied, then the parentheses must be omitted and JX9 is returning NULL instead..
*/
static sxi32 jx9CompileReturn(jx9_gen_state *pGen)
{
sxi32 nRet = 0; /* TRUE if there is a return value */
sxi32 rc;
/* Jump the 'return' keyword */
pGen->pIn++;
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}else if(rc != SXERR_EMPTY ){
nRet = 1;
}
}
/* Emit the done instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, nRet, 0, 0, 0);
return SXRET_OK;
}
/*
* Compile the die/exit language construct.
* The role of these constructs is to terminate execution of the script.
* Shutdown functions will always be executed even if exit() is called.
*/
static sxi32 jx9CompileHalt(jx9_gen_state *pGen)
{
sxi32 nExpr = 0;
sxi32 rc;
/* Jump the die/exit keyword */
pGen->pIn++;
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}else if(rc != SXERR_EMPTY ){
nExpr = 1;
}
}
/* Emit the HALT instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_HALT, nExpr, 0, 0, 0);
return SXRET_OK;
}
/*
* Compile the static statement.
* According to the JX9 language reference
* Another important feature of variable scoping is the static variable.
* A static variable exists only in a local function scope, but it does not lose its value
* when program execution leaves this scope.
* Static variables also provide one way to deal with recursive functions.
*/
static sxi32 jx9CompileStatic(jx9_gen_state *pGen)
{
jx9_vm_func_static_var sStatic; /* Structure describing the static variable */
jx9_vm_func *pFunc; /* Enclosing function */
GenBlock *pBlock;
SyString *pName;
char *zDup;
sxu32 nLine;
sxi32 rc;
/* Jump the static keyword */
nLine = pGen->pIn->nLine;
pGen->pIn++;
/* Extract the enclosing function if any */
pBlock = pGen->pCurrent;
while( pBlock ){
if( pBlock->iFlags & GEN_BLOCK_FUNC){
break;
}
/* Point to the upper block */
pBlock = pBlock->pParent;
}
if( pBlock == 0 ){
/* Static statement, called outside of a function body, treat it as a simple variable. */
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_DOLLAR) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Expected variable after 'static' keyword");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
goto Synchronize;
}
/* Compile the expression holding the variable */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}else if( rc != SXERR_EMPTY ){
/* Emit the POP instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_POP, 1, 0, 0, 0);
}
return SXRET_OK;
}
pFunc = (jx9_vm_func *)pBlock->pUserData;
/* Make sure we are dealing with a valid statement */
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_DOLLAR) == 0 || &pGen->pIn[1] >= pGen->pEnd ||
(pGen->pIn[1].nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Expected variable after 'static' keyword");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
goto Synchronize;
}
pGen->pIn++;
/* Extract variable name */
pName = &pGen->pIn->sData;
pGen->pIn++; /* Jump the var name */
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI/*';'*/|JX9_TK_EQUAL/*'='*/)) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "static: Unexpected token '%z'", &pGen->pIn->sData);
goto Synchronize;
}
/* Initialize the structure describing the static variable */
SySetInit(&sStatic.aByteCode, &pGen->pVm->sAllocator, sizeof(VmInstr));
sStatic.nIdx = SXU32_HIGH; /* Not yet created */
/* Duplicate variable name */
zDup = SyMemBackendStrDup(&pGen->pVm->sAllocator, pName->zString, pName->nByte);
if( zDup == 0 ){
jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Fatal, JX9 engine is running out of memory");
return SXERR_ABORT;
}
SyStringInitFromBuf(&sStatic.sName, zDup, pName->nByte);
/* Check if we have an expression to compile */
if( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_EQUAL) ){
SySet *pInstrContainer;
pGen->pIn++; /* Jump the equal '=' sign */
/* Swap bytecode container */
pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
jx9VmSetByteCodeContainer(pGen->pVm, &sStatic.aByteCode);
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Emit the done instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, (rc != SXERR_EMPTY ? 1 : 0), 0, 0, 0);
/* Restore default bytecode container */
jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer);
}
/* Finally save the compiled static variable in the appropriate container */
SySetPut(&pFunc->aStatic, (const void *)&sStatic);
return SXRET_OK;
Synchronize:
/* Synchronize with the first semi-colon ';', so we can avoid compiling this erroneous
* statement.
*/
while(pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the 'const' statement.
* According to the JX9 language reference
* A constant is an identifier (name) for a simple value. As the name suggests, that value
* cannot change during the execution of the script (except for magic constants, which aren't actually constants).
* A constant is case-sensitive by default. By convention, constant identifiers are always uppercase.
* The name of a constant follows the same rules as any label in JX9. A valid constant name starts
* with a letter or underscore, followed by any number of letters, numbers, or underscores.
* As a regular expression it would be expressed thusly: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*
* Syntax
* You can define a constant by using the define()-function or by using the const keyword outside
* a object definition. Once a constant is defined, it can never be changed or undefined.
* You can get the value of a constant by simply specifying its name. Unlike with variables
* you should not prepend a constant with a $. You can also use the function constant() to read
* a constant's value if you wish to obtain the constant's name dynamically. Use get_defined_constants()
* to get a list of all defined constants.
*/
static sxi32 jx9CompileConstant(jx9_gen_state *pGen)
{
SySet *pConsCode, *pInstrContainer;
sxu32 nLine = pGen->pIn->nLine;
SyString *pName;
sxi32 rc;
pGen->pIn++; /* Jump the 'const' keyword */
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_SSTR|JX9_TK_DSTR|JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
/* Invalid constant name */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "const: Invalid constant name");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Peek constant name */
pName = &pGen->pIn->sData;
/* Make sure the constant name isn't reserved */
if( GenStateIsReservedID(pName) ){
/* Reserved constant */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "const: Cannot redeclare a reserved constant '%z'", pName);
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
pGen->pIn++;
if(pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_EQUAL /* '=' */) == 0 ){
/* Invalid statement*/
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "const: Expected '=' after constant name");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
pGen->pIn++; /*Jump the equal sign */
/* Allocate a new constant value container */
pConsCode = (SySet *)SyMemBackendPoolAlloc(&pGen->pVm->sAllocator, sizeof(SySet));
if( pConsCode == 0 ){
return GenStateOutOfMem(pGen);
}
SySetInit(pConsCode, &pGen->pVm->sAllocator, sizeof(VmInstr));
/* Swap bytecode container */
pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
jx9VmSetByteCodeContainer(pGen->pVm, pConsCode);
/* Compile constant value */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Emit the done instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, (rc != SXERR_EMPTY ? 1 : 0), 0, 0, 0);
jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
SySetSetUserData(pConsCode, pGen->pVm);
/* Register the constant */
rc = jx9VmRegisterConstant(pGen->pVm, pName, jx9VmExpandConstantValue, pConsCode);
if( rc != SXRET_OK ){
SySetRelease(pConsCode);
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pConsCode);
}
return SXRET_OK;
Synchronize:
/* Synchronize with the next-semi-colon and avoid compiling this erroneous statement */
while(pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Compile the uplink construct.
* According to the JX9 language reference
* In JX9 global variables must be declared uplink inside a function if they are going
* to be used in that function.
* Example #1 Using global
* $a = 1;
* $b = 2;
* function Sum()
* {
* uplink $a, $b;
* $b = $a + $b;
* }
* Sum();
* print $b;
* ?>
* The above script will output 3. By declaring $a and $b global within the function
* all references to either variable will refer to the global version. There is no limit
* to the number of global variables that can be manipulated by a function.
*/
static sxi32 jx9CompileUplink(jx9_gen_state *pGen)
{
SyToken *pTmp, *pNext = 0;
sxi32 nExpr;
sxi32 rc;
/* Jump the 'uplink' keyword */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_SEMI) ){
/* Nothing to process */
return SXRET_OK;
}
pTmp = pGen->pEnd;
nExpr = 0;
while( SXRET_OK == jx9GetNextExpr(pGen->pIn, pTmp, &pNext) ){
if( pGen->pIn < pNext ){
pGen->pEnd = pNext;
if( (pGen->pIn->nType & JX9_TK_DOLLAR) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "uplink: Expected variable name");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}else{
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd ){
/* Emit a warning */
jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn[-1].nLine, "uplink: Empty variable name");
}else{
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}else if(rc != SXERR_EMPTY ){
nExpr++;
}
}
}
}
/* Next expression in the stream */
pGen->pIn = pNext;
/* Jump trailing commas */
while( pGen->pIn < pTmp && (pGen->pIn->nType & JX9_TK_COMMA) ){
pGen->pIn++;
}
}
/* Restore token stream */
pGen->pEnd = pTmp;
if( nExpr > 0 ){
/* Emit the uplink instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_UPLINK, nExpr, 0, 0, 0);
}
return SXRET_OK;
}
/*
* Compile a switch block.
* (See block-comment below for more information)
*/
static sxi32 GenStateCompileSwitchBlock(jx9_gen_state *pGen,sxu32 *pBlockStart)
{
sxi32 rc = SXRET_OK;
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI/*';'*/|JX9_TK_COLON/*':'*/)) == 0 ){
/* Unexpected token */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Unexpected token '%z'", &pGen->pIn->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
pGen->pIn++;
}
pGen->pIn++;
/* First instruction to execute in this block. */
*pBlockStart = jx9VmInstrLength(pGen->pVm);
/* Compile the block until we hit a case/default/endswitch keyword
* or the '}' token */
for(;;){
if( pGen->pIn >= pGen->pEnd ){
/* No more input to process */
break;
}
rc = SXRET_OK;
if( (pGen->pIn->nType & JX9_TK_KEYWORD) == 0 ){
if( pGen->pIn->nType & JX9_TK_CCB /*'}' */ ){
rc = SXERR_EOF;
break;
}
}else{
sxi32 nKwrd;
/* Extract the keyword */
nKwrd = SX_PTR_TO_INT(pGen->pIn->pUserData);
if( nKwrd == JX9_TKWRD_CASE || nKwrd == JX9_TKWRD_DEFAULT ){
break;
}
}
/* Compile block */
rc = jx9CompileBlock(&(*pGen));
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
return rc;
}
/*
* Compile a case eXpression.
* (See block-comment below for more information)
*/
static sxi32 GenStateCompileCaseExpr(jx9_gen_state *pGen, jx9_case_expr *pExpr)
{
SySet *pInstrContainer;
SyToken *pEnd, *pTmp;
sxi32 iNest = 0;
sxi32 rc;
/* Delimit the expression */
pEnd = pGen->pIn;
while( pEnd < pGen->pEnd ){
if( pEnd->nType & JX9_TK_LPAREN /*(*/ ){
/* Increment nesting level */
iNest++;
}else if( pEnd->nType & JX9_TK_RPAREN /*)*/ ){
/* Decrement nesting level */
iNest--;
}else if( pEnd->nType & (JX9_TK_SEMI/*';'*/|JX9_TK_COLON/*;'*/) && iNest < 1 ){
break;
}
pEnd++;
}
if( pGen->pIn >= pEnd ){
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine, "Empty case expression");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
}
/* Swap token stream */
pTmp = pGen->pEnd;
pGen->pEnd = pEnd;
pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
jx9VmSetByteCodeContainer(pGen->pVm, &pExpr->aByteCode);
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Emit the done instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, (rc != SXERR_EMPTY ? 1 : 0), 0, 0, 0);
jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer);
/* Update token stream */
pGen->pIn = pEnd;
pGen->pEnd = pTmp;
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
return SXRET_OK;
}
/*
* Compile the smart switch statement.
* According to the JX9 language reference manual
* The switch statement is similar to a series of IF statements on the same expression.
* In many occasions, you may want to compare the same variable (or expression) with many
* different values, and execute a different piece of code depending on which value it equals to.
* This is exactly what the switch statement is for.
* Note: Note that unlike some other languages, the continue statement applies to switch and acts
* similar to break. If you have a switch inside a loop and wish to continue to the next iteration
* of the outer loop, use continue 2.
* Note that switch/case does loose comparision.
* It is important to understand how the switch statement is executed in order to avoid mistakes.
* The switch statement executes line by line (actually, statement by statement).
* In the beginning, no code is executed. Only when a case statement is found with a value that
* matches the value of the switch expression does JX9 begin to execute the statements.
* JX9 continues to execute the statements until the end of the switch block, or the first time
* it sees a break statement. If you don't write a break statement at the end of a case's statement list.
* In a switch statement, the condition is evaluated only once and the result is compared to each
* case statement. In an elseif statement, the condition is evaluated again. If your condition
* is more complicated than a simple compare and/or is in a tight loop, a switch may be faster.
* The statement list for a case can also be empty, which simply passes control into the statement
* list for the next case.
* The case expression may be any expression that evaluates to a simple type, that is, integer
* or floating-point numbers and strings.
*/
static sxi32 jx9CompileSwitch(jx9_gen_state *pGen)
{
GenBlock *pSwitchBlock;
SyToken *pTmp, *pEnd;
jx9_switch *pSwitch;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
/* Jump the 'switch' keyword */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected '(' after 'switch' keyword");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
goto Synchronize;
}
/* Jump the left parenthesis '(' */
pGen->pIn++;
pEnd = 0; /* cc warning */
/* Create the loop block */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_LOOP|GEN_BLOCK_SWITCH,
jx9VmInstrLength(pGen->pVm), 0, &pSwitchBlock);
if( rc != SXRET_OK ){
return SXERR_ABORT;
}
/* Delimit the condition */
jx9DelimitNestedTokens(pGen->pIn, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pGen->pIn == pEnd || pEnd >= pGen->pEnd ){
/* Empty expression */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected expression after 'switch' keyword");
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
}
/* Swap token streams */
pTmp = pGen->pEnd;
pGen->pEnd = pEnd;
/* Compile the expression */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc == SXERR_ABORT ){
/* Expression handler request an operation abort [i.e: Out-of-memory] */
return SXERR_ABORT;
}
/* Update token stream */
while(pGen->pIn < pEnd ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine,
"Switch: Unexpected token '%z'", &pGen->pIn->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
pGen->pIn++;
}
pGen->pIn = &pEnd[1];
pGen->pEnd = pTmp;
if( pGen->pIn >= pGen->pEnd || &pGen->pIn[1] >= pGen->pEnd ||
(pGen->pIn->nType & (JX9_TK_OCB/*'{'*/|JX9_TK_COLON/*:*/)) == 0 ){
pTmp = pGen->pIn;
if( pTmp >= pGen->pEnd ){
pTmp--;
}
/* Unexpected token */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pTmp->nLine, "Switch: Unexpected token '%z'", &pTmp->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
goto Synchronize;
}
pGen->pIn++; /* Jump the leading curly braces/colons */
/* Create the switch blocks container */
pSwitch = (jx9_switch *)SyMemBackendAlloc(&pGen->pVm->sAllocator, sizeof(jx9_switch));
if( pSwitch == 0 ){
/* Abort compilation */
return GenStateOutOfMem(pGen);
}
/* Zero the structure */
SyZero(pSwitch, sizeof(jx9_switch));
/* Initialize fields */
SySetInit(&pSwitch->aCaseExpr, &pGen->pVm->sAllocator, sizeof(jx9_case_expr));
/* Emit the switch instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_SWITCH, 0, 0, pSwitch, 0);
/* Compile case blocks */
for(;;){
sxu32 nKwrd;
if( pGen->pIn >= pGen->pEnd ){
/* No more input to process */
break;
}
if( (pGen->pIn->nType & JX9_TK_KEYWORD) == 0 ){
if( (pGen->pIn->nType & JX9_TK_CCB /*}*/) == 0 ){
/* Unexpected token */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Switch: Unexpected token '%z'",
&pGen->pIn->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* FALL THROUGH */
}
/* Block compiled */
break;
}
/* Extract the keyword */
nKwrd = SX_PTR_TO_INT(pGen->pIn->pUserData);
if( nKwrd == JX9_TKWRD_DEFAULT ){
/*
* Accroding to the JX9 language reference manual
* A special case is the default case. This case matches anything
* that wasn't matched by the other cases.
*/
if( pSwitch->nDefault > 0 ){
/* Default case already compiled */
rc = jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine, "Switch: 'default' case already compiled");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
pGen->pIn++; /* Jump the 'default' keyword */
/* Compile the default block */
rc = GenStateCompileSwitchBlock(pGen,&pSwitch->nDefault);
if( rc == SXERR_ABORT){
return SXERR_ABORT;
}else if( rc == SXERR_EOF ){
break;
}
}else if( nKwrd == JX9_TKWRD_CASE ){
jx9_case_expr sCase;
/* Standard case block */
pGen->pIn++; /* Jump the 'case' keyword */
/* initialize the structure */
SySetInit(&sCase.aByteCode, &pGen->pVm->sAllocator, sizeof(VmInstr));
/* Compile the case expression */
rc = GenStateCompileCaseExpr(pGen, &sCase);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* Compile the case block */
rc = GenStateCompileSwitchBlock(pGen,&sCase.nStart);
/* Insert in the switch container */
SySetPut(&pSwitch->aCaseExpr, (const void *)&sCase);
if( rc == SXERR_ABORT){
return SXERR_ABORT;
}else if( rc == SXERR_EOF ){
break;
}
}else{
/* Unexpected token */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Switch: Unexpected token '%z'",
&pGen->pIn->sData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
break;
}
}
/* Fix all jumps now the destination is resolved */
pSwitch->nOut = jx9VmInstrLength(pGen->pVm);
GenStateFixJumps(pSwitchBlock, -1, jx9VmInstrLength(pGen->pVm));
/* Release the loop block */
GenStateLeaveBlock(pGen, 0);
if( pGen->pIn < pGen->pEnd ){
/* Jump the trailing curly braces */
pGen->pIn++;
}
/* Statement successfully compiled */
return SXRET_OK;
Synchronize:
/* Synchronize with the first semi-colon */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/*
* Process default argument values. That is, a function may define C++-style default value
* as follows:
* function makecoffee($type = "cappuccino")
* {
* return "Making a cup of $type.\n";
* }
* Some features:
* 1 -) Default arguments value can be any complex expression [i.e: function call, annynoymous
* functions, array member, ..]
* 2 -) Full type hinting: (Arguments are automatically casted to the desired type)
* Example:
* function a(string $a){} function b(int $a, string $c, float $d){}
* 3 -) Function overloading!!
* Example:
* function foo($a) {
* return $a.JX9_EOL;
* }
* function foo($a, $b) {
* return $a + $b;
* }
* print foo(5); // Prints "5"
* print foo(5, 2); // Prints "7"
* // Same arg
* function foo(string $a)
* {
* print "a is a string\n";
* dump($a);
* }
* function foo(int $a)
* {
* print "a is integer\n";
* dump($a);
* }
* function foo(array $a)
* {
* print "a is an array\n";
* dump($a);
* }
* foo('This is a great feature'); // a is a string [first foo]
* foo(52); // a is integer [second foo]
* foo(array(14, __TIME__, __DATE__)); // a is an array [third foo]
* Please refer to the official documentation for more information on the powerful extension
* introduced by the JX9 engine.
*/
static sxi32 GenStateProcessArgValue(jx9_gen_state *pGen, jx9_vm_func_arg *pArg, SyToken *pIn, SyToken *pEnd)
{
SyToken *pTmpIn, *pTmpEnd;
SySet *pInstrContainer;
sxi32 rc;
/* Swap token stream */
SWAP_DELIMITER(pGen, pIn, pEnd);
pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
jx9VmSetByteCodeContainer(pGen->pVm, &pArg->aByteCode);
/* Compile the expression holding the argument value */
rc = jx9CompileExpr(&(*pGen), 0, 0);
/* Emit the done instruction */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, (rc != SXERR_EMPTY ? 1 : 0), 0, 0, 0);
jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer);
RE_SWAP_DELIMITER(pGen);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
return SXRET_OK;
}
/*
* Collect function arguments one after one.
* According to the JX9 language reference manual.
* Information may be passed to functions via the argument list, which is a comma-delimited
* list of expressions.
* JX9 supports passing arguments by value (the default), passing by reference
* and default argument values. Variable-length argument lists are also supported,
* see also the function references for func_num_args(), func_get_arg(), and func_get_args()
* for more information.
* Example #1 Passing arrays to functions
* <?jx9
* function takes_array($input)
* {
* print "$input[0] + $input[1] = ", $input[0]+$input[1];
* }
* ?>
* Making arguments be passed by reference
* By default, function arguments are passed by value (so that if the value of the argument
* within the function is changed, it does not get changed outside of the function).
* To allow a function to modify its arguments, they must be passed by reference.
* To have an argument to a function always passed by reference, prepend an ampersand (&)
* to the argument name in the function definition:
* Example #2 Passing function parameters by reference
* <?jx9
* function add_some_extra(&$string)
* {
* $string .= 'and something extra.';
* }
* $str = 'This is a string, ';
* add_some_extra($str);
* print $str; // outputs 'This is a string, and something extra.'
* ?>
*
* JX9 have introduced powerful extension including full type hinting, function overloading
* complex agrument values.Please refer to the official documentation for more information
* on these extension.
*/
static sxi32 GenStateCollectFuncArgs(jx9_vm_func *pFunc, jx9_gen_state *pGen, SyToken *pEnd)
{
jx9_vm_func_arg sArg; /* Current processed argument */
SyToken *pCur, *pIn; /* Token stream */
SyBlob sSig; /* Function signature */
char *zDup; /* Copy of argument name */
sxi32 rc;
pIn = pGen->pIn;
pCur = 0;
SyBlobInit(&sSig, &pGen->pVm->sAllocator);
/* Process arguments one after one */
for(;;){
if( pIn >= pEnd ){
/* No more arguments to process */
break;
}
SyZero(&sArg, sizeof(jx9_vm_func_arg));
SySetInit(&sArg.aByteCode, &pGen->pVm->sAllocator, sizeof(VmInstr));
if( pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD) ){
if( pIn->nType & JX9_TK_KEYWORD ){
sxu32 nKey = (sxu32)(SX_PTR_TO_INT(pIn->pUserData));
if( nKey & JX9_TKWRD_BOOL ){
sArg.nType = MEMOBJ_BOOL;
}else if( nKey & JX9_TKWRD_INT ){
sArg.nType = MEMOBJ_INT;
}else if( nKey & JX9_TKWRD_STRING ){
sArg.nType = MEMOBJ_STRING;
}else if( nKey & JX9_TKWRD_FLOAT ){
sArg.nType = MEMOBJ_REAL;
}else{
jx9GenCompileError(&(*pGen), E_WARNING, pGen->pIn->nLine,
"Invalid argument type '%z', Automatic cast will not be performed",
&pIn->sData);
}
}
pIn++;
}
if( pIn >= pEnd ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Missing argument name");
return rc;
}
if( pIn >= pEnd || (pIn->nType & JX9_TK_DOLLAR) == 0 || &pIn[1] >= pEnd || (pIn[1].nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
/* Invalid argument */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pGen->pIn->nLine, "Invalid argument name");
return rc;
}
pIn++; /* Jump the dollar sign */
/* Copy argument name */
zDup = SyMemBackendStrDup(&pGen->pVm->sAllocator, SyStringData(&pIn->sData), SyStringLength(&pIn->sData));
if( zDup == 0 ){
return GenStateOutOfMem(pGen);
}
SyStringInitFromBuf(&sArg.sName, zDup, SyStringLength(&pIn->sData));
pIn++;
if( pIn < pEnd ){
if( pIn->nType & JX9_TK_EQUAL ){
SyToken *pDefend;
sxi32 iNest = 0;
pIn++; /* Jump the equal sign */
pDefend = pIn;
/* Process the default value associated with this argument */
while( pDefend < pEnd ){
if( (pDefend->nType & JX9_TK_COMMA) && iNest <= 0 ){
break;
}
if( pDefend->nType & (JX9_TK_LPAREN/*'('*/|JX9_TK_OCB/*'{'*/|JX9_TK_OSB/*[*/) ){
/* Increment nesting level */
iNest++;
}else if( pDefend->nType & (JX9_TK_RPAREN/*')'*/|JX9_TK_CCB/*'}'*/|JX9_TK_CSB/*]*/) ){
/* Decrement nesting level */
iNest--;
}
pDefend++;
}
if( pIn >= pDefend ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pIn->nLine, "Missing argument default value");
return rc;
}
/* Process default value */
rc = GenStateProcessArgValue(&(*pGen), &sArg, pIn, pDefend);
if( rc != SXRET_OK ){
return rc;
}
/* Point beyond the default value */
pIn = pDefend;
}
if( pIn < pEnd && (pIn->nType & JX9_TK_COMMA) == 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, pIn->nLine, "Unexpected token '%z'", &pIn->sData);
return rc;
}
pIn++; /* Jump the trailing comma */
}
/* Append argument signature */
if( sArg.nType > 0 ){
int c;
c = 'n'; /* cc warning */
/* Type leading character */
switch(sArg.nType){
case MEMOBJ_HASHMAP:
/* Hashmap aka 'array' */
c = 'h';
break;
case MEMOBJ_INT:
/* Integer */
c = 'i';
break;
case MEMOBJ_BOOL:
/* Bool */
c = 'b';
break;
case MEMOBJ_REAL:
/* Float */
c = 'f';
break;
case MEMOBJ_STRING:
/* String */
c = 's';
break;
default:
break;
}
SyBlobAppend(&sSig, (const void *)&c, sizeof(char));
}
/* Save in the argument set */
SySetPut(&pFunc->aArgs, (const void *)&sArg);
}
if( SyBlobLength(&sSig) > 0 ){
/* Save function signature */
SyStringInitFromBuf(&pFunc->sSignature, SyBlobData(&sSig), SyBlobLength(&sSig));
}
return SXRET_OK;
}
/*
* Compile function [i.e: standard function, annonymous function or closure ] body.
* Return SXRET_OK on success. Any other return value indicates failure
* and this routine takes care of generating the appropriate error message.
*/
static sxi32 GenStateCompileFuncBody(
jx9_gen_state *pGen, /* Code generator state */
jx9_vm_func *pFunc /* Function state */
)
{
SySet *pInstrContainer; /* Instruction container */
GenBlock *pBlock;
sxi32 rc;
/* Attach the new function */
rc = GenStateEnterBlock(&(*pGen), GEN_BLOCK_PROTECTED|GEN_BLOCK_FUNC,jx9VmInstrLength(pGen->pVm), pFunc, &pBlock);
if( rc != SXRET_OK ){
return GenStateOutOfMem(pGen);
}
/* Swap bytecode containers */
pInstrContainer = jx9VmGetByteCodeContainer(pGen->pVm);
jx9VmSetByteCodeContainer(pGen->pVm, &pFunc->aByteCode);
/* Compile the body */
jx9CompileBlock(&(*pGen));
/* Emit the final return if not yet done */
jx9VmEmitInstr(pGen->pVm, JX9_OP_DONE, 0, 0, 0, 0);
/* Restore the default container */
jx9VmSetByteCodeContainer(pGen->pVm, pInstrContainer);
/* Leave function block */
GenStateLeaveBlock(&(*pGen), 0);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
/* All done, function body compiled */
return SXRET_OK;
}
/*
* Compile a JX9 function whether is a Standard or Annonymous function.
* According to the JX9 language reference manual.
* Function names follow the same rules as other labels in JX9. A valid function name
* starts with a letter or underscore, followed by any number of letters, numbers, or
* underscores. As a regular expression, it would be expressed thus:
* [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.
* Functions need not be defined before they are referenced.
* All functions and objectes in JX9 have the global scope - they can be called outside
* a function even if they were defined inside and vice versa.
* It is possible to call recursive functions in JX9. However avoid recursive function/method
* calls with over 32-64 recursion levels.
*
* JX9 have introduced powerful extension including full type hinting, function overloading,
* complex agrument values and more. Please refer to the official documentation for more information
* on these extension.
*/
static sxi32 GenStateCompileFunc(
jx9_gen_state *pGen, /* Code generator state */
SyString *pName, /* Function name. NULL otherwise */
sxi32 iFlags, /* Control flags */
jx9_vm_func **ppFunc /* OUT: function state */
)
{
jx9_vm_func *pFunc;
SyToken *pEnd;
sxu32 nLine;
char *zName;
sxi32 rc;
/* Extract line number */
nLine = pGen->pIn->nLine;
/* Jump the left parenthesis '(' */
pGen->pIn++;
/* Delimit the function signature */
jx9DelimitNestedTokens(pGen->pIn, pGen->pEnd, JX9_TK_LPAREN /* '(' */, JX9_TK_RPAREN /* ')' */, &pEnd);
if( pEnd >= pGen->pEnd ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Missing ')' after function '%z' signature", pName);
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
pGen->pIn = pGen->pEnd;
return SXRET_OK;
}
/* Create the function state */
pFunc = (jx9_vm_func *)SyMemBackendPoolAlloc(&pGen->pVm->sAllocator, sizeof(jx9_vm_func));
if( pFunc == 0 ){
goto OutOfMem;
}
/* function ID */
zName = SyMemBackendStrDup(&pGen->pVm->sAllocator, pName->zString, pName->nByte);
if( zName == 0 ){
/* Don't worry about freeing memory, everything will be released shortly */
goto OutOfMem;
}
/* Initialize the function state */
jx9VmInitFuncState(pGen->pVm, pFunc, zName, pName->nByte, iFlags, 0);
if( pGen->pIn < pEnd ){
/* Collect function arguments */
rc = GenStateCollectFuncArgs(pFunc, &(*pGen), pEnd);
if( rc == SXERR_ABORT ){
/* Don't worry about freeing memory, everything will be released shortly */
return SXERR_ABORT;
}
}
/* Compile function body */
pGen->pIn = &pEnd[1];
/* Compile the body */
rc = GenStateCompileFuncBody(&(*pGen), pFunc);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
if( ppFunc ){
*ppFunc = pFunc;
}
/* Finally register the function */
rc = jx9VmInstallUserFunction(pGen->pVm, pFunc, 0);
return rc;
/* Fall through if something goes wrong */
OutOfMem:
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here.
*/
return GenStateOutOfMem(pGen);
}
/*
* Compile a standard JX9 function.
* Refer to the block-comment above for more information.
*/
static sxi32 jx9CompileFunction(jx9_gen_state *pGen)
{
SyString *pName;
sxi32 iFlags;
sxu32 nLine;
sxi32 rc;
nLine = pGen->pIn->nLine;
pGen->pIn++; /* Jump the 'function' keyword */
iFlags = 0;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) == 0 ){
/* Invalid function name */
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Invalid function name");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* Sychronize with the next semi-colon or braces*/
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
pName = &pGen->pIn->sData;
nLine = pGen->pIn->nLine;
/* Jump the function name */
pGen->pIn++;
if( pGen->pIn >= pGen->pEnd || (pGen->pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, nLine, "Expected '(' after function name '%z'", pName);
if( rc == SXERR_ABORT ){
/* Error count limit reached, abort immediately */
return SXERR_ABORT;
}
/* Sychronize with the next semi-colon or '{' */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & (JX9_TK_SEMI|JX9_TK_OCB)) == 0 ){
pGen->pIn++;
}
return SXRET_OK;
}
/* Compile function body */
rc = GenStateCompileFunc(&(*pGen),pName,iFlags,0);
return rc;
}
/*
* Generate bytecode for a given expression tree.
* If something goes wrong while generating bytecode
* for the expression tree (A very unlikely scenario)
* this function takes care of generating the appropriate
* error message.
*/
static sxi32 GenStateEmitExprCode(
jx9_gen_state *pGen, /* Code generator state */
jx9_expr_node *pNode, /* Root of the expression tree */
sxi32 iFlags /* Control flags */
)
{
VmInstr *pInstr;
sxu32 nJmpIdx;
sxi32 iP1 = 0;
sxu32 iP2 = 0;
void *p3 = 0;
sxi32 iVmOp;
sxi32 rc;
if( pNode->xCode ){
SyToken *pTmpIn, *pTmpEnd;
/* Compile node */
SWAP_DELIMITER(pGen, pNode->pStart, pNode->pEnd);
rc = pNode->xCode(&(*pGen), iFlags);
RE_SWAP_DELIMITER(pGen);
return rc;
}
if( pNode->pOp == 0 ){
jx9GenCompileError(&(*pGen), E_ERROR, pNode->pStart->nLine,
"Invalid expression node, JX9 is aborting compilation");
return SXERR_ABORT;
}
iVmOp = pNode->pOp->iVmOp;
if( pNode->pOp->iOp == EXPR_OP_QUESTY ){
sxu32 nJz, nJmp;
/* Ternary operator require special handling */
/* Phase#1: Compile the condition */
rc = GenStateEmitExprCode(&(*pGen), pNode->pCond, iFlags);
if( rc != SXRET_OK ){
return rc;
}
nJz = nJmp = 0; /* cc -O6 warning */
/* Phase#2: Emit the false jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JZ, 0, 0, 0, &nJz);
if( pNode->pLeft ){
/* Phase#3: Compile the 'then' expression */
rc = GenStateEmitExprCode(&(*pGen), pNode->pLeft, iFlags);
if( rc != SXRET_OK ){
return rc;
}
}
/* Phase#4: Emit the unconditional jump */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JMP, 0, 0, 0, &nJmp);
/* Phase#5: Fix the false jump now the jump destination is resolved. */
pInstr = jx9VmGetInstr(pGen->pVm, nJz);
if( pInstr ){
pInstr->iP2 = jx9VmInstrLength(pGen->pVm);
}
/* Phase#6: Compile the 'else' expression */
if( pNode->pRight ){
rc = GenStateEmitExprCode(&(*pGen), pNode->pRight, iFlags);
if( rc != SXRET_OK ){
return rc;
}
}
if( nJmp > 0 ){
/* Phase#7: Fix the unconditional jump */
pInstr = jx9VmGetInstr(pGen->pVm, nJmp);
if( pInstr ){
pInstr->iP2 = jx9VmInstrLength(pGen->pVm);
}
}
/* All done */
return SXRET_OK;
}
/* Generate code for the left tree */
if( pNode->pLeft ){
if( iVmOp == JX9_OP_CALL ){
jx9_expr_node **apNode;
sxi32 n;
/* Recurse and generate bytecodes for function arguments */
apNode = (jx9_expr_node **)SySetBasePtr(&pNode->aNodeArgs);
/* Read-only load */
iFlags |= EXPR_FLAG_RDONLY_LOAD;
for( n = 0 ; n < (sxi32)SySetUsed(&pNode->aNodeArgs) ; ++n ){
rc = GenStateEmitExprCode(&(*pGen), apNode[n], iFlags&~EXPR_FLAG_LOAD_IDX_STORE);
if( rc != SXRET_OK ){
return rc;
}
}
/* Total number of given arguments */
iP1 = (sxi32)SySetUsed(&pNode->aNodeArgs);
/* Remove stale flags now */
iFlags &= ~EXPR_FLAG_RDONLY_LOAD;
}
rc = GenStateEmitExprCode(&(*pGen), pNode->pLeft, iFlags);
if( rc != SXRET_OK ){
return rc;
}
if( iVmOp == JX9_OP_CALL ){
pInstr = jx9VmPeekInstr(pGen->pVm);
if( pInstr ){
if ( pInstr->iOp == JX9_OP_LOADC ){
/* Prevent constant expansion */
pInstr->iP1 = 0;
}else if( pInstr->iOp == JX9_OP_MEMBER /* $a.b(1, 2, 3) */ ){
/* Annonymous function call, flag that */
pInstr->iP2 = 1;
}
}
}else if( iVmOp == JX9_OP_LOAD_IDX ){
jx9_expr_node **apNode;
sxi32 n;
/* Recurse and generate bytecodes for array index */
apNode = (jx9_expr_node **)SySetBasePtr(&pNode->aNodeArgs);
for( n = 0 ; n < (sxi32)SySetUsed(&pNode->aNodeArgs) ; ++n ){
rc = GenStateEmitExprCode(&(*pGen), apNode[n], iFlags&~EXPR_FLAG_LOAD_IDX_STORE);
if( rc != SXRET_OK ){
return rc;
}
}
if( SySetUsed(&pNode->aNodeArgs) > 0 ){
iP1 = 1; /* Node have an index associated with it */
}
if( iFlags & EXPR_FLAG_LOAD_IDX_STORE ){
/* Create an empty entry when the desired index is not found */
iP2 = 1;
}
}else if( pNode->pOp->iOp == EXPR_OP_COMMA ){
/* POP the left node */
jx9VmEmitInstr(pGen->pVm, JX9_OP_POP, 1, 0, 0, 0);
}
}
rc = SXRET_OK;
nJmpIdx = 0;
/* Generate code for the right tree */
if( pNode->pRight ){
if( iVmOp == JX9_OP_LAND ){
/* Emit the false jump so we can short-circuit the logical and */
jx9VmEmitInstr(pGen->pVm, JX9_OP_JZ, 1/* Keep the value on the stack */, 0, 0, &nJmpIdx);
}else if (iVmOp == JX9_OP_LOR ){
/* Emit the true jump so we can short-circuit the logical or*/
jx9VmEmitInstr(pGen->pVm, JX9_OP_JNZ, 1/* Keep the value on the stack */, 0, 0, &nJmpIdx);
}else if( pNode->pOp->iPrec == 18 /* Combined binary operators [i.e: =, '.=', '+=', *=' ...] precedence */ ){
iFlags |= EXPR_FLAG_LOAD_IDX_STORE;
}
rc = GenStateEmitExprCode(&(*pGen), pNode->pRight, iFlags);
if( iVmOp == JX9_OP_STORE ){
pInstr = jx9VmPeekInstr(pGen->pVm);
if( pInstr ){
if(pInstr->iOp == JX9_OP_MEMBER ){
/* Perform a member store operation [i.e: $this.x = 50] */
iP2 = 1;
}else{
if( pInstr->iOp == JX9_OP_LOAD_IDX ){
/* Transform the STORE instruction to STORE_IDX instruction */
iVmOp = JX9_OP_STORE_IDX;
iP1 = pInstr->iP1;
}else{
p3 = pInstr->p3;
}
/* POP the last dynamic load instruction */
(void)jx9VmPopInstr(pGen->pVm);
}
}
}
}
if( iVmOp > 0 ){
if( iVmOp == JX9_OP_INCR || iVmOp == JX9_OP_DECR ){
if( pNode->iFlags & EXPR_NODE_PRE_INCR ){
/* Pre-increment/decrement operator [i.e: ++$i, --$j ] */
iP1 = 1;
}
}
/* Finally, emit the VM instruction associated with this operator */
jx9VmEmitInstr(pGen->pVm, iVmOp, iP1, iP2, p3, 0);
if( nJmpIdx > 0 ){
/* Fix short-circuited jumps now the destination is resolved */
pInstr = jx9VmGetInstr(pGen->pVm, nJmpIdx);
if( pInstr ){
pInstr->iP2 = jx9VmInstrLength(pGen->pVm);
}
}
}
return rc;
}
/*
* Compile a JX9 expression.
* According to the JX9 language reference manual:
* Expressions are the most important building stones of JX9.
* In JX9, almost anything you write is an expression.
* The simplest yet most accurate way to define an expression
* is "anything that has a value".
* If something goes wrong while compiling the expression, this
* function takes care of generating the appropriate error
* message.
*/
static sxi32 jx9CompileExpr(
jx9_gen_state *pGen, /* Code generator state */
sxi32 iFlags, /* Control flags */
sxi32 (*xTreeValidator)(jx9_gen_state *, jx9_expr_node *) /* Node validator callback.NULL otherwise */
)
{
jx9_expr_node *pRoot;
SySet sExprNode;
SyToken *pEnd;
sxi32 nExpr;
sxi32 iNest;
sxi32 rc;
/* Initialize worker variables */
nExpr = 0;
pRoot = 0;
SySetInit(&sExprNode, &pGen->pVm->sAllocator, sizeof(jx9_expr_node *));
SySetAlloc(&sExprNode, 0x10);
rc = SXRET_OK;
/* Delimit the expression */
pEnd = pGen->pIn;
iNest = 0;
while( pEnd < pGen->pEnd ){
if( pEnd->nType & JX9_TK_OCB /* '{' */ ){
/* Ticket 1433-30: Annonymous/Closure functions body */
iNest++;
}else if(pEnd->nType & JX9_TK_CCB /* '}' */ ){
iNest--;
}else if( pEnd->nType & JX9_TK_SEMI /* ';' */ ){
if( iNest <= 0 ){
break;
}
}
pEnd++;
}
if( iFlags & EXPR_FLAG_COMMA_STATEMENT ){
SyToken *pEnd2 = pGen->pIn;
iNest = 0;
/* Stop at the first comma */
while( pEnd2 < pEnd ){
if( pEnd2->nType & (JX9_TK_OCB/*'{'*/|JX9_TK_OSB/*'['*/|JX9_TK_LPAREN/*'('*/) ){
iNest++;
}else if(pEnd2->nType & (JX9_TK_CCB/*'}'*/|JX9_TK_CSB/*']'*/|JX9_TK_RPAREN/*')'*/)){
iNest--;
}else if( pEnd2->nType & JX9_TK_COMMA /*','*/ ){
if( iNest <= 0 ){
break;
}
}
pEnd2++;
}
if( pEnd2 <pEnd ){
pEnd = pEnd2;
}
}
if( pEnd > pGen->pIn ){
SyToken *pTmp = pGen->pEnd;
/* Swap delimiter */
pGen->pEnd = pEnd;
/* Try to get an expression tree */
rc = jx9ExprMakeTree(&(*pGen), &sExprNode, &pRoot);
if( rc == SXRET_OK && pRoot ){
rc = SXRET_OK;
if( xTreeValidator ){
/* Call the upper layer validator callback */
rc = xTreeValidator(&(*pGen), pRoot);
}
if( rc != SXERR_ABORT ){
/* Generate code for the given tree */
rc = GenStateEmitExprCode(&(*pGen), pRoot, iFlags);
}
nExpr = 1;
}
/* Release the whole tree */
jx9ExprFreeTree(&(*pGen), &sExprNode);
/* Synchronize token stream */
pGen->pEnd = pTmp;
pGen->pIn = pEnd;
if( rc == SXERR_ABORT ){
SySetRelease(&sExprNode);
return SXERR_ABORT;
}
}
SySetRelease(&sExprNode);
return nExpr > 0 ? SXRET_OK : SXERR_EMPTY;
}
/*
* Return a pointer to the node construct handler associated
* with a given node type [i.e: string, integer, float, ...].
*/
JX9_PRIVATE ProcNodeConstruct jx9GetNodeHandler(sxu32 nNodeType)
{
if( nNodeType & JX9_TK_NUM ){
/* Numeric literal: Either real or integer */
return jx9CompileNumLiteral;
}else if( nNodeType & JX9_TK_DSTR ){
/* Double quoted string */
return jx9CompileString;
}else if( nNodeType & JX9_TK_SSTR ){
/* Single quoted string */
return jx9CompileSimpleString;
}else if( nNodeType & JX9_TK_NOWDOC ){
/* Nowdoc */
return jx9CompileNowdoc;
}
return 0;
}
/*
* Jx9 Language construct table.
*/
static const LangConstruct aLangConstruct[] = {
{ JX9_TKWRD_IF, jx9CompileIf },
{ JX9_TKWRD_FUNCTION, jx9CompileFunction },
{ JX9_TKWRD_FOREACH, jx9CompileForeach },
{ JX9_TKWRD_WHILE, jx9CompileWhile },
{ JX9_TKWRD_FOR, jx9CompileFor },
{ JX9_TKWRD_SWITCH, jx9CompileSwitch },
{ JX9_TKWRD_DIE, jx9CompileHalt },
{ JX9_TKWRD_EXIT, jx9CompileHalt },
{ JX9_TKWRD_RETURN, jx9CompileReturn },
{ JX9_TKWRD_BREAK, jx9CompileBreak },
{ JX9_TKWRD_CONTINUE, jx9CompileContinue },
{ JX9_TKWRD_STATIC, jx9CompileStatic },
{ JX9_TKWRD_UPLINK, jx9CompileUplink },
{ JX9_TKWRD_CONST, jx9CompileConstant },
};
/*
* Return a pointer to the statement handler routine associated
* with a given JX9 keyword [i.e: if, for, while, ...].
*/
static ProcLangConstruct GenStateGetStatementHandler(
sxu32 nKeywordID /* Keyword ID*/
)
{
sxu32 n = 0;
for(;;){
if( n >= SX_ARRAYSIZE(aLangConstruct) ){
break;
}
if( aLangConstruct[n].nID == nKeywordID ){
/* Return a pointer to the handler.
*/
return aLangConstruct[n].xConstruct;
}
n++;
}
/* Not a language construct */
return 0;
}
/*
* Compile a jx9 program.
* If something goes wrong while compiling the Jx9 chunk, this function
* takes care of generating the appropriate error message.
*/
static sxi32 GenStateCompileChunk(
jx9_gen_state *pGen, /* Code generator state */
sxi32 iFlags /* Compile flags */
)
{
ProcLangConstruct xCons;
sxi32 rc;
rc = SXRET_OK; /* Prevent compiler warning */
for(;;){
if( pGen->pIn >= pGen->pEnd ){
/* No more input to process */
break;
}
xCons = 0;
if( pGen->pIn->nType & JX9_TK_KEYWORD ){
sxu32 nKeyword = (sxu32)SX_PTR_TO_INT(pGen->pIn->pUserData);
/* Try to extract a language construct handler */
xCons = GenStateGetStatementHandler(nKeyword);
if( xCons == 0 && !jx9IsLangConstruct(nKeyword) ){
rc = jx9GenCompileError(pGen, E_ERROR, pGen->pIn->nLine,
"Syntax error: Unexpected keyword '%z'",
&pGen->pIn->sData);
if( rc == SXERR_ABORT ){
break;
}
/* Synchronize with the first semi-colon and avoid compiling
* this erroneous statement.
*/
xCons = jx9ErrorRecover;
}
}
if( xCons == 0 ){
/* Assume an expression an try to compile it */
rc = jx9CompileExpr(&(*pGen), 0, 0);
if( rc != SXERR_EMPTY ){
/* Pop l-value */
jx9VmEmitInstr(pGen->pVm, JX9_OP_POP, 1, 0, 0, 0);
}
}else{
/* Go compile the sucker */
rc = xCons(&(*pGen));
}
if( rc == SXERR_ABORT ){
/* Request to abort compilation */
break;
}
/* Ignore trailing semi-colons ';' */
while( pGen->pIn < pGen->pEnd && (pGen->pIn->nType & JX9_TK_SEMI) ){
pGen->pIn++;
}
if( iFlags & JX9_COMPILE_SINGLE_STMT ){
/* Compile a single statement and return */
break;
}
/* LOOP ONE */
/* LOOP TWO */
/* LOOP THREE */
/* LOOP FOUR */
}
/* Return compilation status */
return rc;
}
/*
* Compile a raw chunk. The raw chunk can contain JX9 code embedded
* in HTML, XML and so on. This function handle all the stuff.
* This is the only compile interface exported from this file.
*/
JX9_PRIVATE sxi32 jx9CompileScript(
jx9_vm *pVm, /* Generate JX9 bytecodes for this Virtual Machine */
SyString *pScript, /* Script to compile */
sxi32 iFlags /* Compile flags */
)
{
jx9_gen_state *pGen;
SySet aToken;
sxi32 rc;
if( pScript->nByte < 1 ){
/* Nothing to compile */
return JX9_OK;
}
/* Initialize the tokens containers */
SySetInit(&aToken, &pVm->sAllocator, sizeof(SyToken));
SySetAlloc(&aToken, 0xc0);
pGen = &pVm->sCodeGen;
rc = JX9_OK;
/* Tokenize the JX9 chunk first */
jx9Tokenize(pScript->zString,pScript->nByte,&aToken);
if( SySetUsed(&aToken) < 1 ){
return SXERR_EMPTY;
}
/* Point to the head and tail of the token stream. */
pGen->pIn = (SyToken *)SySetBasePtr(&aToken);
pGen->pEnd = &pGen->pIn[SySetUsed(&aToken)];
/* Compile the chunk */
rc = GenStateCompileChunk(pGen,iFlags);
/* Cleanup */
SySetRelease(&aToken);
return rc;
}
/*
* Utility routines.Initialize the code generator.
*/
JX9_PRIVATE sxi32 jx9InitCodeGenerator(
jx9_vm *pVm, /* Target VM */
ProcConsumer xErr, /* Error log consumer callabck */
void *pErrData /* Last argument to xErr() */
)
{
jx9_gen_state *pGen = &pVm->sCodeGen;
/* Zero the structure */
SyZero(pGen, sizeof(jx9_gen_state));
/* Initial state */
pGen->pVm = &(*pVm);
pGen->xErr = xErr;
pGen->pErrData = pErrData;
SyHashInit(&pGen->hLiteral, &pVm->sAllocator, 0, 0);
SyHashInit(&pGen->hVar, &pVm->sAllocator, 0, 0);
/* Create the global scope */
GenStateInitBlock(pGen, &pGen->sGlobal,GEN_BLOCK_GLOBAL,jx9VmInstrLength(&(*pVm)), 0);
/* Point to the global scope */
pGen->pCurrent = &pGen->sGlobal;
return SXRET_OK;
}
/*
* Utility routines. Reset the code generator to it's initial state.
*/
JX9_PRIVATE sxi32 jx9ResetCodeGenerator(
jx9_vm *pVm, /* Target VM */
ProcConsumer xErr, /* Error log consumer callabck */
void *pErrData /* Last argument to xErr() */
)
{
jx9_gen_state *pGen = &pVm->sCodeGen;
GenBlock *pBlock, *pParent;
/* Point to the global scope */
pBlock = pGen->pCurrent;
while( pBlock->pParent != 0 ){
pParent = pBlock->pParent;
GenStateFreeBlock(pBlock);
pBlock = pParent;
}
pGen->xErr = xErr;
pGen->pErrData = pErrData;
pGen->pCurrent = &pGen->sGlobal;
pGen->pIn = pGen->pEnd = 0;
pGen->nErr = 0;
return SXRET_OK;
}
/*
* Generate a compile-time error message.
* If the error count limit is reached (usually 15 error message)
* this function return SXERR_ABORT.In that case upper-layers must
* abort compilation immediately.
*/
JX9_PRIVATE sxi32 jx9GenCompileError(jx9_gen_state *pGen,sxi32 nErrType,sxu32 nLine,const char *zFormat,...)
{
SyBlob *pWorker = &pGen->pVm->pEngine->xConf.sErrConsumer;
const char *zErr = "Error";
va_list ap;
if( nErrType == E_ERROR ){
/* Increment the error counter */
pGen->nErr++;
if( pGen->nErr > 15 ){
/* Error count limit reached */
SyBlobFormat(pWorker, "%u Error count limit reached, JX9 is aborting compilation\n", nLine);
/* Abort immediately */
return SXERR_ABORT;
}
}
switch(nErrType){
case E_WARNING: zErr = "Warning"; break;
case E_PARSE: zErr = "Parse error"; break;
case E_NOTICE: zErr = "Notice"; break;
default:
break;
}
/* Format the error message */
SyBlobFormat(pWorker, "%u %s: ", nLine, zErr);
va_start(ap, zFormat);
SyBlobFormatAp(pWorker, zFormat, ap);
va_end(ap);
/* Append a new line */
SyBlobAppend(pWorker, (const void *)"\n", sizeof(char));
return JX9_OK;
}
/*
* ----------------------------------------------------------
* File: jx9_const.c
* MD5: f3980b00dd1eda0bb2b749424a8dfffe
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: const.c v1.7 Win7 2012-12-13 00:01 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file implement built-in constants for the JX9 engine. */
/*
* JX9_VERSION
* __JX9__
* Expand the current version of the JX9 engine.
*/
static void JX9_VER_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
jx9_value_string(pVal, jx9_lib_signature(), -1/*Compute length automatically*/);
}
#ifdef __WINNT__
#include <Windows.h>
#elif defined(__UNIXES__)
#include <sys/utsname.h>
#endif
/*
* JX9_OS
* __OS__
* Expand the name of the host Operating System.
*/
static void JX9_OS_Const(jx9_value *pVal, void *pUnused)
{
#if defined(__WINNT__)
jx9_value_string(pVal, "WinNT", (int)sizeof("WinNT")-1);
#elif defined(__UNIXES__)
struct utsname sInfo;
if( uname(&sInfo) != 0 ){
jx9_value_string(pVal, "Unix", (int)sizeof("Unix")-1);
}else{
jx9_value_string(pVal, sInfo.sysname, -1);
}
#else
jx9_value_string(pVal,"Host OS", (int)sizeof("Host OS")-1);
#endif
SXUNUSED(pUnused);
}
/*
* JX9_EOL
* Expand the correct 'End Of Line' symbol for this platform.
*/
static void JX9_EOL_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
#ifdef __WINNT__
jx9_value_string(pVal, "\r\n", (int)sizeof("\r\n")-1);
#else
jx9_value_string(pVal, "\n", (int)sizeof(char));
#endif
}
/*
* JX9_INT_MAX
* Expand the largest integer supported.
* Note that JX9 deals with 64-bit integer for all platforms.
*/
static void JX9_INTMAX_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
jx9_value_int64(pVal, SXI64_HIGH);
}
/*
* JX9_INT_SIZE
* Expand the size in bytes of a 64-bit integer.
*/
static void JX9_INTSIZE_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
jx9_value_int64(pVal, sizeof(sxi64));
}
/*
* DIRECTORY_SEPARATOR.
* Expand the directory separator character.
*/
static void JX9_DIRSEP_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
#ifdef __WINNT__
jx9_value_string(pVal, "\\", (int)sizeof(char));
#else
jx9_value_string(pVal, "/", (int)sizeof(char));
#endif
}
/*
* PATH_SEPARATOR.
* Expand the path separator character.
*/
static void JX9_PATHSEP_Const(jx9_value *pVal, void *pUnused)
{
SXUNUSED(pUnused);
#ifdef __WINNT__
jx9_value_string(pVal, ";", (int)sizeof(char));
#else
jx9_value_string(pVal, ":", (int)sizeof(char));
#endif
}
#ifndef __WINNT__
#include <time.h>
#endif
/*
* __TIME__
* Expand the current time (GMT).
*/
static void JX9_TIME_Const(jx9_value *pVal, void *pUnused)
{
Sytm sTm;
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = gmtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
SXUNUSED(pUnused); /* cc warning */
/* Expand */
jx9_value_string_format(pVal, "%02d:%02d:%02d", sTm.tm_hour, sTm.tm_min, sTm.tm_sec);
}
/*
* __DATE__
* Expand the current date in the ISO-8601 format.
*/
static void JX9_DATE_Const(jx9_value *pVal, void *pUnused)
{
Sytm sTm;
#ifdef __WINNT__
SYSTEMTIME sOS;
GetSystemTime(&sOS);
SYSTEMTIME_TO_SYTM(&sOS, &sTm);
#else
struct tm *pTm;
time_t t;
time(&t);
pTm = gmtime(&t);
STRUCT_TM_TO_SYTM(pTm, &sTm);
#endif
SXUNUSED(pUnused); /* cc warning */
/* Expand */
jx9_value_string_format(pVal, "%04d-%02d-%02d", sTm.tm_year, sTm.tm_mon+1, sTm.tm_mday);
}
/*
* __FILE__
* Path of the processed script.
*/
static void JX9_FILE_Const(jx9_value *pVal, void *pUserData)
{
jx9_vm *pVm = (jx9_vm *)pUserData;
SyString *pFile;
/* Peek the top entry */
pFile = (SyString *)SySetPeek(&pVm->aFiles);
if( pFile == 0 ){
/* Expand the magic word: ":MEMORY:" */
jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
}else{
jx9_value_string(pVal, pFile->zString, pFile->nByte);
}
}
/*
* __DIR__
* Directory holding the processed script.
*/
static void JX9_DIR_Const(jx9_value *pVal, void *pUserData)
{
jx9_vm *pVm = (jx9_vm *)pUserData;
SyString *pFile;
/* Peek the top entry */
pFile = (SyString *)SySetPeek(&pVm->aFiles);
if( pFile == 0 ){
/* Expand the magic word: ":MEMORY:" */
jx9_value_string(pVal, ":MEMORY:", (int)sizeof(":MEMORY:")-1);
}else{
if( pFile->nByte > 0 ){
const char *zDir;
int nLen;
zDir = jx9ExtractDirName(pFile->zString, (int)pFile->nByte, &nLen);
jx9_value_string(pVal, zDir, nLen);
}else{
/* Expand '.' as the current directory*/
jx9_value_string(pVal, ".", (int)sizeof(char));
}
}
}
/*
* E_ERROR
* Expands 1
*/
static void JX9_E_ERROR_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* E_WARNING
* Expands 2
*/
static void JX9_E_WARNING_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 2);
SXUNUSED(pUserData);
}
/*
* E_PARSE
* Expands 4
*/
static void JX9_E_PARSE_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 4);
SXUNUSED(pUserData);
}
/*
* E_NOTICE
* Expands 8
*/
static void JX9_E_NOTICE_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 8);
SXUNUSED(pUserData);
}
/*
* CASE_LOWER
* Expands 0.
*/
static void JX9_CASE_LOWER_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 0);
SXUNUSED(pUserData);
}
/*
* CASE_UPPER
* Expands 1.
*/
static void JX9_CASE_UPPER_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* STR_PAD_LEFT
* Expands 0.
*/
static void JX9_STR_PAD_LEFT_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 0);
SXUNUSED(pUserData);
}
/*
* STR_PAD_RIGHT
* Expands 1.
*/
static void JX9_STR_PAD_RIGHT_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* STR_PAD_BOTH
* Expands 2.
*/
static void JX9_STR_PAD_BOTH_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 2);
SXUNUSED(pUserData);
}
/*
* COUNT_NORMAL
* Expands 0
*/
static void JX9_COUNT_NORMAL_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 0);
SXUNUSED(pUserData);
}
/*
* COUNT_RECURSIVE
* Expands 1.
*/
static void JX9_COUNT_RECURSIVE_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* SORT_ASC
* Expands 1.
*/
static void JX9_SORT_ASC_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* SORT_DESC
* Expands 2.
*/
static void JX9_SORT_DESC_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 2);
SXUNUSED(pUserData);
}
/*
* SORT_REGULAR
* Expands 3.
*/
static void JX9_SORT_REG_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 3);
SXUNUSED(pUserData);
}
/*
* SORT_NUMERIC
* Expands 4.
*/
static void JX9_SORT_NUMERIC_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 4);
SXUNUSED(pUserData);
}
/*
* SORT_STRING
* Expands 5.
*/
static void JX9_SORT_STRING_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 5);
SXUNUSED(pUserData);
}
/*
* JX9_ROUND_HALF_UP
* Expands 1.
*/
static void JX9_JX9_ROUND_HALF_UP_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 1);
SXUNUSED(pUserData);
}
/*
* SJX9_ROUND_HALF_DOWN
* Expands 2.
*/
static void JX9_JX9_ROUND_HALF_DOWN_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 2);
SXUNUSED(pUserData);
}
/*
* JX9_ROUND_HALF_EVEN
* Expands 3.
*/
static void JX9_JX9_ROUND_HALF_EVEN_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 3);
SXUNUSED(pUserData);
}
/*
* JX9_ROUND_HALF_ODD
* Expands 4.
*/
static void JX9_JX9_ROUND_HALF_ODD_Const(jx9_value *pVal, void *pUserData)
{
jx9_value_int(pVal, 4);
SXUNUSED(pUserData);
}
#ifdef JX9_ENABLE_MATH_FUNC
/*
* PI
* Expand the value of pi.
*/
static void JX9_M_PI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, JX9_PI);
}
/*
* M_E
* Expand 2.7182818284590452354
*/
static void JX9_M_E_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 2.7182818284590452354);
}
/*
* M_LOG2E
* Expand 2.7182818284590452354
*/
static void JX9_M_LOG2E_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.4426950408889634074);
}
/*
* M_LOG10E
* Expand 0.4342944819032518276
*/
static void JX9_M_LOG10E_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.4342944819032518276);
}
/*
* M_LN2
* Expand 0.69314718055994530942
*/
static void JX9_M_LN2_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.69314718055994530942);
}
/*
* M_LN10
* Expand 2.30258509299404568402
*/
static void JX9_M_LN10_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 2.30258509299404568402);
}
/*
* M_PI_2
* Expand 1.57079632679489661923
*/
static void JX9_M_PI_2_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.57079632679489661923);
}
/*
* M_PI_4
* Expand 0.78539816339744830962
*/
static void JX9_M_PI_4_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.78539816339744830962);
}
/*
* M_1_PI
* Expand 0.31830988618379067154
*/
static void JX9_M_1_PI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.31830988618379067154);
}
/*
* M_2_PI
* Expand 0.63661977236758134308
*/
static void JX9_M_2_PI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.63661977236758134308);
}
/*
* M_SQRTPI
* Expand 1.77245385090551602729
*/
static void JX9_M_SQRTPI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.77245385090551602729);
}
/*
* M_2_SQRTPI
* Expand 1.12837916709551257390
*/
static void JX9_M_2_SQRTPI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.12837916709551257390);
}
/*
* M_SQRT2
* Expand 1.41421356237309504880
*/
static void JX9_M_SQRT2_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.41421356237309504880);
}
/*
* M_SQRT3
* Expand 1.73205080756887729352
*/
static void JX9_M_SQRT3_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.73205080756887729352);
}
/*
* M_SQRT1_2
* Expand 0.70710678118654752440
*/
static void JX9_M_SQRT1_2_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.70710678118654752440);
}
/*
* M_LNPI
* Expand 1.14472988584940017414
*/
static void JX9_M_LNPI_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 1.14472988584940017414);
}
/*
* M_EULER
* Expand 0.57721566490153286061
*/
static void JX9_M_EULER_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_double(pVal, 0.57721566490153286061);
}
#endif /* JX9_DISABLE_BUILTIN_MATH */
/*
* DATE_ATOM
* Expand Atom (example: 2005-08-15T15:52:01+00:00)
*/
static void JX9_DATE_ATOM_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "Y-m-d\\TH:i:sP", -1/*Compute length automatically*/);
}
/*
* DATE_COOKIE
* HTTP Cookies (example: Monday, 15-Aug-05 15:52:01 UTC)
*/
static void JX9_DATE_COOKIE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "l, d-M-y H:i:s T", -1/*Compute length automatically*/);
}
/*
* DATE_ISO8601
* ISO-8601 (example: 2005-08-15T15:52:01+0000)
*/
static void JX9_DATE_ISO8601_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "Y-m-d\\TH:i:sO", -1/*Compute length automatically*/);
}
/*
* DATE_RFC822
* RFC 822 (example: Mon, 15 Aug 05 15:52:01 +0000)
*/
static void JX9_DATE_RFC822_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "D, d M y H:i:s O", -1/*Compute length automatically*/);
}
/*
* DATE_RFC850
* RFC 850 (example: Monday, 15-Aug-05 15:52:01 UTC)
*/
static void JX9_DATE_RFC850_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "l, d-M-y H:i:s T", -1/*Compute length automatically*/);
}
/*
* DATE_RFC1036
* RFC 1123 (example: Mon, 15 Aug 2005 15:52:01 +0000)
*/
static void JX9_DATE_RFC1036_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "D, d M y H:i:s O", -1/*Compute length automatically*/);
}
/*
* DATE_RFC1123
* RFC 1123 (example: Mon, 15 Aug 2005 15:52:01 +0000)
*/
static void JX9_DATE_RFC1123_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "D, d M Y H:i:s O", -1/*Compute length automatically*/);
}
/*
* DATE_RFC2822
* RFC 2822 (Mon, 15 Aug 2005 15:52:01 +0000)
*/
static void JX9_DATE_RFC2822_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "D, d M Y H:i:s O", -1/*Compute length automatically*/);
}
/*
* DATE_RSS
* RSS (Mon, 15 Aug 2005 15:52:01 +0000)
*/
static void JX9_DATE_RSS_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "D, d M Y H:i:s O", -1/*Compute length automatically*/);
}
/*
* DATE_W3C
* World Wide Web Consortium (example: 2005-08-15T15:52:01+00:00)
*/
static void JX9_DATE_W3C_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_string(pVal, "Y-m-d\\TH:i:sP", -1/*Compute length automatically*/);
}
/*
* ENT_COMPAT
* Expand 0x01 (Must be a power of two)
*/
static void JX9_ENT_COMPAT_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x01);
}
/*
* ENT_QUOTES
* Expand 0x02 (Must be a power of two)
*/
static void JX9_ENT_QUOTES_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x02);
}
/*
* ENT_NOQUOTES
* Expand 0x04 (Must be a power of two)
*/
static void JX9_ENT_NOQUOTES_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x04);
}
/*
* ENT_IGNORE
* Expand 0x08 (Must be a power of two)
*/
static void JX9_ENT_IGNORE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x08);
}
/*
* ENT_SUBSTITUTE
* Expand 0x10 (Must be a power of two)
*/
static void JX9_ENT_SUBSTITUTE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x10);
}
/*
* ENT_DISALLOWED
* Expand 0x20 (Must be a power of two)
*/
static void JX9_ENT_DISALLOWED_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x20);
}
/*
* ENT_HTML401
* Expand 0x40 (Must be a power of two)
*/
static void JX9_ENT_HTML401_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x40);
}
/*
* ENT_XML1
* Expand 0x80 (Must be a power of two)
*/
static void JX9_ENT_XML1_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x80);
}
/*
* ENT_XHTML
* Expand 0x100 (Must be a power of two)
*/
static void JX9_ENT_XHTML_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x100);
}
/*
* ENT_HTML5
* Expand 0x200 (Must be a power of two)
*/
static void JX9_ENT_HTML5_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x200);
}
/*
* ISO-8859-1
* ISO_8859_1
* Expand 1
*/
static void JX9_ISO88591_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* UTF-8
* UTF8
* Expand 2
*/
static void JX9_UTF8_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* HTML_ENTITIES
* Expand 1
*/
static void JX9_HTML_ENTITIES_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* HTML_SPECIALCHARS
* Expand 2
*/
static void JX9_HTML_SPECIALCHARS_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* JX9_URL_SCHEME.
* Expand 1
*/
static void JX9_JX9_URL_SCHEME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* JX9_URL_HOST.
* Expand 2
*/
static void JX9_JX9_URL_HOST_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* JX9_URL_PORT.
* Expand 3
*/
static void JX9_JX9_URL_PORT_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 3);
}
/*
* JX9_URL_USER.
* Expand 4
*/
static void JX9_JX9_URL_USER_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 4);
}
/*
* JX9_URL_PASS.
* Expand 5
*/
static void JX9_JX9_URL_PASS_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 5);
}
/*
* JX9_URL_PATH.
* Expand 6
*/
static void JX9_JX9_URL_PATH_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 6);
}
/*
* JX9_URL_QUERY.
* Expand 7
*/
static void JX9_JX9_URL_QUERY_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 7);
}
/*
* JX9_URL_FRAGMENT.
* Expand 8
*/
static void JX9_JX9_URL_FRAGMENT_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 8);
}
/*
* JX9_QUERY_RFC1738
* Expand 1
*/
static void JX9_JX9_QUERY_RFC1738_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* JX9_QUERY_RFC3986
* Expand 1
*/
static void JX9_JX9_QUERY_RFC3986_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* FNM_NOESCAPE
* Expand 0x01 (Must be a power of two)
*/
static void JX9_FNM_NOESCAPE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x01);
}
/*
* FNM_PATHNAME
* Expand 0x02 (Must be a power of two)
*/
static void JX9_FNM_PATHNAME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x02);
}
/*
* FNM_PERIOD
* Expand 0x04 (Must be a power of two)
*/
static void JX9_FNM_PERIOD_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x04);
}
/*
* FNM_CASEFOLD
* Expand 0x08 (Must be a power of two)
*/
static void JX9_FNM_CASEFOLD_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x08);
}
/*
* PATHINFO_DIRNAME
* Expand 1.
*/
static void JX9_PATHINFO_DIRNAME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* PATHINFO_BASENAME
* Expand 2.
*/
static void JX9_PATHINFO_BASENAME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* PATHINFO_EXTENSION
* Expand 3.
*/
static void JX9_PATHINFO_EXTENSION_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 3);
}
/*
* PATHINFO_FILENAME
* Expand 4.
*/
static void JX9_PATHINFO_FILENAME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 4);
}
/*
* ASSERT_ACTIVE.
* Expand the value of JX9_ASSERT_ACTIVE defined in jx9Int.h
*/
static void JX9_ASSERT_ACTIVE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, JX9_ASSERT_DISABLE);
}
/*
* ASSERT_WARNING.
* Expand the value of JX9_ASSERT_WARNING defined in jx9Int.h
*/
static void JX9_ASSERT_WARNING_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, JX9_ASSERT_WARNING);
}
/*
* ASSERT_BAIL.
* Expand the value of JX9_ASSERT_BAIL defined in jx9Int.h
*/
static void JX9_ASSERT_BAIL_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, JX9_ASSERT_BAIL);
}
/*
* ASSERT_QUIET_EVAL.
* Expand the value of JX9_ASSERT_QUIET_EVAL defined in jx9Int.h
*/
static void JX9_ASSERT_QUIET_EVAL_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, JX9_ASSERT_QUIET_EVAL);
}
/*
* ASSERT_CALLBACK.
* Expand the value of JX9_ASSERT_CALLBACK defined in jx9Int.h
*/
static void JX9_ASSERT_CALLBACK_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, JX9_ASSERT_CALLBACK);
}
/*
* SEEK_SET.
* Expand 0
*/
static void JX9_SEEK_SET_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0);
}
/*
* SEEK_CUR.
* Expand 1
*/
static void JX9_SEEK_CUR_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* SEEK_END.
* Expand 2
*/
static void JX9_SEEK_END_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* LOCK_SH.
* Expand 2
*/
static void JX9_LOCK_SH_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* LOCK_NB.
* Expand 5
*/
static void JX9_LOCK_NB_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 5);
}
/*
* LOCK_EX.
* Expand 0x01 (MUST BE A POWER OF TWO)
*/
static void JX9_LOCK_EX_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x01);
}
/*
* LOCK_UN.
* Expand 0
*/
static void JX9_LOCK_UN_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0);
}
/*
* FILE_USE_INC_PATH
* Expand 0x01 (Must be a power of two)
*/
static void JX9_FILE_USE_INCLUDE_PATH_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x1);
}
/*
* FILE_IGN_NL
* Expand 0x02 (Must be a power of two)
*/
static void JX9_FILE_IGNORE_NEW_LINES_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x2);
}
/*
* FILE_SKIP_EL
* Expand 0x04 (Must be a power of two)
*/
static void JX9_FILE_SKIP_EMPTY_LINES_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x4);
}
/*
* FILE_APPEND
* Expand 0x08 (Must be a power of two)
*/
static void JX9_FILE_APPEND_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x08);
}
/*
* SCANDIR_SORT_ASCENDING
* Expand 0
*/
static void JX9_SCANDIR_SORT_ASCENDING_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0);
}
/*
* SCANDIR_SORT_DESCENDING
* Expand 1
*/
static void JX9_SCANDIR_SORT_DESCENDING_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* SCANDIR_SORT_NONE
* Expand 2
*/
static void JX9_SCANDIR_SORT_NONE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* GLOB_MARK
* Expand 0x01 (must be a power of two)
*/
static void JX9_GLOB_MARK_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x01);
}
/*
* GLOB_NOSORT
* Expand 0x02 (must be a power of two)
*/
static void JX9_GLOB_NOSORT_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x02);
}
/*
* GLOB_NOCHECK
* Expand 0x04 (must be a power of two)
*/
static void JX9_GLOB_NOCHECK_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x04);
}
/*
* GLOB_NOESCAPE
* Expand 0x08 (must be a power of two)
*/
static void JX9_GLOB_NOESCAPE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x08);
}
/*
* GLOB_BRACE
* Expand 0x10 (must be a power of two)
*/
static void JX9_GLOB_BRACE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x10);
}
/*
* GLOB_ONLYDIR
* Expand 0x20 (must be a power of two)
*/
static void JX9_GLOB_ONLYDIR_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x20);
}
/*
* GLOB_ERR
* Expand 0x40 (must be a power of two)
*/
static void JX9_GLOB_ERR_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x40);
}
/*
* STDIN
* Expand the STDIN handle as a resource.
*/
static void JX9_STDIN_Const(jx9_value *pVal, void *pUserData)
{
jx9_vm *pVm = (jx9_vm *)pUserData;
void *pResource;
pResource = jx9ExportStdin(pVm);
jx9_value_resource(pVal, pResource);
}
/*
* STDOUT
* Expand the STDOUT handle as a resource.
*/
static void JX9_STDOUT_Const(jx9_value *pVal, void *pUserData)
{
jx9_vm *pVm = (jx9_vm *)pUserData;
void *pResource;
pResource = jx9ExportStdout(pVm);
jx9_value_resource(pVal, pResource);
}
/*
* STDERR
* Expand the STDERR handle as a resource.
*/
static void JX9_STDERR_Const(jx9_value *pVal, void *pUserData)
{
jx9_vm *pVm = (jx9_vm *)pUserData;
void *pResource;
pResource = jx9ExportStderr(pVm);
jx9_value_resource(pVal, pResource);
}
/*
* INI_SCANNER_NORMAL
* Expand 1
*/
static void JX9_INI_SCANNER_NORMAL_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 1);
}
/*
* INI_SCANNER_RAW
* Expand 2
*/
static void JX9_INI_SCANNER_RAW_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 2);
}
/*
* EXTR_OVERWRITE
* Expand 0x01 (Must be a power of two)
*/
static void JX9_EXTR_OVERWRITE_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x1);
}
/*
* EXTR_SKIP
* Expand 0x02 (Must be a power of two)
*/
static void JX9_EXTR_SKIP_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x2);
}
/*
* EXTR_PREFIX_SAME
* Expand 0x04 (Must be a power of two)
*/
static void JX9_EXTR_PREFIX_SAME_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x4);
}
/*
* EXTR_PREFIX_ALL
* Expand 0x08 (Must be a power of two)
*/
static void JX9_EXTR_PREFIX_ALL_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x8);
}
/*
* EXTR_PREFIX_INVALID
* Expand 0x10 (Must be a power of two)
*/
static void JX9_EXTR_PREFIX_INVALID_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x10);
}
/*
* EXTR_IF_EXISTS
* Expand 0x20 (Must be a power of two)
*/
static void JX9_EXTR_IF_EXISTS_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x20);
}
/*
* EXTR_PREFIX_IF_EXISTS
* Expand 0x40 (Must be a power of two)
*/
static void JX9_EXTR_PREFIX_IF_EXISTS_Const(jx9_value *pVal, void *pUserData)
{
SXUNUSED(pUserData); /* cc warning */
jx9_value_int(pVal, 0x40);
}
/*
* Table of built-in constants.
*/
static const jx9_builtin_constant aBuiltIn[] = {
{"JX9_VERSION", JX9_VER_Const },
{"JX9_ENGINE", JX9_VER_Const },
{"__JX9__", JX9_VER_Const },
{"JX9_OS", JX9_OS_Const },
{"__OS__", JX9_OS_Const },
{"JX9_EOL", JX9_EOL_Const },
{"JX9_INT_MAX", JX9_INTMAX_Const },
{"MAXINT", JX9_INTMAX_Const },
{"JX9_INT_SIZE", JX9_INTSIZE_Const },
{"PATH_SEPARATOR", JX9_PATHSEP_Const },
{"DIRECTORY_SEPARATOR", JX9_DIRSEP_Const },
{"DIR_SEP", JX9_DIRSEP_Const },
{"__TIME__", JX9_TIME_Const },
{"__DATE__", JX9_DATE_Const },
{"__FILE__", JX9_FILE_Const },
{"__DIR__", JX9_DIR_Const },
{"E_ERROR", JX9_E_ERROR_Const },
{"E_WARNING", JX9_E_WARNING_Const},
{"E_PARSE", JX9_E_PARSE_Const },
{"E_NOTICE", JX9_E_NOTICE_Const },
{"CASE_LOWER", JX9_CASE_LOWER_Const },
{"CASE_UPPER", JX9_CASE_UPPER_Const },
{"STR_PAD_LEFT", JX9_STR_PAD_LEFT_Const },
{"STR_PAD_RIGHT", JX9_STR_PAD_RIGHT_Const},
{"STR_PAD_BOTH", JX9_STR_PAD_BOTH_Const },
{"COUNT_NORMAL", JX9_COUNT_NORMAL_Const },
{"COUNT_RECURSIVE", JX9_COUNT_RECURSIVE_Const },
{"SORT_ASC", JX9_SORT_ASC_Const },
{"SORT_DESC", JX9_SORT_DESC_Const },
{"SORT_REGULAR", JX9_SORT_REG_Const },
{"SORT_NUMERIC", JX9_SORT_NUMERIC_Const },
{"SORT_STRING", JX9_SORT_STRING_Const },
{"JX9_ROUND_HALF_DOWN", JX9_JX9_ROUND_HALF_DOWN_Const },
{"JX9_ROUND_HALF_EVEN", JX9_JX9_ROUND_HALF_EVEN_Const },
{"JX9_ROUND_HALF_UP", JX9_JX9_ROUND_HALF_UP_Const },
{"JX9_ROUND_HALF_ODD", JX9_JX9_ROUND_HALF_ODD_Const },
#ifdef JX9_ENABLE_MATH_FUNC
{"PI", JX9_M_PI_Const },
{"M_E", JX9_M_E_Const },
{"M_LOG2E", JX9_M_LOG2E_Const },
{"M_LOG10E", JX9_M_LOG10E_Const },
{"M_LN2", JX9_M_LN2_Const },
{"M_LN10", JX9_M_LN10_Const },
{"M_PI_2", JX9_M_PI_2_Const },
{"M_PI_4", JX9_M_PI_4_Const },
{"M_1_PI", JX9_M_1_PI_Const },
{"M_2_PI", JX9_M_2_PI_Const },
{"M_SQRTPI", JX9_M_SQRTPI_Const },
{"M_2_SQRTPI", JX9_M_2_SQRTPI_Const },
{"M_SQRT2", JX9_M_SQRT2_Const },
{"M_SQRT3", JX9_M_SQRT3_Const },
{"M_SQRT1_2", JX9_M_SQRT1_2_Const },
{"M_LNPI", JX9_M_LNPI_Const },
{"M_EULER", JX9_M_EULER_Const },
#endif /* JX9_ENABLE_MATH_FUNC */
{"DATE_ATOM", JX9_DATE_ATOM_Const },
{"DATE_COOKIE", JX9_DATE_COOKIE_Const },
{"DATE_ISO8601", JX9_DATE_ISO8601_Const },
{"DATE_RFC822", JX9_DATE_RFC822_Const },
{"DATE_RFC850", JX9_DATE_RFC850_Const },
{"DATE_RFC1036", JX9_DATE_RFC1036_Const },
{"DATE_RFC1123", JX9_DATE_RFC1123_Const },
{"DATE_RFC2822", JX9_DATE_RFC2822_Const },
{"DATE_RFC3339", JX9_DATE_ATOM_Const },
{"DATE_RSS", JX9_DATE_RSS_Const },
{"DATE_W3C", JX9_DATE_W3C_Const },
{"ENT_COMPAT", JX9_ENT_COMPAT_Const },
{"ENT_QUOTES", JX9_ENT_QUOTES_Const },
{"ENT_NOQUOTES", JX9_ENT_NOQUOTES_Const },
{"ENT_IGNORE", JX9_ENT_IGNORE_Const },
{"ENT_SUBSTITUTE", JX9_ENT_SUBSTITUTE_Const},
{"ENT_DISALLOWED", JX9_ENT_DISALLOWED_Const},
{"ENT_HTML401", JX9_ENT_HTML401_Const },
{"ENT_XML1", JX9_ENT_XML1_Const },
{"ENT_XHTML", JX9_ENT_XHTML_Const },
{"ENT_HTML5", JX9_ENT_HTML5_Const },
{"ISO-8859-1", JX9_ISO88591_Const },
{"ISO_8859_1", JX9_ISO88591_Const },
{"UTF-8", JX9_UTF8_Const },
{"UTF8", JX9_UTF8_Const },
{"HTML_ENTITIES", JX9_HTML_ENTITIES_Const},
{"HTML_SPECIALCHARS", JX9_HTML_SPECIALCHARS_Const },
{"JX9_URL_SCHEME", JX9_JX9_URL_SCHEME_Const},
{"JX9_URL_HOST", JX9_JX9_URL_HOST_Const},
{"JX9_URL_PORT", JX9_JX9_URL_PORT_Const},
{"JX9_URL_USER", JX9_JX9_URL_USER_Const},
{"JX9_URL_PASS", JX9_JX9_URL_PASS_Const},
{"JX9_URL_PATH", JX9_JX9_URL_PATH_Const},
{"JX9_URL_QUERY", JX9_JX9_URL_QUERY_Const},
{"JX9_URL_FRAGMENT", JX9_JX9_URL_FRAGMENT_Const},
{"JX9_QUERY_RFC1738", JX9_JX9_QUERY_RFC1738_Const},
{"JX9_QUERY_RFC3986", JX9_JX9_QUERY_RFC3986_Const},
{"FNM_NOESCAPE", JX9_FNM_NOESCAPE_Const },
{"FNM_PATHNAME", JX9_FNM_PATHNAME_Const },
{"FNM_PERIOD", JX9_FNM_PERIOD_Const },
{"FNM_CASEFOLD", JX9_FNM_CASEFOLD_Const },
{"PATHINFO_DIRNAME", JX9_PATHINFO_DIRNAME_Const },
{"PATHINFO_BASENAME", JX9_PATHINFO_BASENAME_Const },
{"PATHINFO_EXTENSION", JX9_PATHINFO_EXTENSION_Const},
{"PATHINFO_FILENAME", JX9_PATHINFO_FILENAME_Const },
{"ASSERT_ACTIVE", JX9_ASSERT_ACTIVE_Const },
{"ASSERT_WARNING", JX9_ASSERT_WARNING_Const },
{"ASSERT_BAIL", JX9_ASSERT_BAIL_Const },
{"ASSERT_QUIET_EVAL", JX9_ASSERT_QUIET_EVAL_Const },
{"ASSERT_CALLBACK", JX9_ASSERT_CALLBACK_Const },
{"SEEK_SET", JX9_SEEK_SET_Const },
{"SEEK_CUR", JX9_SEEK_CUR_Const },
{"SEEK_END", JX9_SEEK_END_Const },
{"LOCK_EX", JX9_LOCK_EX_Const },
{"LOCK_SH", JX9_LOCK_SH_Const },
{"LOCK_NB", JX9_LOCK_NB_Const },
{"LOCK_UN", JX9_LOCK_UN_Const },
{"FILE_USE_INC_PATH", JX9_FILE_USE_INCLUDE_PATH_Const},
{"FILE_IGN_NL", JX9_FILE_IGNORE_NEW_LINES_Const},
{"FILE_SKIP_EL", JX9_FILE_SKIP_EMPTY_LINES_Const},
{"FILE_APPEND", JX9_FILE_APPEND_Const },
{"SCANDIR_SORT_ASC", JX9_SCANDIR_SORT_ASCENDING_Const },
{"SCANDIR_SORT_DESC", JX9_SCANDIR_SORT_DESCENDING_Const },
{"SCANDIR_SORT_NONE", JX9_SCANDIR_SORT_NONE_Const },
{"GLOB_MARK", JX9_GLOB_MARK_Const },
{"GLOB_NOSORT", JX9_GLOB_NOSORT_Const },
{"GLOB_NOCHECK", JX9_GLOB_NOCHECK_Const },
{"GLOB_NOESCAPE", JX9_GLOB_NOESCAPE_Const},
{"GLOB_BRACE", JX9_GLOB_BRACE_Const },
{"GLOB_ONLYDIR", JX9_GLOB_ONLYDIR_Const },
{"GLOB_ERR", JX9_GLOB_ERR_Const },
{"STDIN", JX9_STDIN_Const },
{"stdin", JX9_STDIN_Const },
{"STDOUT", JX9_STDOUT_Const },
{"stdout", JX9_STDOUT_Const },
{"STDERR", JX9_STDERR_Const },
{"stderr", JX9_STDERR_Const },
{"INI_SCANNER_NORMAL", JX9_INI_SCANNER_NORMAL_Const },
{"INI_SCANNER_RAW", JX9_INI_SCANNER_RAW_Const },
{"EXTR_OVERWRITE", JX9_EXTR_OVERWRITE_Const },
{"EXTR_SKIP", JX9_EXTR_SKIP_Const },
{"EXTR_PREFIX_SAME", JX9_EXTR_PREFIX_SAME_Const },
{"EXTR_PREFIX_ALL", JX9_EXTR_PREFIX_ALL_Const },
{"EXTR_PREFIX_INVALID", JX9_EXTR_PREFIX_INVALID_Const },
{"EXTR_IF_EXISTS", JX9_EXTR_IF_EXISTS_Const },
{"EXTR_PREFIX_IF_EXISTS", JX9_EXTR_PREFIX_IF_EXISTS_Const}
};
/*
* Register the built-in constants defined above.
*/
JX9_PRIVATE void jx9RegisterBuiltInConstant(jx9_vm *pVm)
{
sxu32 n;
/*
* Note that all built-in constants have access to the jx9 virtual machine
* that trigger the constant invocation as their private data.
*/
for( n = 0 ; n < SX_ARRAYSIZE(aBuiltIn) ; ++n ){
jx9_create_constant(&(*pVm), aBuiltIn[n].zName, aBuiltIn[n].xExpand, &(*pVm));
}
}
/*
* ----------------------------------------------------------
* File: jx9_hashmap.c
* MD5: 4e93d15cd37e6093e25d8ede3064e210
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: hashmap.c v2.6 Win7 2012-12-11 00:50 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file implement generic hashmaps used to represent JSON arrays and objects */
/* Allowed node types */
#define HASHMAP_INT_NODE 1 /* Node with an int [i.e: 64-bit integer] key */
#define HASHMAP_BLOB_NODE 2 /* Node with a string/BLOB key */
/*
* Default hash function for int [i.e; 64-bit integer] keys.
*/
static sxu32 IntHash(sxi64 iKey)
{
return (sxu32)(iKey ^ (iKey << 8) ^ (iKey >> 8));
}
/*
* Default hash function for string/BLOB keys.
*/
static sxu32 BinHash(const void *pSrc, sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
sxu32 nH = 5381;
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
}
return nH;
}
/*
* Return the total number of entries in a given hashmap.
* If bRecurisve is set to TRUE then recurse on hashmap entries.
* If the nesting limit is reached, this function abort immediately.
*/
static sxi64 HashmapCount(jx9_hashmap *pMap, int bRecursive, int iRecCount)
{
sxi64 iCount = 0;
if( !bRecursive ){
iCount = pMap->nEntry;
}else{
/* Recursive hashmap walk */
jx9_hashmap_node *pEntry = pMap->pLast;
jx9_value *pElem;
sxu32 n = 0;
for(;;){
if( n >= pMap->nEntry ){
break;
}
/* Point to the element value */
pElem = (jx9_value *)SySetAt(&pMap->pVm->aMemObj, pEntry->nValIdx);
if( pElem ){
if( pElem->iFlags & MEMOBJ_HASHMAP ){
if( iRecCount > 31 ){
/* Nesting limit reached */
return iCount;
}
/* Recurse */
iRecCount++;
iCount += HashmapCount((jx9_hashmap *)pElem->x.pOther, TRUE, iRecCount);
iRecCount--;
}
}
/* Point to the next entry */
pEntry = pEntry->pNext;
++n;
}
/* Update count */
iCount += pMap->nEntry;
}
return iCount;
}
/*
* Allocate a new hashmap node with a 64-bit integer key.
* If something goes wrong [i.e: out of memory], this function return NULL.
* Otherwise a fresh [jx9_hashmap_node] instance is returned.
*/
static jx9_hashmap_node * HashmapNewIntNode(jx9_hashmap *pMap, sxi64 iKey, sxu32 nHash, sxu32 nValIdx)
{
jx9_hashmap_node *pNode;
/* Allocate a new node */
pNode = (jx9_hashmap_node *)SyMemBackendPoolAlloc(&pMap->pVm->sAllocator, sizeof(jx9_hashmap_node));
if( pNode == 0 ){
return 0;
}
/* Zero the stucture */
SyZero(pNode, sizeof(jx9_hashmap_node));
/* Fill in the structure */
pNode->pMap = &(*pMap);
pNode->iType = HASHMAP_INT_NODE;
pNode->nHash = nHash;
pNode->xKey.iKey = iKey;
pNode->nValIdx = nValIdx;
return pNode;
}
/*
* Allocate a new hashmap node with a BLOB key.
* If something goes wrong [i.e: out of memory], this function return NULL.
* Otherwise a fresh [jx9_hashmap_node] instance is returned.
*/
static jx9_hashmap_node * HashmapNewBlobNode(jx9_hashmap *pMap, const void *pKey, sxu32 nKeyLen, sxu32 nHash, sxu32 nValIdx)
{
jx9_hashmap_node *pNode;
/* Allocate a new node */
pNode = (jx9_hashmap_node *)SyMemBackendPoolAlloc(&pMap->pVm->sAllocator, sizeof(jx9_hashmap_node));
if( pNode == 0 ){
return 0;
}
/* Zero the stucture */
SyZero(pNode, sizeof(jx9_hashmap_node));
/* Fill in the structure */
pNode->pMap = &(*pMap);
pNode->iType = HASHMAP_BLOB_NODE;
pNode->nHash = nHash;
SyBlobInit(&pNode->xKey.sKey, &pMap->pVm->sAllocator);
SyBlobAppend(&pNode->xKey.sKey, pKey, nKeyLen);
pNode->nValIdx = nValIdx;
return pNode;
}
/*
* link a hashmap node to the given bucket index (last argument to this function).
*/
static void HashmapNodeLink(jx9_hashmap *pMap, jx9_hashmap_node *pNode, sxu32 nBucketIdx)
{
/* Link */
if( pMap->apBucket[nBucketIdx] != 0 ){
pNode->pNextCollide = pMap->apBucket[nBucketIdx];
pMap->apBucket[nBucketIdx]->pPrevCollide = pNode;
}
pMap->apBucket[nBucketIdx] = pNode;
/* Link to the map list */
if( pMap->pFirst == 0 ){
pMap->pFirst = pMap->pLast = pNode;
/* Point to the first inserted node */
pMap->pCur = pNode;
}else{
MACRO_LD_PUSH(pMap->pLast, pNode);
}
++pMap->nEntry;
}
/*
* Unlink a node from the hashmap.
* If the node count reaches zero then release the whole hash-bucket.
*/
static void jx9HashmapUnlinkNode(jx9_hashmap_node *pNode)
{
jx9_hashmap *pMap = pNode->pMap;
jx9_vm *pVm = pMap->pVm;
/* Unlink from the corresponding bucket */
if( pNode->pPrevCollide == 0 ){
pMap->apBucket[pNode->nHash & (pMap->nSize - 1)] = pNode->pNextCollide;
}else{
pNode->pPrevCollide->pNextCollide = pNode->pNextCollide;
}
if( pNode->pNextCollide ){
pNode->pNextCollide->pPrevCollide = pNode->pPrevCollide;
}
if( pMap->pFirst == pNode ){
pMap->pFirst = pNode->pPrev;
}
if( pMap->pCur == pNode ){
/* Advance the node cursor */
pMap->pCur = pMap->pCur->pPrev; /* Reverse link */
}
/* Unlink from the map list */
MACRO_LD_REMOVE(pMap->pLast, pNode);
/* Restore to the free list */
jx9VmUnsetMemObj(pVm, pNode->nValIdx);
if( pNode->iType == HASHMAP_BLOB_NODE ){
SyBlobRelease(&pNode->xKey.sKey);
}
SyMemBackendPoolFree(&pVm->sAllocator, pNode);
pMap->nEntry--;
if( pMap->nEntry < 1 ){
/* Free the hash-bucket */
SyMemBackendFree(&pVm->sAllocator, pMap->apBucket);
pMap->apBucket = 0;
pMap->nSize = 0;
pMap->pFirst = pMap->pLast = pMap->pCur = 0;
}
}
#define HASHMAP_FILL_FACTOR 3
/*
* Grow the hash-table and rehash all entries.
*/
static sxi32 HashmapGrowBucket(jx9_hashmap *pMap)
{
if( pMap->nEntry >= pMap->nSize * HASHMAP_FILL_FACTOR ){
jx9_hashmap_node **apOld = pMap->apBucket;
jx9_hashmap_node *pEntry, **apNew;
sxu32 nNew = pMap->nSize << 1;
sxu32 nBucket;
sxu32 n;
if( nNew < 1 ){
nNew = 16;
}
/* Allocate a new bucket */
apNew = (jx9_hashmap_node **)SyMemBackendAlloc(&pMap->pVm->sAllocator, nNew * sizeof(jx9_hashmap_node *));
if( apNew == 0 ){
if( pMap->nSize < 1 ){
return SXERR_MEM; /* Fatal */
}
/* Not so fatal here, simply a performance hit */
return SXRET_OK;
}
/* Zero the table */
SyZero((void *)apNew, nNew * sizeof(jx9_hashmap_node *));
/* Reflect the change */
pMap->apBucket = apNew;
pMap->nSize = nNew;
if( apOld == 0 ){
/* First allocated table [i.e: no entry], return immediately */
return SXRET_OK;
}
/* Rehash old entries */
pEntry = pMap->pFirst;
n = 0;
for( ;; ){
if( n >= pMap->nEntry ){
break;
}
/* Clear the old collision link */
pEntry->pNextCollide = pEntry->pPrevCollide = 0;
/* Link to the new bucket */
nBucket = pEntry->nHash & (nNew - 1);
if( pMap->apBucket[nBucket] != 0 ){
pEntry->pNextCollide = pMap->apBucket[nBucket];
pMap->apBucket[nBucket]->pPrevCollide = pEntry;
}
pMap->apBucket[nBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n++;
}
/* Free the old table */
SyMemBackendFree(&pMap->pVm->sAllocator, (void *)apOld);
}
return SXRET_OK;
}
/*
* Insert a 64-bit integer key and it's associated value (if any) in the given
* hashmap.
*/
static sxi32 HashmapInsertIntKey(jx9_hashmap *pMap,sxi64 iKey,jx9_value *pValue)
{
jx9_hashmap_node *pNode;
jx9_value *pObj;
sxu32 nIdx;
sxu32 nHash;
sxi32 rc;
/* Reserve a jx9_value for the value */
pObj = jx9VmReserveMemObj(pMap->pVm,&nIdx);
if( pObj == 0 ){
return SXERR_MEM;
}
if( pValue ){
/* Duplicate the value */
jx9MemObjStore(pValue, pObj);
}
/* Hash the key */
nHash = pMap->xIntHash(iKey);
/* Allocate a new int node */
pNode = HashmapNewIntNode(&(*pMap), iKey, nHash, nIdx);
if( pNode == 0 ){
return SXERR_MEM;
}
/* Make sure the bucket is big enough to hold the new entry */
rc = HashmapGrowBucket(&(*pMap));
if( rc != SXRET_OK ){
SyMemBackendPoolFree(&pMap->pVm->sAllocator, pNode);
return rc;
}
/* Perform the insertion */
HashmapNodeLink(&(*pMap), pNode, nHash & (pMap->nSize - 1));
/* All done */
return SXRET_OK;
}
/*
* Insert a BLOB key and it's associated value (if any) in the given
* hashmap.
*/
static sxi32 HashmapInsertBlobKey(jx9_hashmap *pMap,const void *pKey,sxu32 nKeyLen,jx9_value *pValue)
{
jx9_hashmap_node *pNode;
jx9_value *pObj;
sxu32 nHash;
sxu32 nIdx;
sxi32 rc;
/* Reserve a jx9_value for the value */
pObj = jx9VmReserveMemObj(pMap->pVm,&nIdx);
if( pObj == 0 ){
return SXERR_MEM;
}
if( pValue ){
/* Duplicate the value */
jx9MemObjStore(pValue, pObj);
}
/* Hash the key */
nHash = pMap->xBlobHash(pKey, nKeyLen);
/* Allocate a new blob node */
pNode = HashmapNewBlobNode(&(*pMap), pKey, nKeyLen, nHash, nIdx);
if( pNode == 0 ){
return SXERR_MEM;
}
/* Make sure the bucket is big enough to hold the new entry */
rc = HashmapGrowBucket(&(*pMap));
if( rc != SXRET_OK ){
SyMemBackendPoolFree(&pMap->pVm->sAllocator, pNode);
return rc;
}
/* Perform the insertion */
HashmapNodeLink(&(*pMap), pNode, nHash & (pMap->nSize - 1));
/* All done */
return SXRET_OK;
}
/*
* Check if a given 64-bit integer key exists in the given hashmap.
* Write a pointer to the target node on success. Otherwise
* SXERR_NOTFOUND is returned on failure.
*/
static sxi32 HashmapLookupIntKey(
jx9_hashmap *pMap, /* Target hashmap */
sxi64 iKey, /* lookup key */
jx9_hashmap_node **ppNode /* OUT: target node on success */
)
{
jx9_hashmap_node *pNode;
sxu32 nHash;
if( pMap->nEntry < 1 ){
/* Don't bother hashing, there is no entry anyway */
return SXERR_NOTFOUND;
}
/* Hash the key first */
nHash = pMap->xIntHash(iKey);
/* Point to the appropriate bucket */
pNode = pMap->apBucket[nHash & (pMap->nSize - 1)];
/* Perform the lookup */
for(;;){
if( pNode == 0 ){
break;
}
if( pNode->iType == HASHMAP_INT_NODE
&& pNode->nHash == nHash
&& pNode->xKey.iKey == iKey ){
/* Node found */
if( ppNode ){
*ppNode = pNode;
}
return SXRET_OK;
}
/* Follow the collision link */
pNode = pNode->pNextCollide;
}
/* No such entry */
return SXERR_NOTFOUND;
}
/*
* Check if a given BLOB key exists in the given hashmap.
* Write a pointer to the target node on success. Otherwise
* SXERR_NOTFOUND is returned on failure.
*/
static sxi32 HashmapLookupBlobKey(
jx9_hashmap *pMap, /* Target hashmap */
const void *pKey, /* Lookup key */
sxu32 nKeyLen, /* Key length in bytes */
jx9_hashmap_node **ppNode /* OUT: target node on success */
)
{
jx9_hashmap_node *pNode;
sxu32 nHash;
if( pMap->nEntry < 1 ){
/* Don't bother hashing, there is no entry anyway */
return SXERR_NOTFOUND;
}
/* Hash the key first */
nHash = pMap->xBlobHash(pKey, nKeyLen);
/* Point to the appropriate bucket */
pNode = pMap->apBucket[nHash & (pMap->nSize - 1)];
/* Perform the lookup */
for(;;){
if( pNode == 0 ){
break;
}
if( pNode->iType == HASHMAP_BLOB_NODE
&& pNode->nHash == nHash
&& SyBlobLength(&pNode->xKey.sKey) == nKeyLen
&& SyMemcmp(SyBlobData(&pNode->xKey.sKey), pKey, nKeyLen) == 0 ){
/* Node found */
if( ppNode ){
*ppNode = pNode;
}
return SXRET_OK;
}
/* Follow the collision link */
pNode = pNode->pNextCollide;
}
/* No such entry */
return SXERR_NOTFOUND;
}
/*
* Check if the given BLOB key looks like a decimal number.
* Retrurn TRUE on success.FALSE otherwise.
*/
static int HashmapIsIntKey(SyBlob *pKey)
{
const char *zIn = (const char *)SyBlobData(pKey);
const char *zEnd = &zIn[SyBlobLength(pKey)];
if( (int)(zEnd-zIn) > 1 && zIn[0] == '0' ){
/* Octal not decimal number */
return FALSE;
}
if( (zIn[0] == '-' || zIn[0] == '+') && &zIn[1] < zEnd ){
zIn++;
}
for(;;){
if( zIn >= zEnd ){
return TRUE;
}
if( (unsigned char)zIn[0] >= 0xc0 /* UTF-8 stream */ || !SyisDigit(zIn[0]) ){
break;
}
zIn++;
}
/* Key does not look like a decimal number */
return FALSE;
}
/*
* Check if a given key exists in the given hashmap.
* Write a pointer to the target node on success.
* Otherwise SXERR_NOTFOUND is returned on failure.
*/
static sxi32 HashmapLookup(
jx9_hashmap *pMap, /* Target hashmap */
jx9_value *pKey, /* Lookup key */
jx9_hashmap_node **ppNode /* OUT: target node on success */
)
{
jx9_hashmap_node *pNode = 0; /* cc -O6 warning */
sxi32 rc;
if( pKey->iFlags & (MEMOBJ_STRING|MEMOBJ_HASHMAP|MEMOBJ_RES) ){
if( (pKey->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(&(*pKey));
}
if( SyBlobLength(&pKey->sBlob) > 0 ){
/* Perform a blob lookup */
rc = HashmapLookupBlobKey(&(*pMap), SyBlobData(&pKey->sBlob), SyBlobLength(&pKey->sBlob), &pNode);
goto result;
}
}
/* Perform an int lookup */
if((pKey->iFlags & MEMOBJ_INT) == 0 ){
/* Force an integer cast */
jx9MemObjToInteger(pKey);
}
/* Perform an int lookup */
rc = HashmapLookupIntKey(&(*pMap), pKey->x.iVal, &pNode);
result:
if( rc == SXRET_OK ){
/* Node found */
if( ppNode ){
*ppNode = pNode;
}
return SXRET_OK;
}
/* No such entry */
return SXERR_NOTFOUND;
}
/*
* Insert a given key and it's associated value (if any) in the given
* hashmap.
* If a node with the given key already exists in the database
* then this function overwrite the old value.
*/
static sxi32 HashmapInsert(
jx9_hashmap *pMap, /* Target hashmap */
jx9_value *pKey, /* Lookup key */
jx9_value *pVal /* Node value */
)
{
jx9_hashmap_node *pNode = 0;
sxi32 rc = SXRET_OK;
if( pMap->nEntry < 1 && pKey && (pKey->iFlags & MEMOBJ_STRING) ){
pMap->iFlags |= HASHMAP_JSON_OBJECT;
}
if( pKey && (pKey->iFlags & (MEMOBJ_STRING|MEMOBJ_HASHMAP|MEMOBJ_RES)) ){
if( (pKey->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(&(*pKey));
}
if( SyBlobLength(&pKey->sBlob) < 1 || HashmapIsIntKey(&pKey->sBlob) ){
if(SyBlobLength(&pKey->sBlob) < 1){
/* Automatic index assign */
pKey = 0;
}
goto IntKey;
}
if( SXRET_OK == HashmapLookupBlobKey(&(*pMap), SyBlobData(&pKey->sBlob),
SyBlobLength(&pKey->sBlob), &pNode) ){
/* Overwrite the old value */
jx9_value *pElem;
pElem = (jx9_value *)SySetAt(&pMap->pVm->aMemObj, pNode->nValIdx);
if( pElem ){
if( pVal ){
jx9MemObjStore(pVal, pElem);
}else{
/* Nullify the entry */
jx9MemObjToNull(pElem);
}
}
return SXRET_OK;
}
/* Perform a blob-key insertion */
rc = HashmapInsertBlobKey(&(*pMap),SyBlobData(&pKey->sBlob),SyBlobLength(&pKey->sBlob),&(*pVal));
return rc;
}
IntKey:
if( pKey ){
if((pKey->iFlags & MEMOBJ_INT) == 0 ){
/* Force an integer cast */
jx9MemObjToInteger(pKey);
}
if( SXRET_OK == HashmapLookupIntKey(&(*pMap), pKey->x.iVal, &pNode) ){
/* Overwrite the old value */
jx9_value *pElem;
pElem = (jx9_value *)SySetAt(&pMap->pVm->aMemObj, pNode->nValIdx);
if( pElem ){
if( pVal ){
jx9MemObjStore(pVal, pElem);
}else{
/* Nullify the entry */
jx9MemObjToNull(pElem);
}
}
return SXRET_OK;
}
/* Perform a 64-bit-int-key insertion */
rc = HashmapInsertIntKey(&(*pMap), pKey->x.iVal, &(*pVal));
if( rc == SXRET_OK ){
if( pKey->x.iVal >= pMap->iNextIdx ){
/* Increment the automatic index */
pMap->iNextIdx = pKey->x.iVal + 1;
/* Make sure the automatic index is not reserved */
while( SXRET_OK == HashmapLookupIntKey(&(*pMap), pMap->iNextIdx, 0) ){
pMap->iNextIdx++;
}
}
}
}else{
/* Assign an automatic index */
rc = HashmapInsertIntKey(&(*pMap),pMap->iNextIdx,&(*pVal));
if( rc == SXRET_OK ){
++pMap->iNextIdx;
}
}
/* Insertion result */
return rc;
}
/*
* Extract node value.
*/
static jx9_value * HashmapExtractNodeValue(jx9_hashmap_node *pNode)
{
/* Point to the desired object */
jx9_value *pObj;
pObj = (jx9_value *)SySetAt(&pNode->pMap->pVm->aMemObj, pNode->nValIdx);
return pObj;
}
/*
* Insert a node in the given hashmap.
* If a node with the given key already exists in the database
* then this function overwrite the old value.
*/
static sxi32 HashmapInsertNode(jx9_hashmap *pMap, jx9_hashmap_node *pNode, int bPreserve)
{
jx9_value *pObj;
sxi32 rc;
/* Extract the node value */
pObj = HashmapExtractNodeValue(&(*pNode));
if( pObj == 0 ){
return SXERR_EMPTY;
}
/* Preserve key */
if( pNode->iType == HASHMAP_INT_NODE){
/* Int64 key */
if( !bPreserve ){
/* Assign an automatic index */
rc = HashmapInsert(&(*pMap), 0, pObj);
}else{
rc = HashmapInsertIntKey(&(*pMap), pNode->xKey.iKey, pObj);
}
}else{
/* Blob key */
rc = HashmapInsertBlobKey(&(*pMap), SyBlobData(&pNode->xKey.sKey),
SyBlobLength(&pNode->xKey.sKey), pObj);
}
return rc;
}
/*
* Compare two node values.
* Return 0 if the node values are equals, > 0 if pLeft is greater than pRight
* or < 0 if pRight is greater than pLeft.
* For a full description on jx9_values comparison, refer to the implementation
* of the [jx9MemObjCmp()] function defined in memobj.c or the official
* documenation.
*/
static sxi32 HashmapNodeCmp(jx9_hashmap_node *pLeft, jx9_hashmap_node *pRight, int bStrict)
{
jx9_value sObj1, sObj2;
sxi32 rc;
if( pLeft == pRight ){
/*
* Same node.Refer to the sort() implementation defined
* below for more information on this sceanario.
*/
return 0;
}
/* Do the comparison */
jx9MemObjInit(pLeft->pMap->pVm, &sObj1);
jx9MemObjInit(pLeft->pMap->pVm, &sObj2);
jx9HashmapExtractNodeValue(pLeft, &sObj1, FALSE);
jx9HashmapExtractNodeValue(pRight, &sObj2, FALSE);
rc = jx9MemObjCmp(&sObj1, &sObj2, bStrict, 0);
jx9MemObjRelease(&sObj1);
jx9MemObjRelease(&sObj2);
return rc;
}
/*
* Rehash a node with a 64-bit integer key.
* Refer to [merge_sort(), array_shift()] implementations for more information.
*/
static void HashmapRehashIntNode(jx9_hashmap_node *pEntry)
{
jx9_hashmap *pMap = pEntry->pMap;
sxu32 nBucket;
/* Remove old collision links */
if( pEntry->pPrevCollide ){
pEntry->pPrevCollide->pNextCollide = pEntry->pNextCollide;
}else{
pMap->apBucket[pEntry->nHash & (pMap->nSize - 1)] = pEntry->pNextCollide;
}
if( pEntry->pNextCollide ){
pEntry->pNextCollide->pPrevCollide = pEntry->pPrevCollide;
}
pEntry->pNextCollide = pEntry->pPrevCollide = 0;
/* Compute the new hash */
pEntry->nHash = pMap->xIntHash(pMap->iNextIdx);
pEntry->xKey.iKey = pMap->iNextIdx;
nBucket = pEntry->nHash & (pMap->nSize - 1);
/* Link to the new bucket */
pEntry->pNextCollide = pMap->apBucket[nBucket];
if( pMap->apBucket[nBucket] ){
pMap->apBucket[nBucket]->pPrevCollide = pEntry;
}
pEntry->pNextCollide = pMap->apBucket[nBucket];
pMap->apBucket[nBucket] = pEntry;
/* Increment the automatic index */
pMap->iNextIdx++;
}
/*
* Perform a linear search on a given hashmap.
* Write a pointer to the target node on success.
* Otherwise SXERR_NOTFOUND is returned on failure.
* Refer to [array_intersect(), array_diff(), in_array(), ...] implementations
* for more information.
*/
static int HashmapFindValue(
jx9_hashmap *pMap, /* Target hashmap */
jx9_value *pNeedle, /* Lookup key */
jx9_hashmap_node **ppNode, /* OUT: target node on success */
int bStrict /* TRUE for strict comparison */
)
{
jx9_hashmap_node *pEntry;
jx9_value sVal, *pVal;
jx9_value sNeedle;
sxi32 rc;
sxu32 n;
/* Perform a linear search since we cannot sort the hashmap based on values */
pEntry = pMap->pFirst;
n = pMap->nEntry;
jx9MemObjInit(pMap->pVm, &sVal);
jx9MemObjInit(pMap->pVm, &sNeedle);
for(;;){
if( n < 1 ){
break;
}
/* Extract node value */
pVal = HashmapExtractNodeValue(pEntry);
if( pVal ){
if( (pVal->iFlags|pNeedle->iFlags) & MEMOBJ_NULL ){
sxi32 iF1 = pVal->iFlags;
sxi32 iF2 = pNeedle->iFlags;
if( iF1 == iF2 ){
/* NULL values are equals */
if( ppNode ){
*ppNode = pEntry;
}
return SXRET_OK;
}
}else{
/* Duplicate value */
jx9MemObjLoad(pVal, &sVal);
jx9MemObjLoad(pNeedle, &sNeedle);
rc = jx9MemObjCmp(&sNeedle, &sVal, bStrict, 0);
jx9MemObjRelease(&sVal);
jx9MemObjRelease(&sNeedle);
if( rc == 0 ){
if( ppNode ){
*ppNode = pEntry;
}
/* Match found*/
return SXRET_OK;
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n--;
}
/* No such entry */
return SXERR_NOTFOUND;
}
/*
* Compare two hashmaps.
* Return 0 if the hashmaps are equals.Any other value indicates inequality.
* Note on array comparison operators.
* According to the JX9 language reference manual.
* Array Operators Example Name Result
* $a + $b Union Union of $a and $b.
* $a == $b Equality TRUE if $a and $b have the same key/value pairs.
* $a === $b Identity TRUE if $a and $b have the same key/value pairs in the same
* order and of the same types.
* $a != $b Inequality TRUE if $a is not equal to $b.
* $a <> $b Inequality TRUE if $a is not equal to $b.
* $a !== $b Non-identity TRUE if $a is not identical to $b.
* The + operator returns the right-hand array appended to the left-hand array;
* For keys that exist in both arrays, the elements from the left-hand array will be used
* and the matching elements from the right-hand array will be ignored.
* <?jx9
* $a = array("a" => "apple", "b" => "banana");
* $b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");
* $c = $a + $b; // Union of $a and $b
* print "Union of \$a and \$b: \n";
* dump($c);
* $c = $b + $a; // Union of $b and $a
* print "Union of \$b and \$a: \n";
* dump($c);
* ?>
* When executed, this script will print the following:
* Union of $a and $b:
* array(3) {
* ["a"]=>
* string(5) "apple"
* ["b"]=>
* string(6) "banana"
* ["c"]=>
* string(6) "cherry"
* }
* Union of $b and $a:
* array(3) {
* ["a"]=>
* string(4) "pear"
* ["b"]=>
* string(10) "strawberry"
* ["c"]=>
* string(6) "cherry"
* }
* Elements of arrays are equal for the comparison if they have the same key and value.
*/
JX9_PRIVATE sxi32 jx9HashmapCmp(
jx9_hashmap *pLeft, /* Left hashmap */
jx9_hashmap *pRight, /* Right hashmap */
int bStrict /* TRUE for strict comparison */
)
{
jx9_hashmap_node *pLe, *pRe;
sxi32 rc;
sxu32 n;
if( pLeft == pRight ){
/* Same hashmap instance. This can easily happen since hashmaps are passed by reference.
* Unlike the engine.
*/
return 0;
}
if( pLeft->nEntry != pRight->nEntry ){
/* Must have the same number of entries */
return pLeft->nEntry > pRight->nEntry ? 1 : -1;
}
/* Point to the first inserted entry of the left hashmap */
pLe = pLeft->pFirst;
pRe = 0; /* cc warning */
/* Perform the comparison */
n = pLeft->nEntry;
for(;;){
if( n < 1 ){
break;
}
if( pLe->iType == HASHMAP_INT_NODE){
/* Int key */
rc = HashmapLookupIntKey(&(*pRight), pLe->xKey.iKey, &pRe);
}else{
SyBlob *pKey = &pLe->xKey.sKey;
/* Blob key */
rc = HashmapLookupBlobKey(&(*pRight), SyBlobData(pKey), SyBlobLength(pKey), &pRe);
}
if( rc != SXRET_OK ){
/* No such entry in the right side */
return 1;
}
rc = 0;
if( bStrict ){
/* Make sure, the keys are of the same type */
if( pLe->iType != pRe->iType ){
rc = 1;
}
}
if( !rc ){
/* Compare nodes */
rc = HashmapNodeCmp(pLe, pRe, bStrict);
}
if( rc != 0 ){
/* Nodes key/value differ */
return rc;
}
/* Point to the next entry */
pLe = pLe->pPrev; /* Reverse link */
n--;
}
return 0; /* Hashmaps are equals */
}
/*
* Merge two hashmaps.
* Note on the merge process
* According to the JX9 language reference manual.
* Merges the elements of two arrays together so that the values of one are appended
* to the end of the previous one. It returns the resulting array (pDest).
* If the input arrays have the same string keys, then the later value for that key
* will overwrite the previous one. If, however, the arrays contain numeric keys
* the later value will not overwrite the original value, but will be appended.
* Values in the input array with numeric keys will be renumbered with incrementing
* keys starting from zero in the result array.
*/
static sxi32 HashmapMerge(jx9_hashmap *pSrc, jx9_hashmap *pDest)
{
jx9_hashmap_node *pEntry;
jx9_value sKey, *pVal;
sxi32 rc;
sxu32 n;
if( pSrc == pDest ){
/* Same map. This can easily happen since hashmaps are passed by reference.
* Unlike the engine.
*/
return SXRET_OK;
}
/* Point to the first inserted entry in the source */
pEntry = pSrc->pFirst;
/* Perform the merge */
for( n = 0 ; n < pSrc->nEntry ; ++n ){
/* Extract the node value */
pVal = HashmapExtractNodeValue(pEntry);
if( pEntry->iType == HASHMAP_BLOB_NODE ){
/* Blob key insertion */
jx9MemObjInitFromString(pDest->pVm, &sKey, 0);
jx9MemObjStringAppend(&sKey, (const char *)SyBlobData(&pEntry->xKey.sKey), SyBlobLength(&pEntry->xKey.sKey));
rc = jx9HashmapInsert(&(*pDest), &sKey, pVal);
jx9MemObjRelease(&sKey);
}else{
rc = HashmapInsert(&(*pDest), 0/* Automatic index assign */, pVal);
}
if( rc != SXRET_OK ){
return rc;
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
return SXRET_OK;
}
/*
* Duplicate the contents of a hashmap. Store the copy in pDest.
* Refer to the [array_pad(), array_copy(), ...] implementation for more information.
*/
JX9_PRIVATE sxi32 jx9HashmapDup(jx9_hashmap *pSrc, jx9_hashmap *pDest)
{
jx9_hashmap_node *pEntry;
jx9_value sKey, *pVal;
sxi32 rc;
sxu32 n;
if( pSrc == pDest ){
/* Same map. This can easily happen since hashmaps are passed by reference.
* Unlike the engine.
*/
return SXRET_OK;
}
/* Point to the first inserted entry in the source */
pEntry = pSrc->pFirst;
/* Perform the duplication */
for( n = 0 ; n < pSrc->nEntry ; ++n ){
/* Extract the node value */
pVal = HashmapExtractNodeValue(pEntry);
if( pEntry->iType == HASHMAP_BLOB_NODE ){
/* Blob key insertion */
jx9MemObjInitFromString(pDest->pVm, &sKey, 0);
jx9MemObjStringAppend(&sKey, (const char *)SyBlobData(&pEntry->xKey.sKey), SyBlobLength(&pEntry->xKey.sKey));
rc = jx9HashmapInsert(&(*pDest), &sKey, pVal);
jx9MemObjRelease(&sKey);
}else{
/* Int key insertion */
rc = HashmapInsertIntKey(&(*pDest), pEntry->xKey.iKey, pVal);
}
if( rc != SXRET_OK ){
return rc;
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
return SXRET_OK;
}
/*
* Perform the union of two hashmaps.
* This operation is performed only if the user uses the '+' operator
* with a variable holding an array as follows:
* <?jx9
* $a = array("a" => "apple", "b" => "banana");
* $b = array("a" => "pear", "b" => "strawberry", "c" => "cherry");
* $c = $a + $b; // Union of $a and $b
* print "Union of \$a and \$b: \n";
* dump($c);
* $c = $b + $a; // Union of $b and $a
* print "Union of \$b and \$a: \n";
* dump($c);
* ?>
* When executed, this script will print the following:
* Union of $a and $b:
* array(3) {
* ["a"]=>
* string(5) "apple"
* ["b"]=>
* string(6) "banana"
* ["c"]=>
* string(6) "cherry"
* }
* Union of $b and $a:
* array(3) {
* ["a"]=>
* string(4) "pear"
* ["b"]=>
* string(10) "strawberry"
* ["c"]=>
* string(6) "cherry"
* }
* The + operator returns the right-hand array appended to the left-hand array;
* For keys that exist in both arrays, the elements from the left-hand array will be used
* and the matching elements from the right-hand array will be ignored.
*/
JX9_PRIVATE sxi32 jx9HashmapUnion(jx9_hashmap *pLeft, jx9_hashmap *pRight)
{
jx9_hashmap_node *pEntry;
sxi32 rc = SXRET_OK;
jx9_value *pObj;
sxu32 n;
if( pLeft == pRight ){
/* Same map. This can easily happen since hashmaps are passed by reference.
* Unlike the engine.
*/
return SXRET_OK;
}
/* Perform the union */
pEntry = pRight->pFirst;
for(n = 0 ; n < pRight->nEntry ; ++n ){
/* Make sure the given key does not exists in the left array */
if( pEntry->iType == HASHMAP_BLOB_NODE ){
/* BLOB key */
if( SXRET_OK !=
HashmapLookupBlobKey(&(*pLeft), SyBlobData(&pEntry->xKey.sKey), SyBlobLength(&pEntry->xKey.sKey), 0) ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj ){
/* Perform the insertion */
rc = HashmapInsertBlobKey(&(*pLeft), SyBlobData(&pEntry->xKey.sKey),
SyBlobLength(&pEntry->xKey.sKey),pObj);
if( rc != SXRET_OK ){
return rc;
}
}
}
}else{
/* INT key */
if( SXRET_OK != HashmapLookupIntKey(&(*pLeft), pEntry->xKey.iKey, 0) ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj ){
/* Perform the insertion */
rc = HashmapInsertIntKey(&(*pLeft), pEntry->xKey.iKey, pObj);
if( rc != SXRET_OK ){
return rc;
}
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
return SXRET_OK;
}
/*
* Allocate a new hashmap.
* Return a pointer to the freshly allocated hashmap on success.NULL otherwise.
*/
JX9_PRIVATE jx9_hashmap * jx9NewHashmap(
jx9_vm *pVm, /* VM that trigger the hashmap creation */
sxu32 (*xIntHash)(sxi64), /* Hash function for int keys.NULL otherwise*/
sxu32 (*xBlobHash)(const void *, sxu32) /* Hash function for BLOB keys.NULL otherwise */
)
{
jx9_hashmap *pMap;
/* Allocate a new instance */
pMap = (jx9_hashmap *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_hashmap));
if( pMap == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pMap, sizeof(jx9_hashmap));
/* Fill in the structure */
pMap->pVm = &(*pVm);
pMap->iRef = 1;
/* pMap->iFlags = 0; */
/* Default hash functions */
pMap->xIntHash = xIntHash ? xIntHash : IntHash;
pMap->xBlobHash = xBlobHash ? xBlobHash : BinHash;
return pMap;
}
/*
* Install superglobals in the given virtual machine.
* Note on superglobals.
* According to the JX9 language reference manual.
* Superglobals are built-in variables that are always available in all scopes.
* Description
* All predefined variables in JX9 are "superglobals", which means they
* are available in all scopes throughout a script.
* These variables are:
* $_SERVER
* $_GET
* $_POST
* $_FILES
* $_REQUEST
* $_ENV
*/
JX9_PRIVATE sxi32 jx9HashmapLoadBuiltin(jx9_vm *pVm)
{
static const char * azSuper[] = {
"_SERVER", /* $_SERVER */
"_GET", /* $_GET */
"_POST", /* $_POST */
"_FILES", /* $_FILES */
"_REQUEST", /* $_REQUEST */
"_COOKIE", /* $_COOKIE */
"_ENV", /* $_ENV */
"_HEADER", /* $_HEADER */
"argv" /* $argv */
};
SyString *pFile;
sxi32 rc;
sxu32 n;
/* Install globals variable now */
for( n = 0 ; n < SX_ARRAYSIZE(azSuper) ; n++ ){
jx9_value *pSuper;
/* Request an empty array */
pSuper = jx9_new_array(&(*pVm));
if( pSuper == 0 ){
return SXERR_MEM;
}
/* Install */
rc = jx9_vm_config(&(*pVm),JX9_VM_CONFIG_CREATE_VAR, azSuper[n]/* Super-global name*/, pSuper/* Super-global value */);
if( rc != SXRET_OK ){
return rc;
}
/* Release the value now it have been installed */
jx9_release_value(&(*pVm), pSuper);
}
/* Set some $_SERVER entries */
pFile = (SyString *)SySetPeek(&pVm->aFiles);
/*
* 'SCRIPT_FILENAME'
* The absolute pathname of the currently executing script.
*/
jx9_vm_config(pVm, JX9_VM_CONFIG_SERVER_ATTR,
"SCRIPT_FILENAME",
pFile ? pFile->zString : ":Memory:",
pFile ? pFile->nByte : sizeof(":Memory:") - 1
);
/* All done, all global variables are installed now */
return SXRET_OK;
}
/*
* Release a hashmap.
*/
JX9_PRIVATE sxi32 jx9HashmapRelease(jx9_hashmap *pMap, int FreeDS)
{
jx9_hashmap_node *pEntry, *pNext;
jx9_vm *pVm = pMap->pVm;
sxu32 n;
/* Start the release process */
n = 0;
pEntry = pMap->pFirst;
for(;;){
if( n >= pMap->nEntry ){
break;
}
pNext = pEntry->pPrev; /* Reverse link */
/* Restore the jx9_value to the free list */
jx9VmUnsetMemObj(pVm, pEntry->nValIdx);
/* Release the node */
if( pEntry->iType == HASHMAP_BLOB_NODE ){
SyBlobRelease(&pEntry->xKey.sKey);
}
SyMemBackendPoolFree(&pVm->sAllocator, pEntry);
/* Point to the next entry */
pEntry = pNext;
n++;
}
if( pMap->nEntry > 0 ){
/* Release the hash bucket */
SyMemBackendFree(&pVm->sAllocator, pMap->apBucket);
}
if( FreeDS ){
/* Free the whole instance */
SyMemBackendPoolFree(&pVm->sAllocator, pMap);
}else{
/* Keep the instance but reset it's fields */
pMap->apBucket = 0;
pMap->iNextIdx = 0;
pMap->nEntry = pMap->nSize = 0;
pMap->pFirst = pMap->pLast = pMap->pCur = 0;
}
return SXRET_OK;
}
/*
* Decrement the reference count of a given hashmap.
* If the count reaches zero which mean no more variables
* are pointing to this hashmap, then release the whole instance.
*/
JX9_PRIVATE void jx9HashmapUnref(jx9_hashmap *pMap)
{
pMap->iRef--;
if( pMap->iRef < 1 ){
jx9HashmapRelease(pMap, TRUE);
}
}
/*
* Check if a given key exists in the given hashmap.
* Write a pointer to the target node on success.
* Otherwise SXERR_NOTFOUND is returned on failure.
*/
JX9_PRIVATE sxi32 jx9HashmapLookup(
jx9_hashmap *pMap, /* Target hashmap */
jx9_value *pKey, /* Lookup key */
jx9_hashmap_node **ppNode /* OUT: Target node on success */
)
{
sxi32 rc;
if( pMap->nEntry < 1 ){
/* TICKET 1433-25: Don't bother hashing, the hashmap is empty anyway.
*/
return SXERR_NOTFOUND;
}
rc = HashmapLookup(&(*pMap), &(*pKey), ppNode);
return rc;
}
/*
* Insert a given key and it's associated value (if any) in the given
* hashmap.
* If a node with the given key already exists in the database
* then this function overwrite the old value.
*/
JX9_PRIVATE sxi32 jx9HashmapInsert(
jx9_hashmap *pMap, /* Target hashmap */
jx9_value *pKey, /* Lookup key */
jx9_value *pVal /* Node value.NULL otherwise */
)
{
sxi32 rc;
rc = HashmapInsert(&(*pMap), &(*pKey), &(*pVal));
return rc;
}
/*
* Reset the node cursor of a given hashmap.
*/
JX9_PRIVATE void jx9HashmapResetLoopCursor(jx9_hashmap *pMap)
{
/* Reset the loop cursor */
pMap->pCur = pMap->pFirst;
}
/*
* Return a pointer to the node currently pointed by the node cursor.
* If the cursor reaches the end of the list, then this function
* return NULL.
* Note that the node cursor is automatically advanced by this function.
*/
JX9_PRIVATE jx9_hashmap_node * jx9HashmapGetNextEntry(jx9_hashmap *pMap)
{
jx9_hashmap_node *pCur = pMap->pCur;
if( pCur == 0 ){
/* End of the list, return null */
return 0;
}
/* Advance the node cursor */
pMap->pCur = pCur->pPrev; /* Reverse link */
return pCur;
}
/*
* Extract a node value.
*/
JX9_PRIVATE jx9_value * jx9HashmapGetNodeValue(jx9_hashmap_node *pNode)
{
jx9_value *pValue;
pValue = HashmapExtractNodeValue(pNode);
return pValue;
}
/*
* Extract a node value (Second).
*/
JX9_PRIVATE void jx9HashmapExtractNodeValue(jx9_hashmap_node *pNode, jx9_value *pValue, int bStore)
{
jx9_value *pEntry = HashmapExtractNodeValue(pNode);
if( pEntry ){
if( bStore ){
jx9MemObjStore(pEntry, pValue);
}else{
jx9MemObjLoad(pEntry, pValue);
}
}else{
jx9MemObjRelease(pValue);
}
}
/*
* Extract a node key.
*/
JX9_PRIVATE void jx9HashmapExtractNodeKey(jx9_hashmap_node *pNode,jx9_value *pKey)
{
/* Fill with the current key */
if( pNode->iType == HASHMAP_INT_NODE ){
if( SyBlobLength(&pKey->sBlob) > 0 ){
SyBlobRelease(&pKey->sBlob);
}
pKey->x.iVal = pNode->xKey.iKey;
MemObjSetType(pKey, MEMOBJ_INT);
}else{
SyBlobReset(&pKey->sBlob);
SyBlobAppend(&pKey->sBlob, SyBlobData(&pNode->xKey.sKey), SyBlobLength(&pNode->xKey.sKey));
MemObjSetType(pKey, MEMOBJ_STRING);
}
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
/*
* Store the address of nodes value in the given container.
* Refer to the [vfprintf(), vprintf(), vsprintf()] implementations
* defined in 'builtin.c' for more information.
*/
JX9_PRIVATE int jx9HashmapValuesToSet(jx9_hashmap *pMap, SySet *pOut)
{
jx9_hashmap_node *pEntry = pMap->pFirst;
jx9_value *pValue;
sxu32 n;
/* Initialize the container */
SySetInit(pOut, &pMap->pVm->sAllocator, sizeof(jx9_value *));
for(n = 0 ; n < pMap->nEntry ; n++ ){
/* Extract node value */
pValue = HashmapExtractNodeValue(pEntry);
if( pValue ){
SySetPut(pOut, (const void *)&pValue);
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* Total inserted entries */
return (int)SySetUsed(pOut);
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/*
* Merge sort.
* The merge sort implementation is based on the one found in the SQLite3 source tree.
* Status: Public domain
*/
/* Node comparison callback signature */
typedef sxi32 (*ProcNodeCmp)(jx9_hashmap_node *, jx9_hashmap_node *, void *);
/*
** Inputs:
** a: A sorted, null-terminated linked list. (May be null).
** b: A sorted, null-terminated linked list. (May be null).
** cmp: A pointer to the comparison function.
**
** Return Value:
** A pointer to the head of a sorted list containing the elements
** of both a and b.
**
** Side effects:
** The "next", "prev" pointers for elements in the lists a and b are
** changed.
*/
static jx9_hashmap_node * HashmapNodeMerge(jx9_hashmap_node *pA, jx9_hashmap_node *pB, ProcNodeCmp xCmp, void *pCmpData)
{
jx9_hashmap_node result, *pTail;
/* Prevent compiler warning */
result.pNext = result.pPrev = 0;
pTail = &result;
while( pA && pB ){
if( xCmp(pA, pB, pCmpData) < 0 ){
pTail->pPrev = pA;
pA->pNext = pTail;
pTail = pA;
pA = pA->pPrev;
}else{
pTail->pPrev = pB;
pB->pNext = pTail;
pTail = pB;
pB = pB->pPrev;
}
}
if( pA ){
pTail->pPrev = pA;
pA->pNext = pTail;
}else if( pB ){
pTail->pPrev = pB;
pB->pNext = pTail;
}else{
pTail->pPrev = pTail->pNext = 0;
}
return result.pPrev;
}
/*
** Inputs:
** Map: Input hashmap
** cmp: A comparison function.
**
** Return Value:
** Sorted hashmap.
**
** Side effects:
** The "next" pointers for elements in list are changed.
*/
#define N_SORT_BUCKET 32
static sxi32 HashmapMergeSort(jx9_hashmap *pMap, ProcNodeCmp xCmp, void *pCmpData)
{
jx9_hashmap_node *a[N_SORT_BUCKET], *p, *pIn;
sxu32 i;
SyZero(a, sizeof(a));
/* Point to the first inserted entry */
pIn = pMap->pFirst;
while( pIn ){
p = pIn;
pIn = p->pPrev;
p->pPrev = 0;
for(i=0; i<N_SORT_BUCKET-1; i++){
if( a[i]==0 ){
a[i] = p;
break;
}else{
p = HashmapNodeMerge(a[i], p, xCmp, pCmpData);
a[i] = 0;
}
}
if( i==N_SORT_BUCKET-1 ){
/* To get here, there need to be 2^(N_SORT_BUCKET) elements in he input list.
* But that is impossible.
*/
a[i] = HashmapNodeMerge(a[i], p, xCmp, pCmpData);
}
}
p = a[0];
for(i=1; i<N_SORT_BUCKET; i++){
p = HashmapNodeMerge(p, a[i], xCmp, pCmpData);
}
p->pNext = 0;
/* Reflect the change */
pMap->pFirst = p;
/* Reset the loop cursor */
pMap->pCur = pMap->pFirst;
return SXRET_OK;
}
/*
* Node comparison callback.
* used-by: [sort(), asort(), ...]
*/
static sxi32 HashmapCmpCallback1(jx9_hashmap_node *pA, jx9_hashmap_node *pB, void *pCmpData)
{
jx9_value sA, sB;
sxi32 iFlags;
int rc;
if( pCmpData == 0 ){
/* Perform a standard comparison */
rc = HashmapNodeCmp(pA, pB, FALSE);
return rc;
}
iFlags = SX_PTR_TO_INT(pCmpData);
/* Duplicate node values */
jx9MemObjInit(pA->pMap->pVm, &sA);
jx9MemObjInit(pA->pMap->pVm, &sB);
jx9HashmapExtractNodeValue(pA, &sA, FALSE);
jx9HashmapExtractNodeValue(pB, &sB, FALSE);
if( iFlags == 5 ){
/* String cast */
if( (sA.iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(&sA);
}
if( (sB.iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(&sB);
}
}else{
/* Numeric cast */
jx9MemObjToNumeric(&sA);
jx9MemObjToNumeric(&sB);
}
/* Perform the comparison */
rc = jx9MemObjCmp(&sA, &sB, FALSE, 0);
jx9MemObjRelease(&sA);
jx9MemObjRelease(&sB);
return rc;
}
/*
* Node comparison callback.
* Used by: [rsort(), arsort()];
*/
static sxi32 HashmapCmpCallback3(jx9_hashmap_node *pA, jx9_hashmap_node *pB, void *pCmpData)
{
jx9_value sA, sB;
sxi32 iFlags;
int rc;
if( pCmpData == 0 ){
/* Perform a standard comparison */
rc = HashmapNodeCmp(pA, pB, FALSE);
return -rc;
}
iFlags = SX_PTR_TO_INT(pCmpData);
/* Duplicate node values */
jx9MemObjInit(pA->pMap->pVm, &sA);
jx9MemObjInit(pA->pMap->pVm, &sB);
jx9HashmapExtractNodeValue(pA, &sA, FALSE);
jx9HashmapExtractNodeValue(pB, &sB, FALSE);
if( iFlags == 5 ){
/* String cast */
if( (sA.iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(&sA);
}
if( (sB.iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(&sB);
}
}else{
/* Numeric cast */
jx9MemObjToNumeric(&sA);
jx9MemObjToNumeric(&sB);
}
/* Perform the comparison */
rc = jx9MemObjCmp(&sA, &sB, FALSE, 0);
jx9MemObjRelease(&sA);
jx9MemObjRelease(&sB);
return -rc;
}
/*
* Node comparison callback: Invoke an user-defined callback for the purpose of node comparison.
* used-by: [usort(), uasort()]
*/
static sxi32 HashmapCmpCallback4(jx9_hashmap_node *pA, jx9_hashmap_node *pB, void *pCmpData)
{
jx9_value sResult, *pCallback;
jx9_value *pV1, *pV2;
jx9_value *apArg[2]; /* Callback arguments */
sxi32 rc;
/* Point to the desired callback */
pCallback = (jx9_value *)pCmpData;
/* initialize the result value */
jx9MemObjInit(pA->pMap->pVm, &sResult);
/* Extract nodes values */
pV1 = HashmapExtractNodeValue(pA);
pV2 = HashmapExtractNodeValue(pB);
apArg[0] = pV1;
apArg[1] = pV2;
/* Invoke the callback */
rc = jx9VmCallUserFunction(pA->pMap->pVm, pCallback, 2, apArg, &sResult);
if( rc != SXRET_OK ){
/* An error occured while calling user defined function [i.e: not defined] */
rc = -1; /* Set a dummy result */
}else{
/* Extract callback result */
if((sResult.iFlags & MEMOBJ_INT) == 0 ){
/* Perform an int cast */
jx9MemObjToInteger(&sResult);
}
rc = (sxi32)sResult.x.iVal;
}
jx9MemObjRelease(&sResult);
/* Callback result */
return rc;
}
/*
* Rehash all nodes keys after a merge-sort have been applied.
* Used by [sort(), usort() and rsort()].
*/
static void HashmapSortRehash(jx9_hashmap *pMap)
{
jx9_hashmap_node *p, *pLast;
sxu32 i;
/* Rehash all entries */
pLast = p = pMap->pFirst;
pMap->iNextIdx = 0; /* Reset the automatic index */
i = 0;
for( ;; ){
if( i >= pMap->nEntry ){
pMap->pLast = pLast; /* Fix the last link broken by the merge-sort */
break;
}
if( p->iType == HASHMAP_BLOB_NODE ){
/* Do not maintain index association as requested by the JX9 specification */
SyBlobRelease(&p->xKey.sKey);
/* Change key type */
p->iType = HASHMAP_INT_NODE;
}
HashmapRehashIntNode(p);
/* Point to the next entry */
i++;
pLast = p;
p = p->pPrev; /* Reverse link */
}
}
/*
* Array functions implementation.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* bool sort(array &$array[, int $sort_flags = SORT_REGULAR ] )
* Sort an array.
* Parameters
* $array
* The input array.
* $sort_flags
* The optional second parameter sort_flags may be used to modify the sorting behavior using these values:
* Sorting type flags:
* SORT_REGULAR - compare items normally (don't change types)
* SORT_NUMERIC - compare items numerically
* SORT_STRING - compare items as strings
* Return
* TRUE on success or FALSE on failure.
*
*/
static int jx9_hashmap_sort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
/* Make sure we are dealing with a valid hashmap */
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry > 1 ){
sxi32 iCmpFlags = 0;
if( nArg > 1 ){
/* Extract comparison flags */
iCmpFlags = jx9_value_to_int(apArg[1]);
if( iCmpFlags == 3 /* SORT_REGULAR */ ){
iCmpFlags = 0; /* Standard comparison */
}
}
/* Do the merge sort */
HashmapMergeSort(pMap, HashmapCmpCallback1, SX_INT_TO_PTR(iCmpFlags));
/* Rehash [Do not maintain index association as requested by the JX9 specification] */
HashmapSortRehash(pMap);
}
/* All done, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* bool rsort(array &$array[, int $sort_flags = SORT_REGULAR ] )
* Sort an array in reverse order.
* Parameters
* $array
* The input array.
* $sort_flags
* The optional second parameter sort_flags may be used to modify the sorting behavior using these values:
* Sorting type flags:
* SORT_REGULAR - compare items normally (don't change types)
* SORT_NUMERIC - compare items numerically
* SORT_STRING - compare items as strings
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9_hashmap_rsort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
/* Make sure we are dealing with a valid hashmap */
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry > 1 ){
sxi32 iCmpFlags = 0;
if( nArg > 1 ){
/* Extract comparison flags */
iCmpFlags = jx9_value_to_int(apArg[1]);
if( iCmpFlags == 3 /* SORT_REGULAR */ ){
iCmpFlags = 0; /* Standard comparison */
}
}
/* Do the merge sort */
HashmapMergeSort(pMap, HashmapCmpCallback3, SX_INT_TO_PTR(iCmpFlags));
/* Rehash [Do not maintain index association as requested by the JX9 specification] */
HashmapSortRehash(pMap);
}
/* All done, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* bool usort(array &$array, callable $cmp_function)
* Sort an array by values using a user-defined comparison function.
* Parameters
* $array
* The input array.
* $cmp_function
* The comparison function must return an integer less than, equal to, or greater
* than zero if the first argument is considered to be respectively less than, equal
* to, or greater than the second.
* int callback ( mixed $a, mixed $b )
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9_hashmap_usort(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
/* Make sure we are dealing with a valid hashmap */
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry > 1 ){
jx9_value *pCallback = 0;
ProcNodeCmp xCmp;
xCmp = HashmapCmpCallback4; /* User-defined function as the comparison callback */
if( nArg > 1 && jx9_value_is_callable(apArg[1]) ){
/* Point to the desired callback */
pCallback = apArg[1];
}else{
/* Use the default comparison function */
xCmp = HashmapCmpCallback1;
}
/* Do the merge sort */
HashmapMergeSort(pMap, xCmp, pCallback);
/* Rehash [Do not maintain index association as requested by the JX9 specification] */
HashmapSortRehash(pMap);
}
/* All done, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* int count(array $var [, int $mode = COUNT_NORMAL ])
* Count all elements in an array, or something in an object.
* Parameters
* $var
* The array or the object.
* $mode
* If the optional mode parameter is set to COUNT_RECURSIVE (or 1), count()
* will recursively count the array. This is particularly useful for counting
* all the elements of a multidimensional array. count() does not detect infinite
* recursion.
* Return
* Returns the number of elements in the array.
*/
static int jx9_hashmap_count(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int bRecursive = FALSE;
sxi64 iCount;
if( nArg < 1 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( !jx9_value_is_json_array(apArg[0]) ){
/* TICKET 1433-19: Handle objects */
int res = !jx9_value_is_null(apArg[0]);
jx9_result_int(pCtx, res);
return JX9_OK;
}
if( nArg > 1 ){
/* Recursive count? */
bRecursive = jx9_value_to_int(apArg[1]) == 1 /* COUNT_RECURSIVE */;
}
/* Count */
iCount = HashmapCount((jx9_hashmap *)apArg[0]->x.pOther, bRecursive, 0);
jx9_result_int64(pCtx, iCount);
return JX9_OK;
}
/*
* bool array_key_exists(value $key, array $search)
* Checks if the given key or index exists in the array.
* Parameters
* $key
* Value to check.
* $search
* An array with keys to check.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9_hashmap_key_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
sxi32 rc;
if( nArg < 2 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[1]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the lookup */
rc = jx9HashmapLookup((jx9_hashmap *)apArg[1]->x.pOther, apArg[0], 0);
/* lookup result */
jx9_result_bool(pCtx, rc == SXRET_OK ? 1 : 0);
return JX9_OK;
}
/*
* value array_pop(array $array)
* POP the last inserted element from the array.
* Parameter
* The array to get the value from.
* Return
* Poped value or NULL on failure.
*/
static int jx9_hashmap_pop(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry < 1 ){
/* Noting to pop, return NULL */
jx9_result_null(pCtx);
}else{
jx9_hashmap_node *pLast = pMap->pLast;
jx9_value *pObj;
pObj = HashmapExtractNodeValue(pLast);
if( pObj ){
/* Node value */
jx9_result_value(pCtx, pObj);
/* Unlink the node */
jx9HashmapUnlinkNode(pLast);
}else{
jx9_result_null(pCtx);
}
/* Reset the cursor */
pMap->pCur = pMap->pFirst;
}
return JX9_OK;
}
/*
* int array_push($array, $var, ...)
* Push one or more elements onto the end of array. (Stack insertion)
* Parameters
* array
* The input array.
* var
* On or more value to push.
* Return
* New array count (including old items).
*/
static int jx9_hashmap_push(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
sxi32 rc;
int i;
if( nArg < 1 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
/* Start pushing given values */
for( i = 1 ; i < nArg ; ++i ){
rc = jx9HashmapInsert(pMap, 0, apArg[i]);
if( rc != SXRET_OK ){
break;
}
}
/* Return the new count */
jx9_result_int64(pCtx, (sxi64)pMap->nEntry);
return JX9_OK;
}
/*
* value array_shift(array $array)
* Shift an element off the beginning of array.
* Parameter
* The array to get the value from.
* Return
* Shifted value or NULL on failure.
*/
static int jx9_hashmap_shift(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry < 1 ){
/* Empty hashmap, return NULL */
jx9_result_null(pCtx);
}else{
jx9_hashmap_node *pEntry = pMap->pFirst;
jx9_value *pObj;
sxu32 n;
pObj = HashmapExtractNodeValue(pEntry);
if( pObj ){
/* Node value */
jx9_result_value(pCtx, pObj);
/* Unlink the first node */
jx9HashmapUnlinkNode(pEntry);
}else{
jx9_result_null(pCtx);
}
/* Rehash all int keys */
n = pMap->nEntry;
pEntry = pMap->pFirst;
pMap->iNextIdx = 0; /* Reset the automatic index */
for(;;){
if( n < 1 ){
break;
}
if( pEntry->iType == HASHMAP_INT_NODE ){
HashmapRehashIntNode(pEntry);
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n--;
}
/* Reset the cursor */
pMap->pCur = pMap->pFirst;
}
return JX9_OK;
}
/*
* Extract the node cursor value.
*/
static sxi32 HashmapCurrentValue(jx9_context *pCtx, jx9_hashmap *pMap, int iDirection)
{
jx9_hashmap_node *pCur = pMap->pCur;
jx9_value *pVal;
if( pCur == 0 ){
/* Cursor does not point to anything, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( iDirection != 0 ){
if( iDirection > 0 ){
/* Point to the next entry */
pMap->pCur = pCur->pPrev; /* Reverse link */
pCur = pMap->pCur;
}else{
/* Point to the previous entry */
pMap->pCur = pCur->pNext; /* Reverse link */
pCur = pMap->pCur;
}
if( pCur == 0 ){
/* End of input reached, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
}
/* Point to the desired element */
pVal = HashmapExtractNodeValue(pCur);
if( pVal ){
jx9_result_value(pCtx, pVal);
}else{
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* value current(array $array)
* Return the current element in an array.
* Parameter
* $input: The input array.
* Return
* The current() function simply returns the value of the array element that's currently
* being pointed to by the internal pointer. It does not move the pointer in any way.
* If the internal pointer points beyond the end of the elements list or the array
* is empty, current() returns FALSE.
*/
static int jx9_hashmap_current(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, 0);
return JX9_OK;
}
/*
* value next(array $input)
* Advance the internal array pointer of an array.
* Parameter
* $input: The input array.
* Return
* next() behaves like current(), with one difference. It advances the internal array
* pointer one place forward before returning the element value. That means it returns
* the next array value and advances the internal array pointer by one.
*/
static int jx9_hashmap_next(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, 1);
return JX9_OK;
}
/*
* value prev(array $input)
* Rewind the internal array pointer.
* Parameter
* $input: The input array.
* Return
* Returns the array value in the previous place that's pointed
* to by the internal array pointer, or FALSE if there are no more
* elements.
*/
static int jx9_hashmap_prev(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
HashmapCurrentValue(&(*pCtx), (jx9_hashmap *)apArg[0]->x.pOther, -1);
return JX9_OK;
}
/*
* value end(array $input)
* Set the internal pointer of an array to its last element.
* Parameter
* $input: The input array.
* Return
* Returns the value of the last element or FALSE for empty array.
*/
static int jx9_hashmap_end(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
/* Point to the last node */
pMap->pCur = pMap->pLast;
/* Return the last node value */
HashmapCurrentValue(&(*pCtx), pMap, 0);
return JX9_OK;
}
/*
* value reset(array $array )
* Set the internal pointer of an array to its first element.
* Parameter
* $input: The input array.
* Return
* Returns the value of the first array element, or FALSE if the array is empty.
*/
static int jx9_hashmap_reset(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
/* Point to the first node */
pMap->pCur = pMap->pFirst;
/* Return the last node value if available */
HashmapCurrentValue(&(*pCtx), pMap, 0);
return JX9_OK;
}
/*
* value key(array $array)
* Fetch a key from an array
* Parameter
* $input
* The input array.
* Return
* The key() function simply returns the key of the array element that's currently
* being pointed to by the internal pointer. It does not move the pointer in any way.
* If the internal pointer points beyond the end of the elements list or the array
* is empty, key() returns NULL.
*/
static int jx9_hashmap_simple_key(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap_node *pCur;
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
pCur = pMap->pCur;
if( pCur == 0 ){
/* Cursor does not point to anything, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
if( pCur->iType == HASHMAP_INT_NODE){
/* Key is integer */
jx9_result_int64(pCtx, pCur->xKey.iKey);
}else{
/* Key is blob */
jx9_result_string(pCtx,
(const char *)SyBlobData(&pCur->xKey.sKey), (int)SyBlobLength(&pCur->xKey.sKey));
}
return JX9_OK;
}
/*
* array each(array $input)
* Return the current key and value pair from an array and advance the array cursor.
* Parameter
* $input
* The input array.
* Return
* Returns the current key and value pair from the array array. This pair is returned
* in a four-element array, with the keys 0, 1, key, and value. Elements 0 and key
* contain the key name of the array element, and 1 and value contain the data.
* If the internal pointer for the array points past the end of the array contents
* each() returns FALSE.
*/
static int jx9_hashmap_each(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap_node *pCur;
jx9_hashmap *pMap;
jx9_value *pArray;
jx9_value *pVal;
jx9_value sKey;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the internal representation that describe the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->pCur == 0 ){
/* Cursor does not point to anything, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pCur = pMap->pCur;
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pVal = HashmapExtractNodeValue(pCur);
/* Insert the current value */
jx9_array_add_strkey_elem(pArray, "1", pVal);
jx9_array_add_strkey_elem(pArray, "value", pVal);
/* Make the key */
if( pCur->iType == HASHMAP_INT_NODE ){
jx9MemObjInitFromInt(pMap->pVm, &sKey, pCur->xKey.iKey);
}else{
jx9MemObjInitFromString(pMap->pVm, &sKey, 0);
jx9MemObjStringAppend(&sKey, (const char *)SyBlobData(&pCur->xKey.sKey), SyBlobLength(&pCur->xKey.sKey));
}
/* Insert the current key */
jx9_array_add_elem(pArray, 0, &sKey);
jx9_array_add_strkey_elem(pArray, "key", &sKey);
jx9MemObjRelease(&sKey);
/* Advance the cursor */
pMap->pCur = pCur->pPrev; /* Reverse link */
/* Return the current entry */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* array array_values(array $input)
* Returns all the values from the input array and indexes numerically the array.
* Parameters
* input: The input array.
* Return
* An indexed array of values or NULL on failure.
*/
static int jx9_hashmap_values(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap_node *pNode;
jx9_hashmap *pMap;
jx9_value *pArray;
jx9_value *pObj;
sxu32 n;
if( nArg < 1 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation that describe the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Perform the requested operation */
pNode = pMap->pFirst;
for( n = 0 ; n < pMap->nEntry ; ++n ){
pObj = HashmapExtractNodeValue(pNode);
if( pObj ){
/* perform the insertion */
jx9_array_add_elem(pArray, 0/* Automatic index assign */, pObj);
}
/* Point to the next entry */
pNode = pNode->pPrev; /* Reverse link */
}
/* return the new array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* bool array_same(array $arr1, array $arr2)
* Return TRUE if the given arrays are the same instance.
* This function is useful under JX9 since arrays and objects
* are passed by reference.
* Parameters
* $arr1
* First array
* $arr2
* Second array
* Return
* TRUE if the arrays are the same instance. FALSE otherwise.
* Note
* This function is a symisc eXtension.
*/
static int jx9_hashmap_same(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *p1, *p2;
int rc;
if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
/* Missing or invalid arguments, return FALSE*/
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the hashmaps */
p1 = (jx9_hashmap *)apArg[0]->x.pOther;
p2 = (jx9_hashmap *)apArg[1]->x.pOther;
rc = (p1 == p2);
/* Same instance? */
jx9_result_bool(pCtx, rc);
return JX9_OK;
}
/*
* array array_merge(array $array1, ...)
* Merge one or more arrays.
* Parameters
* $array1
* Initial array to merge.
* ...
* More array to merge.
* Return
* The resulting array.
*/
static int jx9_hashmap_merge(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap, *pSrc;
jx9_value *pArray;
int i;
if( nArg < 1 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)pArray->x.pOther;
/* Start merging */
for( i = 0 ; i < nArg ; i++ ){
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[i]) ){
/* Insert scalar value */
jx9_array_add_elem(pArray, 0, apArg[i]);
}else{
pSrc = (jx9_hashmap *)apArg[i]->x.pOther;
/* Merge the two hashmaps */
HashmapMerge(pSrc, pMap);
}
}
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* bool in_array(value $needle, array $haystack[, bool $strict = FALSE ])
* Checks if a value exists in an array.
* Parameters
* $needle
* The searched value.
* Note:
* If needle is a string, the comparison is done in a case-sensitive manner.
* $haystack
* The target array.
* $strict
* If the third parameter strict is set to TRUE then the in_array() function
* will also check the types of the needle in the haystack.
*/
static int jx9_hashmap_in_array(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pNeedle;
int bStrict;
int rc;
if( nArg < 2 ){
/* Missing argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pNeedle = apArg[0];
bStrict = 0;
if( nArg > 2 ){
bStrict = jx9_value_to_bool(apArg[2]);
}
if( !jx9_value_is_json_array(apArg[1]) ){
/* haystack must be an array, perform a standard comparison */
rc = jx9_value_compare(pNeedle, apArg[1], bStrict);
/* Set the comparison result */
jx9_result_bool(pCtx, rc == 0);
return JX9_OK;
}
/* Perform the lookup */
rc = HashmapFindValue((jx9_hashmap *)apArg[1]->x.pOther, pNeedle, 0, bStrict);
/* Lookup result */
jx9_result_bool(pCtx, rc == SXRET_OK);
return JX9_OK;
}
/*
* array array_copy(array $source)
* Make a blind copy of the target array.
* Parameters
* $source
* Target array
* Return
* Copy of the target array on success. NULL otherwise.
* Note
* This function is a symisc eXtension.
*/
static int jx9_hashmap_copy(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
jx9_value *pArray;
if( nArg < 1 ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)pArray->x.pOther;
if( jx9_value_is_json_array(apArg[0])){
/* Point to the internal representation of the source */
jx9_hashmap *pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
/* Perform the copy */
jx9HashmapDup(pSrc, pMap);
}else{
/* Simple insertion */
jx9HashmapInsert(pMap, 0/* Automatic index assign*/, apArg[0]);
}
/* Return the duplicated array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* bool array_erase(array $source)
* Remove all elements from a given array.
* Parameters
* $source
* Target array
* Return
* TRUE on success. FALSE otherwise.
* Note
* This function is a symisc eXtension.
*/
static int jx9_hashmap_erase(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
if( nArg < 1 ){
/* Missing arguments */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
/* Erase */
jx9HashmapRelease(pMap, FALSE);
return JX9_OK;
}
/*
* array array_diff(array $array1, array $array2, ...)
* Computes the difference of arrays.
* Parameters
* $array1
* The array to compare from
* $array2
* An array to compare against
* $...
* More arrays to compare against
* Return
* Returns an array containing all the entries from array1 that
* are not present in any of the other arrays.
*/
static int jx9_hashmap_diff(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap_node *pEntry;
jx9_hashmap *pSrc, *pMap;
jx9_value *pArray;
jx9_value *pVal;
sxi32 rc;
sxu32 n;
int i;
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
if( nArg == 1 ){
/* Return the first array since we cannot perform a diff */
jx9_result_value(pCtx, apArg[0]);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the source hashmap */
pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
/* Perform the diff */
pEntry = pSrc->pFirst;
n = pSrc->nEntry;
for(;;){
if( n < 1 ){
break;
}
/* Extract the node value */
pVal = HashmapExtractNodeValue(pEntry);
if( pVal ){
for( i = 1 ; i < nArg ; i++ ){
if( !jx9_value_is_json_array(apArg[i])) {
/* ignore */
continue;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)apArg[i]->x.pOther;
/* Perform the lookup */
rc = HashmapFindValue(pMap, pVal, 0, TRUE);
if( rc == SXRET_OK ){
/* Value exist */
break;
}
}
if( i >= nArg ){
/* Perform the insertion */
HashmapInsertNode((jx9_hashmap *)pArray->x.pOther, pEntry, TRUE);
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n--;
}
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* array array_intersect(array $array1 , array $array2, ...)
* Computes the intersection of arrays.
* Parameters
* $array1
* The array to compare from
* $array2
* An array to compare against
* $...
* More arrays to compare against
* Return
* Returns an array containing all of the values in array1 whose values exist
* in all of the parameters. .
* Note that NULL is returned on failure.
*/
static int jx9_hashmap_intersect(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap_node *pEntry;
jx9_hashmap *pSrc, *pMap;
jx9_value *pArray;
jx9_value *pVal;
sxi32 rc;
sxu32 n;
int i;
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
if( nArg == 1 ){
/* Return the first array since we cannot perform a diff */
jx9_result_value(pCtx, apArg[0]);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the source hashmap */
pSrc = (jx9_hashmap *)apArg[0]->x.pOther;
/* Perform the intersection */
pEntry = pSrc->pFirst;
n = pSrc->nEntry;
for(;;){
if( n < 1 ){
break;
}
/* Extract the node value */
pVal = HashmapExtractNodeValue(pEntry);
if( pVal ){
for( i = 1 ; i < nArg ; i++ ){
if( !jx9_value_is_json_array(apArg[i])) {
/* ignore */
continue;
}
/* Point to the internal representation of the hashmap */
pMap = (jx9_hashmap *)apArg[i]->x.pOther;
/* Perform the lookup */
rc = HashmapFindValue(pMap, pVal, 0, TRUE);
if( rc != SXRET_OK ){
/* Value does not exist */
break;
}
}
if( i >= nArg ){
/* Perform the insertion */
HashmapInsertNode((jx9_hashmap *)pArray->x.pOther, pEntry, TRUE);
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n--;
}
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* number array_sum(array $array )
* Calculate the sum of values in an array.
* Parameters
* $array: The input array.
* Return
* Returns the sum of values as an integer or float.
*/
static void DoubleSum(jx9_context *pCtx, jx9_hashmap *pMap)
{
jx9_hashmap_node *pEntry;
jx9_value *pObj;
double dSum = 0;
sxu32 n;
pEntry = pMap->pFirst;
for( n = 0 ; n < pMap->nEntry ; n++ ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj && (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES)) == 0){
if( pObj->iFlags & MEMOBJ_REAL ){
dSum += pObj->x.rVal;
}else if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
dSum += (double)pObj->x.iVal;
}else if( pObj->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pObj->sBlob) > 0 ){
double dv = 0;
SyStrToReal((const char *)SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob), (void *)&dv, 0);
dSum += dv;
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* Return sum */
jx9_result_double(pCtx, dSum);
}
static void Int64Sum(jx9_context *pCtx, jx9_hashmap *pMap)
{
jx9_hashmap_node *pEntry;
jx9_value *pObj;
sxi64 nSum = 0;
sxu32 n;
pEntry = pMap->pFirst;
for( n = 0 ; n < pMap->nEntry ; n++ ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj && (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES)) == 0){
if( pObj->iFlags & MEMOBJ_REAL ){
nSum += (sxi64)pObj->x.rVal;
}else if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
nSum += pObj->x.iVal;
}else if( pObj->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pObj->sBlob) > 0 ){
sxi64 nv = 0;
SyStrToInt64((const char *)SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob), (void *)&nv, 0);
nSum += nv;
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* Return sum */
jx9_result_int64(pCtx, nSum);
}
/* number array_sum(array $array )
* (See block-coment above)
*/
static int jx9_hashmap_sum(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
jx9_value *pObj;
if( nArg < 1 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry < 1 ){
/* Nothing to compute, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* If the first element is of type float, then perform floating
* point computaion.Otherwise switch to int64 computaion.
*/
pObj = HashmapExtractNodeValue(pMap->pFirst);
if( pObj == 0 ){
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( pObj->iFlags & MEMOBJ_REAL ){
DoubleSum(pCtx, pMap);
}else{
Int64Sum(pCtx, pMap);
}
return JX9_OK;
}
/*
* number array_product(array $array )
* Calculate the product of values in an array.
* Parameters
* $array: The input array.
* Return
* Returns the product of values as an integer or float.
*/
static void DoubleProd(jx9_context *pCtx, jx9_hashmap *pMap)
{
jx9_hashmap_node *pEntry;
jx9_value *pObj;
double dProd;
sxu32 n;
pEntry = pMap->pFirst;
dProd = 1;
for( n = 0 ; n < pMap->nEntry ; n++ ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj && (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES)) == 0){
if( pObj->iFlags & MEMOBJ_REAL ){
dProd *= pObj->x.rVal;
}else if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
dProd *= (double)pObj->x.iVal;
}else if( pObj->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pObj->sBlob) > 0 ){
double dv = 0;
SyStrToReal((const char *)SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob), (void *)&dv, 0);
dProd *= dv;
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* Return product */
jx9_result_double(pCtx, dProd);
}
static void Int64Prod(jx9_context *pCtx, jx9_hashmap *pMap)
{
jx9_hashmap_node *pEntry;
jx9_value *pObj;
sxi64 nProd;
sxu32 n;
pEntry = pMap->pFirst;
nProd = 1;
for( n = 0 ; n < pMap->nEntry ; n++ ){
pObj = HashmapExtractNodeValue(pEntry);
if( pObj && (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES)) == 0){
if( pObj->iFlags & MEMOBJ_REAL ){
nProd *= (sxi64)pObj->x.rVal;
}else if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
nProd *= pObj->x.iVal;
}else if( pObj->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pObj->sBlob) > 0 ){
sxi64 nv = 0;
SyStrToInt64((const char *)SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob), (void *)&nv, 0);
nProd *= nv;
}
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* Return product */
jx9_result_int64(pCtx, nProd);
}
/* number array_product(array $array )
* (See block-block comment above)
*/
static int jx9_hashmap_product(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_hashmap *pMap;
jx9_value *pObj;
if( nArg < 1 ){
/* Missing arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid hashmap */
if( !jx9_value_is_json_array(apArg[0]) ){
/* Invalid argument, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry < 1 ){
/* Nothing to compute, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* If the first element is of type float, then perform floating
* point computaion.Otherwise switch to int64 computaion.
*/
pObj = HashmapExtractNodeValue(pMap->pFirst);
if( pObj == 0 ){
jx9_result_int(pCtx, 0);
return JX9_OK;
}
if( pObj->iFlags & MEMOBJ_REAL ){
DoubleProd(pCtx, pMap);
}else{
Int64Prod(pCtx, pMap);
}
return JX9_OK;
}
/*
* array array_map(callback $callback, array $arr1)
* Applies the callback to the elements of the given arrays.
* Parameters
* $callback
* Callback function to run for each element in each array.
* $arr1
* An array to run through the callback function.
* Return
* Returns an array containing all the elements of arr1 after applying
* the callback function to each one.
* NOTE:
* array_map() passes only a single value to the callback.
*/
static int jx9_hashmap_map(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray, *pValue, sKey, sResult;
jx9_hashmap_node *pEntry;
jx9_hashmap *pMap;
sxu32 n;
if( nArg < 2 || !jx9_value_is_json_array(apArg[1]) ){
/* Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_result_null(pCtx);
return JX9_OK;
}
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[1]->x.pOther;
jx9MemObjInit(pMap->pVm, &sResult);
jx9MemObjInit(pMap->pVm, &sKey);
/* Perform the requested operation */
pEntry = pMap->pFirst;
for( n = 0 ; n < pMap->nEntry ; n++ ){
/* Extrcat the node value */
pValue = HashmapExtractNodeValue(pEntry);
if( pValue ){
sxi32 rc;
/* Invoke the supplied callback */
rc = jx9VmCallUserFunction(pMap->pVm, apArg[0], 1, &pValue, &sResult);
/* Extract the node key */
jx9HashmapExtractNodeKey(pEntry, &sKey);
if( rc != SXRET_OK ){
/* An error occured while invoking the supplied callback [i.e: not defined] */
jx9_array_add_elem(pArray, &sKey, pValue); /* Keep the same value */
}else{
/* Insert the callback return value */
jx9_array_add_elem(pArray, &sKey, &sResult);
}
jx9MemObjRelease(&sKey);
jx9MemObjRelease(&sResult);
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* bool array_walk(array &$array, callback $funcname [, value $userdata ] )
* Apply a user function to every member of an array.
* Parameters
* $array
* The input array.
* $funcname
* Typically, funcname takes on two parameters.The array parameter's value being
* the first, and the key/index second.
* Note:
* If funcname needs to be working with the actual values of the array, specify the first
* parameter of funcname as a reference. Then, any changes made to those elements will
* be made in the original array itself.
* $userdata
* If the optional userdata parameter is supplied, it will be passed as the third parameter
* to the callback funcname.
* Return
* Returns TRUE on success or FALSE on failure.
*/
static int jx9_hashmap_walk(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pValue, *pUserData, sKey;
jx9_hashmap_node *pEntry;
jx9_hashmap *pMap;
sxi32 rc;
sxu32 n;
if( nArg < 2 || !jx9_value_is_json_array(apArg[0]) ){
/* Invalid/Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pUserData = nArg > 2 ? apArg[2] : 0;
/* Point to the internal representation of the input hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
jx9MemObjInit(pMap->pVm, &sKey);
/* Perform the desired operation */
pEntry = pMap->pFirst;
for( n = 0 ; n < pMap->nEntry ; n++ ){
/* Extract the node value */
pValue = HashmapExtractNodeValue(pEntry);
if( pValue ){
/* Extract the entry key */
jx9HashmapExtractNodeKey(pEntry, &sKey);
/* Invoke the supplied callback */
rc = jx9VmCallUserFunctionAp(pMap->pVm, apArg[1], 0, pValue, &sKey, pUserData, 0);
jx9MemObjRelease(&sKey);
if( rc != SXRET_OK ){
/* An error occured while invoking the supplied callback [i.e: not defined] */
jx9_result_bool(pCtx, 0); /* return FALSE */
return JX9_OK;
}
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
}
/* All done, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* Table of built-in hashmap functions.
*/
static const jx9_builtin_func aHashmapFunc[] = {
{"count", jx9_hashmap_count },
{"sizeof", jx9_hashmap_count },
{"array_key_exists", jx9_hashmap_key_exists },
{"array_pop", jx9_hashmap_pop },
{"array_push", jx9_hashmap_push },
{"array_shift", jx9_hashmap_shift },
{"array_product", jx9_hashmap_product },
{"array_sum", jx9_hashmap_sum },
{"array_values", jx9_hashmap_values },
{"array_same", jx9_hashmap_same },
{"array_merge", jx9_hashmap_merge },
{"array_diff", jx9_hashmap_diff },
{"array_intersect", jx9_hashmap_intersect},
{"in_array", jx9_hashmap_in_array },
{"array_copy", jx9_hashmap_copy },
{"array_erase", jx9_hashmap_erase },
{"array_map", jx9_hashmap_map },
{"array_walk", jx9_hashmap_walk },
{"sort", jx9_hashmap_sort },
{"rsort", jx9_hashmap_rsort },
{"usort", jx9_hashmap_usort },
{"current", jx9_hashmap_current },
{"each", jx9_hashmap_each },
{"pos", jx9_hashmap_current },
{"next", jx9_hashmap_next },
{"prev", jx9_hashmap_prev },
{"end", jx9_hashmap_end },
{"reset", jx9_hashmap_reset },
{"key", jx9_hashmap_simple_key }
};
/*
* Register the built-in hashmap functions defined above.
*/
JX9_PRIVATE void jx9RegisterHashmapFunctions(jx9_vm *pVm)
{
sxu32 n;
for( n = 0 ; n < SX_ARRAYSIZE(aHashmapFunc) ; n++ ){
jx9_create_function(&(*pVm), aHashmapFunc[n].zName, aHashmapFunc[n].xFunc, 0);
}
}
/*
* Iterate throw hashmap entries and invoke the given callback [i.e: xWalk()] for each
* retrieved entry.
* Note that argument are passed to the callback by copy. That is, any modification to
* the entry value in the callback body will not alter the real value.
* If the callback wishes to abort processing [i.e: it's invocation] it must return
* a value different from JX9_OK.
* Refer to [jx9_array_walk()] for more information.
*/
JX9_PRIVATE sxi32 jx9HashmapWalk(
jx9_hashmap *pMap, /* Target hashmap */
int (*xWalk)(jx9_value *, jx9_value *, void *), /* Walker callback */
void *pUserData /* Last argument to xWalk() */
)
{
jx9_hashmap_node *pEntry;
jx9_value sKey, sValue;
sxi32 rc;
sxu32 n;
/* Initialize walker parameter */
rc = SXRET_OK;
jx9MemObjInit(pMap->pVm, &sKey);
jx9MemObjInit(pMap->pVm, &sValue);
n = pMap->nEntry;
pEntry = pMap->pFirst;
/* Start the iteration process */
for(;;){
if( n < 1 ){
break;
}
/* Extract a copy of the key and a copy the current value */
jx9HashmapExtractNodeKey(pEntry, &sKey);
jx9HashmapExtractNodeValue(pEntry, &sValue, FALSE);
/* Invoke the user callback */
rc = xWalk(&sKey, &sValue, pUserData);
/* Release the copy of the key and the value */
jx9MemObjRelease(&sKey);
jx9MemObjRelease(&sValue);
if( rc != JX9_OK ){
/* Callback request an operation abort */
return SXERR_ABORT;
}
/* Point to the next entry */
pEntry = pEntry->pPrev; /* Reverse link */
n--;
}
/* All done */
return SXRET_OK;
}
/*
* ----------------------------------------------------------
* File: jx9_json.c
* MD5: 31a27f8797418de511c669feed763341
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: json.c v1.0 FreeBSD 2012-12-16 00:28 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file deals with JSON serialization, decoding and stuff like that. */
/*
* Section:
* JSON encoding/decoding routines.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Devel.
*/
/* Forward reference */
static int VmJsonArrayEncode(jx9_value *pKey, jx9_value *pValue, void *pUserData);
static int VmJsonObjectEncode(jx9_value *pKey, jx9_value *pValue, void *pUserData);
/*
* JSON encoder state is stored in an instance
* of the following structure.
*/
typedef struct json_private_data json_private_data;
struct json_private_data
{
SyBlob *pOut; /* Output consumer buffer */
int isFirst; /* True if first encoded entry */
int iFlags; /* JSON encoding flags */
int nRecCount; /* Recursion count */
};
/*
* Returns the JSON representation of a value.In other word perform a JSON encoding operation.
* According to wikipedia
* JSON's basic types are:
* Number (double precision floating-point format in JavaScript, generally depends on implementation)
* String (double-quoted Unicode, with backslash escaping)
* Boolean (true or false)
* Array (an ordered sequence of values, comma-separated and enclosed in square brackets; the values
* do not need to be of the same type)
* Object (an unordered collection of key:value pairs with the ':' character separating the key
* and the value, comma-separated and enclosed in curly braces; the keys must be strings and should
* be distinct from each other)
* null (empty)
* Non-significant white space may be added freely around the "structural characters"
* (i.e. the brackets "[{]}", colon ":" and comma ",").
*/
static sxi32 VmJsonEncode(
jx9_value *pIn, /* Encode this value */
json_private_data *pData /* Context data */
){
SyBlob *pOut = pData->pOut;
int nByte;
if( jx9_value_is_null(pIn) || jx9_value_is_resource(pIn)){
/* null */
SyBlobAppend(pOut, "null", sizeof("null")-1);
}else if( jx9_value_is_bool(pIn) ){
int iBool = jx9_value_to_bool(pIn);
sxu32 iLen;
/* true/false */
iLen = iBool ? sizeof("true") : sizeof("false");
SyBlobAppend(pOut, iBool ? "true" : "false", iLen-1);
}else if( jx9_value_is_numeric(pIn) && !jx9_value_is_string(pIn) ){
const char *zNum;
/* Get a string representation of the number */
zNum = jx9_value_to_string(pIn, &nByte);
SyBlobAppend(pOut,zNum,nByte);
}else if( jx9_value_is_string(pIn) ){
const char *zIn, *zEnd;
int c;
/* Encode the string */
zIn = jx9_value_to_string(pIn, &nByte);
zEnd = &zIn[nByte];
/* Append the double quote */
SyBlobAppend(pOut,"\"", sizeof(char));
for(;;){
if( zIn >= zEnd ){
/* No more input to process */
break;
}
c = zIn[0];
/* Advance the stream cursor */
zIn++;
if( c == '"' || c == '\\' ){
/* Unescape the character */
SyBlobAppend(pOut,"\\", sizeof(char));
}
/* Append character verbatim */
SyBlobAppend(pOut,(const char *)&c,sizeof(char));
}
/* Append the double quote */
SyBlobAppend(pOut,"\"",sizeof(char));
}else if( jx9_value_is_json_array(pIn) ){
/* Encode the array/object */
pData->isFirst = 1;
if( jx9_value_is_json_object(pIn) ){
/* Encode the object instance */
pData->isFirst = 1;
/* Append the curly braces */
SyBlobAppend(pOut, "{",sizeof(char));
/* Iterate throw object attribute */
jx9_array_walk(pIn,VmJsonObjectEncode, pData);
/* Append the closing curly braces */
SyBlobAppend(pOut, "}",sizeof(char));
}else{
/* Append the square bracket or curly braces */
SyBlobAppend(pOut,"[",sizeof(char));
/* Iterate throw array entries */
jx9_array_walk(pIn, VmJsonArrayEncode, pData);
/* Append the closing square bracket or curly braces */
SyBlobAppend(pOut,"]",sizeof(char));
}
}else{
/* Can't happen */
SyBlobAppend(pOut,"null",sizeof("null")-1);
}
/* All done */
return JX9_OK;
}
/*
* The following walker callback is invoked each time we need
* to encode an array to JSON.
*/
static int VmJsonArrayEncode(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
json_private_data *pJson = (json_private_data *)pUserData;
if( pJson->nRecCount > 31 ){
/* Recursion limit reached, return immediately */
SXUNUSED(pKey); /* cc warning */
return JX9_OK;
}
if( !pJson->isFirst ){
/* Append the colon first */
SyBlobAppend(pJson->pOut,",",(int)sizeof(char));
}
/* Encode the value */
pJson->nRecCount++;
VmJsonEncode(pValue, pJson);
pJson->nRecCount--;
pJson->isFirst = 0;
return JX9_OK;
}
/*
* The following walker callback is invoked each time we need to encode
* a object instance [i.e: Object in the JX9 jargon] to JSON.
*/
static int VmJsonObjectEncode(jx9_value *pKey,jx9_value *pValue,void *pUserData)
{
json_private_data *pJson = (json_private_data *)pUserData;
const char *zKey;
int nByte;
if( pJson->nRecCount > 31 ){
/* Recursion limit reached, return immediately */
return JX9_OK;
}
if( !pJson->isFirst ){
/* Append the colon first */
SyBlobAppend(pJson->pOut,",",sizeof(char));
}
/* Extract a string representation of the key */
zKey = jx9_value_to_string(pKey, &nByte);
/* Append the key and the double colon */
if( nByte > 0 ){
SyBlobAppend(pJson->pOut,"\"",sizeof(char));
SyBlobAppend(pJson->pOut,zKey,(sxu32)nByte);
SyBlobAppend(pJson->pOut,"\"",sizeof(char));
}else{
/* Can't happen */
SyBlobAppend(pJson->pOut,"null",sizeof("null")-1);
}
SyBlobAppend(pJson->pOut,":",sizeof(char));
/* Encode the value */
pJson->nRecCount++;
VmJsonEncode(pValue, pJson);
pJson->nRecCount--;
pJson->isFirst = 0;
return JX9_OK;
}
/*
* Returns a string containing the JSON representation of value.
* In other words, perform the serialization of the given JSON object.
*/
JX9_PRIVATE int jx9JsonSerialize(jx9_value *pValue,SyBlob *pOut)
{
json_private_data sJson;
/* Prepare the JSON data */
sJson.nRecCount = 0;
sJson.pOut = pOut;
sJson.isFirst = 1;
sJson.iFlags = 0;
/* Perform the encoding operation */
VmJsonEncode(pValue, &sJson);
/* All done */
return JX9_OK;
}
/* Possible tokens from the JSON tokenization process */
#define JSON_TK_TRUE 0x001 /* Boolean true */
#define JSON_TK_FALSE 0x002 /* Boolean false */
#define JSON_TK_STR 0x004 /* String enclosed in double quotes */
#define JSON_TK_NULL 0x008 /* null */
#define JSON_TK_NUM 0x010 /* Numeric */
#define JSON_TK_OCB 0x020 /* Open curly braces '{' */
#define JSON_TK_CCB 0x040 /* Closing curly braces '}' */
#define JSON_TK_OSB 0x080 /* Open square bracke '[' */
#define JSON_TK_CSB 0x100 /* Closing square bracket ']' */
#define JSON_TK_COLON 0x200 /* Single colon ':' */
#define JSON_TK_COMMA 0x400 /* Single comma ',' */
#define JSON_TK_ID 0x800 /* ID */
#define JSON_TK_INVALID 0x1000 /* Unexpected token */
/*
* Tokenize an entire JSON input.
* Get a single low-level token from the input file.
* Update the stream pointer so that it points to the first
* character beyond the extracted token.
*/
static sxi32 VmJsonTokenize(SyStream *pStream, SyToken *pToken, void *pUserData, void *pCtxData)
{
int *pJsonErr = (int *)pUserData;
SyString *pStr;
int c;
/* Ignore leading white spaces */
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisSpace(pStream->zText[0]) ){
/* Advance the stream cursor */
if( pStream->zText[0] == '\n' ){
/* Update line counter */
pStream->nLine++;
}
pStream->zText++;
}
if( pStream->zText >= pStream->zEnd ){
/* End of input reached */
SXUNUSED(pCtxData); /* cc warning */
return SXERR_EOF;
}
/* Record token starting position and line */
pToken->nLine = pStream->nLine;
pToken->pUserData = 0;
pStr = &pToken->sData;
SyStringInitFromBuf(pStr, pStream->zText, 0);
if( pStream->zText[0] >= 0xc0 || SyisAlpha(pStream->zText[0]) || pStream->zText[0] == '_' ){
/* The following code fragment is taken verbatim from the xPP source tree.
* xPP is a modern embeddable macro processor with advanced features useful for
* application seeking for a production quality, ready to use macro processor.
* xPP is a widely used library developed and maintened by Symisc Systems.
* You can reach the xPP home page by following this link:
* http://xpp.symisc.net/
*/
const unsigned char *zIn;
/* Isolate UTF-8 or alphanumeric stream */
if( pStream->zText[0] < 0xc0 ){
pStream->zText++;
}
for(;;){
zIn = pStream->zText;
if( zIn[0] >= 0xc0 ){
zIn++;
/* UTF-8 stream */
while( zIn < pStream->zEnd && ((zIn[0] & 0xc0) == 0x80) ){
zIn++;
}
}
/* Skip alphanumeric stream */
while( zIn < pStream->zEnd && zIn[0] < 0xc0 && (SyisAlphaNum(zIn[0]) || zIn[0] == '_') ){
zIn++;
}
if( zIn == pStream->zText ){
/* Not an UTF-8 or alphanumeric stream */
break;
}
/* Synchronize pointers */
pStream->zText = zIn;
}
/* Record token length */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
/* A simple identifier */
pToken->nType = JSON_TK_ID;
if( pStr->nByte == sizeof("true") -1 && SyStrnicmp(pStr->zString, "true", sizeof("true")-1) == 0 ){
/* boolean true */
pToken->nType = JSON_TK_TRUE;
}else if( pStr->nByte == sizeof("false") -1 && SyStrnicmp(pStr->zString,"false", sizeof("false")-1) == 0 ){
/* boolean false */
pToken->nType = JSON_TK_FALSE;
}else if( pStr->nByte == sizeof("null") -1 && SyStrnicmp(pStr->zString,"null", sizeof("null")-1) == 0 ){
/* NULL */
pToken->nType = JSON_TK_NULL;
}
return SXRET_OK;
}
if( pStream->zText[0] == '{' || pStream->zText[0] == '[' || pStream->zText[0] == '}' || pStream->zText[0] == ']'
|| pStream->zText[0] == ':' || pStream->zText[0] == ',' ){
/* Single character */
c = pStream->zText[0];
/* Set token type */
switch(c){
case '[': pToken->nType = JSON_TK_OSB; break;
case '{': pToken->nType = JSON_TK_OCB; break;
case '}': pToken->nType = JSON_TK_CCB; break;
case ']': pToken->nType = JSON_TK_CSB; break;
case ':': pToken->nType = JSON_TK_COLON; break;
case ',': pToken->nType = JSON_TK_COMMA; break;
default:
break;
}
/* Advance the stream cursor */
pStream->zText++;
}else if( pStream->zText[0] == '"') {
/* JSON string */
pStream->zText++;
pStr->zString++;
/* Delimit the string */
while( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '"' && pStream->zText[-1] != '\\' ){
break;
}
if( pStream->zText[0] == '\n' ){
/* Update line counter */
pStream->nLine++;
}
pStream->zText++;
}
if( pStream->zText >= pStream->zEnd ){
/* Missing closing '"' */
pToken->nType = JSON_TK_INVALID;
*pJsonErr = SXERR_SYNTAX;
}else{
pToken->nType = JSON_TK_STR;
pStream->zText++; /* Jump the closing double quotes */
}
}else if( pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
/* Number */
pStream->zText++;
pToken->nType = JSON_TK_NUM;
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c == '.' ){
/* Real number */
pStream->zText++;
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c=='e' || c=='E' ){
pStream->zText++;
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c =='+' || c=='-' ){
pStream->zText++;
}
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
}
}
}
}else if( c=='e' || c=='E' ){
/* Real number */
pStream->zText++;
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c =='+' || c=='-' ){
pStream->zText++;
}
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
}
}
}
}else{
/* Unexpected token */
pToken->nType = JSON_TK_INVALID;
/* Advance the stream cursor */
pStream->zText++;
*pJsonErr = SXERR_SYNTAX;
/* Abort processing immediatley */
return SXERR_ABORT;
}
/* record token length */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
if( pToken->nType == JSON_TK_STR ){
pStr->nByte--;
}
/* Return to the lexer */
return SXRET_OK;
}
/*
* JSON decoded input consumer callback signature.
*/
typedef int (*ProcJSONConsumer)(jx9_context *, jx9_value *, jx9_value *, void *);
/*
* JSON decoder state is kept in the following structure.
*/
typedef struct json_decoder json_decoder;
struct json_decoder
{
jx9_context *pCtx; /* Call context */
ProcJSONConsumer xConsumer; /* Consumer callback */
void *pUserData; /* Last argument to xConsumer() */
int iFlags; /* Configuration flags */
SyToken *pIn; /* Token stream */
SyToken *pEnd; /* End of the token stream */
int rec_count; /* Current nesting level */
int *pErr; /* JSON decoding error if any */
};
/* Forward declaration */
static int VmJsonArrayDecoder(jx9_context *pCtx, jx9_value *pKey, jx9_value *pWorker, void *pUserData);
/*
* Dequote [i.e: Resolve all backslash escapes ] a JSON string and store
* the result in the given jx9_value.
*/
static void VmJsonDequoteString(const SyString *pStr, jx9_value *pWorker)
{
const char *zIn = pStr->zString;
const char *zEnd = &pStr->zString[pStr->nByte];
const char *zCur;
int c;
/* Mark the value as a string */
jx9_value_string(pWorker, "", 0); /* Empty string */
for(;;){
zCur = zIn;
while( zIn < zEnd && zIn[0] != '\\' ){
zIn++;
}
if( zIn > zCur ){
/* Append chunk verbatim */
jx9_value_string(pWorker, zCur, (int)(zIn-zCur));
}
zIn++;
if( zIn >= zEnd ){
/* End of the input reached */
break;
}
c = zIn[0];
/* Unescape the character */
switch(c){
case '"': jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
case '\\': jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char)); break;
case 'n': jx9_value_string(pWorker, "\n", (int)sizeof(char)); break;
case 'r': jx9_value_string(pWorker, "\r", (int)sizeof(char)); break;
case 't': jx9_value_string(pWorker, "\t", (int)sizeof(char)); break;
case 'f': jx9_value_string(pWorker, "\f", (int)sizeof(char)); break;
default:
jx9_value_string(pWorker, (const char *)&c, (int)sizeof(char));
break;
}
/* Advance the stream cursor */
zIn++;
}
}
/*
* Returns a jx9_value holding the image of a JSON string. In other word perform a JSON decoding operation.
* According to wikipedia
* JSON's basic types are:
* Number (double precision floating-point format in JavaScript, generally depends on implementation)
* String (double-quoted Unicode, with backslash escaping)
* Boolean (true or false)
* Array (an ordered sequence of values, comma-separated and enclosed in square brackets; the values
* do not need to be of the same type)
* Object (an unordered collection of key:value pairs with the ':' character separating the key
* and the value, comma-separated and enclosed in curly braces; the keys must be strings and should
* be distinct from each other)
* null (empty)
* Non-significant white space may be added freely around the "structural characters" (i.e. the brackets "[{]}", colon ":" and comma ", ").
*/
static sxi32 VmJsonDecode(
json_decoder *pDecoder, /* JSON decoder */
jx9_value *pArrayKey /* Key for the decoded array */
){
jx9_value *pWorker; /* Worker variable */
sxi32 rc;
/* Check if we do not nest to much */
if( pDecoder->rec_count > 31 ){
/* Nesting limit reached, abort decoding immediately */
return SXERR_ABORT;
}
if( pDecoder->pIn->nType & (JSON_TK_STR|JSON_TK_ID|JSON_TK_TRUE|JSON_TK_FALSE|JSON_TK_NULL|JSON_TK_NUM) ){
/* Scalar value */
pWorker = jx9_context_new_scalar(pDecoder->pCtx);
if( pWorker == 0 ){
jx9_context_throw_error(pDecoder->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
/* Abort the decoding operation immediately */
return SXERR_ABORT;
}
/* Reflect the JSON image */
if( pDecoder->pIn->nType & JSON_TK_NULL ){
/* Nullify the value.*/
jx9_value_null(pWorker);
}else if( pDecoder->pIn->nType & (JSON_TK_TRUE|JSON_TK_FALSE) ){
/* Boolean value */
jx9_value_bool(pWorker, (pDecoder->pIn->nType & JSON_TK_TRUE) ? 1 : 0 );
}else if( pDecoder->pIn->nType & JSON_TK_NUM ){
SyString *pStr = &pDecoder->pIn->sData;
/*
* Numeric value.
* Get a string representation first then try to get a numeric
* value.
*/
jx9_value_string(pWorker, pStr->zString, (int)pStr->nByte);
/* Obtain a numeric representation */
jx9MemObjToNumeric(pWorker);
}else if( pDecoder->pIn->nType & JSON_TK_ID ){
SyString *pStr = &pDecoder->pIn->sData;
jx9_value_string(pWorker, pStr->zString, (int)pStr->nByte);
}else{
/* Dequote the string */
VmJsonDequoteString(&pDecoder->pIn->sData, pWorker);
}
/* Invoke the consumer callback */
rc = pDecoder->xConsumer(pDecoder->pCtx, pArrayKey, pWorker, pDecoder->pUserData);
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
/* All done, advance the stream cursor */
pDecoder->pIn++;
}else if( pDecoder->pIn->nType & JSON_TK_OSB /*'[' */) {
ProcJSONConsumer xOld;
void *pOld;
/* Array representation*/
pDecoder->pIn++;
/* Create a working array */
pWorker = jx9_context_new_array(pDecoder->pCtx);
if( pWorker == 0 ){
jx9_context_throw_error(pDecoder->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
/* Abort the decoding operation immediately */
return SXERR_ABORT;
}
/* Save the old consumer */
xOld = pDecoder->xConsumer;
pOld = pDecoder->pUserData;
/* Set the new consumer */
pDecoder->xConsumer = VmJsonArrayDecoder;
pDecoder->pUserData = pWorker;
/* Decode the array */
for(;;){
/* Jump trailing comma. Note that the standard JX9 engine will not let you
* do this.
*/
while( (pDecoder->pIn < pDecoder->pEnd) && (pDecoder->pIn->nType & JSON_TK_COMMA) ){
pDecoder->pIn++;
}
if( pDecoder->pIn >= pDecoder->pEnd || (pDecoder->pIn->nType & JSON_TK_CSB) /*']'*/ ){
if( pDecoder->pIn < pDecoder->pEnd ){
pDecoder->pIn++; /* Jump the trailing ']' */
}
break;
}
/* Recurse and decode the entry */
pDecoder->rec_count++;
rc = VmJsonDecode(pDecoder, 0);
pDecoder->rec_count--;
if( rc == SXERR_ABORT ){
/* Abort processing immediately */
return SXERR_ABORT;
}
/*The cursor is automatically advanced by the VmJsonDecode() function */
if( (pDecoder->pIn < pDecoder->pEnd) &&
((pDecoder->pIn->nType & (JSON_TK_CSB/*']'*/|JSON_TK_COMMA/*','*/))==0) ){
/* Unexpected token, abort immediatley */
*pDecoder->pErr = SXERR_SYNTAX;
return SXERR_ABORT;
}
}
/* Restore the old consumer */
pDecoder->xConsumer = xOld;
pDecoder->pUserData = pOld;
/* Invoke the old consumer on the decoded array */
xOld(pDecoder->pCtx, pArrayKey, pWorker, pOld);
}else if( pDecoder->pIn->nType & JSON_TK_OCB /*'{' */) {
ProcJSONConsumer xOld;
jx9_value *pKey;
void *pOld;
/* Object representation*/
pDecoder->pIn++;
/* Create a working array */
pWorker = jx9_context_new_array(pDecoder->pCtx);
pKey = jx9_context_new_scalar(pDecoder->pCtx);
if( pWorker == 0 || pKey == 0){
jx9_context_throw_error(pDecoder->pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
/* Abort the decoding operation immediately */
return SXERR_ABORT;
}
/* Save the old consumer */
xOld = pDecoder->xConsumer;
pOld = pDecoder->pUserData;
/* Set the new consumer */
pDecoder->xConsumer = VmJsonArrayDecoder;
pDecoder->pUserData = pWorker;
/* Decode the object */
for(;;){
/* Jump trailing comma. Note that the standard JX9 engine will not let you
* do this.
*/
while( (pDecoder->pIn < pDecoder->pEnd) && (pDecoder->pIn->nType & JSON_TK_COMMA) ){
pDecoder->pIn++;
}
if( pDecoder->pIn >= pDecoder->pEnd || (pDecoder->pIn->nType & JSON_TK_CCB) /*'}'*/ ){
if( pDecoder->pIn < pDecoder->pEnd ){
pDecoder->pIn++; /* Jump the trailing ']' */
}
break;
}
if( (pDecoder->pIn->nType & (JSON_TK_ID|JSON_TK_STR)) == 0 || &pDecoder->pIn[1] >= pDecoder->pEnd
|| (pDecoder->pIn[1].nType & JSON_TK_COLON) == 0){
/* Syntax error, return immediately */
*pDecoder->pErr = SXERR_SYNTAX;
return SXERR_ABORT;
}
if( pDecoder->pIn->nType & JSON_TK_ID ){
SyString *pStr = &pDecoder->pIn->sData;
jx9_value_string(pKey, pStr->zString, (int)pStr->nByte);
}else{
/* Dequote the key */
VmJsonDequoteString(&pDecoder->pIn->sData, pKey);
}
/* Jump the key and the colon */
pDecoder->pIn += 2;
/* Recurse and decode the value */
pDecoder->rec_count++;
rc = VmJsonDecode(pDecoder, pKey);
pDecoder->rec_count--;
if( rc == SXERR_ABORT ){
/* Abort processing immediately */
return SXERR_ABORT;
}
/* Reset the internal buffer of the key */
jx9_value_reset_string_cursor(pKey);
/*The cursor is automatically advanced by the VmJsonDecode() function */
}
/* Restore the old consumer */
pDecoder->xConsumer = xOld;
pDecoder->pUserData = pOld;
/* Invoke the old consumer on the decoded object*/
xOld(pDecoder->pCtx, pArrayKey, pWorker, pOld);
/* Release the key */
jx9_context_release_value(pDecoder->pCtx, pKey);
}else{
/* Unexpected token */
return SXERR_ABORT; /* Abort immediately */
}
/* Release the worker variable */
jx9_context_release_value(pDecoder->pCtx, pWorker);
return SXRET_OK;
}
/*
* The following JSON decoder callback is invoked each time
* a JSON array representation [i.e: [15, "hello", FALSE] ]
* is being decoded.
*/
static int VmJsonArrayDecoder(jx9_context *pCtx, jx9_value *pKey, jx9_value *pWorker, void *pUserData)
{
jx9_value *pArray = (jx9_value *)pUserData;
/* Insert the entry */
jx9_array_add_elem(pArray, pKey, pWorker); /* Will make it's own copy */
SXUNUSED(pCtx); /* cc warning */
/* All done */
return SXRET_OK;
}
/*
* Standard JSON decoder callback.
*/
static int VmJsonDefaultDecoder(jx9_context *pCtx, jx9_value *pKey, jx9_value *pWorker, void *pUserData)
{
/* Return the value directly */
jx9_result_value(pCtx, pWorker); /* Will make it's own copy */
SXUNUSED(pKey); /* cc warning */
SXUNUSED(pUserData);
/* All done */
return SXRET_OK;
}
/*
* Exported JSON decoding interface
*/
JX9_PRIVATE int jx9JsonDecode(jx9_context *pCtx,const char *zJSON,int nByte)
{
jx9_vm *pVm = pCtx->pVm;
json_decoder sDecoder;
SySet sToken;
SyLex sLex;
sxi32 rc;
/* Tokenize the input */
SySetInit(&sToken, &pVm->sAllocator, sizeof(SyToken));
rc = SXRET_OK;
SyLexInit(&sLex, &sToken, VmJsonTokenize, &rc);
SyLexTokenizeInput(&sLex,zJSON,(sxu32)nByte, 0, 0, 0);
if( rc != SXRET_OK ){
/* Something goes wrong while tokenizing input. [i.e: Unexpected token] */
SyLexRelease(&sLex);
SySetRelease(&sToken);
/* return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Fill the decoder */
sDecoder.pCtx = pCtx;
sDecoder.pErr = &rc;
sDecoder.pIn = (SyToken *)SySetBasePtr(&sToken);
sDecoder.pEnd = &sDecoder.pIn[SySetUsed(&sToken)];
sDecoder.iFlags = 0;
sDecoder.rec_count = 0;
/* Set a default consumer */
sDecoder.xConsumer = VmJsonDefaultDecoder;
sDecoder.pUserData = 0;
/* Decode the raw JSON input */
rc = VmJsonDecode(&sDecoder, 0);
if( rc == SXERR_ABORT ){
/*
* Something goes wrong while decoding JSON input.Return NULL.
*/
jx9_result_null(pCtx);
}
/* Clean-up the mess left behind */
SyLexRelease(&sLex);
SySetRelease(&sToken);
/* All done */
return JX9_OK;
}
/*
* ----------------------------------------------------------
* File: jx9_lex.c
* MD5: a79518c0635dbaf5dcfaca62efa2faf8
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: lex.c v1.0 FreeBSD 2012-12-09 00:19 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file implements a thread-safe and full reentrant lexical analyzer for the Jx9 programming language */
/* Forward declarations */
static sxu32 keywordCode(const char *z,int n);
static sxi32 LexExtractNowdoc(SyStream *pStream,SyToken *pToken);
/*
* Tokenize a raw jx9 input.
* Get a single low-level token from the input file. Update the stream pointer so that
* it points to the first character beyond the extracted token.
*/
static sxi32 jx9TokenizeInput(SyStream *pStream,SyToken *pToken,void *pUserData,void *pCtxData)
{
SyString *pStr;
sxi32 rc;
/* Ignore leading white spaces */
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisSpace(pStream->zText[0]) ){
/* Advance the stream cursor */
if( pStream->zText[0] == '\n' ){
/* Update line counter */
pStream->nLine++;
}
pStream->zText++;
}
if( pStream->zText >= pStream->zEnd ){
/* End of input reached */
return SXERR_EOF;
}
/* Record token starting position and line */
pToken->nLine = pStream->nLine;
pToken->pUserData = 0;
pStr = &pToken->sData;
SyStringInitFromBuf(pStr, pStream->zText, 0);
if( pStream->zText[0] >= 0xc0 || SyisAlpha(pStream->zText[0]) || pStream->zText[0] == '_' ){
/* The following code fragment is taken verbatim from the xPP source tree.
* xPP is a modern embeddable macro processor with advanced features useful for
* application seeking for a production quality, ready to use macro processor.
* xPP is a widely used library developed and maintened by Symisc Systems.
* You can reach the xPP home page by following this link:
* http://xpp.symisc.net/
*/
const unsigned char *zIn;
sxu32 nKeyword;
/* Isolate UTF-8 or alphanumeric stream */
if( pStream->zText[0] < 0xc0 ){
pStream->zText++;
}
for(;;){
zIn = pStream->zText;
if( zIn[0] >= 0xc0 ){
zIn++;
/* UTF-8 stream */
while( zIn < pStream->zEnd && ((zIn[0] & 0xc0) == 0x80) ){
zIn++;
}
}
/* Skip alphanumeric stream */
while( zIn < pStream->zEnd && zIn[0] < 0xc0 && (SyisAlphaNum(zIn[0]) || zIn[0] == '_') ){
zIn++;
}
if( zIn == pStream->zText ){
/* Not an UTF-8 or alphanumeric stream */
break;
}
/* Synchronize pointers */
pStream->zText = zIn;
}
/* Record token length */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
nKeyword = keywordCode(pStr->zString, (int)pStr->nByte);
if( nKeyword != JX9_TK_ID ){
/* We are dealing with a keyword [i.e: if, function, CREATE, ...], save the keyword ID */
pToken->nType = JX9_TK_KEYWORD;
pToken->pUserData = SX_INT_TO_PTR(nKeyword);
}else{
/* A simple identifier */
pToken->nType = JX9_TK_ID;
}
}else{
sxi32 c;
/* Non-alpha stream */
if( pStream->zText[0] == '#' ||
( pStream->zText[0] == '/' && &pStream->zText[1] < pStream->zEnd && pStream->zText[1] == '/') ){
pStream->zText++;
/* Inline comments */
while( pStream->zText < pStream->zEnd && pStream->zText[0] != '\n' ){
pStream->zText++;
}
/* Tell the upper-layer to ignore this token */
return SXERR_CONTINUE;
}else if( pStream->zText[0] == '/' && &pStream->zText[1] < pStream->zEnd && pStream->zText[1] == '*' ){
pStream->zText += 2;
/* Block comment */
while( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '*' ){
if( &pStream->zText[1] >= pStream->zEnd || pStream->zText[1] == '/' ){
break;
}
}
if( pStream->zText[0] == '\n' ){
pStream->nLine++;
}
pStream->zText++;
}
pStream->zText += 2;
/* Tell the upper-layer to ignore this token */
return SXERR_CONTINUE;
}else if( SyisDigit(pStream->zText[0]) ){
pStream->zText++;
/* Decimal digit stream */
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
/* Mark the token as integer until we encounter a real number */
pToken->nType = JX9_TK_INTEGER;
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c == '.' ){
/* Real number */
pStream->zText++;
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( c=='e' || c=='E' ){
pStream->zText++;
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( (c =='+' || c=='-') && &pStream->zText[1] < pStream->zEnd &&
pStream->zText[1] < 0xc0 && SyisDigit(pStream->zText[1]) ){
pStream->zText++;
}
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
}
}
}
pToken->nType = JX9_TK_REAL;
}else if( c=='e' || c=='E' ){
SXUNUSED(pUserData); /* Prevent compiler warning */
SXUNUSED(pCtxData);
pStream->zText++;
if( pStream->zText < pStream->zEnd ){
c = pStream->zText[0];
if( (c =='+' || c=='-') && &pStream->zText[1] < pStream->zEnd &&
pStream->zText[1] < 0xc0 && SyisDigit(pStream->zText[1]) ){
pStream->zText++;
}
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisDigit(pStream->zText[0]) ){
pStream->zText++;
}
}
pToken->nType = JX9_TK_REAL;
}else if( c == 'x' || c == 'X' ){
/* Hex digit stream */
pStream->zText++;
while( pStream->zText < pStream->zEnd && pStream->zText[0] < 0xc0 && SyisHex(pStream->zText[0]) ){
pStream->zText++;
}
}else if(c == 'b' || c == 'B' ){
/* Binary digit stream */
pStream->zText++;
while( pStream->zText < pStream->zEnd && (pStream->zText[0] == '0' || pStream->zText[0] == '1') ){
pStream->zText++;
}
}
}
/* Record token length */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
return SXRET_OK;
}
c = pStream->zText[0];
pStream->zText++; /* Advance the stream cursor */
/* Assume we are dealing with an operator*/
pToken->nType = JX9_TK_OP;
switch(c){
case '$': pToken->nType = JX9_TK_DOLLAR; break;
case '{': pToken->nType = JX9_TK_OCB; break;
case '}': pToken->nType = JX9_TK_CCB; break;
case '(': pToken->nType = JX9_TK_LPAREN; break;
case '[': pToken->nType |= JX9_TK_OSB; break; /* Bitwise operation here, since the square bracket token '['
* is a potential operator [i.e: subscripting] */
case ']': pToken->nType = JX9_TK_CSB; break;
case ')': {
SySet *pTokSet = pStream->pSet;
/* Assemble type cast operators [i.e: (int), (float), (bool)...] */
if( pTokSet->nUsed >= 2 ){
SyToken *pTmp;
/* Peek the last recongnized token */
pTmp = (SyToken *)SySetPeek(pTokSet);
if( pTmp->nType & JX9_TK_KEYWORD ){
sxi32 nID = SX_PTR_TO_INT(pTmp->pUserData);
if( (sxu32)nID & (JX9_TKWRD_INT|JX9_TKWRD_FLOAT|JX9_TKWRD_STRING|JX9_TKWRD_BOOL) ){
pTmp = (SyToken *)SySetAt(pTokSet, pTokSet->nUsed - 2);
if( pTmp->nType & JX9_TK_LPAREN ){
/* Merge the three tokens '(' 'TYPE' ')' into a single one */
const char * zTypeCast = "(int)";
if( nID & JX9_TKWRD_FLOAT ){
zTypeCast = "(float)";
}else if( nID & JX9_TKWRD_BOOL ){
zTypeCast = "(bool)";
}else if( nID & JX9_TKWRD_STRING ){
zTypeCast = "(string)";
}
/* Reflect the change */
pToken->nType = JX9_TK_OP;
SyStringInitFromBuf(&pToken->sData, zTypeCast, SyStrlen(zTypeCast));
/* Save the instance associated with the type cast operator */
pToken->pUserData = (void *)jx9ExprExtractOperator(&pToken->sData, 0);
/* Remove the two previous tokens */
pTokSet->nUsed -= 2;
return SXRET_OK;
}
}
}
}
pToken->nType = JX9_TK_RPAREN;
break;
}
case '\'':{
/* Single quoted string */
pStr->zString++;
while( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '\'' ){
if( pStream->zText[-1] != '\\' ){
break;
}else{
const unsigned char *zPtr = &pStream->zText[-2];
sxi32 i = 1;
while( zPtr > pStream->zInput && zPtr[0] == '\\' ){
zPtr--;
i++;
}
if((i&1)==0){
break;
}
}
}
if( pStream->zText[0] == '\n' ){
pStream->nLine++;
}
pStream->zText++;
}
/* Record token length and type */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
pToken->nType = JX9_TK_SSTR;
/* Jump the trailing single quote */
pStream->zText++;
return SXRET_OK;
}
case '"':{
sxi32 iNest;
/* Double quoted string */
pStr->zString++;
while( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '{' && &pStream->zText[1] < pStream->zEnd && pStream->zText[1] == '$'){
iNest = 1;
pStream->zText++;
/* TICKET 1433-40: Hnadle braces'{}' in double quoted string where everything is allowed */
while(pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '{' ){
iNest++;
}else if (pStream->zText[0] == '}' ){
iNest--;
if( iNest <= 0 ){
pStream->zText++;
break;
}
}else if( pStream->zText[0] == '\n' ){
pStream->nLine++;
}
pStream->zText++;
}
if( pStream->zText >= pStream->zEnd ){
break;
}
}
if( pStream->zText[0] == '"' ){
if( pStream->zText[-1] != '\\' ){
break;
}else{
const unsigned char *zPtr = &pStream->zText[-2];
sxi32 i = 1;
while( zPtr > pStream->zInput && zPtr[0] == '\\' ){
zPtr--;
i++;
}
if((i&1)==0){
break;
}
}
}
if( pStream->zText[0] == '\n' ){
pStream->nLine++;
}
pStream->zText++;
}
/* Record token length and type */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
pToken->nType = JX9_TK_DSTR;
/* Jump the trailing quote */
pStream->zText++;
return SXRET_OK;
}
case ':':
pToken->nType = JX9_TK_COLON; /* Single colon */
break;
case ',': pToken->nType |= JX9_TK_COMMA; break; /* Comma is also an operator */
case ';': pToken->nType = JX9_TK_SEMI; break;
/* Handle combined operators [i.e: +=, ===, !=== ...] */
case '=':
pToken->nType |= JX9_TK_EQUAL;
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '=' ){
pToken->nType &= ~JX9_TK_EQUAL;
/* Current operator: == */
pStream->zText++;
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: === */
pStream->zText++;
}
}
}
break;
case '!':
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: != */
pStream->zText++;
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: !== */
pStream->zText++;
}
}
break;
case '&':
pToken->nType |= JX9_TK_AMPER;
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '&' ){
pToken->nType &= ~JX9_TK_AMPER;
/* Current operator: && */
pStream->zText++;
}else if( pStream->zText[0] == '=' ){
pToken->nType &= ~JX9_TK_AMPER;
/* Current operator: &= */
pStream->zText++;
}
}
case '.':
if( pStream->zText < pStream->zEnd && (pStream->zText[0] == '.' || pStream->zText[0] == '=') ){
/* Concatenation operator: '..' or '.=' */
pStream->zText++;
}
break;
case '|':
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '|' ){
/* Current operator: || */
pStream->zText++;
}else if( pStream->zText[0] == '=' ){
/* Current operator: |= */
pStream->zText++;
}
}
break;
case '+':
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '+' ){
/* Current operator: ++ */
pStream->zText++;
}else if( pStream->zText[0] == '=' ){
/* Current operator: += */
pStream->zText++;
}
}
break;
case '-':
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '-' ){
/* Current operator: -- */
pStream->zText++;
}else if( pStream->zText[0] == '=' ){
/* Current operator: -= */
pStream->zText++;
}else if( pStream->zText[0] == '>' ){
/* Current operator: -> */
pStream->zText++;
}
}
break;
case '*':
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: *= */
pStream->zText++;
}
break;
case '/':
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: /= */
pStream->zText++;
}
break;
case '%':
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: %= */
pStream->zText++;
}
break;
case '^':
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: ^= */
pStream->zText++;
}
break;
case '<':
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '<' ){
/* Current operator: << */
pStream->zText++;
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '=' ){
/* Current operator: <<= */
pStream->zText++;
}else if( pStream->zText[0] == '<' ){
/* Current Token: <<< */
pStream->zText++;
/* This may be the beginning of a Heredoc/Nowdoc string, try to delimit it */
rc = LexExtractNowdoc(&(*pStream), &(*pToken));
if( rc == SXRET_OK ){
/* Here/Now doc successfuly extracted */
return SXRET_OK;
}
}
}
}else if( pStream->zText[0] == '>' ){
/* Current operator: <> */
pStream->zText++;
}else if( pStream->zText[0] == '=' ){
/* Current operator: <= */
pStream->zText++;
}
}
break;
case '>':
if( pStream->zText < pStream->zEnd ){
if( pStream->zText[0] == '>' ){
/* Current operator: >> */
pStream->zText++;
if( pStream->zText < pStream->zEnd && pStream->zText[0] == '=' ){
/* Current operator: >>= */
pStream->zText++;
}
}else if( pStream->zText[0] == '=' ){
/* Current operator: >= */
pStream->zText++;
}
}
break;
default:
break;
}
if( pStr->nByte <= 0 ){
/* Record token length */
pStr->nByte = (sxu32)((const char *)pStream->zText-pStr->zString);
}
if( pToken->nType & JX9_TK_OP ){
const jx9_expr_op *pOp;
/* Check if the extracted token is an operator */
pOp = jx9ExprExtractOperator(pStr, (SyToken *)SySetPeek(pStream->pSet));
if( pOp == 0 ){
/* Not an operator */
pToken->nType &= ~JX9_TK_OP;
if( pToken->nType <= 0 ){
pToken->nType = JX9_TK_OTHER;
}
}else{
/* Save the instance associated with this operator for later processing */
pToken->pUserData = (void *)pOp;
}
}
}
/* Tell the upper-layer to save the extracted token for later processing */
return SXRET_OK;
}
/***** This file contains automatically generated code ******
**
** The code in this file has been automatically generated by
**
** $Header: /sqlite/sqlite/tool/mkkeywordhash.c,v 1.38 2011/12/21 01:00:46 <chm@symisc.net> $
**
** The code in this file implements a function that determines whether
** or not a given identifier is really a JX9 keyword. The same thing
** might be implemented more directly using a hand-written hash table.
** But by using this automatically generated code, the size of the code
** is substantially reduced. This is important for embedded applications
** on platforms with limited memory.
*/
/* Hash score: 35 */
static sxu32 keywordCode(const char *z, int n)
{
/* zText[] encodes 188 bytes of keywords in 128 bytes */
/* printegereturnconstaticaselseifloatincludefaultDIEXITcontinue */
/* diewhileASPRINTbooleanbreakforeachfunctionimportstringswitch */
/* uplink */
static const char zText[127] = {
'p','r','i','n','t','e','g','e','r','e','t','u','r','n','c','o','n','s',
't','a','t','i','c','a','s','e','l','s','e','i','f','l','o','a','t','i',
'n','c','l','u','d','e','f','a','u','l','t','D','I','E','X','I','T','c',
'o','n','t','i','n','u','e','d','i','e','w','h','i','l','e','A','S','P',
'R','I','N','T','b','o','o','l','e','a','n','b','r','e','a','k','f','o',
'r','e','a','c','h','f','u','n','c','t','i','o','n','i','m','p','o','r',
't','s','t','r','i','n','g','s','w','i','t','c','h','u','p','l','i','n',
'k',
};
static const unsigned char aHash[59] = {
0, 0, 0, 0, 15, 0, 30, 0, 0, 2, 19, 18, 0,
0, 10, 3, 12, 0, 28, 29, 23, 0, 13, 22, 0, 0,
14, 24, 25, 31, 11, 0, 0, 0, 0, 1, 5, 0, 0,
20, 0, 27, 9, 0, 0, 0, 8, 0, 0, 26, 6, 0,
0, 17, 0, 0, 0, 0, 0,
};
static const unsigned char aNext[31] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 21, 7,
0, 0, 0, 0, 0,
};
static const unsigned char aLen[31] = {
5, 7, 3, 6, 5, 6, 4, 2, 6, 4, 2, 5, 7,
7, 3, 4, 8, 3, 5, 2, 5, 4, 7, 5, 3, 7,
8, 6, 6, 6, 6,
};
static const sxu16 aOffset[31] = {
0, 2, 2, 8, 14, 17, 22, 23, 25, 25, 29, 30, 35,
40, 47, 49, 53, 61, 64, 69, 71, 76, 76, 83, 88, 88,
95, 103, 109, 115, 121,
};
static const sxu32 aCode[31] = {
JX9_TKWRD_PRINT, JX9_TKWRD_INT, JX9_TKWRD_INT, JX9_TKWRD_RETURN, JX9_TKWRD_CONST,
JX9_TKWRD_STATIC, JX9_TKWRD_CASE, JX9_TKWRD_AS, JX9_TKWRD_ELIF, JX9_TKWRD_ELSE,
JX9_TKWRD_IF, JX9_TKWRD_FLOAT, JX9_TKWRD_INCLUDE, JX9_TKWRD_DEFAULT, JX9_TKWRD_DIE,
JX9_TKWRD_EXIT, JX9_TKWRD_CONTINUE, JX9_TKWRD_DIE, JX9_TKWRD_WHILE, JX9_TKWRD_AS,
JX9_TKWRD_PRINT, JX9_TKWRD_BOOL, JX9_TKWRD_BOOL, JX9_TKWRD_BREAK, JX9_TKWRD_FOR,
JX9_TKWRD_FOREACH, JX9_TKWRD_FUNCTION, JX9_TKWRD_IMPORT, JX9_TKWRD_STRING, JX9_TKWRD_SWITCH,
JX9_TKWRD_UPLINK,
};
int h, i;
if( n<2 ) return JX9_TK_ID;
h = (((int)z[0]*4) ^ ((int)z[n-1]*3) ^ n) % 59;
for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){
if( (int)aLen[i]==n && SyMemcmp(&zText[aOffset[i]],z,n)==0 ){
/* JX9_TKWRD_PRINT */
/* JX9_TKWRD_INT */
/* JX9_TKWRD_INT */
/* JX9_TKWRD_RETURN */
/* JX9_TKWRD_CONST */
/* JX9_TKWRD_STATIC */
/* JX9_TKWRD_CASE */
/* JX9_TKWRD_AS */
/* JX9_TKWRD_ELIF */
/* JX9_TKWRD_ELSE */
/* JX9_TKWRD_IF */
/* JX9_TKWRD_FLOAT */
/* JX9_TKWRD_INCLUDE */
/* JX9_TKWRD_DEFAULT */
/* JX9_TKWRD_DIE */
/* JX9_TKWRD_EXIT */
/* JX9_TKWRD_CONTINUE */
/* JX9_TKWRD_DIE */
/* JX9_TKWRD_WHILE */
/* JX9_TKWRD_AS */
/* JX9_TKWRD_PRINT */
/* JX9_TKWRD_BOOL */
/* JX9_TKWRD_BOOL */
/* JX9_TKWRD_BREAK */
/* JX9_TKWRD_FOR */
/* JX9_TKWRD_FOREACH */
/* JX9_TKWRD_FUNCTION */
/* JX9_TKWRD_IMPORT */
/* JX9_TKWRD_STRING */
/* JX9_TKWRD_SWITCH */
/* JX9_TKWRD_UPLINK */
return aCode[i];
}
}
return JX9_TK_ID;
}
/*
* Extract a heredoc/nowdoc text from a raw JX9 input.
* According to the JX9 language reference manual:
* A third way to delimit strings is the heredoc syntax: <<<. After this operator, an identifier
* is provided, then a newline. The string itself follows, and then the same identifier again
* to close the quotation.
* The closing identifier must begin in the first column of the line. Also, the identifier must
* follow the same naming rules as any other label in JX9: it must contain only alphanumeric
* characters and underscores, and must start with a non-digit character or underscore.
* Heredoc text behaves just like a double-quoted string, without the double quotes.
* This means that quotes in a heredoc do not need to be escaped, but the escape codes listed
* above can still be used. Variables are expanded, but the same care must be taken when expressing
* complex variables inside a heredoc as with strings.
* Nowdocs are to single-quoted strings what heredocs are to double-quoted strings.
* A nowdoc is specified similarly to a heredoc, but no parsing is done inside a nowdoc.
* The construct is ideal for embedding JX9 code or other large blocks of text without the need
* for escaping. It shares some features in common with the SGML <![CDATA[ ]]> construct, in that
* it declares a block of text which is not for parsing.
* A nowdoc is identified with the same <<< sequence used for heredocs, but the identifier which follows
* is enclosed in single quotes, e.g. <<<'EOT'. All the rules for heredoc identifiers also apply to nowdoc
* identifiers, especially those regarding the appearance of the closing identifier.
*/
static sxi32 LexExtractNowdoc(SyStream *pStream, SyToken *pToken)
{
const unsigned char *zIn = pStream->zText;
const unsigned char *zEnd = pStream->zEnd;
const unsigned char *zPtr;
SyString sDelim;
SyString sStr;
/* Jump leading white spaces */
while( zIn < zEnd && zIn[0] < 0xc0 && SyisSpace(zIn[0]) && zIn[0] != '\n' ){
zIn++;
}
if( zIn >= zEnd ){
/* A simple symbol, return immediately */
return SXERR_CONTINUE;
}
if( zIn[0] == '\'' || zIn[0] == '"' ){
zIn++;
}
if( zIn[0] < 0xc0 && !SyisAlphaNum(zIn[0]) && zIn[0] != '_' ){
/* Invalid delimiter, return immediately */
return SXERR_CONTINUE;
}
/* Isolate the identifier */
sDelim.zString = (const char *)zIn;
for(;;){
zPtr = zIn;
/* Skip alphanumeric stream */
while( zPtr < zEnd && zPtr[0] < 0xc0 && (SyisAlphaNum(zPtr[0]) || zPtr[0] == '_') ){
zPtr++;
}
if( zPtr < zEnd && zPtr[0] >= 0xc0 ){
zPtr++;
/* UTF-8 stream */
while( zPtr < zEnd && ((zPtr[0] & 0xc0) == 0x80) ){
zPtr++;
}
}
if( zPtr == zIn ){
/* Not an UTF-8 or alphanumeric stream */
break;
}
/* Synchronize pointers */
zIn = zPtr;
}
/* Get the identifier length */
sDelim.nByte = (sxu32)((const char *)zIn-sDelim.zString);
if( zIn[0] == '"' || zIn[0] == '\'' ){
/* Jump the trailing single quote */
zIn++;
}
/* Jump trailing white spaces */
while( zIn < zEnd && zIn[0] < 0xc0 && SyisSpace(zIn[0]) && zIn[0] != '\n' ){
zIn++;
}
if( sDelim.nByte <= 0 || zIn >= zEnd || zIn[0] != '\n' ){
/* Invalid syntax */
return SXERR_CONTINUE;
}
pStream->nLine++; /* Increment line counter */
zIn++;
/* Isolate the delimited string */
sStr.zString = (const char *)zIn;
/* Go and found the closing delimiter */
for(;;){
/* Synchronize with the next line */
while( zIn < zEnd && zIn[0] != '\n' ){
zIn++;
}
if( zIn >= zEnd ){
/* End of the input reached, break immediately */
pStream->zText = pStream->zEnd;
break;
}
pStream->nLine++; /* Increment line counter */
zIn++;
if( (sxu32)(zEnd - zIn) >= sDelim.nByte && SyMemcmp((const void *)sDelim.zString, (const void *)zIn, sDelim.nByte) == 0 ){
zPtr = &zIn[sDelim.nByte];
while( zPtr < zEnd && zPtr[0] < 0xc0 && SyisSpace(zPtr[0]) && zPtr[0] != '\n' ){
zPtr++;
}
if( zPtr >= zEnd ){
/* End of input */
pStream->zText = zPtr;
break;
}
if( zPtr[0] == ';' ){
const unsigned char *zCur = zPtr;
zPtr++;
while( zPtr < zEnd && zPtr[0] < 0xc0 && SyisSpace(zPtr[0]) && zPtr[0] != '\n' ){
zPtr++;
}
if( zPtr >= zEnd || zPtr[0] == '\n' ){
/* Closing delimiter found, break immediately */
pStream->zText = zCur; /* Keep the semi-colon */
break;
}
}else if( zPtr[0] == '\n' ){
/* Closing delimiter found, break immediately */
pStream->zText = zPtr; /* Synchronize with the stream cursor */
break;
}
/* Synchronize pointers and continue searching */
zIn = zPtr;
}
} /* For(;;) */
/* Get the delimited string length */
sStr.nByte = (sxu32)((const char *)zIn-sStr.zString);
/* Record token type and length */
pToken->nType = JX9_TK_NOWDOC;
SyStringDupPtr(&pToken->sData, &sStr);
/* Remove trailing white spaces */
SyStringRightTrim(&pToken->sData);
/* All done */
return SXRET_OK;
}
/*
* Tokenize a raw jx9 input.
* This is the public tokenizer called by most code generator routines.
*/
JX9_PRIVATE sxi32 jx9Tokenize(const char *zInput,sxu32 nLen,SySet *pOut)
{
SyLex sLexer;
sxi32 rc;
/* Initialize the lexer */
rc = SyLexInit(&sLexer, &(*pOut),jx9TokenizeInput,0);
if( rc != SXRET_OK ){
return rc;
}
/* Tokenize input */
rc = SyLexTokenizeInput(&sLexer, zInput, nLen, 0, 0, 0);
/* Release the lexer */
SyLexRelease(&sLexer);
/* Tokenization result */
return rc;
}
/*
* ----------------------------------------------------------
* File: jx9_lib.c
* MD5: a684fb6677b1ab0110d03536f1280c50
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: lib.c v5.1 Win7 2012-08-08 04:19 stable <chm@symisc.net> $ */
/*
* Symisc Run-Time API: A modern thread safe replacement of the standard libc
* Copyright (C) Symisc Systems 2007-2012, http://www.symisc.net/
*
* The Symisc Run-Time API is an independent project developed by symisc systems
* internally as a secure replacement of the standard libc.
* The library is re-entrant, thread-safe and platform independent.
*/
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
#if defined(__WINNT__)
#include <Windows.h>
#else
#include <stdlib.h>
#endif
#if defined(JX9_ENABLE_THREADS)
/* SyRunTimeApi: sxmutex.c */
#if defined(__WINNT__)
struct SyMutex
{
CRITICAL_SECTION sMutex;
sxu32 nType; /* Mutex type, one of SXMUTEX_TYPE_* */
};
/* Preallocated static mutex */
static SyMutex aStaticMutexes[] = {
{{0}, SXMUTEX_TYPE_STATIC_1},
{{0}, SXMUTEX_TYPE_STATIC_2},
{{0}, SXMUTEX_TYPE_STATIC_3},
{{0}, SXMUTEX_TYPE_STATIC_4},
{{0}, SXMUTEX_TYPE_STATIC_5},
{{0}, SXMUTEX_TYPE_STATIC_6}
};
static BOOL winMutexInit = FALSE;
static LONG winMutexLock = 0;
static sxi32 WinMutexGlobaInit(void)
{
LONG rc;
rc = InterlockedCompareExchange(&winMutexLock, 1, 0);
if ( rc == 0 ){
sxu32 n;
for( n = 0 ; n < SX_ARRAYSIZE(aStaticMutexes) ; ++n ){
InitializeCriticalSection(&aStaticMutexes[n].sMutex);
}
winMutexInit = TRUE;
}else{
/* Someone else is doing this for us */
while( winMutexInit == FALSE ){
Sleep(1);
}
}
return SXRET_OK;
}
static void WinMutexGlobalRelease(void)
{
LONG rc;
rc = InterlockedCompareExchange(&winMutexLock, 0, 1);
if( rc == 1 ){
/* The first to decrement to zero does the actual global release */
if( winMutexInit == TRUE ){
sxu32 n;
for( n = 0 ; n < SX_ARRAYSIZE(aStaticMutexes) ; ++n ){
DeleteCriticalSection(&aStaticMutexes[n].sMutex);
}
winMutexInit = FALSE;
}
}
}
static SyMutex * WinMutexNew(int nType)
{
SyMutex *pMutex = 0;
if( nType == SXMUTEX_TYPE_FAST || nType == SXMUTEX_TYPE_RECURSIVE ){
/* Allocate a new mutex */
pMutex = (SyMutex *)HeapAlloc(GetProcessHeap(), 0, sizeof(SyMutex));
if( pMutex == 0 ){
return 0;
}
InitializeCriticalSection(&pMutex->sMutex);
}else{
/* Use a pre-allocated static mutex */
if( nType > SXMUTEX_TYPE_STATIC_6 ){
nType = SXMUTEX_TYPE_STATIC_6;
}
pMutex = &aStaticMutexes[nType - 3];
}
pMutex->nType = nType;
return pMutex;
}
static void WinMutexRelease(SyMutex *pMutex)
{
if( pMutex->nType == SXMUTEX_TYPE_FAST || pMutex->nType == SXMUTEX_TYPE_RECURSIVE ){
DeleteCriticalSection(&pMutex->sMutex);
HeapFree(GetProcessHeap(), 0, pMutex);
}
}
static void WinMutexEnter(SyMutex *pMutex)
{
EnterCriticalSection(&pMutex->sMutex);
}
static sxi32 WinMutexTryEnter(SyMutex *pMutex)
{
#ifdef _WIN32_WINNT
BOOL rc;
/* Only WindowsNT platforms */
rc = TryEnterCriticalSection(&pMutex->sMutex);
if( rc ){
return SXRET_OK;
}else{
return SXERR_BUSY;
}
#else
return SXERR_NOTIMPLEMENTED;
#endif
}
static void WinMutexLeave(SyMutex *pMutex)
{
LeaveCriticalSection(&pMutex->sMutex);
}
/* Export Windows mutex interfaces */
static const SyMutexMethods sWinMutexMethods = {
WinMutexGlobaInit, /* xGlobalInit() */
WinMutexGlobalRelease, /* xGlobalRelease() */
WinMutexNew, /* xNew() */
WinMutexRelease, /* xRelease() */
WinMutexEnter, /* xEnter() */
WinMutexTryEnter, /* xTryEnter() */
WinMutexLeave /* xLeave() */
};
JX9_PRIVATE const SyMutexMethods * SyMutexExportMethods(void)
{
return &sWinMutexMethods;
}
#elif defined(__UNIXES__)
#include <pthread.h>
struct SyMutex
{
pthread_mutex_t sMutex;
sxu32 nType;
};
static SyMutex * UnixMutexNew(int nType)
{
static SyMutex aStaticMutexes[] = {
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_1},
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_2},
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_3},
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_4},
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_5},
{PTHREAD_MUTEX_INITIALIZER, SXMUTEX_TYPE_STATIC_6}
};
SyMutex *pMutex;
if( nType == SXMUTEX_TYPE_FAST || nType == SXMUTEX_TYPE_RECURSIVE ){
pthread_mutexattr_t sRecursiveAttr;
/* Allocate a new mutex */
pMutex = (SyMutex *)malloc(sizeof(SyMutex));
if( pMutex == 0 ){
return 0;
}
if( nType == SXMUTEX_TYPE_RECURSIVE ){
pthread_mutexattr_init(&sRecursiveAttr);
pthread_mutexattr_settype(&sRecursiveAttr, PTHREAD_MUTEX_RECURSIVE);
}
pthread_mutex_init(&pMutex->sMutex, nType == SXMUTEX_TYPE_RECURSIVE ? &sRecursiveAttr : 0 );
if( nType == SXMUTEX_TYPE_RECURSIVE ){
pthread_mutexattr_destroy(&sRecursiveAttr);
}
}else{
/* Use a pre-allocated static mutex */
if( nType > SXMUTEX_TYPE_STATIC_6 ){
nType = SXMUTEX_TYPE_STATIC_6;
}
pMutex = &aStaticMutexes[nType - 3];
}
pMutex->nType = nType;
return pMutex;
}
static void UnixMutexRelease(SyMutex *pMutex)
{
if( pMutex->nType == SXMUTEX_TYPE_FAST || pMutex->nType == SXMUTEX_TYPE_RECURSIVE ){
pthread_mutex_destroy(&pMutex->sMutex);
free(pMutex);
}
}
static void UnixMutexEnter(SyMutex *pMutex)
{
pthread_mutex_lock(&pMutex->sMutex);
}
static void UnixMutexLeave(SyMutex *pMutex)
{
pthread_mutex_unlock(&pMutex->sMutex);
}
/* Export pthread mutex interfaces */
static const SyMutexMethods sPthreadMutexMethods = {
0, /* xGlobalInit() */
0, /* xGlobalRelease() */
UnixMutexNew, /* xNew() */
UnixMutexRelease, /* xRelease() */
UnixMutexEnter, /* xEnter() */
0, /* xTryEnter() */
UnixMutexLeave /* xLeave() */
};
JX9_PRIVATE const SyMutexMethods * SyMutexExportMethods(void)
{
return &sPthreadMutexMethods;
}
#else
/* Host application must register their own mutex subsystem if the target
* platform is not an UNIX-like or windows systems.
*/
struct SyMutex
{
sxu32 nType;
};
static SyMutex * DummyMutexNew(int nType)
{
static SyMutex sMutex;
SXUNUSED(nType);
return &sMutex;
}
static void DummyMutexRelease(SyMutex *pMutex)
{
SXUNUSED(pMutex);
}
static void DummyMutexEnter(SyMutex *pMutex)
{
SXUNUSED(pMutex);
}
static void DummyMutexLeave(SyMutex *pMutex)
{
SXUNUSED(pMutex);
}
/* Export the dummy mutex interfaces */
static const SyMutexMethods sDummyMutexMethods = {
0, /* xGlobalInit() */
0, /* xGlobalRelease() */
DummyMutexNew, /* xNew() */
DummyMutexRelease, /* xRelease() */
DummyMutexEnter, /* xEnter() */
0, /* xTryEnter() */
DummyMutexLeave /* xLeave() */
};
JX9_PRIVATE const SyMutexMethods * SyMutexExportMethods(void)
{
return &sDummyMutexMethods;
}
#endif /* __WINNT__ */
#endif /* JX9_ENABLE_THREADS */
static void * SyOSHeapAlloc(sxu32 nByte)
{
void *pNew;
#if defined(__WINNT__)
pNew = HeapAlloc(GetProcessHeap(), 0, nByte);
#else
pNew = malloc((size_t)nByte);
#endif
return pNew;
}
static void * SyOSHeapRealloc(void *pOld, sxu32 nByte)
{
void *pNew;
#if defined(__WINNT__)
pNew = HeapReAlloc(GetProcessHeap(), 0, pOld, nByte);
#else
pNew = realloc(pOld, (size_t)nByte);
#endif
return pNew;
}
static void SyOSHeapFree(void *pPtr)
{
#if defined(__WINNT__)
HeapFree(GetProcessHeap(), 0, pPtr);
#else
free(pPtr);
#endif
}
/* SyRunTimeApi:sxstr.c */
JX9_PRIVATE sxu32 SyStrlen(const char *zSrc)
{
register const char *zIn = zSrc;
#if defined(UNTRUST)
if( zIn == 0 ){
return 0;
}
#endif
for(;;){
if( !zIn[0] ){ break; } zIn++;
if( !zIn[0] ){ break; } zIn++;
if( !zIn[0] ){ break; } zIn++;
if( !zIn[0] ){ break; } zIn++;
}
return (sxu32)(zIn - zSrc);
}
JX9_PRIVATE sxi32 SyByteFind(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos)
{
const char *zIn = zStr;
const char *zEnd;
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
if( zIn >= zEnd ){ break; }if( zIn[0] == c ){ if( pPos ){ *pPos = (sxu32)(zIn - zStr); } return SXRET_OK; } zIn++;
}
return SXERR_NOTFOUND;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyByteFind2(const char *zStr, sxu32 nLen, sxi32 c, sxu32 *pPos)
{
const char *zIn = zStr;
const char *zEnd;
zEnd = &zIn[nLen - 1];
for( ;; ){
if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos = (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos = (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos = (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
if( zEnd < zIn ){ break; } if( zEnd[0] == c ){ if( pPos ){ *pPos = (sxu32)(zEnd - zIn);} return SXRET_OK; } zEnd--;
}
return SXERR_NOTFOUND;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE sxi32 SyByteListFind(const char *zSrc, sxu32 nLen, const char *zList, sxu32 *pFirstPos)
{
const char *zIn = zSrc;
const char *zPtr;
const char *zEnd;
sxi32 c;
zEnd = &zSrc[nLen];
for(;;){
if( zIn >= zEnd ){ break; } for(zPtr = zList ; (c = zPtr[0]) != 0 ; zPtr++ ){ if( zIn[0] == c ){ if( pFirstPos ){ *pFirstPos = (sxu32)(zIn - zSrc); } return SXRET_OK; } } zIn++;
if( zIn >= zEnd ){ break; } for(zPtr = zList ; (c = zPtr[0]) != 0 ; zPtr++ ){ if( zIn[0] == c ){ if( pFirstPos ){ *pFirstPos = (sxu32)(zIn - zSrc); } return SXRET_OK; } } zIn++;
if( zIn >= zEnd ){ break; } for(zPtr = zList ; (c = zPtr[0]) != 0 ; zPtr++ ){ if( zIn[0] == c ){ if( pFirstPos ){ *pFirstPos = (sxu32)(zIn - zSrc); } return SXRET_OK; } } zIn++;
if( zIn >= zEnd ){ break; } for(zPtr = zList ; (c = zPtr[0]) != 0 ; zPtr++ ){ if( zIn[0] == c ){ if( pFirstPos ){ *pFirstPos = (sxu32)(zIn - zSrc); } return SXRET_OK; } } zIn++;
}
return SXERR_NOTFOUND;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyStrncmp(const char *zLeft, const char *zRight, sxu32 nLen)
{
const unsigned char *zP = (const unsigned char *)zLeft;
const unsigned char *zQ = (const unsigned char *)zRight;
if( SX_EMPTY_STR(zP) || SX_EMPTY_STR(zQ) ){
return SX_EMPTY_STR(zP) ? (SX_EMPTY_STR(zQ) ? 0 : -1) :1;
}
if( nLen <= 0 ){
return 0;
}
for(;;){
if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
if( nLen <= 0 ){ return 0; } if( zP[0] == 0 || zQ[0] == 0 || zP[0] != zQ[0] ){ break; } zP++; zQ++; nLen--;
}
return (sxi32)(zP[0] - zQ[0]);
}
#endif
JX9_PRIVATE sxi32 SyStrnicmp(const char *zLeft, const char *zRight, sxu32 SLen)
{
register unsigned char *p = (unsigned char *)zLeft;
register unsigned char *q = (unsigned char *)zRight;
if( SX_EMPTY_STR(p) || SX_EMPTY_STR(q) ){
return SX_EMPTY_STR(p)? SX_EMPTY_STR(q) ? 0 : -1 :1;
}
for(;;){
if( !SLen ){ return 0; }if( !*p || !*q || SyCharToLower(*p) != SyCharToLower(*q) ){ break; }p++;q++;--SLen;
if( !SLen ){ return 0; }if( !*p || !*q || SyCharToLower(*p) != SyCharToLower(*q) ){ break; }p++;q++;--SLen;
if( !SLen ){ return 0; }if( !*p || !*q || SyCharToLower(*p) != SyCharToLower(*q) ){ break; }p++;q++;--SLen;
if( !SLen ){ return 0; }if( !*p || !*q || SyCharToLower(*p) != SyCharToLower(*q) ){ break; }p++;q++;--SLen;
}
return (sxi32)(SyCharToLower(p[0]) - SyCharToLower(q[0]));
}
JX9_PRIVATE sxu32 Systrcpy(char *zDest, sxu32 nDestLen, const char *zSrc, sxu32 nLen)
{
unsigned char *zBuf = (unsigned char *)zDest;
unsigned char *zIn = (unsigned char *)zSrc;
unsigned char *zEnd;
#if defined(UNTRUST)
if( zSrc == (const char *)zDest ){
return 0;
}
#endif
if( nLen <= 0 ){
nLen = SyStrlen(zSrc);
}
zEnd = &zBuf[nDestLen - 1]; /* reserve a room for the null terminator */
for(;;){
if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
if( zBuf >= zEnd || nLen == 0 ){ break;} zBuf[0] = zIn[0]; zIn++; zBuf++; nLen--;
}
zBuf[0] = 0;
return (sxu32)(zBuf-(unsigned char *)zDest);
}
/* SyRunTimeApi:sxmem.c */
JX9_PRIVATE void SyZero(void *pSrc, sxu32 nSize)
{
register unsigned char *zSrc = (unsigned char *)pSrc;
unsigned char *zEnd;
#if defined(UNTRUST)
if( zSrc == 0 || nSize <= 0 ){
return ;
}
#endif
zEnd = &zSrc[nSize];
for(;;){
if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
if( zSrc >= zEnd ){break;} zSrc[0] = 0; zSrc++;
}
}
JX9_PRIVATE sxi32 SyMemcmp(const void *pB1, const void *pB2, sxu32 nSize)
{
sxi32 rc;
if( nSize <= 0 ){
return 0;
}
if( pB1 == 0 || pB2 == 0 ){
return pB1 != 0 ? 1 : (pB2 == 0 ? 0 : -1);
}
SX_MACRO_FAST_CMP(pB1, pB2, nSize, rc);
return rc;
}
JX9_PRIVATE sxu32 SyMemcpy(const void *pSrc, void *pDest, sxu32 nLen)
{
if( pSrc == 0 || pDest == 0 ){
return 0;
}
if( pSrc == (const void *)pDest ){
return nLen;
}
SX_MACRO_FAST_MEMCPY(pSrc, pDest, nLen);
return nLen;
}
static void * MemOSAlloc(sxu32 nBytes)
{
sxu32 *pChunk;
pChunk = (sxu32 *)SyOSHeapAlloc(nBytes + sizeof(sxu32));
if( pChunk == 0 ){
return 0;
}
pChunk[0] = nBytes;
return (void *)&pChunk[1];
}
static void * MemOSRealloc(void *pOld, sxu32 nBytes)
{
sxu32 *pOldChunk;
sxu32 *pChunk;
pOldChunk = (sxu32 *)(((char *)pOld)-sizeof(sxu32));
if( pOldChunk[0] >= nBytes ){
return pOld;
}
pChunk = (sxu32 *)SyOSHeapRealloc(pOldChunk, nBytes + sizeof(sxu32));
if( pChunk == 0 ){
return 0;
}
pChunk[0] = nBytes;
return (void *)&pChunk[1];
}
static void MemOSFree(void *pBlock)
{
void *pChunk;
pChunk = (void *)(((char *)pBlock)-sizeof(sxu32));
SyOSHeapFree(pChunk);
}
static sxu32 MemOSChunkSize(void *pBlock)
{
sxu32 *pChunk;
pChunk = (sxu32 *)(((char *)pBlock)-sizeof(sxu32));
return pChunk[0];
}
/* Export OS allocation methods */
static const SyMemMethods sOSAllocMethods = {
MemOSAlloc,
MemOSRealloc,
MemOSFree,
MemOSChunkSize,
0,
0,
0
};
static void * MemBackendAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
SyMemBlock *pBlock;
sxi32 nRetry = 0;
/* Append an extra block so we can tracks allocated chunks and avoid memory
* leaks.
*/
nByte += sizeof(SyMemBlock);
for(;;){
pBlock = (SyMemBlock *)pBackend->pMethods->xAlloc(nByte);
if( pBlock != 0 || pBackend->xMemError == 0 || nRetry > SXMEM_BACKEND_RETRY
|| SXERR_RETRY != pBackend->xMemError(pBackend->pUserData) ){
break;
}
nRetry++;
}
if( pBlock == 0 ){
return 0;
}
pBlock->pNext = pBlock->pPrev = 0;
/* Link to the list of already tracked blocks */
MACRO_LD_PUSH(pBackend->pBlocks, pBlock);
#if defined(UNTRUST)
pBlock->nGuard = SXMEM_BACKEND_MAGIC;
#endif
pBackend->nBlock++;
return (void *)&pBlock[1];
}
JX9_PRIVATE void * SyMemBackendAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
void *pChunk;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return 0;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
pChunk = MemBackendAlloc(&(*pBackend), nByte);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return pChunk;
}
static void * MemBackendRealloc(SyMemBackend *pBackend, void * pOld, sxu32 nByte)
{
SyMemBlock *pBlock, *pNew, *pPrev, *pNext;
sxu32 nRetry = 0;
if( pOld == 0 ){
return MemBackendAlloc(&(*pBackend), nByte);
}
pBlock = (SyMemBlock *)(((char *)pOld) - sizeof(SyMemBlock));
#if defined(UNTRUST)
if( pBlock->nGuard != SXMEM_BACKEND_MAGIC ){
return 0;
}
#endif
nByte += sizeof(SyMemBlock);
pPrev = pBlock->pPrev;
pNext = pBlock->pNext;
for(;;){
pNew = (SyMemBlock *)pBackend->pMethods->xRealloc(pBlock, nByte);
if( pNew != 0 || pBackend->xMemError == 0 || nRetry > SXMEM_BACKEND_RETRY ||
SXERR_RETRY != pBackend->xMemError(pBackend->pUserData) ){
break;
}
nRetry++;
}
if( pNew == 0 ){
return 0;
}
if( pNew != pBlock ){
if( pPrev == 0 ){
pBackend->pBlocks = pNew;
}else{
pPrev->pNext = pNew;
}
if( pNext ){
pNext->pPrev = pNew;
}
#if defined(UNTRUST)
pNew->nGuard = SXMEM_BACKEND_MAGIC;
#endif
}
return (void *)&pNew[1];
}
JX9_PRIVATE void * SyMemBackendRealloc(SyMemBackend *pBackend, void * pOld, sxu32 nByte)
{
void *pChunk;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return 0;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
pChunk = MemBackendRealloc(&(*pBackend), pOld, nByte);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return pChunk;
}
static sxi32 MemBackendFree(SyMemBackend *pBackend, void * pChunk)
{
SyMemBlock *pBlock;
pBlock = (SyMemBlock *)(((char *)pChunk) - sizeof(SyMemBlock));
#if defined(UNTRUST)
if( pBlock->nGuard != SXMEM_BACKEND_MAGIC ){
return SXERR_CORRUPT;
}
#endif
/* Unlink from the list of active blocks */
if( pBackend->nBlock > 0 ){
/* Release the block */
#if defined(UNTRUST)
/* Mark as stale block */
pBlock->nGuard = 0x635B;
#endif
MACRO_LD_REMOVE(pBackend->pBlocks, pBlock);
pBackend->nBlock--;
pBackend->pMethods->xFree(pBlock);
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendFree(SyMemBackend *pBackend, void * pChunk)
{
sxi32 rc;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return SXERR_CORRUPT;
}
#endif
if( pChunk == 0 ){
return SXRET_OK;
}
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
rc = MemBackendFree(&(*pBackend), pChunk);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return rc;
}
#if defined(JX9_ENABLE_THREADS)
JX9_PRIVATE sxi32 SyMemBackendMakeThreadSafe(SyMemBackend *pBackend, const SyMutexMethods *pMethods)
{
SyMutex *pMutex;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) || pMethods == 0 || pMethods->xNew == 0){
return SXERR_CORRUPT;
}
#endif
pMutex = pMethods->xNew(SXMUTEX_TYPE_FAST);
if( pMutex == 0 ){
return SXERR_OS;
}
/* Attach the mutex to the memory backend */
pBackend->pMutex = pMutex;
pBackend->pMutexMethods = pMethods;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendDisbaleMutexing(SyMemBackend *pBackend)
{
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return SXERR_CORRUPT;
}
#endif
if( pBackend->pMutex == 0 ){
/* There is no mutex subsystem at all */
return SXRET_OK;
}
SyMutexRelease(pBackend->pMutexMethods, pBackend->pMutex);
pBackend->pMutexMethods = 0;
pBackend->pMutex = 0;
return SXRET_OK;
}
#endif
/*
* Memory pool allocator
*/
#define SXMEM_POOL_MAGIC 0xDEAD
#define SXMEM_POOL_MAXALLOC (1<<(SXMEM_POOL_NBUCKETS+SXMEM_POOL_INCR))
#define SXMEM_POOL_MINALLOC (1<<(SXMEM_POOL_INCR))
static sxi32 MemPoolBucketAlloc(SyMemBackend *pBackend, sxu32 nBucket)
{
char *zBucket, *zBucketEnd;
SyMemHeader *pHeader;
sxu32 nBucketSize;
/* Allocate one big block first */
zBucket = (char *)MemBackendAlloc(&(*pBackend), SXMEM_POOL_MAXALLOC);
if( zBucket == 0 ){
return SXERR_MEM;
}
zBucketEnd = &zBucket[SXMEM_POOL_MAXALLOC];
/* Divide the big block into mini bucket pool */
nBucketSize = 1 << (nBucket + SXMEM_POOL_INCR);
pBackend->apPool[nBucket] = pHeader = (SyMemHeader *)zBucket;
for(;;){
if( &zBucket[nBucketSize] >= zBucketEnd ){
break;
}
pHeader->pNext = (SyMemHeader *)&zBucket[nBucketSize];
/* Advance the cursor to the next available chunk */
pHeader = pHeader->pNext;
zBucket += nBucketSize;
}
pHeader->pNext = 0;
return SXRET_OK;
}
static void * MemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
SyMemHeader *pBucket, *pNext;
sxu32 nBucketSize;
sxu32 nBucket;
if( nByte + sizeof(SyMemHeader) >= SXMEM_POOL_MAXALLOC ){
/* Allocate a big chunk directly */
pBucket = (SyMemHeader *)MemBackendAlloc(&(*pBackend), nByte+sizeof(SyMemHeader));
if( pBucket == 0 ){
return 0;
}
/* Record as big block */
pBucket->nBucket = (sxu32)(SXMEM_POOL_MAGIC << 16) | SXU16_HIGH;
return (void *)(pBucket+1);
}
/* Locate the appropriate bucket */
nBucket = 0;
nBucketSize = SXMEM_POOL_MINALLOC;
while( nByte + sizeof(SyMemHeader) > nBucketSize ){
nBucketSize <<= 1;
nBucket++;
}
pBucket = pBackend->apPool[nBucket];
if( pBucket == 0 ){
sxi32 rc;
rc = MemPoolBucketAlloc(&(*pBackend), nBucket);
if( rc != SXRET_OK ){
return 0;
}
pBucket = pBackend->apPool[nBucket];
}
/* Remove from the free list */
pNext = pBucket->pNext;
pBackend->apPool[nBucket] = pNext;
/* Record bucket&magic number */
pBucket->nBucket = (SXMEM_POOL_MAGIC << 16) | nBucket;
return (void *)&pBucket[1];
}
JX9_PRIVATE void * SyMemBackendPoolAlloc(SyMemBackend *pBackend, sxu32 nByte)
{
void *pChunk;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return 0;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
pChunk = MemBackendPoolAlloc(&(*pBackend), nByte);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return pChunk;
}
static sxi32 MemBackendPoolFree(SyMemBackend *pBackend, void * pChunk)
{
SyMemHeader *pHeader;
sxu32 nBucket;
/* Get the corresponding bucket */
pHeader = (SyMemHeader *)(((char *)pChunk) - sizeof(SyMemHeader));
/* Sanity check to avoid misuse */
if( (pHeader->nBucket >> 16) != SXMEM_POOL_MAGIC ){
return SXERR_CORRUPT;
}
nBucket = pHeader->nBucket & 0xFFFF;
if( nBucket == SXU16_HIGH ){
/* Free the big block */
MemBackendFree(&(*pBackend), pHeader);
}else{
/* Return to the free list */
pHeader->pNext = pBackend->apPool[nBucket & 0x0f];
pBackend->apPool[nBucket & 0x0f] = pHeader;
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendPoolFree(SyMemBackend *pBackend, void * pChunk)
{
sxi32 rc;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) || pChunk == 0 ){
return SXERR_CORRUPT;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
rc = MemBackendPoolFree(&(*pBackend), pChunk);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return rc;
}
#if 0
static void * MemBackendPoolRealloc(SyMemBackend *pBackend, void * pOld, sxu32 nByte)
{
sxu32 nBucket, nBucketSize;
SyMemHeader *pHeader;
void * pNew;
if( pOld == 0 ){
/* Allocate a new pool */
pNew = MemBackendPoolAlloc(&(*pBackend), nByte);
return pNew;
}
/* Get the corresponding bucket */
pHeader = (SyMemHeader *)(((char *)pOld) - sizeof(SyMemHeader));
/* Sanity check to avoid misuse */
if( (pHeader->nBucket >> 16) != SXMEM_POOL_MAGIC ){
return 0;
}
nBucket = pHeader->nBucket & 0xFFFF;
if( nBucket == SXU16_HIGH ){
/* Big block */
return MemBackendRealloc(&(*pBackend), pHeader, nByte);
}
nBucketSize = 1 << (nBucket + SXMEM_POOL_INCR);
if( nBucketSize >= nByte + sizeof(SyMemHeader) ){
/* The old bucket can honor the requested size */
return pOld;
}
/* Allocate a new pool */
pNew = MemBackendPoolAlloc(&(*pBackend), nByte);
if( pNew == 0 ){
return 0;
}
/* Copy the old data into the new block */
SyMemcpy(pOld, pNew, nBucketSize);
/* Free the stale block */
MemBackendPoolFree(&(*pBackend), pOld);
return pNew;
}
JX9_PRIVATE void * SyMemBackendPoolRealloc(SyMemBackend *pBackend, void * pOld, sxu32 nByte)
{
void *pChunk;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return 0;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
pChunk = MemBackendPoolRealloc(&(*pBackend), pOld, nByte);
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
}
return pChunk;
}
#endif
JX9_PRIVATE sxi32 SyMemBackendInit(SyMemBackend *pBackend, ProcMemError xMemErr, void * pUserData)
{
#if defined(UNTRUST)
if( pBackend == 0 ){
return SXERR_EMPTY;
}
#endif
/* Zero the allocator first */
SyZero(&(*pBackend), sizeof(SyMemBackend));
pBackend->xMemError = xMemErr;
pBackend->pUserData = pUserData;
/* Switch to the OS memory allocator */
pBackend->pMethods = &sOSAllocMethods;
if( pBackend->pMethods->xInit ){
/* Initialize the backend */
if( SXRET_OK != pBackend->pMethods->xInit(pBackend->pMethods->pUserData) ){
return SXERR_ABORT;
}
}
#if defined(UNTRUST)
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
#endif
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendInitFromOthers(SyMemBackend *pBackend, const SyMemMethods *pMethods, ProcMemError xMemErr, void * pUserData)
{
#if defined(UNTRUST)
if( pBackend == 0 || pMethods == 0){
return SXERR_EMPTY;
}
#endif
if( pMethods->xAlloc == 0 || pMethods->xRealloc == 0 || pMethods->xFree == 0 || pMethods->xChunkSize == 0 ){
/* mandatory methods are missing */
return SXERR_INVALID;
}
/* Zero the allocator first */
SyZero(&(*pBackend), sizeof(SyMemBackend));
pBackend->xMemError = xMemErr;
pBackend->pUserData = pUserData;
/* Switch to the host application memory allocator */
pBackend->pMethods = pMethods;
if( pBackend->pMethods->xInit ){
/* Initialize the backend */
if( SXRET_OK != pBackend->pMethods->xInit(pBackend->pMethods->pUserData) ){
return SXERR_ABORT;
}
}
#if defined(UNTRUST)
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
#endif
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendInitFromParent(SyMemBackend *pBackend,const SyMemBackend *pParent)
{
sxu8 bInheritMutex;
#if defined(UNTRUST)
if( pBackend == 0 || SXMEM_BACKEND_CORRUPT(pParent) ){
return SXERR_CORRUPT;
}
#endif
/* Zero the allocator first */
SyZero(&(*pBackend), sizeof(SyMemBackend));
pBackend->pMethods = pParent->pMethods;
pBackend->xMemError = pParent->xMemError;
pBackend->pUserData = pParent->pUserData;
bInheritMutex = pParent->pMutexMethods ? TRUE : FALSE;
if( bInheritMutex ){
pBackend->pMutexMethods = pParent->pMutexMethods;
/* Create a private mutex */
pBackend->pMutex = pBackend->pMutexMethods->xNew(SXMUTEX_TYPE_FAST);
if( pBackend->pMutex == 0){
return SXERR_OS;
}
}
#if defined(UNTRUST)
pBackend->nMagic = SXMEM_BACKEND_MAGIC;
#endif
return SXRET_OK;
}
static sxi32 MemBackendRelease(SyMemBackend *pBackend)
{
SyMemBlock *pBlock, *pNext;
pBlock = pBackend->pBlocks;
for(;;){
if( pBackend->nBlock == 0 ){
break;
}
pNext = pBlock->pNext;
pBackend->pMethods->xFree(pBlock);
pBlock = pNext;
pBackend->nBlock--;
/* LOOP ONE */
if( pBackend->nBlock == 0 ){
break;
}
pNext = pBlock->pNext;
pBackend->pMethods->xFree(pBlock);
pBlock = pNext;
pBackend->nBlock--;
/* LOOP TWO */
if( pBackend->nBlock == 0 ){
break;
}
pNext = pBlock->pNext;
pBackend->pMethods->xFree(pBlock);
pBlock = pNext;
pBackend->nBlock--;
/* LOOP THREE */
if( pBackend->nBlock == 0 ){
break;
}
pNext = pBlock->pNext;
pBackend->pMethods->xFree(pBlock);
pBlock = pNext;
pBackend->nBlock--;
/* LOOP FOUR */
}
if( pBackend->pMethods->xRelease ){
pBackend->pMethods->xRelease(pBackend->pMethods->pUserData);
}
pBackend->pMethods = 0;
pBackend->pBlocks = 0;
#if defined(UNTRUST)
pBackend->nMagic = 0x2626;
#endif
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMemBackendRelease(SyMemBackend *pBackend)
{
sxi32 rc;
#if defined(UNTRUST)
if( SXMEM_BACKEND_CORRUPT(pBackend) ){
return SXERR_INVALID;
}
#endif
if( pBackend->pMutexMethods ){
SyMutexEnter(pBackend->pMutexMethods, pBackend->pMutex);
}
rc = MemBackendRelease(&(*pBackend));
if( pBackend->pMutexMethods ){
SyMutexLeave(pBackend->pMutexMethods, pBackend->pMutex);
SyMutexRelease(pBackend->pMutexMethods, pBackend->pMutex);
}
return rc;
}
JX9_PRIVATE void * SyMemBackendDup(SyMemBackend *pBackend, const void *pSrc, sxu32 nSize)
{
void *pNew;
#if defined(UNTRUST)
if( pSrc == 0 || nSize <= 0 ){
return 0;
}
#endif
pNew = SyMemBackendAlloc(&(*pBackend), nSize);
if( pNew ){
SyMemcpy(pSrc, pNew, nSize);
}
return pNew;
}
JX9_PRIVATE char * SyMemBackendStrDup(SyMemBackend *pBackend, const char *zSrc, sxu32 nSize)
{
char *zDest;
zDest = (char *)SyMemBackendAlloc(&(*pBackend), nSize + 1);
if( zDest ){
Systrcpy(zDest, nSize+1, zSrc, nSize);
}
return zDest;
}
JX9_PRIVATE sxi32 SyBlobInitFromBuf(SyBlob *pBlob, void *pBuffer, sxu32 nSize)
{
#if defined(UNTRUST)
if( pBlob == 0 || pBuffer == 0 || nSize < 1 ){
return SXERR_EMPTY;
}
#endif
pBlob->pBlob = pBuffer;
pBlob->mByte = nSize;
pBlob->nByte = 0;
pBlob->pAllocator = 0;
pBlob->nFlags = SXBLOB_LOCKED|SXBLOB_STATIC;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobInit(SyBlob *pBlob, SyMemBackend *pAllocator)
{
#if defined(UNTRUST)
if( pBlob == 0 ){
return SXERR_EMPTY;
}
#endif
pBlob->pBlob = 0;
pBlob->mByte = pBlob->nByte = 0;
pBlob->pAllocator = &(*pAllocator);
pBlob->nFlags = 0;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobReadOnly(SyBlob *pBlob, const void *pData, sxu32 nByte)
{
#if defined(UNTRUST)
if( pBlob == 0 ){
return SXERR_EMPTY;
}
#endif
pBlob->pBlob = (void *)pData;
pBlob->nByte = nByte;
pBlob->mByte = 0;
pBlob->nFlags |= SXBLOB_RDONLY;
return SXRET_OK;
}
#ifndef SXBLOB_MIN_GROWTH
#define SXBLOB_MIN_GROWTH 16
#endif
static sxi32 BlobPrepareGrow(SyBlob *pBlob, sxu32 *pByte)
{
sxu32 nByte;
void *pNew;
nByte = *pByte;
if( pBlob->nFlags & (SXBLOB_LOCKED|SXBLOB_STATIC) ){
if ( SyBlobFreeSpace(pBlob) < nByte ){
*pByte = SyBlobFreeSpace(pBlob);
if( (*pByte) == 0 ){
return SXERR_SHORT;
}
}
return SXRET_OK;
}
if( pBlob->nFlags & SXBLOB_RDONLY ){
/* Make a copy of the read-only item */
if( pBlob->nByte > 0 ){
pNew = SyMemBackendDup(pBlob->pAllocator, pBlob->pBlob, pBlob->nByte);
if( pNew == 0 ){
return SXERR_MEM;
}
pBlob->pBlob = pNew;
pBlob->mByte = pBlob->nByte;
}else{
pBlob->pBlob = 0;
pBlob->mByte = 0;
}
/* Remove the read-only flag */
pBlob->nFlags &= ~SXBLOB_RDONLY;
}
if( SyBlobFreeSpace(pBlob) >= nByte ){
return SXRET_OK;
}
if( pBlob->mByte > 0 ){
nByte = nByte + pBlob->mByte * 2 + SXBLOB_MIN_GROWTH;
}else if ( nByte < SXBLOB_MIN_GROWTH ){
nByte = SXBLOB_MIN_GROWTH;
}
pNew = SyMemBackendRealloc(pBlob->pAllocator, pBlob->pBlob, nByte);
if( pNew == 0 ){
return SXERR_MEM;
}
pBlob->pBlob = pNew;
pBlob->mByte = nByte;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobAppend(SyBlob *pBlob, const void *pData, sxu32 nSize)
{
sxu8 *zBlob;
sxi32 rc;
if( nSize < 1 ){
return SXRET_OK;
}
rc = BlobPrepareGrow(&(*pBlob), &nSize);
if( SXRET_OK != rc ){
return rc;
}
if( pData ){
zBlob = (sxu8 *)pBlob->pBlob ;
zBlob = &zBlob[pBlob->nByte];
pBlob->nByte += nSize;
SX_MACRO_FAST_MEMCPY(pData, zBlob, nSize);
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobNullAppend(SyBlob *pBlob)
{
sxi32 rc;
sxu32 n;
n = pBlob->nByte;
rc = SyBlobAppend(&(*pBlob), (const void *)"\0", sizeof(char));
if (rc == SXRET_OK ){
pBlob->nByte = n;
}
return rc;
}
JX9_PRIVATE sxi32 SyBlobDup(SyBlob *pSrc, SyBlob *pDest)
{
sxi32 rc = SXRET_OK;
if( pSrc->nByte > 0 ){
rc = SyBlobAppend(&(*pDest), pSrc->pBlob, pSrc->nByte);
}
return rc;
}
JX9_PRIVATE sxi32 SyBlobReset(SyBlob *pBlob)
{
pBlob->nByte = 0;
if( pBlob->nFlags & SXBLOB_RDONLY ){
/* Read-only (Not malloced chunk) */
pBlob->pBlob = 0;
pBlob->mByte = 0;
pBlob->nFlags &= ~SXBLOB_RDONLY;
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobTruncate(SyBlob *pBlob,sxu32 nNewLen)
{
if( nNewLen < pBlob->nByte ){
pBlob->nByte = nNewLen;
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBlobRelease(SyBlob *pBlob)
{
if( (pBlob->nFlags & (SXBLOB_STATIC|SXBLOB_RDONLY)) == 0 && pBlob->mByte > 0 ){
SyMemBackendFree(pBlob->pAllocator, pBlob->pBlob);
}
pBlob->pBlob = 0;
pBlob->nByte = pBlob->mByte = 0;
pBlob->nFlags = 0;
return SXRET_OK;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBlobSearch(const void *pBlob, sxu32 nLen, const void *pPattern, sxu32 pLen, sxu32 *pOfft)
{
const char *zIn = (const char *)pBlob;
const char *zEnd;
sxi32 rc;
if( pLen > nLen ){
return SXERR_NOTFOUND;
}
zEnd = &zIn[nLen-pLen];
for(;;){
if( zIn > zEnd ){break;} SX_MACRO_FAST_CMP(zIn, pPattern, pLen, rc); if( rc == 0 ){ if( pOfft ){ *pOfft = (sxu32)(zIn - (const char *)pBlob);} return SXRET_OK; } zIn++;
if( zIn > zEnd ){break;} SX_MACRO_FAST_CMP(zIn, pPattern, pLen, rc); if( rc == 0 ){ if( pOfft ){ *pOfft = (sxu32)(zIn - (const char *)pBlob);} return SXRET_OK; } zIn++;
if( zIn > zEnd ){break;} SX_MACRO_FAST_CMP(zIn, pPattern, pLen, rc); if( rc == 0 ){ if( pOfft ){ *pOfft = (sxu32)(zIn - (const char *)pBlob);} return SXRET_OK; } zIn++;
if( zIn > zEnd ){break;} SX_MACRO_FAST_CMP(zIn, pPattern, pLen, rc); if( rc == 0 ){ if( pOfft ){ *pOfft = (sxu32)(zIn - (const char *)pBlob);} return SXRET_OK; } zIn++;
}
return SXERR_NOTFOUND;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/* SyRunTimeApi:sxds.c */
JX9_PRIVATE sxi32 SySetInit(SySet *pSet, SyMemBackend *pAllocator, sxu32 ElemSize)
{
pSet->nSize = 0 ;
pSet->nUsed = 0;
pSet->nCursor = 0;
pSet->eSize = ElemSize;
pSet->pAllocator = pAllocator;
pSet->pBase = 0;
pSet->pUserData = 0;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetPut(SySet *pSet, const void *pItem)
{
unsigned char *zbase;
if( pSet->nUsed >= pSet->nSize ){
void *pNew;
if( pSet->pAllocator == 0 ){
return SXERR_LOCKED;
}
if( pSet->nSize <= 0 ){
pSet->nSize = 4;
}
pNew = SyMemBackendRealloc(pSet->pAllocator, pSet->pBase, pSet->eSize * pSet->nSize * 2);
if( pNew == 0 ){
return SXERR_MEM;
}
pSet->pBase = pNew;
pSet->nSize <<= 1;
}
zbase = (unsigned char *)pSet->pBase;
SX_MACRO_FAST_MEMCPY(pItem, &zbase[pSet->nUsed * pSet->eSize], pSet->eSize);
pSet->nUsed++;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetAlloc(SySet *pSet, sxi32 nItem)
{
if( pSet->nSize > 0 ){
return SXERR_LOCKED;
}
if( nItem < 8 ){
nItem = 8;
}
pSet->pBase = SyMemBackendAlloc(pSet->pAllocator, pSet->eSize * nItem);
if( pSet->pBase == 0 ){
return SXERR_MEM;
}
pSet->nSize = nItem;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetReset(SySet *pSet)
{
pSet->nUsed = 0;
pSet->nCursor = 0;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetResetCursor(SySet *pSet)
{
pSet->nCursor = 0;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetGetNextEntry(SySet *pSet, void **ppEntry)
{
register unsigned char *zSrc;
if( pSet->nCursor >= pSet->nUsed ){
/* Reset cursor */
pSet->nCursor = 0;
return SXERR_EOF;
}
zSrc = (unsigned char *)SySetBasePtr(pSet);
if( ppEntry ){
*ppEntry = (void *)&zSrc[pSet->nCursor * pSet->eSize];
}
pSet->nCursor++;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SySetRelease(SySet *pSet)
{
sxi32 rc = SXRET_OK;
if( pSet->pAllocator && pSet->pBase ){
rc = SyMemBackendFree(pSet->pAllocator, pSet->pBase);
}
pSet->pBase = 0;
pSet->nUsed = 0;
pSet->nCursor = 0;
return rc;
}
JX9_PRIVATE void * SySetPeek(SySet *pSet)
{
const char *zBase;
if( pSet->nUsed <= 0 ){
return 0;
}
zBase = (const char *)pSet->pBase;
return (void *)&zBase[(pSet->nUsed - 1) * pSet->eSize];
}
JX9_PRIVATE void * SySetPop(SySet *pSet)
{
const char *zBase;
void *pData;
if( pSet->nUsed <= 0 ){
return 0;
}
zBase = (const char *)pSet->pBase;
pSet->nUsed--;
pData = (void *)&zBase[pSet->nUsed * pSet->eSize];
return pData;
}
JX9_PRIVATE void * SySetAt(SySet *pSet, sxu32 nIdx)
{
const char *zBase;
if( nIdx >= pSet->nUsed ){
/* Out of range */
return 0;
}
zBase = (const char *)pSet->pBase;
return (void *)&zBase[nIdx * pSet->eSize];
}
/* Private hash entry */
struct SyHashEntry_Pr
{
const void *pKey; /* Hash key */
sxu32 nKeyLen; /* Key length */
void *pUserData; /* User private data */
/* Private fields */
sxu32 nHash;
SyHash *pHash;
SyHashEntry_Pr *pNext, *pPrev; /* Next and previous entry in the list */
SyHashEntry_Pr *pNextCollide, *pPrevCollide; /* Collision list */
};
#define INVALID_HASH(H) ((H)->apBucket == 0)
JX9_PRIVATE sxi32 SyHashInit(SyHash *pHash, SyMemBackend *pAllocator, ProcHash xHash, ProcCmp xCmp)
{
SyHashEntry_Pr **apNew;
#if defined(UNTRUST)
if( pHash == 0 ){
return SXERR_EMPTY;
}
#endif
/* Allocate a new table */
apNew = (SyHashEntry_Pr **)SyMemBackendAlloc(&(*pAllocator), sizeof(SyHashEntry_Pr *) * SXHASH_BUCKET_SIZE);
if( apNew == 0 ){
return SXERR_MEM;
}
SyZero((void *)apNew, sizeof(SyHashEntry_Pr *) * SXHASH_BUCKET_SIZE);
pHash->pAllocator = &(*pAllocator);
pHash->xHash = xHash ? xHash : SyBinHash;
pHash->xCmp = xCmp ? xCmp : SyMemcmp;
pHash->pCurrent = pHash->pList = 0;
pHash->nEntry = 0;
pHash->apBucket = apNew;
pHash->nBucketSize = SXHASH_BUCKET_SIZE;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyHashRelease(SyHash *pHash)
{
SyHashEntry_Pr *pEntry, *pNext;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) ){
return SXERR_EMPTY;
}
#endif
pEntry = pHash->pList;
for(;;){
if( pHash->nEntry == 0 ){
break;
}
pNext = pEntry->pNext;
SyMemBackendPoolFree(pHash->pAllocator, pEntry);
pEntry = pNext;
pHash->nEntry--;
}
if( pHash->apBucket ){
SyMemBackendFree(pHash->pAllocator, (void *)pHash->apBucket);
}
pHash->apBucket = 0;
pHash->nBucketSize = 0;
pHash->pAllocator = 0;
return SXRET_OK;
}
static SyHashEntry_Pr * HashGetEntry(SyHash *pHash, const void *pKey, sxu32 nKeyLen)
{
SyHashEntry_Pr *pEntry;
sxu32 nHash;
nHash = pHash->xHash(pKey, nKeyLen);
pEntry = pHash->apBucket[nHash & (pHash->nBucketSize - 1)];
for(;;){
if( pEntry == 0 ){
break;
}
if( pEntry->nHash == nHash && pEntry->nKeyLen == nKeyLen &&
pHash->xCmp(pEntry->pKey, pKey, nKeyLen) == 0 ){
return pEntry;
}
pEntry = pEntry->pNextCollide;
}
/* Entry not found */
return 0;
}
JX9_PRIVATE SyHashEntry * SyHashGet(SyHash *pHash, const void *pKey, sxu32 nKeyLen)
{
SyHashEntry_Pr *pEntry;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) ){
return 0;
}
#endif
if( pHash->nEntry < 1 || nKeyLen < 1 ){
/* Don't bother hashing, return immediately */
return 0;
}
pEntry = HashGetEntry(&(*pHash), pKey, nKeyLen);
if( pEntry == 0 ){
return 0;
}
return (SyHashEntry *)pEntry;
}
static sxi32 HashDeleteEntry(SyHash *pHash, SyHashEntry_Pr *pEntry, void **ppUserData)
{
sxi32 rc;
if( pEntry->pPrevCollide == 0 ){
pHash->apBucket[pEntry->nHash & (pHash->nBucketSize - 1)] = pEntry->pNextCollide;
}else{
pEntry->pPrevCollide->pNextCollide = pEntry->pNextCollide;
}
if( pEntry->pNextCollide ){
pEntry->pNextCollide->pPrevCollide = pEntry->pPrevCollide;
}
MACRO_LD_REMOVE(pHash->pList, pEntry);
pHash->nEntry--;
if( ppUserData ){
/* Write a pointer to the user data */
*ppUserData = pEntry->pUserData;
}
/* Release the entry */
rc = SyMemBackendPoolFree(pHash->pAllocator, pEntry);
return rc;
}
JX9_PRIVATE sxi32 SyHashDeleteEntry(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void **ppUserData)
{
SyHashEntry_Pr *pEntry;
sxi32 rc;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) ){
return SXERR_CORRUPT;
}
#endif
pEntry = HashGetEntry(&(*pHash), pKey, nKeyLen);
if( pEntry == 0 ){
return SXERR_NOTFOUND;
}
rc = HashDeleteEntry(&(*pHash), pEntry, ppUserData);
return rc;
}
JX9_PRIVATE sxi32 SyHashForEach(SyHash *pHash, sxi32 (*xStep)(SyHashEntry *, void *), void *pUserData)
{
SyHashEntry_Pr *pEntry;
sxi32 rc;
sxu32 n;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) || xStep == 0){
return 0;
}
#endif
pEntry = pHash->pList;
for( n = 0 ; n < pHash->nEntry ; n++ ){
/* Invoke the callback */
rc = xStep((SyHashEntry *)pEntry, pUserData);
if( rc != SXRET_OK ){
return rc;
}
/* Point to the next entry */
pEntry = pEntry->pNext;
}
return SXRET_OK;
}
static sxi32 HashGrowTable(SyHash *pHash)
{
sxu32 nNewSize = pHash->nBucketSize * 2;
SyHashEntry_Pr *pEntry;
SyHashEntry_Pr **apNew;
sxu32 n, iBucket;
/* Allocate a new larger table */
apNew = (SyHashEntry_Pr **)SyMemBackendAlloc(pHash->pAllocator, nNewSize * sizeof(SyHashEntry_Pr *));
if( apNew == 0 ){
/* Not so fatal, simply a performance hit */
return SXRET_OK;
}
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(SyHashEntry_Pr *));
/* Rehash all entries */
for( n = 0, pEntry = pHash->pList; n < pHash->nEntry ; n++ ){
pEntry->pNextCollide = pEntry->pPrevCollide = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextCollide = apNew[iBucket];
if( apNew[iBucket] != 0 ){
apNew[iBucket]->pPrevCollide = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
}
/* Release the old table and reflect the change */
SyMemBackendFree(pHash->pAllocator, (void *)pHash->apBucket);
pHash->apBucket = apNew;
pHash->nBucketSize = nNewSize;
return SXRET_OK;
}
static sxi32 HashInsert(SyHash *pHash, SyHashEntry_Pr *pEntry)
{
sxu32 iBucket = pEntry->nHash & (pHash->nBucketSize - 1);
/* Insert the entry in its corresponding bcuket */
pEntry->pNextCollide = pHash->apBucket[iBucket];
if( pHash->apBucket[iBucket] != 0 ){
pHash->apBucket[iBucket]->pPrevCollide = pEntry;
}
pHash->apBucket[iBucket] = pEntry;
/* Link to the entry list */
MACRO_LD_PUSH(pHash->pList, pEntry);
if( pHash->nEntry == 0 ){
pHash->pCurrent = pHash->pList;
}
pHash->nEntry++;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyHashInsert(SyHash *pHash, const void *pKey, sxu32 nKeyLen, void *pUserData)
{
SyHashEntry_Pr *pEntry;
sxi32 rc;
#if defined(UNTRUST)
if( INVALID_HASH(pHash) || pKey == 0 ){
return SXERR_CORRUPT;
}
#endif
if( pHash->nEntry >= pHash->nBucketSize * SXHASH_FILL_FACTOR ){
rc = HashGrowTable(&(*pHash));
if( rc != SXRET_OK ){
return rc;
}
}
/* Allocate a new hash entry */
pEntry = (SyHashEntry_Pr *)SyMemBackendPoolAlloc(pHash->pAllocator, sizeof(SyHashEntry_Pr));
if( pEntry == 0 ){
return SXERR_MEM;
}
/* Zero the entry */
SyZero(pEntry, sizeof(SyHashEntry_Pr));
pEntry->pHash = pHash;
pEntry->pKey = pKey;
pEntry->nKeyLen = nKeyLen;
pEntry->pUserData = pUserData;
pEntry->nHash = pHash->xHash(pEntry->pKey, pEntry->nKeyLen);
/* Finally insert the entry in its corresponding bucket */
rc = HashInsert(&(*pHash), pEntry);
return rc;
}
/* SyRunTimeApi:sxutils.c */
JX9_PRIVATE sxi32 SyStrIsNumeric(const char *zSrc, sxu32 nLen, sxu8 *pReal, const char **pzTail)
{
const char *zCur, *zEnd;
#ifdef UNTRUST
if( SX_EMPTY_STR(zSrc) ){
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
/* Jump leading white spaces */
while( zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && (zSrc[0] == '+' || zSrc[0] == '-') ){
zSrc++;
}
zCur = zSrc;
if( pReal ){
*pReal = FALSE;
}
for(;;){
if( zSrc >= zEnd || (unsigned char)zSrc[0] >= 0xc0 || !SyisDigit(zSrc[0]) ){ break; } zSrc++;
if( zSrc >= zEnd || (unsigned char)zSrc[0] >= 0xc0 || !SyisDigit(zSrc[0]) ){ break; } zSrc++;
if( zSrc >= zEnd || (unsigned char)zSrc[0] >= 0xc0 || !SyisDigit(zSrc[0]) ){ break; } zSrc++;
if( zSrc >= zEnd || (unsigned char)zSrc[0] >= 0xc0 || !SyisDigit(zSrc[0]) ){ break; } zSrc++;
};
if( zSrc < zEnd && zSrc > zCur ){
int c = zSrc[0];
if( c == '.' ){
zSrc++;
if( pReal ){
*pReal = TRUE;
}
if( pzTail ){
while( zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 && SyisDigit(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && (zSrc[0] == 'e' || zSrc[0] == 'E') ){
zSrc++;
if( zSrc < zEnd && (zSrc[0] == '+' || zSrc[0] == '-') ){
zSrc++;
}
while( zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 && SyisDigit(zSrc[0]) ){
zSrc++;
}
}
}
}else if( c == 'e' || c == 'E' ){
zSrc++;
if( pReal ){
*pReal = TRUE;
}
if( pzTail ){
if( zSrc < zEnd && (zSrc[0] == '+' || zSrc[0] == '-') ){
zSrc++;
}
while( zSrc < zEnd && (unsigned char)zSrc[0] < 0xc0 && SyisDigit(zSrc[0]) ){
zSrc++;
}
}
}
}
if( pzTail ){
/* Point to the non numeric part */
*pzTail = zSrc;
}
return zSrc > zCur ? SXRET_OK /* String prefix is numeric */ : SXERR_INVALID /* Not a digit stream */;
}
#define SXINT32_MIN_STR "2147483648"
#define SXINT32_MAX_STR "2147483647"
#define SXINT64_MIN_STR "9223372036854775808"
#define SXINT64_MAX_STR "9223372036854775807"
JX9_PRIVATE sxi32 SyStrToInt32(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
int isNeg = FALSE;
const char *zEnd;
sxi32 nVal = 0;
sxi16 i;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while(zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && ( zSrc[0] == '-' || zSrc[0] == '+' ) ){
isNeg = (zSrc[0] == '-') ? TRUE :FALSE;
zSrc++;
}
/* Skip leading zero */
while(zSrc < zEnd && zSrc[0] == '0' ){
zSrc++;
}
i = 10;
if( (sxu32)(zEnd-zSrc) >= 10 ){
/* Handle overflow */
i = SyMemcmp(zSrc, (isNeg == TRUE) ? SXINT32_MIN_STR : SXINT32_MAX_STR, nLen) <= 0 ? 10 : 9;
}
for(;;){
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
}
/* Skip trailing spaces */
while(zSrc < zEnd && SyisSpace(zSrc[0])){
zSrc++;
}
if( zRest ){
*zRest = (char *)zSrc;
}
if( pOutVal ){
if( isNeg == TRUE && nVal != 0 ){
nVal = -nVal;
}
*(sxi32 *)pOutVal = nVal;
}
return (zSrc >= zEnd) ? SXRET_OK : SXERR_SYNTAX;
}
JX9_PRIVATE sxi32 SyStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
int isNeg = FALSE;
const char *zEnd;
sxi64 nVal;
sxi16 i;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while(zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && ( zSrc[0] == '-' || zSrc[0] == '+' ) ){
isNeg = (zSrc[0] == '-') ? TRUE :FALSE;
zSrc++;
}
/* Skip leading zero */
while(zSrc < zEnd && zSrc[0] == '0' ){
zSrc++;
}
i = 19;
if( (sxu32)(zEnd-zSrc) >= 19 ){
i = SyMemcmp(zSrc, isNeg ? SXINT64_MIN_STR : SXINT64_MAX_STR, 19) <= 0 ? 19 : 18 ;
}
nVal = 0;
for(;;){
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
if(zSrc >= zEnd || !i || !SyisDigit(zSrc[0])){ break; } nVal = nVal * 10 + ( zSrc[0] - '0' ) ; --i ; zSrc++;
}
/* Skip trailing spaces */
while(zSrc < zEnd && SyisSpace(zSrc[0])){
zSrc++;
}
if( zRest ){
*zRest = (char *)zSrc;
}
if( pOutVal ){
if( isNeg == TRUE && nVal != 0 ){
nVal = -nVal;
}
*(sxi64 *)pOutVal = nVal;
}
return (zSrc >= zEnd) ? SXRET_OK : SXERR_SYNTAX;
}
JX9_PRIVATE sxi32 SyHexToint(sxi32 c)
{
switch(c){
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
case 'A': case 'a': return 10;
case 'B': case 'b': return 11;
case 'C': case 'c': return 12;
case 'D': case 'd': return 13;
case 'E': case 'e': return 14;
case 'F': case 'f': return 15;
}
return -1;
}
JX9_PRIVATE sxi32 SyHexStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
const char *zIn, *zEnd;
int isNeg = FALSE;
sxi64 nVal = 0;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while( zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && ( *zSrc == '-' || *zSrc == '+' ) ){
isNeg = (zSrc[0] == '-') ? TRUE :FALSE;
zSrc++;
}
if( zSrc < &zEnd[-2] && zSrc[0] == '0' && (zSrc[1] == 'x' || zSrc[1] == 'X') ){
/* Bypass hex prefix */
zSrc += sizeof(char) * 2;
}
/* Skip leading zero */
while(zSrc < zEnd && zSrc[0] == '0' ){
zSrc++;
}
zIn = zSrc;
for(;;){
if(zSrc >= zEnd || !SyisHex(zSrc[0]) || (int)(zSrc-zIn) > 15) break; nVal = nVal * 16 + SyHexToint(zSrc[0]); zSrc++ ;
if(zSrc >= zEnd || !SyisHex(zSrc[0]) || (int)(zSrc-zIn) > 15) break; nVal = nVal * 16 + SyHexToint(zSrc[0]); zSrc++ ;
if(zSrc >= zEnd || !SyisHex(zSrc[0]) || (int)(zSrc-zIn) > 15) break; nVal = nVal * 16 + SyHexToint(zSrc[0]); zSrc++ ;
if(zSrc >= zEnd || !SyisHex(zSrc[0]) || (int)(zSrc-zIn) > 15) break; nVal = nVal * 16 + SyHexToint(zSrc[0]); zSrc++ ;
}
while( zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zRest ){
*zRest = zSrc;
}
if( pOutVal ){
if( isNeg == TRUE && nVal != 0 ){
nVal = -nVal;
}
*(sxi64 *)pOutVal = nVal;
}
return zSrc >= zEnd ? SXRET_OK : SXERR_SYNTAX;
}
JX9_PRIVATE sxi32 SyOctalStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
const char *zIn, *zEnd;
int isNeg = FALSE;
sxi64 nVal = 0;
int c;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while(zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && ( zSrc[0] == '-' || zSrc[0] == '+' ) ){
isNeg = (zSrc[0] == '-') ? TRUE :FALSE;
zSrc++;
}
/* Skip leading zero */
while(zSrc < zEnd && zSrc[0] == '0' ){
zSrc++;
}
zIn = zSrc;
for(;;){
if(zSrc >= zEnd || !SyisDigit(zSrc[0])){ break; } if( (c=zSrc[0]-'0') > 7 || (int)(zSrc-zIn) > 20){ break;} nVal = nVal * 8 + c; zSrc++;
if(zSrc >= zEnd || !SyisDigit(zSrc[0])){ break; } if( (c=zSrc[0]-'0') > 7 || (int)(zSrc-zIn) > 20){ break;} nVal = nVal * 8 + c; zSrc++;
if(zSrc >= zEnd || !SyisDigit(zSrc[0])){ break; } if( (c=zSrc[0]-'0') > 7 || (int)(zSrc-zIn) > 20){ break;} nVal = nVal * 8 + c; zSrc++;
if(zSrc >= zEnd || !SyisDigit(zSrc[0])){ break; } if( (c=zSrc[0]-'0') > 7 || (int)(zSrc-zIn) > 20){ break;} nVal = nVal * 8 + c; zSrc++;
}
/* Skip trailing spaces */
while(zSrc < zEnd && SyisSpace(zSrc[0])){
zSrc++;
}
if( zRest ){
*zRest = zSrc;
}
if( pOutVal ){
if( isNeg == TRUE && nVal != 0 ){
nVal = -nVal;
}
*(sxi64 *)pOutVal = nVal;
}
return (zSrc >= zEnd) ? SXRET_OK : SXERR_SYNTAX;
}
JX9_PRIVATE sxi32 SyBinaryStrToInt64(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
const char *zIn, *zEnd;
int isNeg = FALSE;
sxi64 nVal = 0;
int c;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxi32 *)pOutVal = 0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while(zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && ( zSrc[0] == '-' || zSrc[0] == '+' ) ){
isNeg = (zSrc[0] == '-') ? TRUE :FALSE;
zSrc++;
}
if( zSrc < &zEnd[-2] && zSrc[0] == '0' && (zSrc[1] == 'b' || zSrc[1] == 'B') ){
/* Bypass binary prefix */
zSrc += sizeof(char) * 2;
}
/* Skip leading zero */
while(zSrc < zEnd && zSrc[0] == '0' ){
zSrc++;
}
zIn = zSrc;
for(;;){
if(zSrc >= zEnd || (zSrc[0] != '1' && zSrc[0] != '0') || (int)(zSrc-zIn) > 62){ break; } c = zSrc[0] - '0'; nVal = (nVal << 1) + c; zSrc++;
if(zSrc >= zEnd || (zSrc[0] != '1' && zSrc[0] != '0') || (int)(zSrc-zIn) > 62){ break; } c = zSrc[0] - '0'; nVal = (nVal << 1) + c; zSrc++;
if(zSrc >= zEnd || (zSrc[0] != '1' && zSrc[0] != '0') || (int)(zSrc-zIn) > 62){ break; } c = zSrc[0] - '0'; nVal = (nVal << 1) + c; zSrc++;
if(zSrc >= zEnd || (zSrc[0] != '1' && zSrc[0] != '0') || (int)(zSrc-zIn) > 62){ break; } c = zSrc[0] - '0'; nVal = (nVal << 1) + c; zSrc++;
}
/* Skip trailing spaces */
while(zSrc < zEnd && SyisSpace(zSrc[0])){
zSrc++;
}
if( zRest ){
*zRest = zSrc;
}
if( pOutVal ){
if( isNeg == TRUE && nVal != 0 ){
nVal = -nVal;
}
*(sxi64 *)pOutVal = nVal;
}
return (zSrc >= zEnd) ? SXRET_OK : SXERR_SYNTAX;
}
JX9_PRIVATE sxi32 SyStrToReal(const char *zSrc, sxu32 nLen, void * pOutVal, const char **zRest)
{
#define SXDBL_DIG 15
#define SXDBL_MAX_EXP 308
#define SXDBL_MIN_EXP_PLUS 307
static const sxreal aTab[] = {
10,
1.0e2,
1.0e4,
1.0e8,
1.0e16,
1.0e32,
1.0e64,
1.0e128,
1.0e256
};
sxu8 neg = FALSE;
sxreal Val = 0.0;
const char *zEnd;
sxi32 Lim, exp;
sxreal *p = 0;
#ifdef UNTRUST
if( SX_EMPTY_STR(zSrc) ){
if( pOutVal ){
*(sxreal *)pOutVal = 0.0;
}
return SXERR_EMPTY;
}
#endif
zEnd = &zSrc[nLen];
while( zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zSrc < zEnd && (zSrc[0] == '-' || zSrc[0] == '+' ) ){
neg = zSrc[0] == '-' ? TRUE : FALSE ;
zSrc++;
}
Lim = SXDBL_DIG ;
for(;;){
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; zSrc++ ; --Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; zSrc++ ; --Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; zSrc++ ; --Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; zSrc++ ; --Lim;
}
if( zSrc < zEnd && ( zSrc[0] == '.' || zSrc[0] == ',' ) ){
sxreal dec = 1.0;
zSrc++;
for(;;){
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; dec *= 10.0; zSrc++ ;--Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; dec *= 10.0; zSrc++ ;--Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; dec *= 10.0; zSrc++ ;--Lim;
if(zSrc >= zEnd||!Lim||!SyisDigit(zSrc[0])) break ; Val = Val * 10.0 + (zSrc[0] - '0') ; dec *= 10.0; zSrc++ ;--Lim;
}
Val /= dec;
}
if( neg == TRUE && Val != 0.0 ) {
Val = -Val ;
}
if( Lim <= 0 ){
/* jump overflow digit */
while( zSrc < zEnd ){
if( zSrc[0] == 'e' || zSrc[0] == 'E' ){
break;
}
zSrc++;
}
}
neg = FALSE;
if( zSrc < zEnd && ( zSrc[0] == 'e' || zSrc[0] == 'E' ) ){
zSrc++;
if( zSrc < zEnd && ( zSrc[0] == '-' || zSrc[0] == '+') ){
neg = zSrc[0] == '-' ? TRUE : FALSE ;
zSrc++;
}
exp = 0;
while( zSrc < zEnd && SyisDigit(zSrc[0]) && exp < SXDBL_MAX_EXP ){
exp = exp * 10 + (zSrc[0] - '0');
zSrc++;
}
if( neg ){
if( exp > SXDBL_MIN_EXP_PLUS ) exp = SXDBL_MIN_EXP_PLUS ;
}else if ( exp > SXDBL_MAX_EXP ){
exp = SXDBL_MAX_EXP;
}
for( p = (sxreal *)aTab ; exp ; exp >>= 1 , p++ ){
if( exp & 01 ){
if( neg ){
Val /= *p ;
}else{
Val *= *p;
}
}
}
}
while( zSrc < zEnd && SyisSpace(zSrc[0]) ){
zSrc++;
}
if( zRest ){
*zRest = zSrc;
}
if( pOutVal ){
*(sxreal *)pOutVal = Val;
}
return zSrc >= zEnd ? SXRET_OK : SXERR_SYNTAX;
}
/* SyRunTimeApi:sxlib.c */
JX9_PRIVATE sxu32 SyBinHash(const void *pSrc, sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
sxu32 nH = 5381;
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
}
return nH;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBase64Encode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData)
{
static const unsigned char zBase64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
unsigned char *zIn = (unsigned char *)zSrc;
unsigned char z64[4];
sxu32 i;
sxi32 rc;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) || xConsumer == 0){
return SXERR_EMPTY;
}
#endif
for(i = 0; i + 2 < nLen; i += 3){
z64[0] = zBase64[(zIn[i] >> 2) & 0x3F];
z64[1] = zBase64[( ((zIn[i] & 0x03) << 4) | (zIn[i+1] >> 4)) & 0x3F];
z64[2] = zBase64[( ((zIn[i+1] & 0x0F) << 2) | (zIn[i + 2] >> 6) ) & 0x3F];
z64[3] = zBase64[ zIn[i + 2] & 0x3F];
rc = xConsumer((const void *)z64, sizeof(z64), pUserData);
if( rc != SXRET_OK ){return SXERR_ABORT;}
}
if ( i+1 < nLen ){
z64[0] = zBase64[(zIn[i] >> 2) & 0x3F];
z64[1] = zBase64[( ((zIn[i] & 0x03) << 4) | (zIn[i+1] >> 4)) & 0x3F];
z64[2] = zBase64[(zIn[i+1] & 0x0F) << 2 ];
z64[3] = '=';
rc = xConsumer((const void *)z64, sizeof(z64), pUserData);
if( rc != SXRET_OK ){return SXERR_ABORT;}
}else if( i < nLen ){
z64[0] = zBase64[(zIn[i] >> 2) & 0x3F];
z64[1] = zBase64[(zIn[i] & 0x03) << 4];
z64[2] = '=';
z64[3] = '=';
rc = xConsumer((const void *)z64, sizeof(z64), pUserData);
if( rc != SXRET_OK ){return SXERR_ABORT;}
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyBase64Decode(const char *zB64, sxu32 nLen, ProcConsumer xConsumer, void *pUserData)
{
static const sxu32 aBase64Trans[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0, 0,
0, 0, 0
};
sxu32 n, w, x, y, z;
sxi32 rc;
unsigned char zOut[10];
#if defined(UNTRUST)
if( SX_EMPTY_STR(zB64) || xConsumer == 0 ){
return SXERR_EMPTY;
}
#endif
while(nLen > 0 && zB64[nLen - 1] == '=' ){
nLen--;
}
for( n = 0 ; n+3<nLen ; n += 4){
w = aBase64Trans[zB64[n] & 0x7F];
x = aBase64Trans[zB64[n+1] & 0x7F];
y = aBase64Trans[zB64[n+2] & 0x7F];
z = aBase64Trans[zB64[n+3] & 0x7F];
zOut[0] = ((w<<2) & 0xFC) | ((x>>4) & 0x03);
zOut[1] = ((x<<4) & 0xF0) | ((y>>2) & 0x0F);
zOut[2] = ((y<<6) & 0xC0) | (z & 0x3F);
rc = xConsumer((const void *)zOut, sizeof(unsigned char)*3, pUserData);
if( rc != SXRET_OK ){ return SXERR_ABORT;}
}
if( n+2 < nLen ){
w = aBase64Trans[zB64[n] & 0x7F];
x = aBase64Trans[zB64[n+1] & 0x7F];
y = aBase64Trans[zB64[n+2] & 0x7F];
zOut[0] = ((w<<2) & 0xFC) | ((x>>4) & 0x03);
zOut[1] = ((x<<4) & 0xF0) | ((y>>2) & 0x0F);
rc = xConsumer((const void *)zOut, sizeof(unsigned char)*2, pUserData);
if( rc != SXRET_OK ){ return SXERR_ABORT;}
}else if( n+1 < nLen ){
w = aBase64Trans[zB64[n] & 0x7F];
x = aBase64Trans[zB64[n+1] & 0x7F];
zOut[0] = ((w<<2) & 0xFC) | ((x>>4) & 0x03);
rc = xConsumer((const void *)zOut, sizeof(unsigned char)*1, pUserData);
if( rc != SXRET_OK ){ return SXERR_ABORT;}
}
return SXRET_OK;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
#define INVALID_LEXER(LEX) ( LEX == 0 || LEX->xTokenizer == 0 )
JX9_PRIVATE sxi32 SyLexInit(SyLex *pLex, SySet *pSet, ProcTokenizer xTokenizer, void *pUserData)
{
SyStream *pStream;
#if defined (UNTRUST)
if ( pLex == 0 || xTokenizer == 0 ){
return SXERR_CORRUPT;
}
#endif
pLex->pTokenSet = 0;
/* Initialize lexer fields */
if( pSet ){
if ( SySetElemSize(pSet) != sizeof(SyToken) ){
return SXERR_INVALID;
}
pLex->pTokenSet = pSet;
}
pStream = &pLex->sStream;
pLex->xTokenizer = xTokenizer;
pLex->pUserData = pUserData;
pStream->nLine = 1;
pStream->nIgn = 0;
pStream->zText = pStream->zEnd = 0;
pStream->pSet = pSet;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyLexTokenizeInput(SyLex *pLex, const char *zInput, sxu32 nLen, void *pCtxData, ProcSort xSort, ProcCmp xCmp)
{
const unsigned char *zCur;
SyStream *pStream;
SyToken sToken;
sxi32 rc;
#if defined (UNTRUST)
if ( INVALID_LEXER(pLex) || zInput == 0 ){
return SXERR_CORRUPT;
}
#endif
pStream = &pLex->sStream;
/* Point to the head of the input */
pStream->zText = pStream->zInput = (const unsigned char *)zInput;
/* Point to the end of the input */
pStream->zEnd = &pStream->zInput[nLen];
for(;;){
if( pStream->zText >= pStream->zEnd ){
/* End of the input reached */
break;
}
zCur = pStream->zText;
/* Call the tokenizer callback */
rc = pLex->xTokenizer(pStream, &sToken, pLex->pUserData, pCtxData);
if( rc != SXRET_OK && rc != SXERR_CONTINUE ){
/* Tokenizer callback request an operation abort */
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
break;
}
if( rc == SXERR_CONTINUE ){
/* Request to ignore this token */
pStream->nIgn++;
}else if( pLex->pTokenSet ){
/* Put the token in the set */
rc = SySetPut(pLex->pTokenSet, (const void *)&sToken);
if( rc != SXRET_OK ){
break;
}
}
if( zCur >= pStream->zText ){
/* Automatic advance of the stream cursor */
pStream->zText = &zCur[1];
}
}
if( xSort && pLex->pTokenSet ){
SyToken *aToken = (SyToken *)SySetBasePtr(pLex->pTokenSet);
/* Sort the extrated tokens */
if( xCmp == 0 ){
/* Use a default comparison function */
xCmp = SyMemcmp;
}
xSort(aToken, SySetUsed(pLex->pTokenSet), sizeof(SyToken), xCmp);
}
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyLexRelease(SyLex *pLex)
{
sxi32 rc = SXRET_OK;
#if defined (UNTRUST)
if ( INVALID_LEXER(pLex) ){
return SXERR_CORRUPT;
}
#else
SXUNUSED(pLex); /* Prevent compiler warning */
#endif
return rc;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
#define SAFE_HTTP(C) (SyisAlphaNum(c) || c == '_' || c == '-' || c == '$' || c == '.' )
JX9_PRIVATE sxi32 SyUriEncode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData)
{
unsigned char *zIn = (unsigned char *)zSrc;
unsigned char zHex[3] = { '%', 0, 0 };
unsigned char zOut[2];
unsigned char *zCur, *zEnd;
sxi32 c;
sxi32 rc;
#ifdef UNTRUST
if( SX_EMPTY_STR(zSrc) || xConsumer == 0 ){
return SXERR_EMPTY;
}
#endif
rc = SXRET_OK;
zEnd = &zIn[nLen]; zCur = zIn;
for(;;){
if( zCur >= zEnd ){
if( zCur != zIn ){
rc = xConsumer(zIn, (sxu32)(zCur-zIn), pUserData);
}
break;
}
c = zCur[0];
if( SAFE_HTTP(c) ){
zCur++; continue;
}
if( zCur != zIn && SXRET_OK != (rc = xConsumer(zIn, (sxu32)(zCur-zIn), pUserData))){
break;
}
if( c == ' ' ){
zOut[0] = '+';
rc = xConsumer((const void *)zOut, sizeof(unsigned char), pUserData);
}else{
zHex[1] = "0123456789ABCDEF"[(c >> 4) & 0x0F];
zHex[2] = "0123456789ABCDEF"[c & 0x0F];
rc = xConsumer(zHex, sizeof(zHex), pUserData);
}
if( SXRET_OK != rc ){
break;
}
zIn = &zCur[1]; zCur = zIn ;
}
return rc == SXRET_OK ? SXRET_OK : SXERR_ABORT;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
static sxi32 SyAsciiToHex(sxi32 c)
{
if( c >= 'a' && c <= 'f' ){
c += 10 - 'a';
return c;
}
if( c >= '0' && c <= '9' ){
c -= '0';
return c;
}
if( c >= 'A' && c <= 'F') {
c += 10 - 'A';
return c;
}
return 0;
}
JX9_PRIVATE sxi32 SyUriDecode(const char *zSrc, sxu32 nLen, ProcConsumer xConsumer, void *pUserData, int bUTF8)
{
static const sxu8 Utf8Trans[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00
};
const char *zIn = zSrc;
const char *zEnd;
const char *zCur;
sxu8 *zOutPtr;
sxu8 zOut[10];
sxi32 c, d;
sxi32 rc;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zSrc) || xConsumer == 0 ){
return SXERR_EMPTY;
}
#endif
rc = SXRET_OK;
zEnd = &zSrc[nLen];
zCur = zIn;
for(;;){
while(zCur < zEnd && zCur[0] != '%' && zCur[0] != '+' ){
zCur++;
}
if( zCur != zIn ){
/* Consume input */
rc = xConsumer(zIn, (unsigned int)(zCur-zIn), pUserData);
if( rc != SXRET_OK ){
/* User consumer routine request an operation abort */
break;
}
}
if( zCur >= zEnd ){
rc = SXRET_OK;
break;
}
/* Decode unsafe HTTP characters */
zOutPtr = zOut;
if( zCur[0] == '+' ){
*zOutPtr++ = ' ';
zCur++;
}else{
if( &zCur[2] >= zEnd ){
rc = SXERR_OVERFLOW;
break;
}
c = (SyAsciiToHex(zCur[1]) <<4) | SyAsciiToHex(zCur[2]);
zCur += 3;
if( c < 0x000C0 ){
*zOutPtr++ = (sxu8)c;
}else{
c = Utf8Trans[c-0xC0];
while( zCur[0] == '%' ){
d = (SyAsciiToHex(zCur[1]) <<4) | SyAsciiToHex(zCur[2]);
if( (d&0xC0) != 0x80 ){
break;
}
c = (c<<6) + (0x3f & d);
zCur += 3;
}
if( bUTF8 == FALSE ){
*zOutPtr++ = (sxu8)c;
}else{
SX_WRITE_UTF8(zOutPtr, c);
}
}
}
/* Consume the decoded characters */
rc = xConsumer((const void *)zOut, (unsigned int)(zOutPtr-zOut), pUserData);
if( rc != SXRET_OK ){
break;
}
/* Synchronize pointers */
zIn = zCur;
}
return rc;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
static const char *zEngDay[] = {
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
static const char *zEngMonth[] = {
"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"
};
static const char * GetDay(sxi32 i)
{
return zEngDay[ i % 7 ];
}
static const char * GetMonth(sxi32 i)
{
return zEngMonth[ i % 12 ];
}
JX9_PRIVATE const char * SyTimeGetDay(sxi32 iDay)
{
return GetDay(iDay);
}
JX9_PRIVATE const char * SyTimeGetMonth(sxi32 iMonth)
{
return GetMonth(iMonth);
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/* SyRunTimeApi: sxfmt.c */
#define SXFMT_BUFSIZ 1024 /* Conversion buffer size */
/*
** Conversion types fall into various categories as defined by the
** following enumeration.
*/
#define SXFMT_RADIX 1 /* Integer types.%d, %x, %o, and so forth */
#define SXFMT_FLOAT 2 /* Floating point.%f */
#define SXFMT_EXP 3 /* Exponentional notation.%e and %E */
#define SXFMT_GENERIC 4 /* Floating or exponential, depending on exponent.%g */
#define SXFMT_SIZE 5 /* Total number of characters processed so far.%n */
#define SXFMT_STRING 6 /* Strings.%s */
#define SXFMT_PERCENT 7 /* Percent symbol.%% */
#define SXFMT_CHARX 8 /* Characters.%c */
#define SXFMT_ERROR 9 /* Used to indicate no such conversion type */
/* Extension by Symisc Systems */
#define SXFMT_RAWSTR 13 /* %z Pointer to raw string (SyString *) */
#define SXFMT_UNUSED 15
/*
** Allowed values for SyFmtInfo.flags
*/
#define SXFLAG_SIGNED 0x01
#define SXFLAG_UNSIGNED 0x02
/* Allowed values for SyFmtConsumer.nType */
#define SXFMT_CONS_PROC 1 /* Consumer is a procedure */
#define SXFMT_CONS_STR 2 /* Consumer is a managed string */
#define SXFMT_CONS_FILE 5 /* Consumer is an open File */
#define SXFMT_CONS_BLOB 6 /* Consumer is a BLOB */
/*
** Each builtin conversion character (ex: the 'd' in "%d") is described
** by an instance of the following structure
*/
typedef struct SyFmtInfo SyFmtInfo;
struct SyFmtInfo
{
char fmttype; /* The format field code letter [i.e: 'd', 's', 'x'] */
sxu8 base; /* The base for radix conversion */
int flags; /* One or more of SXFLAG_ constants below */
sxu8 type; /* Conversion paradigm */
char *charset; /* The character set for conversion */
char *prefix; /* Prefix on non-zero values in alt format */
};
typedef struct SyFmtConsumer SyFmtConsumer;
struct SyFmtConsumer
{
sxu32 nLen; /* Total output length */
sxi32 nType; /* Type of the consumer see below */
sxi32 rc; /* Consumer return value;Abort processing if rc != SXRET_OK */
union{
struct{
ProcConsumer xUserConsumer;
void *pUserData;
}sFunc;
SyBlob *pBlob;
}uConsumer;
};
#ifndef SX_OMIT_FLOATINGPOINT
static int getdigit(sxlongreal *val, int *cnt)
{
sxlongreal d;
int digit;
if( (*cnt)++ >= 16 ){
return '0';
}
digit = (int)*val;
d = digit;
*val = (*val - d)*10.0;
return digit + '0' ;
}
#endif /* SX_OMIT_FLOATINGPOINT */
/*
* The following routine was taken from the SQLITE2 source tree and was
* extended by Symisc Systems to fit its need.
* Status: Public Domain
*/
static sxi32 InternFormat(ProcConsumer xConsumer, void *pUserData, const char *zFormat, va_list ap)
{
/*
* The following table is searched linearly, so it is good to put the most frequently
* used conversion types first.
*/
static const SyFmtInfo aFmt[] = {
{ 'd', 10, SXFLAG_SIGNED, SXFMT_RADIX, "0123456789", 0 },
{ 's', 0, 0, SXFMT_STRING, 0, 0 },
{ 'c', 0, 0, SXFMT_CHARX, 0, 0 },
{ 'x', 16, 0, SXFMT_RADIX, "0123456789abcdef", "x0" },
{ 'X', 16, 0, SXFMT_RADIX, "0123456789ABCDEF", "X0" },
/* -- Extensions by Symisc Systems -- */
{ 'z', 0, 0, SXFMT_RAWSTR, 0, 0 }, /* Pointer to a raw string (SyString *) */
{ 'B', 2, 0, SXFMT_RADIX, "01", "b0"},
/* -- End of Extensions -- */
{ 'o', 8, 0, SXFMT_RADIX, "01234567", "0" },
{ 'u', 10, 0, SXFMT_RADIX, "0123456789", 0 },
#ifndef SX_OMIT_FLOATINGPOINT
{ 'f', 0, SXFLAG_SIGNED, SXFMT_FLOAT, 0, 0 },
{ 'e', 0, SXFLAG_SIGNED, SXFMT_EXP, "e", 0 },
{ 'E', 0, SXFLAG_SIGNED, SXFMT_EXP, "E", 0 },
{ 'g', 0, SXFLAG_SIGNED, SXFMT_GENERIC, "e", 0 },
{ 'G', 0, SXFLAG_SIGNED, SXFMT_GENERIC, "E", 0 },
#endif
{ 'i', 10, SXFLAG_SIGNED, SXFMT_RADIX, "0123456789", 0 },
{ 'n', 0, 0, SXFMT_SIZE, 0, 0 },
{ '%', 0, 0, SXFMT_PERCENT, 0, 0 },
{ 'p', 10, 0, SXFMT_RADIX, "0123456789", 0 }
};
int c; /* Next character in the format string */
char *bufpt; /* Pointer to the conversion buffer */
int precision; /* Precision of the current field */
int length; /* Length of the field */
int idx; /* A general purpose loop counter */
int width; /* Width of the current field */
sxu8 flag_leftjustify; /* True if "-" flag is present */
sxu8 flag_plussign; /* True if "+" flag is present */
sxu8 flag_blanksign; /* True if " " flag is present */
sxu8 flag_alternateform; /* True if "#" flag is present */
sxu8 flag_zeropad; /* True if field width constant starts with zero */
sxu8 flag_long; /* True if "l" flag is present */
sxi64 longvalue; /* Value for integer types */
const SyFmtInfo *infop; /* Pointer to the appropriate info structure */
char buf[SXFMT_BUFSIZ]; /* Conversion buffer */
char prefix; /* Prefix character."+" or "-" or " " or '\0'.*/
sxu8 errorflag = 0; /* True if an error is encountered */
sxu8 xtype; /* Conversion paradigm */
char *zExtra;
static char spaces[] = " ";
#define etSPACESIZE ((int)sizeof(spaces)-1)
#ifndef SX_OMIT_FLOATINGPOINT
sxlongreal realvalue; /* Value for real types */
int exp; /* exponent of real numbers */
double rounder; /* Used for rounding floating point values */
sxu8 flag_dp; /* True if decimal point should be shown */
sxu8 flag_rtz; /* True if trailing zeros should be removed */
sxu8 flag_exp; /* True to force display of the exponent */
int nsd; /* Number of significant digits returned */
#endif
int rc;
length = 0;
bufpt = 0;
for(; (c=(*zFormat))!=0; ++zFormat){
if( c!='%' ){
unsigned int amt;
bufpt = (char *)zFormat;
amt = 1;
while( (c=(*++zFormat))!='%' && c!=0 ) amt++;
rc = xConsumer((const void *)bufpt, amt, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
if( c==0 ){
return errorflag > 0 ? SXERR_FORMAT : SXRET_OK;
}
}
if( (c=(*++zFormat))==0 ){
errorflag = 1;
rc = xConsumer("%", sizeof("%")-1, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
return errorflag > 0 ? SXERR_FORMAT : SXRET_OK;
}
/* Find out what flags are present */
flag_leftjustify = flag_plussign = flag_blanksign =
flag_alternateform = flag_zeropad = 0;
do{
switch( c ){
case '-': flag_leftjustify = 1; c = 0; break;
case '+': flag_plussign = 1; c = 0; break;
case ' ': flag_blanksign = 1; c = 0; break;
case '#': flag_alternateform = 1; c = 0; break;
case '0': flag_zeropad = 1; c = 0; break;
default: break;
}
}while( c==0 && (c=(*++zFormat))!=0 );
/* Get the field width */
width = 0;
if( c=='*' ){
width = va_arg(ap, int);
if( width<0 ){
flag_leftjustify = 1;
width = -width;
}
c = *++zFormat;
}else{
while( c>='0' && c<='9' ){
width = width*10 + c - '0';
c = *++zFormat;
}
}
if( width > SXFMT_BUFSIZ-10 ){
width = SXFMT_BUFSIZ-10;
}
/* Get the precision */
precision = -1;
if( c=='.' ){
precision = 0;
c = *++zFormat;
if( c=='*' ){
precision = va_arg(ap, int);
if( precision<0 ) precision = -precision;
c = *++zFormat;
}else{
while( c>='0' && c<='9' ){
precision = precision*10 + c - '0';
c = *++zFormat;
}
}
}
/* Get the conversion type modifier */
flag_long = 0;
if( c=='l' || c == 'q' /* BSD quad (expect a 64-bit integer) */ ){
flag_long = (c == 'q') ? 2 : 1;
c = *++zFormat;
if( c == 'l' ){
/* Standard printf emulation 'lld' (expect a 64bit integer) */
flag_long = 2;
}
}
/* Fetch the info entry for the field */
infop = 0;
xtype = SXFMT_ERROR;
for(idx=0; idx< (int)SX_ARRAYSIZE(aFmt); idx++){
if( c==aFmt[idx].fmttype ){
infop = &aFmt[idx];
xtype = infop->type;
break;
}
}
zExtra = 0;
/*
** At this point, variables are initialized as follows:
**
** flag_alternateform TRUE if a '#' is present.
** flag_plussign TRUE if a '+' is present.
** flag_leftjustify TRUE if a '-' is present or if the
** field width was negative.
** flag_zeropad TRUE if the width began with 0.
** flag_long TRUE if the letter 'l' (ell) or 'q'(BSD quad) prefixed
** the conversion character.
** flag_blanksign TRUE if a ' ' is present.
** width The specified field width.This is
** always non-negative.Zero is the default.
** precision The specified precision.The default
** is -1.
** xtype The object of the conversion.
** infop Pointer to the appropriate info struct.
*/
switch( xtype ){
case SXFMT_RADIX:
if( flag_long > 0 ){
if( flag_long > 1 ){
/* BSD quad: expect a 64-bit integer */
longvalue = va_arg(ap, sxi64);
}else{
longvalue = va_arg(ap, sxlong);
}
}else{
if( infop->flags & SXFLAG_SIGNED ){
longvalue = va_arg(ap, sxi32);
}else{
longvalue = va_arg(ap, sxu32);
}
}
/* Limit the precision to prevent overflowing buf[] during conversion */
if( precision>SXFMT_BUFSIZ-40 ) precision = SXFMT_BUFSIZ-40;
#if 1
/* For the format %#x, the value zero is printed "0" not "0x0".
** I think this is stupid.*/
if( longvalue==0 ) flag_alternateform = 0;
#else
/* More sensible: turn off the prefix for octal (to prevent "00"),
** but leave the prefix for hex.*/
if( longvalue==0 && infop->base==8 ) flag_alternateform = 0;
#endif
if( infop->flags & SXFLAG_SIGNED ){
if( longvalue<0 ){
longvalue = -longvalue;
/* Ticket 1433-003 */
if( longvalue < 0 ){
/* Overflow */
longvalue= 0x7FFFFFFFFFFFFFFF;
}
prefix = '-';
}else if( flag_plussign ) prefix = '+';
else if( flag_blanksign ) prefix = ' ';
else prefix = 0;
}else{
if( longvalue<0 ){
longvalue = -longvalue;
/* Ticket 1433-003 */
if( longvalue < 0 ){
/* Overflow */
longvalue= 0x7FFFFFFFFFFFFFFF;
}
}
prefix = 0;
}
if( flag_zeropad && precision<width-(prefix!=0) ){
precision = width-(prefix!=0);
}
bufpt = &buf[SXFMT_BUFSIZ-1];
{
register char *cset; /* Use registers for speed */
register int base;
cset = infop->charset;
base = infop->base;
do{ /* Convert to ascii */
*(--bufpt) = cset[longvalue%base];
longvalue = longvalue/base;
}while( longvalue>0 );
}
length = &buf[SXFMT_BUFSIZ-1]-bufpt;
for(idx=precision-length; idx>0; idx--){
*(--bufpt) = '0'; /* Zero pad */
}
if( prefix ) *(--bufpt) = prefix; /* Add sign */
if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
char *pre, x;
pre = infop->prefix;
if( *bufpt!=pre[0] ){
for(pre=infop->prefix; (x=(*pre))!=0; pre++) *(--bufpt) = x;
}
}
length = &buf[SXFMT_BUFSIZ-1]-bufpt;
break;
case SXFMT_FLOAT:
case SXFMT_EXP:
case SXFMT_GENERIC:
#ifndef SX_OMIT_FLOATINGPOINT
realvalue = va_arg(ap, double);
if( precision<0 ) precision = 6; /* Set default precision */
if( precision>SXFMT_BUFSIZ-40) precision = SXFMT_BUFSIZ-40;
if( realvalue<0.0 ){
realvalue = -realvalue;
prefix = '-';
}else{
if( flag_plussign ) prefix = '+';
else if( flag_blanksign ) prefix = ' ';
else prefix = 0;
}
if( infop->type==SXFMT_GENERIC && precision>0 ) precision--;
rounder = 0.0;
#if 0
/* Rounding works like BSD when the constant 0.4999 is used.Wierd! */
for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
#else
/* It makes more sense to use 0.5 */
for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1);
#endif
if( infop->type==SXFMT_FLOAT ) realvalue += rounder;
/* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
exp = 0;
if( realvalue>0.0 ){
while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; }
while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; }
if( exp>350 || exp<-350 ){
bufpt = "NaN";
length = 3;
break;
}
}
bufpt = buf;
/*
** If the field type is etGENERIC, then convert to either etEXP
** or etFLOAT, as appropriate.
*/
flag_exp = xtype==SXFMT_EXP;
if( xtype!=SXFMT_FLOAT ){
realvalue += rounder;
if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
}
if( xtype==SXFMT_GENERIC ){
flag_rtz = !flag_alternateform;
if( exp<-4 || exp>precision ){
xtype = SXFMT_EXP;
}else{
precision = precision - exp;
xtype = SXFMT_FLOAT;
}
}else{
flag_rtz = 0;
}
/*
** The "exp+precision" test causes output to be of type etEXP if
** the precision is too large to fit in buf[].
*/
nsd = 0;
if( xtype==SXFMT_FLOAT && exp+precision<SXFMT_BUFSIZ-30 ){
flag_dp = (precision>0 || flag_alternateform);
if( prefix ) *(bufpt++) = prefix; /* Sign */
if( exp<0 ) *(bufpt++) = '0'; /* Digits before "." */
else for(; exp>=0; exp--) *(bufpt++) = (char)getdigit(&realvalue, &nsd);
if( flag_dp ) *(bufpt++) = '.'; /* The decimal point */
for(exp++; exp<0 && precision>0; precision--, exp++){
*(bufpt++) = '0';
}
while( (precision--)>0 ) *(bufpt++) = (char)getdigit(&realvalue, &nsd);
*(bufpt--) = 0; /* Null terminate */
if( flag_rtz && flag_dp ){ /* Remove trailing zeros and "." */
while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0;
if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0;
}
bufpt++; /* point to next free slot */
}else{ /* etEXP or etGENERIC */
flag_dp = (precision>0 || flag_alternateform);
if( prefix ) *(bufpt++) = prefix; /* Sign */
*(bufpt++) = (char)getdigit(&realvalue, &nsd); /* First digit */
if( flag_dp ) *(bufpt++) = '.'; /* Decimal point */
while( (precision--)>0 ) *(bufpt++) = (char)getdigit(&realvalue, &nsd);
bufpt--; /* point to last digit */
if( flag_rtz && flag_dp ){ /* Remove tail zeros */
while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0;
if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0;
}
bufpt++; /* point to next free slot */
if( exp || flag_exp ){
*(bufpt++) = infop->charset[0];
if( exp<0 ){ *(bufpt++) = '-'; exp = -exp; } /* sign of exp */
else { *(bufpt++) = '+'; }
if( exp>=100 ){
*(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */
exp %= 100;
}
*(bufpt++) = (char)(exp/10+'0'); /* 10's digit */
*(bufpt++) = (char)(exp%10+'0'); /* 1's digit */
}
}
/* The converted number is in buf[] and zero terminated.Output it.
** Note that the number is in the usual order, not reversed as with
** integer conversions.*/
length = bufpt-buf;
bufpt = buf;
/* Special case: Add leading zeros if the flag_zeropad flag is
** set and we are not left justified */
if( flag_zeropad && !flag_leftjustify && length < width){
int i;
int nPad = width - length;
for(i=width; i>=nPad; i--){
bufpt[i] = bufpt[i-nPad];
}
i = prefix!=0;
while( nPad-- ) bufpt[i++] = '0';
length = width;
}
#else
bufpt = " ";
length = (int)sizeof(" ") - 1;
#endif /* SX_OMIT_FLOATINGPOINT */
break;
case SXFMT_SIZE:{
int *pSize = va_arg(ap, int *);
*pSize = ((SyFmtConsumer *)pUserData)->nLen;
length = width = 0;
}
break;
case SXFMT_PERCENT:
buf[0] = '%';
bufpt = buf;
length = 1;
break;
case SXFMT_CHARX:
c = va_arg(ap, int);
buf[0] = (char)c;
/* Limit the precision to prevent overflowing buf[] during conversion */
if( precision>SXFMT_BUFSIZ-40 ) precision = SXFMT_BUFSIZ-40;
if( precision>=0 ){
for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
length = precision;
}else{
length =1;
}
bufpt = buf;
break;
case SXFMT_STRING:
bufpt = va_arg(ap, char*);
if( bufpt==0 ){
bufpt = " ";
length = (int)sizeof(" ")-1;
break;
}
length = precision;
if( precision < 0 ){
/* Symisc extension */
length = (int)SyStrlen(bufpt);
}
if( precision>=0 && precision<length ) length = precision;
break;
case SXFMT_RAWSTR:{
/* Symisc extension */
SyString *pStr = va_arg(ap, SyString *);
if( pStr == 0 || pStr->zString == 0 ){
bufpt = " ";
length = (int)sizeof(char);
break;
}
bufpt = (char *)pStr->zString;
length = (int)pStr->nByte;
break;
}
case SXFMT_ERROR:
buf[0] = '?';
bufpt = buf;
length = (int)sizeof(char);
if( c==0 ) zFormat--;
break;
}/* End switch over the format type */
/*
** The text of the conversion is pointed to by "bufpt" and is
** "length" characters long.The field width is "width".Do
** the output.
*/
if( !flag_leftjustify ){
register int nspace;
nspace = width-length;
if( nspace>0 ){
while( nspace>=etSPACESIZE ){
rc = xConsumer(spaces, etSPACESIZE, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
nspace -= etSPACESIZE;
}
if( nspace>0 ){
rc = xConsumer(spaces, (unsigned int)nspace, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
}
}
if( length>0 ){
rc = xConsumer(bufpt, (unsigned int)length, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
if( flag_leftjustify ){
register int nspace;
nspace = width-length;
if( nspace>0 ){
while( nspace>=etSPACESIZE ){
rc = xConsumer(spaces, etSPACESIZE, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
nspace -= etSPACESIZE;
}
if( nspace>0 ){
rc = xConsumer(spaces, (unsigned int)nspace, pUserData);
if( rc != SXRET_OK ){
return SXERR_ABORT; /* Consumer routine request an operation abort */
}
}
}
}
}/* End for loop over the format string */
return errorflag ? SXERR_FORMAT : SXRET_OK;
}
static sxi32 FormatConsumer(const void *pSrc, unsigned int nLen, void *pData)
{
SyFmtConsumer *pConsumer = (SyFmtConsumer *)pData;
sxi32 rc = SXERR_ABORT;
switch(pConsumer->nType){
case SXFMT_CONS_PROC:
/* User callback */
rc = pConsumer->uConsumer.sFunc.xUserConsumer(pSrc, nLen, pConsumer->uConsumer.sFunc.pUserData);
break;
case SXFMT_CONS_BLOB:
/* Blob consumer */
rc = SyBlobAppend(pConsumer->uConsumer.pBlob, pSrc, (sxu32)nLen);
break;
default:
/* Unknown consumer */
break;
}
/* Update total number of bytes consumed so far */
pConsumer->nLen += nLen;
pConsumer->rc = rc;
return rc;
}
static sxi32 FormatMount(sxi32 nType, void *pConsumer, ProcConsumer xUserCons, void *pUserData, sxu32 *pOutLen, const char *zFormat, va_list ap)
{
SyFmtConsumer sCons;
sCons.nType = nType;
sCons.rc = SXRET_OK;
sCons.nLen = 0;
if( pOutLen ){
*pOutLen = 0;
}
switch(nType){
case SXFMT_CONS_PROC:
#if defined(UNTRUST)
if( xUserCons == 0 ){
return SXERR_EMPTY;
}
#endif
sCons.uConsumer.sFunc.xUserConsumer = xUserCons;
sCons.uConsumer.sFunc.pUserData = pUserData;
break;
case SXFMT_CONS_BLOB:
sCons.uConsumer.pBlob = (SyBlob *)pConsumer;
break;
default:
return SXERR_UNKNOWN;
}
InternFormat(FormatConsumer, &sCons, zFormat, ap);
if( pOutLen ){
*pOutLen = sCons.nLen;
}
return sCons.rc;
}
JX9_PRIVATE sxi32 SyProcFormat(ProcConsumer xConsumer, void *pData, const char *zFormat, ...)
{
va_list ap;
sxi32 rc;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return SXERR_EMPTY;
}
#endif
va_start(ap, zFormat);
rc = FormatMount(SXFMT_CONS_PROC, 0, xConsumer, pData, 0, zFormat, ap);
va_end(ap);
return rc;
}
JX9_PRIVATE sxu32 SyBlobFormat(SyBlob *pBlob, const char *zFormat, ...)
{
va_list ap;
sxu32 n;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return 0;
}
#endif
va_start(ap, zFormat);
FormatMount(SXFMT_CONS_BLOB, &(*pBlob), 0, 0, &n, zFormat, ap);
va_end(ap);
return n;
}
JX9_PRIVATE sxu32 SyBlobFormatAp(SyBlob *pBlob, const char *zFormat, va_list ap)
{
sxu32 n = 0; /* cc warning */
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return 0;
}
#endif
FormatMount(SXFMT_CONS_BLOB, &(*pBlob), 0, 0, &n, zFormat, ap);
return n;
}
JX9_PRIVATE sxu32 SyBufferFormat(char *zBuf, sxu32 nLen, const char *zFormat, ...)
{
SyBlob sBlob;
va_list ap;
sxu32 n;
#if defined(UNTRUST)
if( SX_EMPTY_STR(zFormat) ){
return 0;
}
#endif
if( SXRET_OK != SyBlobInitFromBuf(&sBlob, zBuf, nLen - 1) ){
return 0;
}
va_start(ap, zFormat);
FormatMount(SXFMT_CONS_BLOB, &sBlob, 0, 0, 0, zFormat, ap);
va_end(ap);
n = SyBlobLength(&sBlob);
/* Append the null terminator */
sBlob.mByte++;
SyBlobAppend(&sBlob, "\0", sizeof(char));
return n;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
/*
* Zip File Format:
*
* Byte order: Little-endian
*
* [Local file header + Compressed data [+ Extended local header]?]*
* [Central directory]*
* [End of central directory record]
*
* Local file header:*
* Offset Length Contents
* 0 4 bytes Local file header signature (0x04034b50)
* 4 2 bytes Version needed to extract
* 6 2 bytes General purpose bit flag
* 8 2 bytes Compression method
* 10 2 bytes Last mod file time
* 12 2 bytes Last mod file date
* 14 4 bytes CRC-32
* 18 4 bytes Compressed size (n)
* 22 4 bytes Uncompressed size
* 26 2 bytes Filename length (f)
* 28 2 bytes Extra field length (e)
* 30 (f)bytes Filename
* (e)bytes Extra field
* (n)bytes Compressed data
*
* Extended local header:*
* Offset Length Contents
* 0 4 bytes Extended Local file header signature (0x08074b50)
* 4 4 bytes CRC-32
* 8 4 bytes Compressed size
* 12 4 bytes Uncompressed size
*
* Extra field:?(if any)
* Offset Length Contents
* 0 2 bytes Header ID (0x001 until 0xfb4a) see extended appnote from Info-zip
* 2 2 bytes Data size (g)
* (g) bytes (g) bytes of extra field
*
* Central directory:*
* Offset Length Contents
* 0 4 bytes Central file header signature (0x02014b50)
* 4 2 bytes Version made by
* 6 2 bytes Version needed to extract
* 8 2 bytes General purpose bit flag
* 10 2 bytes Compression method
* 12 2 bytes Last mod file time
* 14 2 bytes Last mod file date
* 16 4 bytes CRC-32
* 20 4 bytes Compressed size
* 24 4 bytes Uncompressed size
* 28 2 bytes Filename length (f)
* 30 2 bytes Extra field length (e)
* 32 2 bytes File comment length (c)
* 34 2 bytes Disk number start
* 36 2 bytes Internal file attributes
* 38 4 bytes External file attributes
* 42 4 bytes Relative offset of local header
* 46 (f)bytes Filename
* (e)bytes Extra field
* (c)bytes File comment
*
* End of central directory record:
* Offset Length Contents
* 0 4 bytes End of central dir signature (0x06054b50)
* 4 2 bytes Number of this disk
* 6 2 bytes Number of the disk with the start of the central directory
* 8 2 bytes Total number of entries in the central dir on this disk
* 10 2 bytes Total number of entries in the central dir
* 12 4 bytes Size of the central directory
* 16 4 bytes Offset of start of central directory with respect to the starting disk number
* 20 2 bytes zipfile comment length (c)
* 22 (c)bytes zipfile comment
*
* compression method: (2 bytes)
* 0 - The file is stored (no compression)
* 1 - The file is Shrunk
* 2 - The file is Reduced with compression factor 1
* 3 - The file is Reduced with compression factor 2
* 4 - The file is Reduced with compression factor 3
* 5 - The file is Reduced with compression factor 4
* 6 - The file is Imploded
* 7 - Reserved for Tokenizing compression algorithm
* 8 - The file is Deflated
*/
#define SXMAKE_ZIP_WORKBUF (SXU16_HIGH/2) /* 32KB Initial working buffer size */
#define SXMAKE_ZIP_EXTRACT_VER 0x000a /* Version needed to extract */
#define SXMAKE_ZIP_VER 0x003 /* Version made by */
#define SXZIP_CENTRAL_MAGIC 0x02014b50
#define SXZIP_END_CENTRAL_MAGIC 0x06054b50
#define SXZIP_LOCAL_MAGIC 0x04034b50
/*#define SXZIP_CRC32_START 0xdebb20e3*/
#define SXZIP_LOCAL_HDRSZ 30 /* Local header size */
#define SXZIP_LOCAL_EXT_HDRZ 16 /* Extended local header(footer) size */
#define SXZIP_CENTRAL_HDRSZ 46 /* Central directory header size */
#define SXZIP_END_CENTRAL_HDRSZ 22 /* End of central directory header size */
#define SXARCHIVE_HASH_SIZE 64 /* Starting hash table size(MUST BE POWER OF 2)*/
static sxi32 SyLittleEndianUnpack32(sxu32 *uNB, const unsigned char *buf, sxu32 Len)
{
if( Len < sizeof(sxu32) ){
return SXERR_SHORT;
}
*uNB = buf[0] + (buf[1] << 8) + (buf[2] << 16) + (buf[3] << 24);
return SXRET_OK;
}
static sxi32 SyLittleEndianUnpack16(sxu16 *pOut, const unsigned char *zBuf, sxu32 nLen)
{
if( nLen < sizeof(sxu16) ){
return SXERR_SHORT;
}
*pOut = zBuf[0] + (zBuf[1] <<8);
return SXRET_OK;
}
/*
* Archive hashtable manager
*/
static sxi32 ArchiveHashGetEntry(SyArchive *pArch, const char *zName, sxu32 nLen, SyArchiveEntry **ppEntry)
{
SyArchiveEntry *pBucketEntry;
SyString sEntry;
sxu32 nHash;
nHash = pArch->xHash(zName, nLen);
pBucketEntry = pArch->apHash[nHash & (pArch->nSize - 1)];
SyStringInitFromBuf(&sEntry, zName, nLen);
for(;;){
if( pBucketEntry == 0 ){
break;
}
if( nHash == pBucketEntry->nHash && pArch->xCmp(&sEntry, &pBucketEntry->sFileName) == 0 ){
if( ppEntry ){
*ppEntry = pBucketEntry;
}
return SXRET_OK;
}
pBucketEntry = pBucketEntry->pNextHash;
}
return SXERR_NOTFOUND;
}
static void ArchiveHashBucketInstall(SyArchiveEntry **apTable, sxu32 nBucket, SyArchiveEntry *pEntry)
{
pEntry->pNextHash = apTable[nBucket];
if( apTable[nBucket] != 0 ){
apTable[nBucket]->pPrevHash = pEntry;
}
apTable[nBucket] = pEntry;
}
static sxi32 ArchiveHashGrowTable(SyArchive *pArch)
{
sxu32 nNewSize = pArch->nSize * 2;
SyArchiveEntry **apNew;
SyArchiveEntry *pEntry;
sxu32 n;
/* Allocate a new table */
apNew = (SyArchiveEntry **)SyMemBackendAlloc(pArch->pAllocator, nNewSize * sizeof(SyArchiveEntry *));
if( apNew == 0 ){
return SXRET_OK; /* Not so fatal, simply a performance hit */
}
SyZero(apNew, nNewSize * sizeof(SyArchiveEntry *));
/* Rehash old entries */
for( n = 0 , pEntry = pArch->pList ; n < pArch->nLoaded ; n++ , pEntry = pEntry->pNext ){
pEntry->pNextHash = pEntry->pPrevHash = 0;
ArchiveHashBucketInstall(apNew, pEntry->nHash & (nNewSize - 1), pEntry);
}
/* Release the old table */
SyMemBackendFree(pArch->pAllocator, pArch->apHash);
pArch->apHash = apNew;
pArch->nSize = nNewSize;
return SXRET_OK;
}
static sxi32 ArchiveHashInstallEntry(SyArchive *pArch, SyArchiveEntry *pEntry)
{
if( pArch->nLoaded > pArch->nSize * 3 ){
ArchiveHashGrowTable(&(*pArch));
}
pEntry->nHash = pArch->xHash(SyStringData(&pEntry->sFileName), SyStringLength(&pEntry->sFileName));
/* Install the entry in its bucket */
ArchiveHashBucketInstall(pArch->apHash, pEntry->nHash & (pArch->nSize - 1), pEntry);
MACRO_LD_PUSH(pArch->pList, pEntry);
pArch->nLoaded++;
return SXRET_OK;
}
/*
* Parse the End of central directory and report status
*/
static sxi32 ParseEndOfCentralDirectory(SyArchive *pArch, const unsigned char *zBuf)
{
sxu32 nMagic = 0; /* cc -O6 warning */
sxi32 rc;
/* Sanity check */
rc = SyLittleEndianUnpack32(&nMagic, zBuf, sizeof(sxu32));
if( /* rc != SXRET_OK || */nMagic != SXZIP_END_CENTRAL_MAGIC ){
return SXERR_CORRUPT;
}
/* # of entries */
rc = SyLittleEndianUnpack16((sxu16 *)&pArch->nEntry, &zBuf[8], sizeof(sxu16));
if( /* rc != SXRET_OK || */ pArch->nEntry > SXI16_HIGH /* SXU16_HIGH */ ){
return SXERR_CORRUPT;
}
/* Size of central directory */
rc = SyLittleEndianUnpack32(&pArch->nCentralSize, &zBuf[12], sizeof(sxu32));
if( /*rc != SXRET_OK ||*/ pArch->nCentralSize > SXI32_HIGH ){
return SXERR_CORRUPT;
}
/* Starting offset of central directory */
rc = SyLittleEndianUnpack32(&pArch->nCentralOfft, &zBuf[16], sizeof(sxu32));
if( /*rc != SXRET_OK ||*/ pArch->nCentralSize > SXI32_HIGH ){
return SXERR_CORRUPT;
}
return SXRET_OK;
}
/*
* Fill the zip entry with the appropriate information from the central directory
*/
static sxi32 GetCentralDirectoryEntry(SyArchive *pArch, SyArchiveEntry *pEntry, const unsigned char *zCentral, sxu32 *pNextOffset)
{
SyString *pName = &pEntry->sFileName; /* File name */
sxu16 nDosDate, nDosTime;
sxu16 nComment = 0 ;
sxu32 nMagic = 0; /* cc -O6 warning */
sxi32 rc;
nDosDate = nDosTime = 0; /* cc -O6 warning */
SXUNUSED(pArch);
/* Sanity check */
rc = SyLittleEndianUnpack32(&nMagic, zCentral, sizeof(sxu32));
if( /* rc != SXRET_OK || */ nMagic != SXZIP_CENTRAL_MAGIC ){
rc = SXERR_CORRUPT;
/*
* Try to recover by examing the next central directory record.
* Dont worry here, there is no risk of an infinite loop since
* the buffer size is delimited.
*/
/* pName->nByte = 0; nComment = 0; pName->nExtra = 0 */
goto update;
}
/*
* entry name length
*/
SyLittleEndianUnpack16((sxu16 *)&pName->nByte, &zCentral[28], sizeof(sxu16));
if( pName->nByte > SXI16_HIGH /* SXU16_HIGH */){
rc = SXERR_BIG;
goto update;
}
/* Extra information */
SyLittleEndianUnpack16(&pEntry->nExtra, &zCentral[30], sizeof(sxu16));
/* Comment length */
SyLittleEndianUnpack16(&nComment, &zCentral[32], sizeof(sxu16));
/* Compression method 0 == stored / 8 == deflated */
rc = SyLittleEndianUnpack16(&pEntry->nComprMeth, &zCentral[10], sizeof(sxu16));
/* DOS Timestamp */
SyLittleEndianUnpack16(&nDosTime, &zCentral[12], sizeof(sxu16));
SyLittleEndianUnpack16(&nDosDate, &zCentral[14], sizeof(sxu16));
SyDosTimeFormat((nDosDate << 16 | nDosTime), &pEntry->sFmt);
/* Little hack to fix month index */
pEntry->sFmt.tm_mon--;
/* CRC32 */
rc = SyLittleEndianUnpack32(&pEntry->nCrc, &zCentral[16], sizeof(sxu32));
/* Content size before compression */
rc = SyLittleEndianUnpack32(&pEntry->nByte, &zCentral[24], sizeof(sxu32));
if( pEntry->nByte > SXI32_HIGH ){
rc = SXERR_BIG;
goto update;
}
/*
* Content size after compression.
* Note that if the file is stored pEntry->nByte should be equal to pEntry->nByteCompr
*/
rc = SyLittleEndianUnpack32(&pEntry->nByteCompr, &zCentral[20], sizeof(sxu32));
if( pEntry->nByteCompr > SXI32_HIGH ){
rc = SXERR_BIG;
goto update;
}
/* Finally grab the contents offset */
SyLittleEndianUnpack32(&pEntry->nOfft, &zCentral[42], sizeof(sxu32));
if( pEntry->nOfft > SXI32_HIGH ){
rc = SXERR_BIG;
goto update;
}
rc = SXRET_OK;
update:
/* Update the offset to point to the next central directory record */
*pNextOffset = SXZIP_CENTRAL_HDRSZ + pName->nByte + pEntry->nExtra + nComment;
return rc; /* Report failure or success */
}
static sxi32 ZipFixOffset(SyArchiveEntry *pEntry, void *pSrc)
{
sxu16 nExtra, nNameLen;
unsigned char *zHdr;
nExtra = nNameLen = 0;
zHdr = (unsigned char *)pSrc;
zHdr = &zHdr[pEntry->nOfft];
if( SyMemcmp(zHdr, "PK\003\004", sizeof(sxu32)) != 0 ){
return SXERR_CORRUPT;
}
SyLittleEndianUnpack16(&nNameLen, &zHdr[26], sizeof(sxu16));
SyLittleEndianUnpack16(&nExtra, &zHdr[28], sizeof(sxu16));
/* Fix contents offset */
pEntry->nOfft += SXZIP_LOCAL_HDRSZ + nExtra + nNameLen;
return SXRET_OK;
}
/*
* Extract all valid entries from the central directory
*/
static sxi32 ZipExtract(SyArchive *pArch, const unsigned char *zCentral, sxu32 nLen, void *pSrc)
{
SyArchiveEntry *pEntry, *pDup;
const unsigned char *zEnd ; /* End of central directory */
sxu32 nIncr, nOfft; /* Central Offset */
SyString *pName; /* Entry name */
char *zName;
sxi32 rc;
nOfft = nIncr = 0;
zEnd = &zCentral[nLen];
for(;;){
if( &zCentral[nOfft] >= zEnd ){
break;
}
/* Add a new entry */
pEntry = (SyArchiveEntry *)SyMemBackendPoolAlloc(pArch->pAllocator, sizeof(SyArchiveEntry));
if( pEntry == 0 ){
break;
}
SyZero(pEntry, sizeof(SyArchiveEntry));
pEntry->nMagic = SXARCH_MAGIC;
nIncr = 0;
rc = GetCentralDirectoryEntry(&(*pArch), pEntry, &zCentral[nOfft], &nIncr);
if( rc == SXRET_OK ){
/* Fix the starting record offset so we can access entry contents correctly */
rc = ZipFixOffset(pEntry, pSrc);
}
if(rc != SXRET_OK ){
sxu32 nJmp = 0;
SyMemBackendPoolFree(pArch->pAllocator, pEntry);
/* Try to recover by brute-forcing for a valid central directory record */
if( SXRET_OK == SyBlobSearch((const void *)&zCentral[nOfft + nIncr], (sxu32)(zEnd - &zCentral[nOfft + nIncr]),
(const void *)"PK\001\002", sizeof(sxu32), &nJmp)){
nOfft += nIncr + nJmp; /* Check next entry */
continue;
}
break; /* Giving up, archive is hopelessly corrupted */
}
pName = &pEntry->sFileName;
pName->zString = (const char *)&zCentral[nOfft + SXZIP_CENTRAL_HDRSZ];
if( pName->nByte <= 0 || ( pEntry->nByte <= 0 && pName->zString[pName->nByte - 1] != '/') ){
/* Ignore zero length records (except folders) and records without names */
SyMemBackendPoolFree(pArch->pAllocator, pEntry);
nOfft += nIncr; /* Check next entry */
continue;
}
zName = SyMemBackendStrDup(pArch->pAllocator, pName->zString, pName->nByte);
if( zName == 0 ){
SyMemBackendPoolFree(pArch->pAllocator, pEntry);
nOfft += nIncr; /* Check next entry */
continue;
}
pName->zString = (const char *)zName;
/* Check for duplicates */
rc = ArchiveHashGetEntry(&(*pArch), pName->zString, pName->nByte, &pDup);
if( rc == SXRET_OK ){
/* Another entry with the same name exists ; link them together */
pEntry->pNextName = pDup->pNextName;
pDup->pNextName = pEntry;
pDup->nDup++;
}else{
/* Insert in hashtable */
ArchiveHashInstallEntry(pArch, pEntry);
}
nOfft += nIncr; /* Check next record */
}
pArch->pCursor = pArch->pList;
return pArch->nLoaded > 0 ? SXRET_OK : SXERR_EMPTY;
}
JX9_PRIVATE sxi32 SyZipExtractFromBuf(SyArchive *pArch, const char *zBuf, sxu32 nLen)
{
const unsigned char *zCentral, *zEnd;
sxi32 rc;
#if defined(UNTRUST)
if( SXARCH_INVALID(pArch) || zBuf == 0 ){
return SXERR_INVALID;
}
#endif
/* The miminal size of a zip archive:
* LOCAL_HDR_SZ + CENTRAL_HDR_SZ + END_OF_CENTRAL_HDR_SZ
* 30 46 22
*/
if( nLen < SXZIP_LOCAL_HDRSZ + SXZIP_CENTRAL_HDRSZ + SXZIP_END_CENTRAL_HDRSZ ){
return SXERR_CORRUPT; /* Don't bother processing return immediately */
}
zEnd = (unsigned char *)&zBuf[nLen - SXZIP_END_CENTRAL_HDRSZ];
/* Find the end of central directory */
while( ((sxu32)((unsigned char *)&zBuf[nLen] - zEnd) < (SXZIP_END_CENTRAL_HDRSZ + SXI16_HIGH)) &&
zEnd > (unsigned char *)zBuf && SyMemcmp(zEnd, "PK\005\006", sizeof(sxu32)) != 0 ){
zEnd--;
}
/* Parse the end of central directory */
rc = ParseEndOfCentralDirectory(&(*pArch), zEnd);
if( rc != SXRET_OK ){
return rc;
}
/* Find the starting offset of the central directory */
zCentral = &zEnd[-(sxi32)pArch->nCentralSize];
if( zCentral <= (unsigned char *)zBuf || SyMemcmp(zCentral, "PK\001\002", sizeof(sxu32)) != 0 ){
if( pArch->nCentralOfft >= nLen ){
/* Corrupted central directory offset */
return SXERR_CORRUPT;
}
zCentral = (unsigned char *)&zBuf[pArch->nCentralOfft];
if( SyMemcmp(zCentral, "PK\001\002", sizeof(sxu32)) != 0 ){
/* Corrupted zip archive */
return SXERR_CORRUPT;
}
/* Fall thru and extract all valid entries from the central directory */
}
rc = ZipExtract(&(*pArch), zCentral, (sxu32)(zEnd - zCentral), (void *)zBuf);
return rc;
}
/*
* Default comparison function.
*/
static sxi32 ArchiveHashCmp(const SyString *pStr1, const SyString *pStr2)
{
sxi32 rc;
rc = SyStringCmp(pStr1, pStr2, SyMemcmp);
return rc;
}
JX9_PRIVATE sxi32 SyArchiveInit(SyArchive *pArch, SyMemBackend *pAllocator, ProcHash xHash, ProcRawStrCmp xCmp)
{
SyArchiveEntry **apHash;
#if defined(UNTRUST)
if( pArch == 0 ){
return SXERR_EMPTY;
}
#endif
SyZero(pArch, sizeof(SyArchive));
/* Allocate a new hashtable */
apHash = (SyArchiveEntry **)SyMemBackendAlloc(&(*pAllocator), SXARCHIVE_HASH_SIZE * sizeof(SyArchiveEntry *));
if( apHash == 0){
return SXERR_MEM;
}
SyZero(apHash, SXARCHIVE_HASH_SIZE * sizeof(SyArchiveEntry *));
pArch->apHash = apHash;
pArch->xHash = xHash ? xHash : SyBinHash;
pArch->xCmp = xCmp ? xCmp : ArchiveHashCmp;
pArch->nSize = SXARCHIVE_HASH_SIZE;
pArch->pAllocator = &(*pAllocator);
pArch->nMagic = SXARCH_MAGIC;
return SXRET_OK;
}
static sxi32 ArchiveReleaseEntry(SyMemBackend *pAllocator, SyArchiveEntry *pEntry)
{
SyArchiveEntry *pDup = pEntry->pNextName;
SyArchiveEntry *pNextDup;
/* Release duplicates first since there are not stored in the hashtable */
for(;;){
if( pEntry->nDup == 0 ){
break;
}
pNextDup = pDup->pNextName;
pDup->nMagic = 0x2661;
SyMemBackendFree(pAllocator, (void *)SyStringData(&pDup->sFileName));
SyMemBackendPoolFree(pAllocator, pDup);
pDup = pNextDup;
pEntry->nDup--;
}
pEntry->nMagic = 0x2661;
SyMemBackendFree(pAllocator, (void *)SyStringData(&pEntry->sFileName));
SyMemBackendPoolFree(pAllocator, pEntry);
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyArchiveRelease(SyArchive *pArch)
{
SyArchiveEntry *pEntry, *pNext;
pEntry = pArch->pList;
for(;;){
if( pArch->nLoaded < 1 ){
break;
}
pNext = pEntry->pNext;
MACRO_LD_REMOVE(pArch->pList, pEntry);
ArchiveReleaseEntry(pArch->pAllocator, pEntry);
pEntry = pNext;
pArch->nLoaded--;
}
SyMemBackendFree(pArch->pAllocator, pArch->apHash);
pArch->pCursor = 0;
pArch->nMagic = 0x2626;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyArchiveResetLoopCursor(SyArchive *pArch)
{
pArch->pCursor = pArch->pList;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyArchiveGetNextEntry(SyArchive *pArch, SyArchiveEntry **ppEntry)
{
SyArchiveEntry *pNext;
if( pArch->pCursor == 0 ){
/* Rewind the cursor */
pArch->pCursor = pArch->pList;
return SXERR_EOF;
}
*ppEntry = pArch->pCursor;
pNext = pArch->pCursor->pNext;
/* Advance the cursor to the next entry */
pArch->pCursor = pNext;
return SXRET_OK;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/*
* Psuedo Random Number Generator (PRNG)
* @authors: SQLite authors <http://www.sqlite.org/>
* @status: Public Domain
* NOTE:
* Nothing in this file or anywhere else in the library does any kind of
* encryption.The RC4 algorithm is being used as a PRNG (pseudo-random
* number generator) not as an encryption device.
*/
#define SXPRNG_MAGIC 0x13C4
#ifdef __UNIXES__
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#endif
static sxi32 SyOSUtilRandomSeed(void *pBuf, sxu32 nLen, void *pUnused)
{
char *zBuf = (char *)pBuf;
#ifdef __WINNT__
DWORD nProcessID; /* Yes, keep it uninitialized when compiling using the MinGW32 builds tools */
#elif defined(__UNIXES__)
pid_t pid;
int fd;
#else
char zGarbage[128]; /* Yes, keep this buffer uninitialized */
#endif
SXUNUSED(pUnused);
#ifdef __WINNT__
#ifndef __MINGW32__
nProcessID = GetProcessId(GetCurrentProcess());
#endif
SyMemcpy((const void *)&nProcessID, zBuf, SXMIN(nLen, sizeof(DWORD)));
if( (sxu32)(&zBuf[nLen] - &zBuf[sizeof(DWORD)]) >= sizeof(SYSTEMTIME) ){
GetSystemTime((LPSYSTEMTIME)&zBuf[sizeof(DWORD)]);
}
#elif defined(__UNIXES__)
fd = open("/dev/urandom", O_RDONLY);
if (fd >= 0 ){
if( read(fd, zBuf, nLen) > 0 ){
close(fd);
return SXRET_OK;
}
/* FALL THRU */
close(fd);
}
pid = getpid();
SyMemcpy((const void *)&pid, zBuf, SXMIN(nLen, sizeof(pid_t)));
if( &zBuf[nLen] - &zBuf[sizeof(pid_t)] >= (int)sizeof(struct timeval) ){
gettimeofday((struct timeval *)&zBuf[sizeof(pid_t)], 0);
}
#else
/* Fill with uninitialized data */
SyMemcpy(zGarbage, zBuf, SXMIN(nLen, sizeof(zGarbage)));
#endif
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyRandomnessInit(SyPRNGCtx *pCtx, ProcRandomSeed xSeed, void * pUserData)
{
char zSeed[256];
sxu8 t;
sxi32 rc;
sxu32 i;
if( pCtx->nMagic == SXPRNG_MAGIC ){
return SXRET_OK; /* Already initialized */
}
/* Initialize the state of the random number generator once,
** the first time this routine is called.The seed value does
** not need to contain a lot of randomness since we are not
** trying to do secure encryption or anything like that...
*/
if( xSeed == 0 ){
xSeed = SyOSUtilRandomSeed;
}
rc = xSeed(zSeed, sizeof(zSeed), pUserData);
if( rc != SXRET_OK ){
return rc;
}
pCtx->i = pCtx->j = 0;
for(i=0; i < SX_ARRAYSIZE(pCtx->s) ; i++){
pCtx->s[i] = (unsigned char)i;
}
for(i=0; i < sizeof(zSeed) ; i++){
pCtx->j += pCtx->s[i] + zSeed[i];
t = pCtx->s[pCtx->j];
pCtx->s[pCtx->j] = pCtx->s[i];
pCtx->s[i] = t;
}
pCtx->nMagic = SXPRNG_MAGIC;
return SXRET_OK;
}
/*
* Get a single 8-bit random value using the RC4 PRNG.
*/
static sxu8 randomByte(SyPRNGCtx *pCtx)
{
sxu8 t;
/* Generate and return single random byte */
pCtx->i++;
t = pCtx->s[pCtx->i];
pCtx->j += t;
pCtx->s[pCtx->i] = pCtx->s[pCtx->j];
pCtx->s[pCtx->j] = t;
t += pCtx->s[pCtx->i];
return pCtx->s[t];
}
JX9_PRIVATE sxi32 SyRandomness(SyPRNGCtx *pCtx, void *pBuf, sxu32 nLen)
{
unsigned char *zBuf = (unsigned char *)pBuf;
unsigned char *zEnd = &zBuf[nLen];
#if defined(UNTRUST)
if( pCtx == 0 || pBuf == 0 || nLen <= 0 ){
return SXERR_EMPTY;
}
#endif
if(pCtx->nMagic != SXPRNG_MAGIC ){
return SXERR_CORRUPT;
}
for(;;){
if( zBuf >= zEnd ){break;} zBuf[0] = randomByte(pCtx); zBuf++;
if( zBuf >= zEnd ){break;} zBuf[0] = randomByte(pCtx); zBuf++;
if( zBuf >= zEnd ){break;} zBuf[0] = randomByte(pCtx); zBuf++;
if( zBuf >= zEnd ){break;} zBuf[0] = randomByte(pCtx); zBuf++;
}
return SXRET_OK;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_HASH_FUNC
/* SyRunTimeApi: sxhash.c */
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest.This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*
* To compute the message digest of a chunk of bytes, declare an
* MD5Context structure, pass it to MD5Init, call MD5Update as
* needed on buffers full of bytes, and then call MD5Final, which
* will fill a supplied 16-byte array with the digest.
*/
#define SX_MD5_BINSZ 16
#define SX_MD5_HEXSZ 32
/*
* Note: this code is harmless on little-endian machines.
*/
static void byteReverse (unsigned char *buf, unsigned longs)
{
sxu32 t;
do {
t = (sxu32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
((unsigned)buf[1]<<8 | buf[0]);
*(sxu32*)buf = t;
buf += 4;
} while (--longs);
}
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#ifdef F1
#undef F1
#endif
#ifdef F2
#undef F2
#endif
#ifdef F3
#undef F3
#endif
#ifdef F4
#undef F4
#endif
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm.*/
#define SX_MD5STEP(f, w, x, y, z, data, s) \
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data.MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
static void MD5Transform(sxu32 buf[4], const sxu32 in[16])
{
register sxu32 a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
SX_MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);
SX_MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);
SX_MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);
SX_MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);
SX_MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);
SX_MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);
SX_MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);
SX_MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);
SX_MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);
SX_MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);
SX_MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);
SX_MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);
SX_MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);
SX_MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);
SX_MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);
SX_MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);
SX_MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);
SX_MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);
SX_MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);
SX_MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);
SX_MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);
SX_MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);
SX_MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);
SX_MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);
SX_MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);
SX_MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);
SX_MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);
SX_MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);
SX_MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);
SX_MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);
SX_MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);
SX_MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);
SX_MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);
SX_MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);
SX_MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);
SX_MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);
SX_MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);
SX_MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);
SX_MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);
SX_MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);
SX_MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);
SX_MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);
SX_MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);
SX_MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);
SX_MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);
SX_MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);
SX_MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);
SX_MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);
SX_MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);
SX_MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);
SX_MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);
SX_MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);
SX_MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);
SX_MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);
SX_MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);
SX_MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);
SX_MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);
SX_MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);
SX_MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);
SX_MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);
SX_MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);
SX_MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);
SX_MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);
SX_MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
JX9_PRIVATE void MD5Update(MD5Context *ctx, const unsigned char *buf, unsigned int len)
{
sxu32 t;
/* Update bitcount */
t = ctx->bits[0];
if ((ctx->bits[0] = t + ((sxu32)len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
/* Handle any leading odd-sized chunks */
if ( t ) {
unsigned char *p = (unsigned char *)ctx->in + t;
t = 64-t;
if (len < t) {
SyMemcpy(buf, p, len);
return;
}
SyMemcpy(buf, p, t);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (sxu32*)ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64) {
SyMemcpy(buf, ctx->in, 64);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (sxu32*)ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data.*/
SyMemcpy(buf, ctx->in, len);
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
JX9_PRIVATE void MD5Final(unsigned char digest[16], MD5Context *ctx){
unsigned count;
unsigned char *p;
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* Set the first char of padding to 0x80.This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
SyZero(p, count);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (sxu32*)ctx->in);
/* Now fill the next block with 56 bytes */
SyZero(ctx->in, 56);
} else {
/* Pad block to 56 bytes */
SyZero(p, count-8);
}
byteReverse(ctx->in, 14);
/* Append length in bits and transform */
((sxu32*)ctx->in)[ 14 ] = ctx->bits[0];
((sxu32*)ctx->in)[ 15 ] = ctx->bits[1];
MD5Transform(ctx->buf, (sxu32*)ctx->in);
byteReverse((unsigned char *)ctx->buf, 4);
SyMemcpy(ctx->buf, digest, 0x10);
SyZero(ctx, sizeof(ctx)); /* In case it's sensitive */
}
#undef F1
#undef F2
#undef F3
#undef F4
JX9_PRIVATE sxi32 MD5Init(MD5Context *pCtx)
{
pCtx->buf[0] = 0x67452301;
pCtx->buf[1] = 0xefcdab89;
pCtx->buf[2] = 0x98badcfe;
pCtx->buf[3] = 0x10325476;
pCtx->bits[0] = 0;
pCtx->bits[1] = 0;
return SXRET_OK;
}
JX9_PRIVATE sxi32 SyMD5Compute(const void *pIn, sxu32 nLen, unsigned char zDigest[16])
{
MD5Context sCtx;
MD5Init(&sCtx);
MD5Update(&sCtx, (const unsigned char *)pIn, nLen);
MD5Final(zDigest, &sCtx);
return SXRET_OK;
}
/*
* SHA-1 in C
* By Steve Reid <steve@edmweb.com>
* Status: Public Domain
*/
/*
* blk0() and blk() perform the initial expand.
* I got the idea of expanding during the round function from SSLeay
*
* blk0le() for little-endian and blk0be() for big-endian.
*/
#if __GNUC__ && (defined(__i386__) || defined(__x86_64__))
/*
* GCC by itself only generates left rotates. Use right rotates if
* possible to be kinder to dinky implementations with iterative rotate
* instructions.
*/
#define SHA_ROT(op, x, k) \
({ unsigned int y; asm(op " %1, %0" : "=r" (y) : "I" (k), "0" (x)); y; })
#define rol(x, k) SHA_ROT("roll", x, k)
#define ror(x, k) SHA_ROT("rorl", x, k)
#else
/* Generic C equivalent */
#define SHA_ROT(x, l, r) ((x) << (l) | (x) >> (r))
#define rol(x, k) SHA_ROT(x, k, 32-(k))
#define ror(x, k) SHA_ROT(x, 32-(k), k)
#endif
#define blk0le(i) (block[i] = (ror(block[i], 8)&0xFF00FF00) \
|(rol(block[i], 8)&0x00FF00FF))
#define blk0be(i) block[i]
#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
^block[(i+2)&15]^block[i&15], 1))
/*
* (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
*
* Rl0() for little-endian and Rb0() for big-endian. Endianness is
* determined at run-time.
*/
#define Rl0(v, w, x, y, z, i) \
z+=((w&(x^y))^y)+blk0le(i)+0x5A827999+rol(v, 5);w=ror(w, 2);
#define Rb0(v, w, x, y, z, i) \
z+=((w&(x^y))^y)+blk0be(i)+0x5A827999+rol(v, 5);w=ror(w, 2);
#define R1(v, w, x, y, z, i) \
z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v, 5);w=ror(w, 2);
#define R2(v, w, x, y, z, i) \
z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v, 5);w=ror(w, 2);
#define R3(v, w, x, y, z, i) \
z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v, 5);w=ror(w, 2);
#define R4(v, w, x, y, z, i) \
z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v, 5);w=ror(w, 2);
/*
* Hash a single 512-bit block. This is the core of the algorithm.
*/
#define a qq[0]
#define b qq[1]
#define c qq[2]
#define d qq[3]
#define e qq[4]
static void SHA1Transform(unsigned int state[5], const unsigned char buffer[64])
{
unsigned int qq[5]; /* a, b, c, d, e; */
static int one = 1;
unsigned int block[16];
SyMemcpy(buffer, (void *)block, 64);
SyMemcpy(state, qq, 5*sizeof(unsigned int));
/* Copy context->state[] to working vars */
/*
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
*/
/* 4 rounds of 20 operations each. Loop unrolled. */
if( 1 == *(unsigned char*)&one ){
Rl0(a, b, c, d, e, 0); Rl0(e, a, b, c, d, 1); Rl0(d, e, a, b, c, 2); Rl0(c, d, e, a, b, 3);
Rl0(b, c, d, e, a, 4); Rl0(a, b, c, d, e, 5); Rl0(e, a, b, c, d, 6); Rl0(d, e, a, b, c, 7);
Rl0(c, d, e, a, b, 8); Rl0(b, c, d, e, a, 9); Rl0(a, b, c, d, e, 10); Rl0(e, a, b, c, d, 11);
Rl0(d, e, a, b, c, 12); Rl0(c, d, e, a, b, 13); Rl0(b, c, d, e, a, 14); Rl0(a, b, c, d, e, 15);
}else{
Rb0(a, b, c, d, e, 0); Rb0(e, a, b, c, d, 1); Rb0(d, e, a, b, c, 2); Rb0(c, d, e, a, b, 3);
Rb0(b, c, d, e, a, 4); Rb0(a, b, c, d, e, 5); Rb0(e, a, b, c, d, 6); Rb0(d, e, a, b, c, 7);
Rb0(c, d, e, a, b, 8); Rb0(b, c, d, e, a, 9); Rb0(a, b, c, d, e, 10); Rb0(e, a, b, c, d, 11);
Rb0(d, e, a, b, c, 12); Rb0(c, d, e, a, b, 13); Rb0(b, c, d, e, a, 14); Rb0(a, b, c, d, e, 15);
}
R1(e, a, b, c, d, 16); R1(d, e, a, b, c, 17); R1(c, d, e, a, b, 18); R1(b, c, d, e, a, 19);
R2(a, b, c, d, e, 20); R2(e, a, b, c, d, 21); R2(d, e, a, b, c, 22); R2(c, d, e, a, b, 23);
R2(b, c, d, e, a, 24); R2(a, b, c, d, e, 25); R2(e, a, b, c, d, 26); R2(d, e, a, b, c, 27);
R2(c, d, e, a, b, 28); R2(b, c, d, e, a, 29); R2(a, b, c, d, e, 30); R2(e, a, b, c, d, 31);
R2(d, e, a, b, c, 32); R2(c, d, e, a, b, 33); R2(b, c, d, e, a, 34); R2(a, b, c, d, e, 35);
R2(e, a, b, c, d, 36); R2(d, e, a, b, c, 37); R2(c, d, e, a, b, 38); R2(b, c, d, e, a, 39);
R3(a, b, c, d, e, 40); R3(e, a, b, c, d, 41); R3(d, e, a, b, c, 42); R3(c, d, e, a, b, 43);
R3(b, c, d, e, a, 44); R3(a, b, c, d, e, 45); R3(e, a, b, c, d, 46); R3(d, e, a, b, c, 47);
R3(c, d, e, a, b, 48); R3(b, c, d, e, a, 49); R3(a, b, c, d, e, 50); R3(e, a, b, c, d, 51);
R3(d, e, a, b, c, 52); R3(c, d, e, a, b, 53); R3(b, c, d, e, a, 54); R3(a, b, c, d, e, 55);
R3(e, a, b, c, d, 56); R3(d, e, a, b, c, 57); R3(c, d, e, a, b, 58); R3(b, c, d, e, a, 59);
R4(a, b, c, d, e, 60); R4(e, a, b, c, d, 61); R4(d, e, a, b, c, 62); R4(c, d, e, a, b, 63);
R4(b, c, d, e, a, 64); R4(a, b, c, d, e, 65); R4(e, a, b, c, d, 66); R4(d, e, a, b, c, 67);
R4(c, d, e, a, b, 68); R4(b, c, d, e, a, 69); R4(a, b, c, d, e, 70); R4(e, a, b, c, d, 71);
R4(d, e, a, b, c, 72); R4(c, d, e, a, b, 73); R4(b, c, d, e, a, 74); R4(a, b, c, d, e, 75);
R4(e, a, b, c, d, 76); R4(d, e, a, b, c, 77); R4(c, d, e, a, b, 78); R4(b, c, d, e, a, 79);
/* Add the working vars back into context.state[] */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
}
#undef a
#undef b
#undef c
#undef d
#undef e
/*
* SHA1Init - Initialize new context
*/
JX9_PRIVATE void SHA1Init(SHA1Context *context){
/* SHA1 initialization constants */
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
context->state[4] = 0xC3D2E1F0;
context->count[0] = context->count[1] = 0;
}
/*
* Run your data through this.
*/
JX9_PRIVATE void SHA1Update(SHA1Context *context, const unsigned char *data, unsigned int len){
unsigned int i, j;
j = context->count[0];
if ((context->count[0] += len << 3) < j)
context->count[1] += (len>>29)+1;
j = (j >> 3) & 63;
if ((j + len) > 63) {
(void)SyMemcpy(data, &context->buffer[j], (i = 64-j));
SHA1Transform(context->state, context->buffer);
for ( ; i + 63 < len; i += 64)
SHA1Transform(context->state, &data[i]);
j = 0;
} else {
i = 0;
}
(void)SyMemcpy(&data[i], &context->buffer[j], len - i);
}
/*
* Add padding and return the message digest.
*/
JX9_PRIVATE void SHA1Final(SHA1Context *context, unsigned char digest[20]){
unsigned int i;
unsigned char finalcount[8];
for (i = 0; i < 8; i++) {
finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
>> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
}
SHA1Update(context, (const unsigned char *)"\200", 1);
while ((context->count[0] & 504) != 448)
SHA1Update(context, (const unsigned char *)"\0", 1);
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
if (digest) {
for (i = 0; i < 20; i++)
digest[i] = (unsigned char)
((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
}
}
#undef Rl0
#undef Rb0
#undef R1
#undef R2
#undef R3
#undef R4
JX9_PRIVATE sxi32 SySha1Compute(const void *pIn, sxu32 nLen, unsigned char zDigest[20])
{
SHA1Context sCtx;
SHA1Init(&sCtx);
SHA1Update(&sCtx, (const unsigned char *)pIn, nLen);
SHA1Final(&sCtx, zDigest);
return SXRET_OK;
}
static const sxu32 crc32_table[] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
};
#define CRC32C(c, d) (c = ( crc32_table[(c ^ (d)) & 0xFF] ^ (c>>8) ) )
static sxu32 SyCrc32Update(sxu32 crc32, const void *pSrc, sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
if( zIn == 0 ){
return crc32;
}
zEnd = &zIn[nLen];
for(;;){
if(zIn >= zEnd ){ break; } CRC32C(crc32, zIn[0]); zIn++;
if(zIn >= zEnd ){ break; } CRC32C(crc32, zIn[0]); zIn++;
if(zIn >= zEnd ){ break; } CRC32C(crc32, zIn[0]); zIn++;
if(zIn >= zEnd ){ break; } CRC32C(crc32, zIn[0]); zIn++;
}
return crc32;
}
JX9_PRIVATE sxu32 SyCrc32(const void *pSrc, sxu32 nLen)
{
return SyCrc32Update(SXU32_HIGH, pSrc, nLen);
}
#endif /* JX9_DISABLE_HASH_FUNC */
#endif /* JX9_DISABLE_BUILTIN_FUNC */
#ifndef JX9_DISABLE_BUILTIN_FUNC
JX9_PRIVATE sxi32 SyBinToHexConsumer(const void *pIn, sxu32 nLen, ProcConsumer xConsumer, void *pConsumerData)
{
static const unsigned char zHexTab[] = "0123456789abcdef";
const unsigned char *zIn, *zEnd;
unsigned char zOut[3];
sxi32 rc;
#if defined(UNTRUST)
if( pIn == 0 || xConsumer == 0 ){
return SXERR_EMPTY;
}
#endif
zIn = (const unsigned char *)pIn;
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){
break;
}
zOut[0] = zHexTab[zIn[0] >> 4]; zOut[1] = zHexTab[zIn[0] & 0x0F];
rc = xConsumer((const void *)zOut, sizeof(char)*2, pConsumerData);
if( rc != SXRET_OK ){
return rc;
}
zIn++;
}
return SXRET_OK;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
JX9_PRIVATE void SyBigEndianPack32(unsigned char *buf,sxu32 nb)
{
buf[3] = nb & 0xFF ; nb >>=8;
buf[2] = nb & 0xFF ; nb >>=8;
buf[1] = nb & 0xFF ; nb >>=8;
buf[0] = (unsigned char)nb ;
}
JX9_PRIVATE void SyBigEndianUnpack32(const unsigned char *buf,sxu32 *uNB)
{
*uNB = buf[3] + (buf[2] << 8) + (buf[1] << 16) + (buf[0] << 24);
}
JX9_PRIVATE void SyBigEndianPack16(unsigned char *buf,sxu16 nb)
{
buf[1] = nb & 0xFF ; nb >>=8;
buf[0] = (unsigned char)nb ;
}
JX9_PRIVATE void SyBigEndianUnpack16(const unsigned char *buf,sxu16 *uNB)
{
*uNB = buf[1] + (buf[0] << 8);
}
JX9_PRIVATE void SyBigEndianPack64(unsigned char *buf,sxu64 n64)
{
buf[7] = n64 & 0xFF; n64 >>=8;
buf[6] = n64 & 0xFF; n64 >>=8;
buf[5] = n64 & 0xFF; n64 >>=8;
buf[4] = n64 & 0xFF; n64 >>=8;
buf[3] = n64 & 0xFF; n64 >>=8;
buf[2] = n64 & 0xFF; n64 >>=8;
buf[1] = n64 & 0xFF; n64 >>=8;
buf[0] = (sxu8)n64 ;
}
JX9_PRIVATE void SyBigEndianUnpack64(const unsigned char *buf,sxu64 *n64)
{
sxu32 u1,u2;
u1 = buf[7] + (buf[6] << 8) + (buf[5] << 16) + (buf[4] << 24);
u2 = buf[3] + (buf[2] << 8) + (buf[1] << 16) + (buf[0] << 24);
*n64 = (((sxu64)u2) << 32) | u1;
}
JX9_PRIVATE sxi32 SyBlobAppendBig64(SyBlob *pBlob,sxu64 n64)
{
unsigned char zBuf[8];
sxi32 rc;
SyBigEndianPack64(zBuf,n64);
rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
return rc;
}
JX9_PRIVATE sxi32 SyBlobAppendBig32(SyBlob *pBlob,sxu32 n32)
{
unsigned char zBuf[4];
sxi32 rc;
SyBigEndianPack32(zBuf,n32);
rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
return rc;
}
JX9_PRIVATE sxi32 SyBlobAppendBig16(SyBlob *pBlob,sxu16 n16)
{
unsigned char zBuf[2];
sxi32 rc;
SyBigEndianPack16(zBuf,n16);
rc = SyBlobAppend(pBlob,(const void *)zBuf,sizeof(zBuf));
return rc;
}
JX9_PRIVATE void SyTimeFormatToDos(Sytm *pFmt,sxu32 *pOut)
{
sxi32 nDate,nTime;
nDate = ((pFmt->tm_year - 1980) << 9) + (pFmt->tm_mon << 5) + pFmt->tm_mday;
nTime = (pFmt->tm_hour << 11) + (pFmt->tm_min << 5)+ (pFmt->tm_sec >> 1);
*pOut = (nDate << 16) | nTime;
}
JX9_PRIVATE void SyDosTimeFormat(sxu32 nDosDate, Sytm *pOut)
{
sxu16 nDate;
sxu16 nTime;
nDate = nDosDate >> 16;
nTime = nDosDate & 0xFFFF;
pOut->tm_isdst = 0;
pOut->tm_year = 1980 + (nDate >> 9);
pOut->tm_mon = (nDate % (1<<9))>>5;
pOut->tm_mday = (nDate % (1<<9))&0x1F;
pOut->tm_hour = nTime >> 11;
pOut->tm_min = (nTime % (1<<11)) >> 5;
pOut->tm_sec = ((nTime % (1<<11))& 0x1F )<<1;
}
/*
* ----------------------------------------------------------
* File: jx9_memobj.c
* MD5: 8692d7f4cb297c0946066b4a9034c637
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: memobj.c v2.7 FreeBSD 2012-08-09 03:40 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* This file manage low-level stuff related to indexed memory objects [i.e: jx9_value] */
/*
* Notes on memory objects [i.e: jx9_value].
* Internally, the JX9 virtual machine manipulates nearly all JX9 values
* [i.e: string, int, float, resource, object, bool, null..] as jx9_values structures.
* Each jx9_values struct may cache multiple representations (string,
* integer etc.) of the same value.
*/
/*
* Convert a 64-bit IEEE double into a 64-bit signed integer.
* If the double is too large, return 0x8000000000000000.
*
* Most systems appear to do this simply by assigning ariables and without
* the extra range tests.
* But there are reports that windows throws an expection if the floating
* point value is out of range.
*/
static sxi64 MemObjRealToInt(jx9_value *pObj)
{
#ifdef JX9_OMIT_FLOATING_POINT
/* Real and 64bit integer are the same when floating point arithmetic
* is omitted from the build.
*/
return pObj->x.rVal;
#else
/*
** Many compilers we encounter do not define constants for the
** minimum and maximum 64-bit integers, or they define them
** inconsistently. And many do not understand the "LL" notation.
** So we define our own static constants here using nothing
** larger than a 32-bit integer constant.
*/
static const sxi64 maxInt = LARGEST_INT64;
static const sxi64 minInt = SMALLEST_INT64;
jx9_real r = pObj->x.rVal;
if( r<(jx9_real)minInt ){
return minInt;
}else if( r>(jx9_real)maxInt ){
/* minInt is correct here - not maxInt. It turns out that assigning
** a very large positive number to an integer results in a very large
** negative integer. This makes no sense, but it is what x86 hardware
** does so for compatibility we will do the same in software. */
return minInt;
}else{
return (sxi64)r;
}
#endif
}
/*
* Convert a raw token value typically a stream of digit [i.e: hex, octal, binary or decimal]
* to a 64-bit integer.
*/
JX9_PRIVATE sxi64 jx9TokenValueToInt64(SyString *pVal)
{
sxi64 iVal = 0;
if( pVal->nByte <= 0 ){
return 0;
}
if( pVal->zString[0] == '0' ){
sxi32 c;
if( pVal->nByte == sizeof(char) ){
return 0;
}
c = pVal->zString[1];
if( c == 'x' || c == 'X' ){
/* Hex digit stream */
SyHexStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
}else if( c == 'b' || c == 'B' ){
/* Binary digit stream */
SyBinaryStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
}else{
/* Octal digit stream */
SyOctalStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
}
}else{
/* Decimal digit stream */
SyStrToInt64(pVal->zString, pVal->nByte, (void *)&iVal, 0);
}
return iVal;
}
/*
* Return some kind of 64-bit integer value which is the best we can
* do at representing the value that pObj describes as a string
* representation.
*/
static sxi64 MemObjStringToInt(jx9_value *pObj)
{
SyString sVal;
SyStringInitFromBuf(&sVal, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
return jx9TokenValueToInt64(&sVal);
}
/*
* Return some kind of integer value which is the best we can
* do at representing the value that pObj describes as an integer.
* If pObj is an integer, then the value is exact. If pObj is
* a floating-point then the value returned is the integer part.
* If pObj is a string, then we make an attempt to convert it into
* a integer and return that.
* If pObj represents a NULL value, return 0.
*/
static sxi64 MemObjIntValue(jx9_value *pObj)
{
sxi32 iFlags;
iFlags = pObj->iFlags;
if (iFlags & MEMOBJ_REAL ){
return MemObjRealToInt(&(*pObj));
}else if( iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
return pObj->x.iVal;
}else if (iFlags & MEMOBJ_STRING) {
return MemObjStringToInt(&(*pObj));
}else if( iFlags & MEMOBJ_NULL ){
return 0;
}else if( iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pObj->x.pOther;
sxu32 n = pMap->nEntry;
jx9HashmapUnref(pMap);
/* Return total number of entries in the hashmap */
return n;
}else if(iFlags & MEMOBJ_RES ){
return pObj->x.pOther != 0;
}
/* CANT HAPPEN */
return 0;
}
/*
* Return some kind of real value which is the best we can
* do at representing the value that pObj describes as a real.
* If pObj is a real, then the value is exact.If pObj is an
* integer then the integer is promoted to real and that value
* is returned.
* If pObj is a string, then we make an attempt to convert it
* into a real and return that.
* If pObj represents a NULL value, return 0.0
*/
static jx9_real MemObjRealValue(jx9_value *pObj)
{
sxi32 iFlags;
iFlags = pObj->iFlags;
if( iFlags & MEMOBJ_REAL ){
return pObj->x.rVal;
}else if (iFlags & (MEMOBJ_INT|MEMOBJ_BOOL) ){
return (jx9_real)pObj->x.iVal;
}else if (iFlags & MEMOBJ_STRING){
SyString sString;
#ifdef JX9_OMIT_FLOATING_POINT
jx9_real rVal = 0;
#else
jx9_real rVal = 0.0;
#endif
SyStringInitFromBuf(&sString, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
if( SyBlobLength(&pObj->sBlob) > 0 ){
/* Convert as much as we can */
#ifdef JX9_OMIT_FLOATING_POINT
rVal = MemObjStringToInt(&(*pObj));
#else
SyStrToReal(sString.zString, sString.nByte, (void *)&rVal, 0);
#endif
}
return rVal;
}else if( iFlags & MEMOBJ_NULL ){
#ifdef JX9_OMIT_FLOATING_POINT
return 0;
#else
return 0.0;
#endif
}else if( iFlags & MEMOBJ_HASHMAP ){
/* Return the total number of entries in the hashmap */
jx9_hashmap *pMap = (jx9_hashmap *)pObj->x.pOther;
jx9_real n = (jx9_real)pMap->nEntry;
jx9HashmapUnref(pMap);
return n;
}else if(iFlags & MEMOBJ_RES ){
return (jx9_real)(pObj->x.pOther != 0);
}
/* NOT REACHED */
return 0;
}
/*
* Return the string representation of a given jx9_value.
* This function never fail and always return SXRET_OK.
*/
static sxi32 MemObjStringValue(SyBlob *pOut,jx9_value *pObj)
{
if( pObj->iFlags & MEMOBJ_REAL ){
SyBlobFormat(&(*pOut), "%.15g", pObj->x.rVal);
}else if( pObj->iFlags & MEMOBJ_INT ){
SyBlobFormat(&(*pOut), "%qd", pObj->x.iVal);
/* %qd (BSD quad) is equivalent to %lld in the libc printf */
}else if( pObj->iFlags & MEMOBJ_BOOL ){
if( pObj->x.iVal ){
SyBlobAppend(&(*pOut),"true", sizeof("true")-1);
}else{
SyBlobAppend(&(*pOut),"false", sizeof("false")-1);
}
}else if( pObj->iFlags & MEMOBJ_HASHMAP ){
/* Serialize JSON object or array */
jx9JsonSerialize(pObj,pOut);
jx9HashmapUnref((jx9_hashmap *)pObj->x.pOther);
}else if(pObj->iFlags & MEMOBJ_RES ){
SyBlobFormat(&(*pOut), "ResourceID_%#x", pObj->x.pOther);
}
return SXRET_OK;
}
/*
* Return some kind of boolean value which is the best we can do
* at representing the value that pObj describes as a boolean.
* When converting to boolean, the following values are considered FALSE:
* NULL
* the boolean FALSE itself.
* the integer 0 (zero).
* the real 0.0 (zero).
* the empty string, a stream of zero [i.e: "0", "00", "000", ...] and the string
* "false".
* an array with zero elements.
*/
static sxi32 MemObjBooleanValue(jx9_value *pObj)
{
sxi32 iFlags;
iFlags = pObj->iFlags;
if (iFlags & MEMOBJ_REAL ){
#ifdef JX9_OMIT_FLOATING_POINT
return pObj->x.rVal ? 1 : 0;
#else
return pObj->x.rVal != 0.0 ? 1 : 0;
#endif
}else if( iFlags & MEMOBJ_INT ){
return pObj->x.iVal ? 1 : 0;
}else if (iFlags & MEMOBJ_STRING) {
SyString sString;
SyStringInitFromBuf(&sString, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
if( sString.nByte == 0 ){
/* Empty string */
return 0;
}else if( (sString.nByte == sizeof("true") - 1 && SyStrnicmp(sString.zString, "true", sizeof("true")-1) == 0) ||
(sString.nByte == sizeof("on") - 1 && SyStrnicmp(sString.zString, "on", sizeof("on")-1) == 0) ||
(sString.nByte == sizeof("yes") - 1 && SyStrnicmp(sString.zString, "yes", sizeof("yes")-1) == 0) ){
return 1;
}else if( sString.nByte == sizeof("false") - 1 && SyStrnicmp(sString.zString, "false", sizeof("false")-1) == 0 ){
return 0;
}else{
const char *zIn, *zEnd;
zIn = sString.zString;
zEnd = &zIn[sString.nByte];
while( zIn < zEnd && zIn[0] == '0' ){
zIn++;
}
return zIn >= zEnd ? 0 : 1;
}
}else if( iFlags & MEMOBJ_NULL ){
return 0;
}else if( iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pObj->x.pOther;
sxu32 n = pMap->nEntry;
jx9HashmapUnref(pMap);
return n > 0 ? TRUE : FALSE;
}else if(iFlags & MEMOBJ_RES ){
return pObj->x.pOther != 0;
}
/* NOT REACHED */
return 0;
}
/*
* If the jx9_value is of type real, try to make it an integer also.
*/
static sxi32 MemObjTryIntger(jx9_value *pObj)
{
sxi64 iVal = MemObjRealToInt(&(*pObj));
/* Only mark the value as an integer if
**
** (1) the round-trip conversion real->int->real is a no-op, and
** (2) The integer is neither the largest nor the smallest
** possible integer
**
** The second and third terms in the following conditional enforces
** the second condition under the assumption that addition overflow causes
** values to wrap around. On x86 hardware, the third term is always
** true and could be omitted. But we leave it in because other
** architectures might behave differently.
*/
if( pObj->x.rVal ==(jx9_real)iVal && iVal>SMALLEST_INT64 && iVal<LARGEST_INT64 ){
pObj->x.iVal = iVal;
pObj->iFlags = MEMOBJ_INT;
}
return SXRET_OK;
}
/*
* Convert a jx9_value to type integer.Invalidate any prior representations.
*/
JX9_PRIVATE sxi32 jx9MemObjToInteger(jx9_value *pObj)
{
if( (pObj->iFlags & MEMOBJ_INT) == 0 ){
/* Preform the conversion */
pObj->x.iVal = MemObjIntValue(&(*pObj));
/* Invalidate any prior representations */
SyBlobRelease(&pObj->sBlob);
MemObjSetType(pObj, MEMOBJ_INT);
}
return SXRET_OK;
}
/*
* Convert a jx9_value to type real (Try to get an integer representation also).
* Invalidate any prior representations
*/
JX9_PRIVATE sxi32 jx9MemObjToReal(jx9_value *pObj)
{
if((pObj->iFlags & MEMOBJ_REAL) == 0 ){
/* Preform the conversion */
pObj->x.rVal = MemObjRealValue(&(*pObj));
/* Invalidate any prior representations */
SyBlobRelease(&pObj->sBlob);
MemObjSetType(pObj, MEMOBJ_REAL);
}
return SXRET_OK;
}
/*
* Convert a jx9_value to type boolean.Invalidate any prior representations.
*/
JX9_PRIVATE sxi32 jx9MemObjToBool(jx9_value *pObj)
{
if( (pObj->iFlags & MEMOBJ_BOOL) == 0 ){
/* Preform the conversion */
pObj->x.iVal = MemObjBooleanValue(&(*pObj));
/* Invalidate any prior representations */
SyBlobRelease(&pObj->sBlob);
MemObjSetType(pObj, MEMOBJ_BOOL);
}
return SXRET_OK;
}
/*
* Convert a jx9_value to type string.Prior representations are NOT invalidated.
*/
JX9_PRIVATE sxi32 jx9MemObjToString(jx9_value *pObj)
{
sxi32 rc = SXRET_OK;
if( (pObj->iFlags & MEMOBJ_STRING) == 0 ){
/* Perform the conversion */
SyBlobReset(&pObj->sBlob); /* Reset the internal buffer */
rc = MemObjStringValue(&pObj->sBlob, &(*pObj));
MemObjSetType(pObj, MEMOBJ_STRING);
}
return rc;
}
/*
* Nullify a jx9_value.In other words invalidate any prior
* representation.
*/
JX9_PRIVATE sxi32 jx9MemObjToNull(jx9_value *pObj)
{
return jx9MemObjRelease(pObj);
}
/*
* Convert a jx9_value to type array.Invalidate any prior representations.
* According to the JX9 language reference manual.
* For any of the types: integer, float, string, boolean converting a value
* to an array results in an array with a single element with index zero
* and the value of the scalar which was converted.
*/
JX9_PRIVATE sxi32 jx9MemObjToHashmap(jx9_value *pObj)
{
if( (pObj->iFlags & MEMOBJ_HASHMAP) == 0 ){
jx9_hashmap *pMap;
/* Allocate a new hashmap instance */
pMap = jx9NewHashmap(pObj->pVm, 0, 0);
if( pMap == 0 ){
return SXERR_MEM;
}
if( (pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_RES)) == 0 ){
/*
* According to the JX9 language reference manual.
* For any of the types: integer, float, string, boolean converting a value
* to an array results in an array with a single element with index zero
* and the value of the scalar which was converted.
*/
/* Insert a single element */
jx9HashmapInsert(pMap, 0/* Automatic index assign */, &(*pObj));
SyBlobRelease(&pObj->sBlob);
}
/* Invalidate any prior representation */
MemObjSetType(pObj, MEMOBJ_HASHMAP);
pObj->x.pOther = pMap;
}
return SXRET_OK;
}
/*
* Return a pointer to the appropriate convertion method associated
* with the given type.
* Note on type juggling.
* Accoding to the JX9 language reference manual
* JX9 does not require (or support) explicit type definition in variable
* declaration; a variable's type is determined by the context in which
* the variable is used. That is to say, if a string value is assigned
* to variable $var, $var becomes a string. If an integer value is then
* assigned to $var, it becomes an integer.
*/
JX9_PRIVATE ProcMemObjCast jx9MemObjCastMethod(sxi32 iFlags)
{
if( iFlags & MEMOBJ_STRING ){
return jx9MemObjToString;
}else if( iFlags & MEMOBJ_INT ){
return jx9MemObjToInteger;
}else if( iFlags & MEMOBJ_REAL ){
return jx9MemObjToReal;
}else if( iFlags & MEMOBJ_BOOL ){
return jx9MemObjToBool;
}else if( iFlags & MEMOBJ_HASHMAP ){
return jx9MemObjToHashmap;
}
/* NULL cast */
return jx9MemObjToNull;
}
/*
* Check whether the jx9_value is numeric [i.e: int/float/bool] or looks
* like a numeric number [i.e: if the jx9_value is of type string.].
* Return TRUE if numeric.FALSE otherwise.
*/
JX9_PRIVATE sxi32 jx9MemObjIsNumeric(jx9_value *pObj)
{
if( pObj->iFlags & ( MEMOBJ_BOOL|MEMOBJ_INT|MEMOBJ_REAL) ){
return TRUE;
}else if( pObj->iFlags & (MEMOBJ_NULL|MEMOBJ_HASHMAP|MEMOBJ_RES) ){
return FALSE;
}else if( pObj->iFlags & MEMOBJ_STRING ){
SyString sStr;
sxi32 rc;
SyStringInitFromBuf(&sStr, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
if( sStr.nByte <= 0 ){
/* Empty string */
return FALSE;
}
/* Check if the string representation looks like a numeric number */
rc = SyStrIsNumeric(sStr.zString, sStr.nByte, 0, 0);
return rc == SXRET_OK ? TRUE : FALSE;
}
/* NOT REACHED */
return FALSE;
}
/*
* Check whether the jx9_value is empty.Return TRUE if empty.
* FALSE otherwise.
* An jx9_value is considered empty if the following are true:
* NULL value.
* Boolean FALSE.
* Integer/Float with a 0 (zero) value.
* An empty string or a stream of 0 (zero) [i.e: "0", "00", "000", ...].
* An empty array.
* NOTE
* OBJECT VALUE MUST NOT BE MODIFIED.
*/
JX9_PRIVATE sxi32 jx9MemObjIsEmpty(jx9_value *pObj)
{
if( pObj->iFlags & MEMOBJ_NULL ){
return TRUE;
}else if( pObj->iFlags & MEMOBJ_INT ){
return pObj->x.iVal == 0 ? TRUE : FALSE;
}else if( pObj->iFlags & MEMOBJ_REAL ){
return pObj->x.rVal == (jx9_real)0 ? TRUE : FALSE;
}else if( pObj->iFlags & MEMOBJ_BOOL ){
return !pObj->x.iVal;
}else if( pObj->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pObj->sBlob) <= 0 ){
return TRUE;
}else{
const char *zIn, *zEnd;
zIn = (const char *)SyBlobData(&pObj->sBlob);
zEnd = &zIn[SyBlobLength(&pObj->sBlob)];
while( zIn < zEnd ){
if( zIn[0] != '0' ){
break;
}
zIn++;
}
return zIn >= zEnd ? TRUE : FALSE;
}
}else if( pObj->iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pObj->x.pOther;
return pMap->nEntry == 0 ? TRUE : FALSE;
}else if ( pObj->iFlags & (MEMOBJ_RES) ){
return FALSE;
}
/* Assume empty by default */
return TRUE;
}
/*
* Convert a jx9_value so that it has types MEMOBJ_REAL or MEMOBJ_INT
* or both.
* Invalidate any prior representations. Every effort is made to force
* the conversion, even if the input is a string that does not look
* completely like a number.Convert as much of the string as we can
* and ignore the rest.
*/
JX9_PRIVATE sxi32 jx9MemObjToNumeric(jx9_value *pObj)
{
if( pObj->iFlags & (MEMOBJ_INT|MEMOBJ_REAL|MEMOBJ_BOOL|MEMOBJ_NULL) ){
if( pObj->iFlags & (MEMOBJ_BOOL|MEMOBJ_NULL) ){
if( pObj->iFlags & MEMOBJ_NULL ){
pObj->x.iVal = 0;
}
MemObjSetType(pObj, MEMOBJ_INT);
}
/* Already numeric */
return SXRET_OK;
}
if( pObj->iFlags & MEMOBJ_STRING ){
sxi32 rc = SXERR_INVALID;
sxu8 bReal = FALSE;
SyString sString;
SyStringInitFromBuf(&sString, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
/* Check if the given string looks like a numeric number */
if( sString.nByte > 0 ){
rc = SyStrIsNumeric(sString.zString, sString.nByte, &bReal, 0);
}
if( bReal ){
jx9MemObjToReal(&(*pObj));
}else{
if( rc != SXRET_OK ){
/* The input does not look at all like a number, set the value to 0 */
pObj->x.iVal = 0;
}else{
/* Convert as much as we can */
pObj->x.iVal = MemObjStringToInt(&(*pObj));
}
MemObjSetType(pObj, MEMOBJ_INT);
SyBlobRelease(&pObj->sBlob);
}
}else if(pObj->iFlags & (MEMOBJ_HASHMAP|MEMOBJ_RES)){
jx9MemObjToInteger(pObj);
}else{
/* Perform a blind cast */
jx9MemObjToReal(&(*pObj));
}
return SXRET_OK;
}
/*
* Try a get an integer representation of the given jx9_value.
* If the jx9_value is not of type real, this function is a no-op.
*/
JX9_PRIVATE sxi32 jx9MemObjTryInteger(jx9_value *pObj)
{
if( pObj->iFlags & MEMOBJ_REAL ){
/* Work only with reals */
MemObjTryIntger(&(*pObj));
}
return SXRET_OK;
}
/*
* Initialize a jx9_value to the null type.
*/
JX9_PRIVATE sxi32 jx9MemObjInit(jx9_vm *pVm, jx9_value *pObj)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
/* Set the NULL type */
pObj->iFlags = MEMOBJ_NULL;
return SXRET_OK;
}
/*
* Initialize a jx9_value to the integer type.
*/
JX9_PRIVATE sxi32 jx9MemObjInitFromInt(jx9_vm *pVm, jx9_value *pObj, sxi64 iVal)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
/* Set the desired type */
pObj->x.iVal = iVal;
pObj->iFlags = MEMOBJ_INT;
return SXRET_OK;
}
/*
* Initialize a jx9_value to the boolean type.
*/
JX9_PRIVATE sxi32 jx9MemObjInitFromBool(jx9_vm *pVm, jx9_value *pObj, sxi32 iVal)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
/* Set the desired type */
pObj->x.iVal = iVal ? 1 : 0;
pObj->iFlags = MEMOBJ_BOOL;
return SXRET_OK;
}
#if 0
/*
* Initialize a jx9_value to the real type.
*/
JX9_PRIVATE sxi32 jx9MemObjInitFromReal(jx9_vm *pVm, jx9_value *pObj, jx9_real rVal)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
/* Set the desired type */
pObj->x.rVal = rVal;
pObj->iFlags = MEMOBJ_REAL;
return SXRET_OK;
}
#endif
/*
* Initialize a jx9_value to the array type.
*/
JX9_PRIVATE sxi32 jx9MemObjInitFromArray(jx9_vm *pVm, jx9_value *pObj, jx9_hashmap *pArray)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
/* Set the desired type */
pObj->iFlags = MEMOBJ_HASHMAP;
pObj->x.pOther = pArray;
return SXRET_OK;
}
/*
* Initialize a jx9_value to the string type.
*/
JX9_PRIVATE sxi32 jx9MemObjInitFromString(jx9_vm *pVm, jx9_value *pObj, const SyString *pVal)
{
/* Zero the structure */
SyZero(pObj, sizeof(jx9_value));
/* Initialize fields */
pObj->pVm = pVm;
SyBlobInit(&pObj->sBlob, &pVm->sAllocator);
if( pVal ){
/* Append contents */
SyBlobAppend(&pObj->sBlob, (const void *)pVal->zString, pVal->nByte);
}
/* Set the desired type */
pObj->iFlags = MEMOBJ_STRING;
return SXRET_OK;
}
/*
* Append some contents to the internal buffer of a given jx9_value.
* If the given jx9_value is not of type string, this function
* invalidate any prior representation and set the string type.
* Then a simple append operation is performed.
*/
JX9_PRIVATE sxi32 jx9MemObjStringAppend(jx9_value *pObj, const char *zData, sxu32 nLen)
{
sxi32 rc;
if( (pObj->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pObj);
MemObjSetType(pObj, MEMOBJ_STRING);
}
/* Append contents */
rc = SyBlobAppend(&pObj->sBlob, zData, nLen);
return rc;
}
#if 0
/*
* Format and append some contents to the internal buffer of a given jx9_value.
* If the given jx9_value is not of type string, this function invalidate
* any prior representation and set the string type.
* Then a simple format and append operation is performed.
*/
JX9_PRIVATE sxi32 jx9MemObjStringFormat(jx9_value *pObj, const char *zFormat, va_list ap)
{
sxi32 rc;
if( (pObj->iFlags & MEMOBJ_STRING) == 0 ){
/* Invalidate any prior representation */
jx9MemObjRelease(pObj);
MemObjSetType(pObj, MEMOBJ_STRING);
}
/* Format and append contents */
rc = SyBlobFormatAp(&pObj->sBlob, zFormat, ap);
return rc;
}
#endif
/*
* Duplicate the contents of a jx9_value.
*/
JX9_PRIVATE sxi32 jx9MemObjStore(jx9_value *pSrc, jx9_value *pDest)
{
jx9_hashmap *pMap = 0;
sxi32 rc;
if( pSrc->iFlags & MEMOBJ_HASHMAP ){
/* Increment reference count */
((jx9_hashmap *)pSrc->x.pOther)->iRef++;
}
if( pDest->iFlags & MEMOBJ_HASHMAP ){
pMap = (jx9_hashmap *)pDest->x.pOther;
}
SyMemcpy((const void *)&(*pSrc), &(*pDest), sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
rc = SXRET_OK;
if( SyBlobLength(&pSrc->sBlob) > 0 ){
SyBlobReset(&pDest->sBlob);
rc = SyBlobDup(&pSrc->sBlob, &pDest->sBlob);
}else{
if( SyBlobLength(&pDest->sBlob) > 0 ){
SyBlobRelease(&pDest->sBlob);
}
}
if( pMap ){
jx9HashmapUnref(pMap);
}
return rc;
}
/*
* Duplicate the contents of a jx9_value but do not copy internal
* buffer contents, simply point to it.
*/
JX9_PRIVATE sxi32 jx9MemObjLoad(jx9_value *pSrc, jx9_value *pDest)
{
SyMemcpy((const void *)&(*pSrc), &(*pDest),
sizeof(jx9_value)-(sizeof(jx9_vm *)+sizeof(SyBlob)+sizeof(sxu32)));
if( pSrc->iFlags & MEMOBJ_HASHMAP ){
/* Increment reference count */
((jx9_hashmap *)pSrc->x.pOther)->iRef++;
}
if( SyBlobLength(&pDest->sBlob) > 0 ){
SyBlobRelease(&pDest->sBlob);
}
if( SyBlobLength(&pSrc->sBlob) > 0 ){
SyBlobReadOnly(&pDest->sBlob, SyBlobData(&pSrc->sBlob), SyBlobLength(&pSrc->sBlob));
}
return SXRET_OK;
}
/*
* Invalidate any prior representation of a given jx9_value.
*/
JX9_PRIVATE sxi32 jx9MemObjRelease(jx9_value *pObj)
{
if( (pObj->iFlags & MEMOBJ_NULL) == 0 ){
if( pObj->iFlags & MEMOBJ_HASHMAP ){
jx9HashmapUnref((jx9_hashmap *)pObj->x.pOther);
}
/* Release the internal buffer */
SyBlobRelease(&pObj->sBlob);
/* Invalidate any prior representation */
pObj->iFlags = MEMOBJ_NULL;
}
return SXRET_OK;
}
/*
* Compare two jx9_values.
* Return 0 if the values are equals, > 0 if pObj1 is greater than pObj2
* or < 0 if pObj2 is greater than pObj1.
* Type comparison table taken from the JX9 language reference manual.
* Comparisons of $x with JX9 functions Expression
* gettype() empty() is_null() isset() boolean : if($x)
* $x = ""; string TRUE FALSE TRUE FALSE
* $x = null NULL TRUE TRUE FALSE FALSE
* var $x; NULL TRUE TRUE FALSE FALSE
* $x is undefined NULL TRUE TRUE FALSE FALSE
* $x = array(); array TRUE FALSE TRUE FALSE
* $x = false; boolean TRUE FALSE TRUE FALSE
* $x = true; boolean FALSE FALSE TRUE TRUE
* $x = 1; integer FALSE FALSE TRUE TRUE
* $x = 42; integer FALSE FALSE TRUE TRUE
* $x = 0; integer TRUE FALSE TRUE FALSE
* $x = -1; integer FALSE FALSE TRUE TRUE
* $x = "1"; string FALSE FALSE TRUE TRUE
* $x = "0"; string TRUE FALSE TRUE FALSE
* $x = "-1"; string FALSE FALSE TRUE TRUE
* $x = "jx9"; string FALSE FALSE TRUE TRUE
* $x = "true"; string FALSE FALSE TRUE TRUE
* $x = "false"; string FALSE FALSE TRUE TRUE
* Loose comparisons with ==
* TRUE FALSE 1 0 -1 "1" "0" "-1" NULL array() "jx9" ""
* TRUE TRUE FALSE TRUE FALSE TRUE TRUE FALSE TRUE FALSE FALSE TRUE FALSE
* FALSE FALSE TRUE FALSE TRUE FALSE FALSE TRUE FALSE TRUE TRUE FALSE TRUE
* 1 TRUE FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE
* 0 FALSE TRUE FALSE TRUE FALSE FALSE TRUE FALSE TRUE FALSE TRUE TRUE
* -1 TRUE FALSE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE
* "1" TRUE FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE
* "0" FALSE TRUE FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE
* "-1" TRUE FALSE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE
* NULL FALSE TRUE FALSE TRUE FALSE FALSE FALSE FALSE TRUE TRUE FALSE TRUE
* array() FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE TRUE TRUE FALSE FALSE
* "jx9" TRUE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE
* "" FALSE TRUE FALSE TRUE FALSE FALSE FALSE FALSE TRUE FALSE FALSE TRUE
* Strict comparisons with ===
* TRUE FALSE 1 0 -1 "1" "0" "-1" NULL array() "jx9" ""
* TRUE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
* FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
* 1 FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
* 0 FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
* -1 FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE FALSE
* "1" FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE FALSE
* "0" FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE
* "-1" FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE
* NULL FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE
* array() FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE
* "jx9" FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE
* "" FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE
*/
JX9_PRIVATE sxi32 jx9MemObjCmp(jx9_value *pObj1, jx9_value *pObj2, int bStrict, int iNest)
{
sxi32 iComb;
sxi32 rc;
if( bStrict ){
sxi32 iF1, iF2;
/* Strict comparisons with === */
iF1 = pObj1->iFlags;
iF2 = pObj2->iFlags;
if( iF1 != iF2 ){
/* Not of the same type */
return 1;
}
}
/* Combine flag together */
iComb = pObj1->iFlags|pObj2->iFlags;
if( iComb & (MEMOBJ_RES|MEMOBJ_BOOL) ){
/* Convert to boolean: Keep in mind FALSE < TRUE */
if( (pObj1->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pObj1);
}
if( (pObj2->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pObj2);
}
return (sxi32)((pObj1->x.iVal != 0) - (pObj2->x.iVal != 0));
}else if( iComb & MEMOBJ_NULL ){
if( (pObj1->iFlags & MEMOBJ_NULL) == 0 ){
return 1;
}
if( (pObj2->iFlags & MEMOBJ_NULL) == 0 ){
return -1;
}
}else if ( iComb & MEMOBJ_HASHMAP ){
/* Hashmap aka 'array' comparison */
if( (pObj1->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* Array is always greater */
return -1;
}
if( (pObj2->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* Array is always greater */
return 1;
}
/* Perform the comparison */
rc = jx9HashmapCmp((jx9_hashmap *)pObj1->x.pOther, (jx9_hashmap *)pObj2->x.pOther, bStrict);
return rc;
}else if ( iComb & MEMOBJ_STRING ){
SyString s1, s2;
/* Perform a strict string comparison.*/
if( (pObj1->iFlags&MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pObj1);
}
if( (pObj2->iFlags&MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pObj2);
}
SyStringInitFromBuf(&s1, SyBlobData(&pObj1->sBlob), SyBlobLength(&pObj1->sBlob));
SyStringInitFromBuf(&s2, SyBlobData(&pObj2->sBlob), SyBlobLength(&pObj2->sBlob));
/*
* Strings are compared using memcmp(). If one value is an exact prefix of the
* other, then the shorter value is less than the longer value.
*/
rc = SyMemcmp((const void *)s1.zString, (const void *)s2.zString, SXMIN(s1.nByte, s2.nByte));
if( rc == 0 ){
if( s1.nByte != s2.nByte ){
rc = s1.nByte < s2.nByte ? -1 : 1;
}
}
return rc;
}else if( iComb & (MEMOBJ_INT|MEMOBJ_REAL) ){
/* Perform a numeric comparison if one of the operand is numeric(integer or real) */
if( (pObj1->iFlags & (MEMOBJ_INT|MEMOBJ_REAL)) == 0 ){
jx9MemObjToNumeric(pObj1);
}
if( (pObj2->iFlags & (MEMOBJ_INT|MEMOBJ_REAL)) == 0 ){
jx9MemObjToNumeric(pObj2);
}
if( (pObj1->iFlags & pObj2->iFlags & MEMOBJ_INT) == 0) {
jx9_real r1, r2;
/* Compare as reals */
if( (pObj1->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pObj1);
}
r1 = pObj1->x.rVal;
if( (pObj2->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pObj2);
}
r2 = pObj2->x.rVal;
if( r1 > r2 ){
return 1;
}else if( r1 < r2 ){
return -1;
}
return 0;
}else{
/* Integer comparison */
if( pObj1->x.iVal > pObj2->x.iVal ){
return 1;
}else if( pObj1->x.iVal < pObj2->x.iVal ){
return -1;
}
return 0;
}
}
/* NOT REACHED */
SXUNUSED(iNest);
return 0;
}
/*
* Perform an addition operation of two jx9_values.
* The reason this function is implemented here rather than 'vm.c'
* is that the '+' operator is overloaded.
* That is, the '+' operator is used for arithmetic operation and also
* used for operation on arrays [i.e: union]. When used with an array
* The + operator returns the right-hand array appended to the left-hand array.
* For keys that exist in both arrays, the elements from the left-hand array
* will be used, and the matching elements from the right-hand array will
* be ignored.
* This function take care of handling all the scenarios.
*/
JX9_PRIVATE sxi32 jx9MemObjAdd(jx9_value *pObj1, jx9_value *pObj2, int bAddStore)
{
if( ((pObj1->iFlags|pObj2->iFlags) & MEMOBJ_HASHMAP) == 0 ){
/* Arithemtic operation */
jx9MemObjToNumeric(pObj1);
jx9MemObjToNumeric(pObj2);
if( (pObj1->iFlags|pObj2->iFlags) & MEMOBJ_REAL ){
/* Floating point arithmetic */
jx9_real a, b;
if( (pObj1->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pObj1);
}
if( (pObj2->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pObj2);
}
a = pObj1->x.rVal;
b = pObj2->x.rVal;
pObj1->x.rVal = a+b;
MemObjSetType(pObj1, MEMOBJ_REAL);
/* Try to get an integer representation also */
MemObjTryIntger(&(*pObj1));
}else{
/* Integer arithmetic */
sxi64 a, b;
a = pObj1->x.iVal;
b = pObj2->x.iVal;
pObj1->x.iVal = a+b;
MemObjSetType(pObj1, MEMOBJ_INT);
}
}else{
if( (pObj1->iFlags|pObj2->iFlags) & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap;
sxi32 rc;
if( bAddStore ){
/* Do not duplicate the hashmap, use the left one since its an add&store operation.
*/
if( (pObj1->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* Force a hashmap cast */
rc = jx9MemObjToHashmap(pObj1);
if( rc != SXRET_OK ){
jx9VmThrowError(pObj1->pVm, 0, JX9_CTX_ERR, "JX9 is running out of memory while creating array");
return rc;
}
}
/* Point to the structure that describe the hashmap */
pMap = (jx9_hashmap *)pObj1->x.pOther;
}else{
/* Create a new hashmap */
pMap = jx9NewHashmap(pObj1->pVm, 0, 0);
if( pMap == 0){
jx9VmThrowError(pObj1->pVm, 0, JX9_CTX_ERR, "JX9 is running out of memory while creating array");
return SXERR_MEM;
}
}
if( !bAddStore ){
if(pObj1->iFlags & MEMOBJ_HASHMAP ){
/* Perform a hashmap duplication */
jx9HashmapDup((jx9_hashmap *)pObj1->x.pOther, pMap);
}else{
if((pObj1->iFlags & MEMOBJ_NULL) == 0 ){
/* Simple insertion */
jx9HashmapInsert(pMap, 0, pObj1);
}
}
}
/* Perform the union */
if(pObj2->iFlags & MEMOBJ_HASHMAP ){
jx9HashmapUnion(pMap, (jx9_hashmap *)pObj2->x.pOther);
}else{
if((pObj2->iFlags & MEMOBJ_NULL) == 0 ){
/* Simple insertion */
jx9HashmapInsert(pMap, 0, pObj2);
}
}
/* Reflect the change */
if( pObj1->iFlags & MEMOBJ_STRING ){
SyBlobRelease(&pObj1->sBlob);
}
pObj1->x.pOther = pMap;
MemObjSetType(pObj1, MEMOBJ_HASHMAP);
}
}
return SXRET_OK;
}
/*
* Return a printable representation of the type of a given
* jx9_value.
*/
JX9_PRIVATE const char * jx9MemObjTypeDump(jx9_value *pVal)
{
const char *zType = "";
if( pVal->iFlags & MEMOBJ_NULL ){
zType = "null";
}else if( pVal->iFlags & MEMOBJ_INT ){
zType = "int";
}else if( pVal->iFlags & MEMOBJ_REAL ){
zType = "float";
}else if( pVal->iFlags & MEMOBJ_STRING ){
zType = "string";
}else if( pVal->iFlags & MEMOBJ_BOOL ){
zType = "bool";
}else if( pVal->iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pVal->x.pOther;
if( pMap->iFlags & HASHMAP_JSON_OBJECT ){
zType = "JSON Object";
}else{
zType = "JSON Array";
}
}else if( pVal->iFlags & MEMOBJ_RES ){
zType = "resource";
}
return zType;
}
/*
* Dump a jx9_value [i.e: get a printable representation of it's type and contents.].
* Store the dump in the given blob.
*/
JX9_PRIVATE sxi32 jx9MemObjDump(
SyBlob *pOut, /* Store the dump here */
jx9_value *pObj /* Dump this */
)
{
sxi32 rc = SXRET_OK;
const char *zType;
/* Get value type first */
zType = jx9MemObjTypeDump(pObj);
SyBlobAppend(&(*pOut), zType, SyStrlen(zType));
if((pObj->iFlags & MEMOBJ_NULL) == 0 ){
SyBlobAppend(&(*pOut), "(", sizeof(char));
if( pObj->iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pObj->x.pOther;
SyBlobFormat(pOut,"%u ",pMap->nEntry);
/* Dump hashmap entries */
rc = jx9JsonSerialize(pObj,pOut);
}else{
SyBlob *pContents = &pObj->sBlob;
/* Get a printable representation of the contents */
if((pObj->iFlags & MEMOBJ_STRING) == 0 ){
MemObjStringValue(&(*pOut), &(*pObj));
}else{
/* Append length first */
SyBlobFormat(&(*pOut), "%u '", SyBlobLength(&pObj->sBlob));
if( SyBlobLength(pContents) > 0 ){
SyBlobAppend(&(*pOut), SyBlobData(pContents), SyBlobLength(pContents));
}
SyBlobAppend(&(*pOut), "'", sizeof(char));
}
}
SyBlobAppend(&(*pOut), ")", sizeof(char));
}
#ifdef __WINNT__
SyBlobAppend(&(*pOut), "\r\n", sizeof("\r\n")-1);
#else
SyBlobAppend(&(*pOut), "\n", sizeof(char));
#endif
return rc;
}
/*
* ----------------------------------------------------------
* File: jx9_parse.c
* MD5: d8fcac4c6cd7672f0103c0bf4a4b61fc
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: parse.c v1.2 FreeBSD 2012-12-11 00:46 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/* Expression parser for the Jx9 programming language */
/* Operators associativity */
#define EXPR_OP_ASSOC_LEFT 0x01 /* Left associative operator */
#define EXPR_OP_ASSOC_RIGHT 0x02 /* Right associative operator */
#define EXPR_OP_NON_ASSOC 0x04 /* Non-associative operator */
/*
* Operators table
* This table is sorted by operators priority (highest to lowest) according
* the JX9 language reference manual.
* JX9 implements all the 60 JX9 operators and have introduced the eq and ne operators.
* The operators precedence table have been improved dramatically so that you can do same
* amazing things now such as array dereferencing, on the fly function call, anonymous function
* as array values, object member access on instantiation and so on.
* Refer to the following page for a full discussion on these improvements:
* http://jx9.symisc.net/features.html
*/
static const jx9_expr_op aOpTable[] = {
/* Postfix operators */
/* Precedence 2(Highest), left-associative */
{ {".", sizeof(char)}, EXPR_OP_DOT, 2, EXPR_OP_ASSOC_LEFT , JX9_OP_MEMBER },
{ {"[", sizeof(char)}, EXPR_OP_SUBSCRIPT, 2, EXPR_OP_ASSOC_LEFT , JX9_OP_LOAD_IDX},
/* Precedence 3, non-associative */
{ {"++", sizeof(char)*2}, EXPR_OP_INCR, 3, EXPR_OP_NON_ASSOC , JX9_OP_INCR},
{ {"--", sizeof(char)*2}, EXPR_OP_DECR, 3, EXPR_OP_NON_ASSOC , JX9_OP_DECR},
/* Unary operators */
/* Precedence 4, right-associative */
{ {"-", sizeof(char)}, EXPR_OP_UMINUS, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_UMINUS },
{ {"+", sizeof(char)}, EXPR_OP_UPLUS, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_UPLUS },
{ {"~", sizeof(char)}, EXPR_OP_BITNOT, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_BITNOT },
{ {"!", sizeof(char)}, EXPR_OP_LOGNOT, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_LNOT },
/* Cast operators */
{ {"(int)", sizeof("(int)")-1 }, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_INT },
{ {"(bool)", sizeof("(bool)")-1 }, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_BOOL },
{ {"(string)", sizeof("(string)")-1}, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_STR },
{ {"(float)", sizeof("(float)")-1 }, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_REAL },
{ {"(array)", sizeof("(array)")-1 }, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_ARRAY }, /* Not used, but reserved for future use */
{ {"(object)", sizeof("(object)")-1 }, EXPR_OP_TYPECAST, 4, EXPR_OP_ASSOC_RIGHT, JX9_OP_CVT_ARRAY }, /* Not used, but reserved for future use */
/* Binary operators */
/* Precedence 7, left-associative */
{ {"*", sizeof(char)}, EXPR_OP_MUL, 7, EXPR_OP_ASSOC_LEFT , JX9_OP_MUL},
{ {"/", sizeof(char)}, EXPR_OP_DIV, 7, EXPR_OP_ASSOC_LEFT , JX9_OP_DIV},
{ {"%", sizeof(char)}, EXPR_OP_MOD, 7, EXPR_OP_ASSOC_LEFT , JX9_OP_MOD},
/* Precedence 8, left-associative */
{ {"+", sizeof(char)}, EXPR_OP_ADD, 8, EXPR_OP_ASSOC_LEFT, JX9_OP_ADD},
{ {"-", sizeof(char)}, EXPR_OP_SUB, 8, EXPR_OP_ASSOC_LEFT, JX9_OP_SUB},
{ {"..", sizeof(char)*2},EXPR_OP_DDOT, 8, EXPR_OP_ASSOC_LEFT, JX9_OP_CAT},
/* Precedence 9, left-associative */
{ {"<<", sizeof(char)*2}, EXPR_OP_SHL, 9, EXPR_OP_ASSOC_LEFT, JX9_OP_SHL},
{ {">>", sizeof(char)*2}, EXPR_OP_SHR, 9, EXPR_OP_ASSOC_LEFT, JX9_OP_SHR},
/* Precedence 10, non-associative */
{ {"<", sizeof(char)}, EXPR_OP_LT, 10, EXPR_OP_NON_ASSOC, JX9_OP_LT},
{ {">", sizeof(char)}, EXPR_OP_GT, 10, EXPR_OP_NON_ASSOC, JX9_OP_GT},
{ {"<=", sizeof(char)*2}, EXPR_OP_LE, 10, EXPR_OP_NON_ASSOC, JX9_OP_LE},
{ {">=", sizeof(char)*2}, EXPR_OP_GE, 10, EXPR_OP_NON_ASSOC, JX9_OP_GE},
{ {"<>", sizeof(char)*2}, EXPR_OP_NE, 10, EXPR_OP_NON_ASSOC, JX9_OP_NEQ},
/* Precedence 11, non-associative */
{ {"==", sizeof(char)*2}, EXPR_OP_EQ, 11, EXPR_OP_NON_ASSOC, JX9_OP_EQ},
{ {"!=", sizeof(char)*2}, EXPR_OP_NE, 11, EXPR_OP_NON_ASSOC, JX9_OP_NEQ},
{ {"===", sizeof(char)*3}, EXPR_OP_TEQ, 11, EXPR_OP_NON_ASSOC, JX9_OP_TEQ},
{ {"!==", sizeof(char)*3}, EXPR_OP_TNE, 11, EXPR_OP_NON_ASSOC, JX9_OP_TNE},
/* Precedence 12, left-associative */
{ {"&", sizeof(char)}, EXPR_OP_BAND, 12, EXPR_OP_ASSOC_LEFT, JX9_OP_BAND},
/* Binary operators */
/* Precedence 13, left-associative */
{ {"^", sizeof(char)}, EXPR_OP_XOR, 13, EXPR_OP_ASSOC_LEFT, JX9_OP_BXOR},
/* Precedence 14, left-associative */
{ {"|", sizeof(char)}, EXPR_OP_BOR, 14, EXPR_OP_ASSOC_LEFT, JX9_OP_BOR},
/* Precedence 15, left-associative */
{ {"&&", sizeof(char)*2}, EXPR_OP_LAND, 15, EXPR_OP_ASSOC_LEFT, JX9_OP_LAND},
/* Precedence 16, left-associative */
{ {"||", sizeof(char)*2}, EXPR_OP_LOR, 16, EXPR_OP_ASSOC_LEFT, JX9_OP_LOR},
/* Ternary operator */
/* Precedence 17, left-associative */
{ {"?", sizeof(char)}, EXPR_OP_QUESTY, 17, EXPR_OP_ASSOC_LEFT, 0},
/* Combined binary operators */
/* Precedence 18, right-associative */
{ {"=", sizeof(char)}, EXPR_OP_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_STORE},
{ {"+=", sizeof(char)*2}, EXPR_OP_ADD_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_ADD_STORE },
{ {"-=", sizeof(char)*2}, EXPR_OP_SUB_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_SUB_STORE },
{ {".=", sizeof(char)*2}, EXPR_OP_DOT_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_CAT_STORE },
{ {"*=", sizeof(char)*2}, EXPR_OP_MUL_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_MUL_STORE },
{ {"/=", sizeof(char)*2}, EXPR_OP_DIV_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_DIV_STORE },
{ {"%=", sizeof(char)*2}, EXPR_OP_MOD_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_MOD_STORE },
{ {"&=", sizeof(char)*2}, EXPR_OP_AND_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_BAND_STORE },
{ {"|=", sizeof(char)*2}, EXPR_OP_OR_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_BOR_STORE },
{ {"^=", sizeof(char)*2}, EXPR_OP_XOR_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_BXOR_STORE },
{ {"<<=", sizeof(char)*3}, EXPR_OP_SHL_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_SHL_STORE },
{ {">>=", sizeof(char)*3}, EXPR_OP_SHR_ASSIGN, 18, EXPR_OP_ASSOC_RIGHT, JX9_OP_SHR_STORE },
/* Precedence 22, left-associative [Lowest operator] */
{ {",", sizeof(char)}, EXPR_OP_COMMA, 22, EXPR_OP_ASSOC_LEFT, 0}, /* IMP-0139-COMMA: Symisc eXtension */
};
/* Function call operator need special handling */
static const jx9_expr_op sFCallOp = {{"(", sizeof(char)}, EXPR_OP_FUNC_CALL, 2, EXPR_OP_ASSOC_LEFT , JX9_OP_CALL};
/*
* Check if the given token is a potential operator or not.
* This function is called by the lexer each time it extract a token that may
* look like an operator.
* Return a structure [i.e: jx9_expr_op instnace ] that describe the operator on success.
* Otherwise NULL.
* Note that the function take care of handling ambiguity [i.e: whether we are dealing with
* a binary minus or unary minus.]
*/
JX9_PRIVATE const jx9_expr_op * jx9ExprExtractOperator(SyString *pStr, SyToken *pLast)
{
sxu32 n = 0;
sxi32 rc;
/* Do a linear lookup on the operators table */
for(;;){
if( n >= SX_ARRAYSIZE(aOpTable) ){
break;
}
rc = SyStringCmp(pStr, &aOpTable[n].sOp, SyMemcmp);
if( rc == 0 ){
if( aOpTable[n].sOp.nByte != sizeof(char) || (aOpTable[n].iOp != EXPR_OP_UMINUS && aOpTable[n].iOp != EXPR_OP_UPLUS) || pLast == 0 ){
if( aOpTable[n].iOp == EXPR_OP_SUBSCRIPT && (pLast == 0 || (pLast->nType & (JX9_TK_ID|JX9_TK_CSB/*]*/|JX9_TK_RPAREN/*)*/)) == 0) ){
/* JSON Array not subscripting, return NULL */
return 0;
}
/* There is no ambiguity here, simply return the first operator seen */
return &aOpTable[n];
}
/* Handle ambiguity */
if( pLast->nType & (JX9_TK_LPAREN/*'('*/|JX9_TK_OCB/*'{'*/|JX9_TK_OSB/*'['*/|JX9_TK_COLON/*:*/|JX9_TK_COMMA/*, '*/) ){
/* Unary opertors have prcedence here over binary operators */
return &aOpTable[n];
}
if( pLast->nType & JX9_TK_OP ){
const jx9_expr_op *pOp = (const jx9_expr_op *)pLast->pUserData;
/* Ticket 1433-31: Handle the '++', '--' operators case */
if( pOp->iOp != EXPR_OP_INCR && pOp->iOp != EXPR_OP_DECR ){
/* Unary opertors have prcedence here over binary operators */
return &aOpTable[n];
}
}
}
++n; /* Next operator in the table */
}
/* No such operator */
return 0;
}
/*
* Delimit a set of token stream.
* This function take care of handling the nesting level and stops when it hit
* the end of the input or the ending token is found and the nesting level is zero.
*/
JX9_PRIVATE void jx9DelimitNestedTokens(SyToken *pIn,SyToken *pEnd,sxu32 nTokStart,sxu32 nTokEnd,SyToken **ppEnd)
{
SyToken *pCur = pIn;
sxi32 iNest = 1;
for(;;){
if( pCur >= pEnd ){
break;
}
if( pCur->nType & nTokStart ){
/* Increment nesting level */
iNest++;
}else if( pCur->nType & nTokEnd ){
/* Decrement nesting level */
iNest--;
if( iNest <= 0 ){
break;
}
}
/* Advance cursor */
pCur++;
}
/* Point to the end of the chunk */
*ppEnd = pCur;
}
/*
* Retrun TRUE if the given ID represent a language construct [i.e: print, print..]. FALSE otherwise.
* Note on reserved keywords.
* According to the JX9 language reference manual:
* These words have special meaning in JX9. Some of them represent things which look like
* functions, some look like constants, and so on--but they're not, really: they are language
* constructs. You cannot use any of the following words as constants, object names, function
* or method names. Using them as variable names is generally OK, but could lead to confusion.
*/
JX9_PRIVATE int jx9IsLangConstruct(sxu32 nKeyID)
{
if( nKeyID == JX9_TKWRD_PRINT || nKeyID == JX9_TKWRD_EXIT || nKeyID == JX9_TKWRD_DIE
|| nKeyID == JX9_TKWRD_INCLUDE|| nKeyID == JX9_TKWRD_IMPORT ){
return TRUE;
}
/* Not a language construct */
return FALSE;
}
/*
* Point to the next expression that should be evaluated shortly.
* The cursor stops when it hit a comma ', ' or a semi-colon and the nesting
* level is zero.
*/
JX9_PRIVATE sxi32 jx9GetNextExpr(SyToken *pStart,SyToken *pEnd,SyToken **ppNext)
{
SyToken *pCur = pStart;
sxi32 iNest = 0;
if( pCur >= pEnd || (pCur->nType & JX9_TK_SEMI/*';'*/) ){
/* Last expression */
return SXERR_EOF;
}
while( pCur < pEnd ){
if( (pCur->nType & (JX9_TK_COMMA/*','*/|JX9_TK_SEMI/*';'*/)) && iNest <= 0){
break;
}
if( pCur->nType & (JX9_TK_LPAREN/*'('*/|JX9_TK_OSB/*'['*/|JX9_TK_OCB/*'{'*/) ){
iNest++;
}else if( pCur->nType & (JX9_TK_RPAREN/*')'*/|JX9_TK_CSB/*']'*/|JX9_TK_CCB/*'}*/) ){
iNest--;
}
pCur++;
}
*ppNext = pCur;
return SXRET_OK;
}
/*
* Collect and assemble tokens holding annonymous functions/closure body.
* When errors, JX9 take care of generating the appropriate error message.
* Note on annonymous functions.
* According to the JX9 language reference manual:
* Anonymous functions, also known as closures, allow the creation of functions
* which have no specified name. They are most useful as the value of callback
* parameters, but they have many other uses.
* Closures may also inherit variables from the parent scope. Any such variables
* must be declared in the function header. Inheriting variables from the parent
* scope is not the same as using global variables. Global variables exist in the global scope
* which is the same no matter what function is executing. The parent scope of a closure is the
* function in which the closure was declared (not necessarily the function it was called from).
*
* Some example:
* $greet = function($name)
* {
* printf("Hello %s\r\n", $name);
* };
* $greet('World');
* $greet('JX9');
*
* $double = function($a) {
* return $a * 2;
* };
* // This is our range of numbers
* $numbers = range(1, 5);
* // Use the Annonymous function as a callback here to
* // double the size of each element in our
* // range
* $new_numbers = array_map($double, $numbers);
* print implode(' ', $new_numbers);
*/
static sxi32 ExprAssembleAnnon(jx9_gen_state *pGen,SyToken **ppCur, SyToken *pEnd)
{
SyToken *pIn = *ppCur;
sxu32 nLine;
sxi32 rc;
/* Jump the 'function' keyword */
nLine = pIn->nLine;
pIn++;
if( pIn < pEnd && (pIn->nType & (JX9_TK_ID|JX9_TK_KEYWORD)) ){
pIn++;
}
if( pIn >= pEnd || (pIn->nType & JX9_TK_LPAREN) == 0 ){
/* Syntax error */
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Missing opening parenthesis '(' while declaring annonymous function");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
goto Synchronize;
}
pIn++; /* Jump the leading parenthesis '(' */
jx9DelimitNestedTokens(pIn, pEnd, JX9_TK_LPAREN/*'('*/, JX9_TK_RPAREN/*')'*/, &pIn);
if( pIn >= pEnd || &pIn[1] >= pEnd ){
/* Syntax error */
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Syntax error while declaring annonymous function");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
goto Synchronize;
}
pIn++; /* Jump the trailing parenthesis */
if( pIn->nType & JX9_TK_OCB /*'{'*/ ){
pIn++; /* Jump the leading curly '{' */
jx9DelimitNestedTokens(pIn, pEnd, JX9_TK_OCB/*'{'*/, JX9_TK_CCB/*'}'*/, &pIn);
if( pIn < pEnd ){
pIn++;
}
}else{
/* Syntax error */
rc = jx9GenCompileError(&(*pGen), E_ERROR, nLine, "Syntax error while declaring annonymous function, missing '{'");
if( rc == SXERR_ABORT ){
return SXERR_ABORT;
}
}
rc = SXRET_OK;
Synchronize:
/* Synchronize pointers */
*ppCur = pIn;
return rc;
}
/*
* Make sure we are dealing with a valid expression tree.
* This function check for balanced parenthesis, braces, brackets and so on.
* When errors, JX9 take care of generating the appropriate error message.
* Return SXRET_OK on success. Any other return value indicates syntax error.
*/
static sxi32 ExprVerifyNodes(jx9_gen_state *pGen, jx9_expr_node **apNode, sxi32 nNode)
{
sxi32 iParen, iSquare, iBraces;
sxi32 i, rc;
if( nNode > 0 && apNode[0]->pOp && (apNode[0]->pOp->iOp == EXPR_OP_ADD || apNode[0]->pOp->iOp == EXPR_OP_SUB) ){
/* Fix and mark as an unary not binary plus/minus operator */
apNode[0]->pOp = jx9ExprExtractOperator(&apNode[0]->pStart->sData, 0);
apNode[0]->pStart->pUserData = (void *)apNode[0]->pOp;
}
iParen = iSquare = iBraces = 0;
for( i = 0 ; i < nNode ; ++i ){
if( apNode[i]->pStart->nType & JX9_TK_LPAREN /*'('*/){
if( i > 0 && ( apNode[i-1]->xCode == jx9CompileVariable || apNode[i-1]->xCode == jx9CompileLiteral ||
(apNode[i - 1]->pStart->nType & (JX9_TK_ID|JX9_TK_KEYWORD|JX9_TK_SSTR|JX9_TK_DSTR|JX9_TK_RPAREN/*')'*/|JX9_TK_CSB/*]*/))) ){
/* Ticket 1433-033: Take care to ignore alpha-stream [i.e: or, xor] operators followed by an opening parenthesis */
if( (apNode[i - 1]->pStart->nType & JX9_TK_OP) == 0 ){
/* We are dealing with a postfix [i.e: function call] operator
* not a simple left parenthesis. Mark the node.
*/
apNode[i]->pStart->nType |= JX9_TK_OP;
apNode[i]->pStart->pUserData = (void *)&sFCallOp; /* Function call operator */
apNode[i]->pOp = &sFCallOp;
}
}
iParen++;
}else if( apNode[i]->pStart->nType & JX9_TK_RPAREN/*')*/){
if( iParen <= 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, apNode[i]->pStart->nLine, "Syntax error: Unexpected token ')'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
iParen--;
}else if( apNode[i]->pStart->nType & JX9_TK_OSB /*'['*/ && apNode[i]->xCode == 0 ){
iSquare++;
}else if (apNode[i]->pStart->nType & JX9_TK_CSB /*']'*/){
if( iSquare <= 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, apNode[i]->pStart->nLine, "Syntax error: Unexpected token ']'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
iSquare--;
}else if( apNode[i]->pStart->nType & JX9_TK_OCB /*'{'*/ && apNode[i]->xCode == 0 ){
iBraces++;
}else if (apNode[i]->pStart->nType & JX9_TK_CCB /*'}'*/){
if( iBraces <= 0 ){
rc = jx9GenCompileError(&(*pGen), E_ERROR, apNode[i]->pStart->nLine, "Syntax error: Unexpected token '}'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
iBraces--;
}else if( apNode[i]->pStart->nType & JX9_TK_OP ){
const jx9_expr_op *pOp = (const jx9_expr_op *)apNode[i]->pOp;
if( i > 0 && (pOp->iOp == EXPR_OP_UMINUS || pOp->iOp == EXPR_OP_UPLUS)){
if( apNode[i-1]->xCode == jx9CompileVariable || apNode[i-1]->xCode == jx9CompileLiteral ){
sxi32 iExprOp = EXPR_OP_SUB; /* Binary minus */
sxu32 n = 0;
if( pOp->iOp == EXPR_OP_UPLUS ){
iExprOp = EXPR_OP_ADD; /* Binary plus */
}
/*
* TICKET 1433-013: This is a fix around an obscure bug when the user uses
* a variable name which is an alpha-stream operator [i.e: $and, $xor, $eq..].
*/
while( n < SX_ARRAYSIZE(aOpTable) && aOpTable[n].iOp != iExprOp ){
++n;
}
pOp = &aOpTable[n];
/* Mark as binary '+' or '-', not an unary */
apNode[i]->pOp = pOp;
apNode[i]->pStart->pUserData = (void *)pOp;
}
}
}
}
if( iParen != 0 || iSquare != 0 || iBraces != 0){
rc = jx9GenCompileError(&(*pGen), E_ERROR, apNode[0]->pStart->nLine, "Syntax error, mismatched '(', '[' or '{'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
return SXRET_OK;
}
/*
* Extract a single expression node from the input.
* On success store the freshly extractd node in ppNode.
* When errors, JX9 take care of generating the appropriate error message.
* An expression node can be a variable [i.e: $var], an operator [i.e: ++]
* an annonymous function [i.e: function(){ return "Hello"; }, a double/single
* quoted string, a heredoc/nowdoc, a literal [i.e: JX9_EOL], a namespace path
* [i.e: namespaces\path\to..], a array/list [i.e: array(4, 5, 6)] and so on.
*/
static sxi32 ExprExtractNode(jx9_gen_state *pGen, jx9_expr_node **ppNode)
{
jx9_expr_node *pNode;
SyToken *pCur;
sxi32 rc;
/* Allocate a new node */
pNode = (jx9_expr_node *)SyMemBackendPoolAlloc(&pGen->pVm->sAllocator, sizeof(jx9_expr_node));
if( pNode == 0 ){
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here.
*/
return SXERR_MEM;
}
/* Zero the structure */
SyZero(pNode, sizeof(jx9_expr_node));
SySetInit(&pNode->aNodeArgs, &pGen->pVm->sAllocator, sizeof(jx9_expr_node **));
/* Point to the head of the token stream */
pCur = pNode->pStart = pGen->pIn;
/* Start collecting tokens */
if( pCur->nType & JX9_TK_OP ){
/* Point to the instance that describe this operator */
pNode->pOp = (const jx9_expr_op *)pCur->pUserData;
/* Advance the stream cursor */
pCur++;
}else if( pCur->nType & JX9_TK_DOLLAR ){
/* Isolate variable */
pCur++; /* Jump the dollar sign */
if( pCur >= pGen->pEnd ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine,"Invalid variable name");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
return rc;
}
pCur++; /* Jump the variable name */
pNode->xCode = jx9CompileVariable;
}else if( pCur->nType & JX9_TK_OCB /* '{' */ ){
/* JSON Object, assemble tokens */
pCur++;
jx9DelimitNestedTokens(pCur, pGen->pEnd, JX9_TK_OCB /* '[' */, JX9_TK_CCB /* ']' */, &pCur);
if( pCur < pGen->pEnd ){
pCur++;
}else{
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine,"JSON Object: Missing closing braces '}'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
return rc;
}
pNode->xCode = jx9CompileJsonObject;
}else if( pCur->nType & JX9_TK_OSB /* '[' */ && !(pCur->nType & JX9_TK_OP) ){
/* JSON Array, assemble tokens */
pCur++;
jx9DelimitNestedTokens(pCur, pGen->pEnd, JX9_TK_OSB /* '[' */, JX9_TK_CSB /* ']' */, &pCur);
if( pCur < pGen->pEnd ){
pCur++;
}else{
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine,"JSON Array: Missing closing square bracket ']'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
return rc;
}
pNode->xCode = jx9CompileJsonArray;
}else if( pCur->nType & JX9_TK_KEYWORD ){
int nKeyword = SX_PTR_TO_INT(pCur->pUserData);
if( nKeyword == JX9_TKWRD_FUNCTION ){
/* Annonymous function */
if( &pCur[1] >= pGen->pEnd ){
/* Assume a literal */
pCur++;
pNode->xCode = jx9CompileLiteral;
}else{
/* Assemble annonymous functions body */
rc = ExprAssembleAnnon(&(*pGen), &pCur, pGen->pEnd);
if( rc != SXRET_OK ){
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
return rc;
}
pNode->xCode = jx9CompileAnnonFunc;
}
}else if( jx9IsLangConstruct(nKeyword) && &pCur[1] < pGen->pEnd ){
/* Language constructs [i.e: print,die...] require special handling */
jx9DelimitNestedTokens(pCur, pGen->pEnd, JX9_TK_LPAREN|JX9_TK_OCB|JX9_TK_OSB, JX9_TK_RPAREN|JX9_TK_CCB|JX9_TK_CSB, &pCur);
pNode->xCode = jx9CompileLangConstruct;
}else{
/* Assume a literal */
pCur++;
pNode->xCode = jx9CompileLiteral;
}
}else if( pCur->nType & (JX9_TK_ID) ){
/* Constants, function name, namespace path, object name... */
pCur++;
pNode->xCode = jx9CompileLiteral;
}else{
if( (pCur->nType & (JX9_TK_LPAREN|JX9_TK_RPAREN|JX9_TK_COMMA|JX9_TK_CSB|JX9_TK_OCB|JX9_TK_CCB|JX9_TK_COLON)) == 0 ){
/* Point to the code generator routine */
pNode->xCode = jx9GetNodeHandler(pCur->nType);
if( pNode->xCode == 0 ){
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "Syntax error: Unexpected token '%z'", &pNode->pStart->sData);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
return rc;
}
}
/* Advance the stream cursor */
pCur++;
}
/* Point to the end of the token stream */
pNode->pEnd = pCur;
/* Save the node for later processing */
*ppNode = pNode;
/* Synchronize cursors */
pGen->pIn = pCur;
return SXRET_OK;
}
/*
* Free an expression tree.
*/
static void ExprFreeTree(jx9_gen_state *pGen, jx9_expr_node *pNode)
{
if( pNode->pLeft ){
/* Release the left tree */
ExprFreeTree(&(*pGen), pNode->pLeft);
}
if( pNode->pRight ){
/* Release the right tree */
ExprFreeTree(&(*pGen), pNode->pRight);
}
if( pNode->pCond ){
/* Release the conditional tree used by the ternary operator */
ExprFreeTree(&(*pGen), pNode->pCond);
}
if( SySetUsed(&pNode->aNodeArgs) > 0 ){
jx9_expr_node **apArg;
sxu32 n;
/* Release node arguments */
apArg = (jx9_expr_node **)SySetBasePtr(&pNode->aNodeArgs);
for( n = 0 ; n < SySetUsed(&pNode->aNodeArgs) ; ++n ){
ExprFreeTree(&(*pGen), apArg[n]);
}
SySetRelease(&pNode->aNodeArgs);
}
/* Finally, release this node */
SyMemBackendPoolFree(&pGen->pVm->sAllocator, pNode);
}
/*
* Free an expression tree.
* This function is a wrapper around ExprFreeTree() defined above.
*/
JX9_PRIVATE sxi32 jx9ExprFreeTree(jx9_gen_state *pGen, SySet *pNodeSet)
{
jx9_expr_node **apNode;
sxu32 n;
apNode = (jx9_expr_node **)SySetBasePtr(pNodeSet);
for( n = 0 ; n < SySetUsed(pNodeSet) ; ++n ){
if( apNode[n] ){
ExprFreeTree(&(*pGen), apNode[n]);
}
}
return SXRET_OK;
}
/*
* Check if the given node is a modifialbe l/r-value.
* Return TRUE if modifiable.FALSE otherwise.
*/
static int ExprIsModifiableValue(jx9_expr_node *pNode)
{
sxi32 iExprOp;
if( pNode->pOp == 0 ){
return pNode->xCode == jx9CompileVariable ? TRUE : FALSE;
}
iExprOp = pNode->pOp->iOp;
if( iExprOp == EXPR_OP_DOT /*'.' */ ){
return TRUE;
}
if( iExprOp == EXPR_OP_SUBSCRIPT/*'[]'*/ ){
if( pNode->pLeft->pOp ) {
if( pNode->pLeft->pOp->iOp != EXPR_OP_SUBSCRIPT /*'['*/ && pNode->pLeft->pOp->iOp != EXPR_OP_DOT /*'.'*/){
return FALSE;
}
}else if( pNode->pLeft->xCode != jx9CompileVariable ){
return FALSE;
}
return TRUE;
}
/* Not a modifiable l or r-value */
return FALSE;
}
/* Forward declaration */
static sxi32 ExprMakeTree(jx9_gen_state *pGen, jx9_expr_node **apNode, sxi32 nToken);
/* Macro to check if the given node is a terminal */
#define NODE_ISTERM(NODE) (apNode[NODE] && (!apNode[NODE]->pOp || apNode[NODE]->pLeft ))
/*
* Buid an expression tree for each given function argument.
* When errors, JX9 take care of generating the appropriate error message.
*/
static sxi32 ExprProcessFuncArguments(jx9_gen_state *pGen, jx9_expr_node *pOp, jx9_expr_node **apNode, sxi32 nToken)
{
sxi32 iNest, iCur, iNode;
sxi32 rc;
/* Process function arguments from left to right */
iCur = 0;
for(;;){
if( iCur >= nToken ){
/* No more arguments to process */
break;
}
iNode = iCur;
iNest = 0;
while( iCur < nToken ){
if( apNode[iCur] ){
if( (apNode[iCur]->pStart->nType & JX9_TK_COMMA) && apNode[iCur]->pLeft == 0 && iNest <= 0 ){
break;
}else if( apNode[iCur]->pStart->nType & (JX9_TK_LPAREN|JX9_TK_OSB|JX9_TK_OCB) ){
iNest++;
}else if( apNode[iCur]->pStart->nType & (JX9_TK_RPAREN|JX9_TK_CCB|JX9_TK_CSB) ){
iNest--;
}
}
iCur++;
}
if( iCur > iNode ){
ExprMakeTree(&(*pGen), &apNode[iNode], iCur-iNode);
if( apNode[iNode] ){
/* Put a pointer to the root of the tree in the arguments set */
SySetPut(&pOp->aNodeArgs, (const void *)&apNode[iNode]);
}else{
/* Empty function argument */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pOp->pStart->nLine, "Empty function argument");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
}else{
rc = jx9GenCompileError(&(*pGen), E_ERROR, pOp->pStart->nLine, "Missing function argument");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Jump trailing comma */
if( iCur < nToken && apNode[iCur] && (apNode[iCur]->pStart->nType & JX9_TK_COMMA) ){
iCur++;
if( iCur >= nToken ){
/* missing function argument */
rc = jx9GenCompileError(&(*pGen), E_ERROR, pOp->pStart->nLine, "Missing function argument");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
}
}
return SXRET_OK;
}
/*
* Create an expression tree from an array of tokens.
* If successful, the root of the tree is stored in apNode[0].
* When errors, JX9 take care of generating the appropriate error message.
*/
static sxi32 ExprMakeTree(jx9_gen_state *pGen, jx9_expr_node **apNode, sxi32 nToken)
{
sxi32 i, iLeft, iRight;
jx9_expr_node *pNode;
sxi32 iCur;
sxi32 rc;
if( nToken <= 0 || (nToken == 1 && apNode[0]->xCode) ){
/* TICKET 1433-17: self evaluating node */
return SXRET_OK;
}
/* Process expressions enclosed in parenthesis first */
for( iCur = 0 ; iCur < nToken ; ++iCur ){
sxi32 iNest;
/* Note that, we use strict comparison here '!=' instead of the bitwise and '&' operator
* since the LPAREN token can also be an operator [i.e: Function call].
*/
if( apNode[iCur] == 0 || apNode[iCur]->pStart->nType != JX9_TK_LPAREN ){
continue;
}
iNest = 1;
iLeft = iCur;
/* Find the closing parenthesis */
iCur++;
while( iCur < nToken ){
if( apNode[iCur] ){
if( apNode[iCur]->pStart->nType & JX9_TK_RPAREN /* ')' */){
/* Decrement nesting level */
iNest--;
if( iNest <= 0 ){
break;
}
}else if( apNode[iCur]->pStart->nType & JX9_TK_LPAREN /* '(' */ ){
/* Increment nesting level */
iNest++;
}
}
iCur++;
}
if( iCur - iLeft > 1 ){
/* Recurse and process this expression */
rc = ExprMakeTree(&(*pGen), &apNode[iLeft + 1], iCur - iLeft - 1);
if( rc != SXRET_OK ){
return rc;
}
}
/* Free the left and right nodes */
ExprFreeTree(&(*pGen), apNode[iLeft]);
ExprFreeTree(&(*pGen), apNode[iCur]);
apNode[iLeft] = 0;
apNode[iCur] = 0;
}
/* Handle postfix [i.e: function call, member access] operators with precedence 2 */
iLeft = -1;
for( iCur = 0 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 2 && pNode->pLeft == 0 ){
if( pNode->pOp->iOp == EXPR_OP_FUNC_CALL ){
/* Collect function arguments */
sxi32 iPtr = 0;
sxi32 nFuncTok = 0;
while( nFuncTok + iCur < nToken ){
if( apNode[nFuncTok+iCur] ){
if( apNode[nFuncTok+iCur]->pStart->nType & JX9_TK_LPAREN /*'('*/ ){
iPtr++;
}else if ( apNode[nFuncTok+iCur]->pStart->nType & JX9_TK_RPAREN /*')'*/){
iPtr--;
if( iPtr <= 0 ){
break;
}
}
}
nFuncTok++;
}
if( nFuncTok + iCur >= nToken ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "Missing right parenthesis ')'");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
if( iLeft < 0 || !NODE_ISTERM(iLeft) /*|| ( apNode[iLeft]->pOp && apNode[iLeft]->pOp->iPrec != 2)*/ ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "Invalid function name");
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
if( nFuncTok > 1 ){
/* Process function arguments */
rc = ExprProcessFuncArguments(&(*pGen), pNode, &apNode[iCur+1], nFuncTok-1);
if( rc != SXRET_OK ){
return rc;
}
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
apNode[iLeft] = 0;
for( iPtr = 1; iPtr <= nFuncTok ; iPtr++ ){
apNode[iCur+iPtr] = 0;
}
}else if (pNode->pOp->iOp == EXPR_OP_SUBSCRIPT ){
/* Subscripting */
sxi32 iArrTok = iCur + 1;
sxi32 iNest = 1;
if( iLeft >= 0 && (apNode[iLeft]->xCode == jx9CompileVariable || (apNode[iLeft]->pOp && apNode[iLeft]->pOp->iPrec == 2 /* postfix */) ) ){
/* Collect index tokens */
while( iArrTok < nToken ){
if( apNode[iArrTok] ){
if( apNode[iArrTok]->pStart->nType & JX9_TK_OSB /*'['*/){
/* Increment nesting level */
iNest++;
}else if( apNode[iArrTok]->pStart->nType & JX9_TK_CSB /*']'*/){
/* Decrement nesting level */
iNest--;
if( iNest <= 0 ){
break;
}
}
}
++iArrTok;
}
if( iArrTok > iCur + 1 ){
/* Recurse and process this expression */
rc = ExprMakeTree(&(*pGen), &apNode[iCur+1], iArrTok - iCur - 1);
if( rc != SXRET_OK ){
return rc;
}
/* Link the node to it's index */
SySetPut(&pNode->aNodeArgs, (const void *)&apNode[iCur+1]);
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
pNode->pRight = 0;
apNode[iLeft] = 0;
for( iNest = iCur + 1 ; iNest <= iArrTok ; ++iNest ){
apNode[iNest] = 0;
}
}
}else{
/* Member access operators [i.e: '.' ] */
iRight = iCur + 1;
while( iRight < nToken && apNode[iRight] == 0 ){
iRight++;
}
if( iRight >= nToken || iLeft < 0 || !NODE_ISTERM(iRight) || !NODE_ISTERM(iLeft) ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing/Invalid member name", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
if( pNode->pLeft->pOp == 0 && pNode->pLeft->xCode != jx9CompileVariable ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine,
"'%z': Expecting a variable as left operand", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
pNode->pRight = apNode[iRight];
apNode[iLeft] = apNode[iRight] = 0;
}
}
iLeft = iCur;
}
/* Handle post/pre icrement/decrement [i.e: ++/--] operators with precedence 3 */
iLeft = -1;
for( iCur = 0 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 3 && pNode->pLeft == 0){
if( iLeft >= 0 && ((apNode[iLeft]->pOp && apNode[iLeft]->pOp->iPrec == 2 /* Postfix */)
|| apNode[iLeft]->xCode == jx9CompileVariable) ){
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
apNode[iLeft] = 0;
}
}
iLeft = iCur;
}
iLeft = -1;
for( iCur = nToken - 1 ; iCur >= 0 ; iCur-- ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 3 && pNode->pLeft == 0){
if( iLeft < 0 || (apNode[iLeft]->pOp == 0 && apNode[iLeft]->xCode != jx9CompileVariable)
|| ( apNode[iLeft]->pOp && apNode[iLeft]->pOp->iPrec != 2 /* Postfix */) ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z' operator needs l-value", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
apNode[iLeft] = 0;
/* Mark as pre-increment/decrement node */
pNode->iFlags |= EXPR_NODE_PRE_INCR;
}
iLeft = iCur;
}
/* Handle right associative unary and cast operators [i.e: !, (string), ~...] with precedence 4 */
iLeft = 0;
for( iCur = nToken - 1 ; iCur >= 0 ; iCur-- ){
if( apNode[iCur] ){
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 4 && pNode->pLeft == 0){
if( iLeft > 0 ){
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
apNode[iLeft] = 0;
if( pNode->pLeft && pNode->pLeft->pOp && pNode->pLeft->pOp->iPrec > 4 ){
if( pNode->pLeft->pLeft == 0 || pNode->pLeft->pRight == 0 ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pLeft->pStart->nLine, "'%z': Missing operand", &pNode->pLeft->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
}
}else{
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing operand", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
}
/* Save terminal position */
iLeft = iCur;
}
}
/* Process left and non-associative binary operators [i.e: *, /, &&, ||...]*/
for( i = 7 ; i < 17 ; i++ ){
iLeft = -1;
for( iCur = 0 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == i && pNode->pLeft == 0 ){
/* Get the right node */
iRight = iCur + 1;
while( iRight < nToken && apNode[iRight] == 0 ){
iRight++;
}
if( iRight >= nToken || iLeft < 0 || !NODE_ISTERM(iRight) || !NODE_ISTERM(iLeft) ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing/Invalid operand", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
pNode->pRight = apNode[iRight];
apNode[iLeft] = apNode[iRight] = 0;
}
iLeft = iCur;
}
}
/* Handle the ternary operator. (expr1) ? (expr2) : (expr3)
* Note that we do not need a precedence loop here since
* we are dealing with a single operator.
*/
iLeft = -1;
for( iCur = 0 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iOp == EXPR_OP_QUESTY && pNode->pLeft == 0 ){
sxi32 iNest = 1;
if( iLeft < 0 || !NODE_ISTERM(iLeft) ){
/* Missing condition */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Syntax error", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Get the right node */
iRight = iCur + 1;
while( iRight < nToken ){
if( apNode[iRight] ){
if( apNode[iRight]->pOp && apNode[iRight]->pOp->iOp == EXPR_OP_QUESTY && apNode[iRight]->pCond == 0){
/* Increment nesting level */
++iNest;
}else if( apNode[iRight]->pStart->nType & JX9_TK_COLON /*:*/ ){
/* Decrement nesting level */
--iNest;
if( iNest <= 0 ){
break;
}
}
}
iRight++;
}
if( iRight > iCur + 1 ){
/* Recurse and process the then expression */
rc = ExprMakeTree(&(*pGen), &apNode[iCur + 1], iRight - iCur - 1);
if( rc != SXRET_OK ){
return rc;
}
/* Link the node to the tree */
pNode->pLeft = apNode[iCur + 1];
}else{
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing 'then' expression", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
apNode[iCur + 1] = 0;
if( iRight + 1 < nToken ){
/* Recurse and process the else expression */
rc = ExprMakeTree(&(*pGen), &apNode[iRight + 1], nToken - iRight - 1);
if( rc != SXRET_OK ){
return rc;
}
/* Link the node to the tree */
pNode->pRight = apNode[iRight + 1];
apNode[iRight + 1] = apNode[iRight] = 0;
}else{
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing 'else' expression", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Point to the condition */
pNode->pCond = apNode[iLeft];
apNode[iLeft] = 0;
break;
}
iLeft = iCur;
}
/* Process right associative binary operators [i.e: '=', '+=', '/=']
* Note: All right associative binary operators have precedence 18
* so there is no need for a precedence loop here.
*/
iRight = -1;
for( iCur = nToken - 1 ; iCur >= 0 ; iCur--){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 18 && pNode->pLeft == 0 ){
/* Get the left node */
iLeft = iCur - 1;
while( iLeft >= 0 && apNode[iLeft] == 0 ){
iLeft--;
}
if( iLeft < 0 || iRight < 0 || !NODE_ISTERM(iRight) || !NODE_ISTERM(iLeft) ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing/Invalid operand", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
if( ExprIsModifiableValue(apNode[iLeft]) == FALSE ){
if( pNode->pOp->iVmOp != JX9_OP_STORE ){
/* Left operand must be a modifiable l-value */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine,
"'%z': Left operand must be a modifiable l-value", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
}
/* Link the node to the tree (Reverse) */
pNode->pLeft = apNode[iRight];
pNode->pRight = apNode[iLeft];
apNode[iLeft] = apNode[iRight] = 0;
}
iRight = iCur;
}
/* Process the lowest precedence operator (22, comma) */
iLeft = -1;
for( iCur = 0 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] == 0 ){
continue;
}
pNode = apNode[iCur];
if( pNode->pOp && pNode->pOp->iPrec == 22 /* ',' */ && pNode->pLeft == 0 ){
/* Get the right node */
iRight = iCur + 1;
while( iRight < nToken && apNode[iRight] == 0 ){
iRight++;
}
if( iRight >= nToken || iLeft < 0 || !NODE_ISTERM(iRight) || !NODE_ISTERM(iLeft) ){
/* Syntax error */
rc = jx9GenCompileError(pGen, E_ERROR, pNode->pStart->nLine, "'%z': Missing/Invalid operand", &pNode->pOp->sOp);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
/* Link the node to the tree */
pNode->pLeft = apNode[iLeft];
pNode->pRight = apNode[iRight];
apNode[iLeft] = apNode[iRight] = 0;
}
iLeft = iCur;
}
/* Point to the root of the expression tree */
for( iCur = 1 ; iCur < nToken ; ++iCur ){
if( apNode[iCur] ){
if( (apNode[iCur]->pOp || apNode[iCur]->xCode ) && apNode[0] != 0){
rc = jx9GenCompileError(pGen, E_ERROR, apNode[iCur]->pStart->nLine, "Unexpected token '%z'", &apNode[iCur]->pStart->sData);
if( rc != SXERR_ABORT ){
rc = SXERR_SYNTAX;
}
return rc;
}
apNode[0] = apNode[iCur];
apNode[iCur] = 0;
}
}
return SXRET_OK;
}
/*
* Build an expression tree from the freshly extracted raw tokens.
* If successful, the root of the tree is stored in ppRoot.
* When errors, JX9 take care of generating the appropriate error message.
* This is the public interface used by the most code generator routines.
*/
JX9_PRIVATE sxi32 jx9ExprMakeTree(jx9_gen_state *pGen, SySet *pExprNode, jx9_expr_node **ppRoot)
{
jx9_expr_node **apNode;
jx9_expr_node *pNode;
sxi32 rc;
/* Reset node container */
SySetReset(pExprNode);
pNode = 0; /* Prevent compiler warning */
/* Extract nodes one after one until we hit the end of the input */
while( pGen->pIn < pGen->pEnd ){
rc = ExprExtractNode(&(*pGen), &pNode);
if( rc != SXRET_OK ){
return rc;
}
/* Save the extracted node */
SySetPut(pExprNode, (const void *)&pNode);
}
if( SySetUsed(pExprNode) < 1 ){
/* Empty expression [i.e: A semi-colon;] */
*ppRoot = 0;
return SXRET_OK;
}
apNode = (jx9_expr_node **)SySetBasePtr(pExprNode);
/* Make sure we are dealing with valid nodes */
rc = ExprVerifyNodes(&(*pGen), apNode, (sxi32)SySetUsed(pExprNode));
if( rc != SXRET_OK ){
/* Don't worry about freeing memory, upper layer will
* cleanup the mess left behind.
*/
*ppRoot = 0;
return rc;
}
/* Build the tree */
rc = ExprMakeTree(&(*pGen), apNode, (sxi32)SySetUsed(pExprNode));
if( rc != SXRET_OK ){
/* Something goes wrong [i.e: Syntax error] */
*ppRoot = 0;
return rc;
}
/* Point to the root of the tree */
*ppRoot = apNode[0];
return SXRET_OK;
}
/*
* ----------------------------------------------------------
* File: jx9_vfs.c
* MD5: 8b73046a366acaf6aa7227c2133e16c0
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: vfs.c v2.1 Ubuntu 2012-12-13 00:013 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/*
* This file implement a virtual file systems (VFS) for the JX9 engine.
*/
/*
* Given a string containing the path of a file or directory, this function
* return the parent directory's path.
*/
JX9_PRIVATE const char * jx9ExtractDirName(const char *zPath, int nByte, int *pLen)
{
const char *zEnd = &zPath[nByte - 1];
int c, d;
c = d = '/';
#ifdef __WINNT__
d = '\\';
#endif
while( zEnd > zPath && ( (int)zEnd[0] != c && (int)zEnd[0] != d ) ){
zEnd--;
}
*pLen = (int)(zEnd-zPath);
#ifdef __WINNT__
if( (*pLen) == (int)sizeof(char) && zPath[0] == '/' ){
/* Normalize path on windows */
return "\\";
}
#endif
if( zEnd == zPath && ( (int)zEnd[0] != c && (int)zEnd[0] != d) ){
/* No separator, return "." as the current directory */
*pLen = sizeof(char);
return ".";
}
if( (*pLen) == 0 ){
*pLen = sizeof(char);
#ifdef __WINNT__
return "\\";
#else
return "/";
#endif
}
return zPath;
}
/*
* Omit the vfs layer implementation from the built if the JX9_DISABLE_BUILTIN_FUNC directive is defined.
*/
#ifndef JX9_DISABLE_BUILTIN_FUNC
/*
* bool chdir(string $directory)
* Change the current directory.
* Parameters
* $directory
* The new current directory
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_chdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xChdir == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xChdir(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool chroot(string $directory)
* Change the root directory.
* Parameters
* $directory
* The path to change the root directory to
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_chroot(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xChroot == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xChroot(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* string getcwd(void)
* Gets the current working directory.
* Parameters
* None
* Return
* Returns the current working directory on success, or FALSE on failure.
*/
static int jx9Vfs_getcwd(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
int rc;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xGetcwd == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
jx9_result_string(pCtx, "", 0);
/* Perform the requested operation */
rc = pVfs->xGetcwd(pCtx);
if( rc != JX9_OK ){
/* Error, return FALSE */
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* bool rmdir(string $directory)
* Removes directory.
* Parameters
* $directory
* The path to the directory
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_rmdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xRmdir == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xRmdir(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool is_dir(string $filename)
* Tells whether the given filename is a directory.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_dir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xIsdir == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xIsdir(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool mkdir(string $pathname[, int $mode = 0777])
* Make a directory.
* Parameters
* $pathname
* The directory path.
* $mode
* The mode is 0777 by default, which means the widest possible access.
* Note:
* mode is ignored on Windows.
* Note that you probably want to specify the mode as an octal number, which means
* it should have a leading zero. The mode is also modified by the current umask
* which you can change using umask().
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_mkdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iRecursive = 0;
const char *zPath;
jx9_vfs *pVfs;
int iMode, rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xMkdir == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
#ifdef __WINNT__
iMode = 0;
#else
/* Assume UNIX */
iMode = 0777;
#endif
if( nArg > 1 ){
iMode = jx9_value_to_int(apArg[1]);
if( nArg > 2 ){
iRecursive = jx9_value_to_bool(apArg[2]);
}
}
/* Perform the requested operation */
rc = pVfs->xMkdir(zPath, iMode, iRecursive);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool rename(string $oldname, string $newname)
* Attempts to rename oldname to newname.
* Parameters
* $oldname
* Old name.
* $newname
* New name.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_rename(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zOld, *zNew;
jx9_vfs *pVfs;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xRename == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
zOld = jx9_value_to_string(apArg[0], 0);
zNew = jx9_value_to_string(apArg[1], 0);
rc = pVfs->xRename(zOld, zNew);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK );
return JX9_OK;
}
/*
* string realpath(string $path)
* Returns canonicalized absolute pathname.
* Parameters
* $path
* Target path.
* Return
* Canonicalized absolute pathname on success. or FALSE on failure.
*/
static int jx9Vfs_realpath(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xRealpath == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Set an empty string untnil the underlying OS interface change that */
jx9_result_string(pCtx, "", 0);
/* Perform the requested operation */
zPath = jx9_value_to_string(apArg[0], 0);
rc = pVfs->xRealpath(zPath, pCtx);
if( rc != JX9_OK ){
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int sleep(int $seconds)
* Delays the program execution for the given number of seconds.
* Parameters
* $seconds
* Halt time in seconds.
* Return
* Zero on success or FALSE on failure.
*/
static int jx9Vfs_sleep(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
int rc, nSleep;
if( nArg < 1 || !jx9_value_is_int(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xSleep == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Amount to sleep */
nSleep = jx9_value_to_int(apArg[0]);
if( nSleep < 0 ){
/* Invalid value, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation (Microseconds) */
rc = pVfs->xSleep((unsigned int)(nSleep * SX_USEC_PER_SEC));
if( rc != JX9_OK ){
/* Return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return zero */
jx9_result_int(pCtx, 0);
}
return JX9_OK;
}
/*
* void usleep(int $micro_seconds)
* Delays program execution for the given number of micro seconds.
* Parameters
* $micro_seconds
* Halt time in micro seconds. A micro second is one millionth of a second.
* Return
* None.
*/
static int jx9Vfs_usleep(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
int nSleep;
if( nArg < 1 || !jx9_value_is_int(apArg[0]) ){
/* Missing/Invalid argument, return immediately */
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xSleep == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
return JX9_OK;
}
/* Amount to sleep */
nSleep = jx9_value_to_int(apArg[0]);
if( nSleep < 0 ){
/* Invalid value, return immediately */
return JX9_OK;
}
/* Perform the requested operation (Microseconds) */
pVfs->xSleep((unsigned int)nSleep);
return JX9_OK;
}
/*
* bool unlink (string $filename)
* Delete a file.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_unlink(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xUnlink == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xUnlink(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool chmod(string $filename, int $mode)
* Attempts to change the mode of the specified file to that given in mode.
* Parameters
* $filename
* Path to the file.
* $mode
* Mode (Must be an integer)
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_chmod(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int iMode;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xChmod == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Extract the mode */
iMode = jx9_value_to_int(apArg[1]);
/* Perform the requested operation */
rc = pVfs->xChmod(zPath, iMode);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool chown(string $filename, string $user)
* Attempts to change the owner of the file filename to user user.
* Parameters
* $filename
* Path to the file.
* $user
* Username.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_chown(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath, *zUser;
jx9_vfs *pVfs;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xChown == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Extract the user */
zUser = jx9_value_to_string(apArg[1], 0);
/* Perform the requested operation */
rc = pVfs->xChown(zPath, zUser);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool chgrp(string $filename, string $group)
* Attempts to change the group of the file filename to group.
* Parameters
* $filename
* Path to the file.
* $group
* groupname.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_chgrp(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath, *zGroup;
jx9_vfs *pVfs;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xChgrp == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Extract the user */
zGroup = jx9_value_to_string(apArg[1], 0);
/* Perform the requested operation */
rc = pVfs->xChgrp(zPath, zGroup);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* int64 disk_free_space(string $directory)
* Returns available space on filesystem or disk partition.
* Parameters
* $directory
* A directory of the filesystem or disk partition.
* Return
* Returns the number of available bytes as a 64-bit integer or FALSE on failure.
*/
static int jx9Vfs_disk_free_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iSize;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFreeSpace == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iSize = pVfs->xFreeSpace(zPath);
/* IO return value */
jx9_result_int64(pCtx, iSize);
return JX9_OK;
}
/*
* int64 disk_total_space(string $directory)
* Returns the total size of a filesystem or disk partition.
* Parameters
* $directory
* A directory of the filesystem or disk partition.
* Return
* Returns the number of available bytes as a 64-bit integer or FALSE on failure.
*/
static int jx9Vfs_disk_total_space(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iSize;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xTotalSpace == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iSize = pVfs->xTotalSpace(zPath);
/* IO return value */
jx9_result_int64(pCtx, iSize);
return JX9_OK;
}
/*
* bool file_exists(string $filename)
* Checks whether a file or directory exists.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_file_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFileExists == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xFileExists(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* int64 file_size(string $filename)
* Gets the size for the given file.
* Parameters
* $filename
* Path to the file.
* Return
* File size on success or FALSE on failure.
*/
static int jx9Vfs_file_size(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iSize;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFileSize == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iSize = pVfs->xFileSize(zPath);
/* IO return value */
jx9_result_int64(pCtx, iSize);
return JX9_OK;
}
/*
* int64 fileatime(string $filename)
* Gets the last access time of the given file.
* Parameters
* $filename
* Path to the file.
* Return
* File atime on success or FALSE on failure.
*/
static int jx9Vfs_file_atime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iTime;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFileAtime == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iTime = pVfs->xFileAtime(zPath);
/* IO return value */
jx9_result_int64(pCtx, iTime);
return JX9_OK;
}
/*
* int64 filemtime(string $filename)
* Gets file modification time.
* Parameters
* $filename
* Path to the file.
* Return
* File mtime on success or FALSE on failure.
*/
static int jx9Vfs_file_mtime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iTime;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFileMtime == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iTime = pVfs->xFileMtime(zPath);
/* IO return value */
jx9_result_int64(pCtx, iTime);
return JX9_OK;
}
/*
* int64 filectime(string $filename)
* Gets inode change time of file.
* Parameters
* $filename
* Path to the file.
* Return
* File ctime on success or FALSE on failure.
*/
static int jx9Vfs_file_ctime(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_int64 iTime;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFileCtime == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
iTime = pVfs->xFileCtime(zPath);
/* IO return value */
jx9_result_int64(pCtx, iTime);
return JX9_OK;
}
/*
* bool is_file(string $filename)
* Tells whether the filename is a regular file.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xIsfile == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xIsfile(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool is_link(string $filename)
* Tells whether the filename is a symbolic link.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_link(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xIslink == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xIslink(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool is_readable(string $filename)
* Tells whether a file exists and is readable.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_readable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xReadable == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xReadable(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool is_writable(string $filename)
* Tells whether the filename is writable.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_writable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xWritable == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xWritable(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool is_executable(string $filename)
* Tells whether the filename is executable.
* Parameters
* $filename
* Path to the file.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_is_executable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xExecutable == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xExecutable(zPath);
/* IO return value */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* string filetype(string $filename)
* Gets file type.
* Parameters
* $filename
* Path to the file.
* Return
* The type of the file. Possible values are fifo, char, dir, block, link
* file, socket and unknown.
*/
static int jx9Vfs_filetype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
jx9_vfs *pVfs;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return 'unknown' */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xFiletype == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the desired directory */
zPath = jx9_value_to_string(apArg[0], 0);
/* Set the empty string as the default return value */
jx9_result_string(pCtx, "", 0);
/* Perform the requested operation */
pVfs->xFiletype(zPath, pCtx);
return JX9_OK;
}
/*
* array stat(string $filename)
* Gives information about a file.
* Parameters
* $filename
* Path to the file.
* Return
* An associative array on success holding the following entries on success
* 0 dev device number
* 1 ino inode number (zero on windows)
* 2 mode inode protection mode
* 3 nlink number of links
* 4 uid userid of owner (zero on windows)
* 5 gid groupid of owner (zero on windows)
* 6 rdev device type, if inode device
* 7 size size in bytes
* 8 atime time of last access (Unix timestamp)
* 9 mtime time of last modification (Unix timestamp)
* 10 ctime time of last inode change (Unix timestamp)
* 11 blksize blocksize of filesystem IO (zero on windows)
* 12 blocks number of 512-byte blocks allocated.
* Note:
* FALSE is returned on failure.
*/
static int jx9Vfs_stat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray, *pValue;
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xStat == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Create the array and the working value */
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pValue == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xStat(zPath, pArray, pValue);
if( rc != JX9_OK ){
/* IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return the associative array */
jx9_result_value(pCtx, pArray);
}
/* Don't worry about freeing memory here, everything will be released
* automatically as soon we return from this function. */
return JX9_OK;
}
/*
* array lstat(string $filename)
* Gives information about a file or symbolic link.
* Parameters
* $filename
* Path to the file.
* Return
* An associative array on success holding the following entries on success
* 0 dev device number
* 1 ino inode number (zero on windows)
* 2 mode inode protection mode
* 3 nlink number of links
* 4 uid userid of owner (zero on windows)
* 5 gid groupid of owner (zero on windows)
* 6 rdev device type, if inode device
* 7 size size in bytes
* 8 atime time of last access (Unix timestamp)
* 9 mtime time of last modification (Unix timestamp)
* 10 ctime time of last inode change (Unix timestamp)
* 11 blksize blocksize of filesystem IO (zero on windows)
* 12 blocks number of 512-byte blocks allocated.
* Note:
* FALSE is returned on failure.
*/
static int jx9Vfs_lstat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray, *pValue;
const char *zPath;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xlStat == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Create the array and the working value */
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pValue == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zPath = jx9_value_to_string(apArg[0], 0);
/* Perform the requested operation */
rc = pVfs->xlStat(zPath, pArray, pValue);
if( rc != JX9_OK ){
/* IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return the associative array */
jx9_result_value(pCtx, pArray);
}
/* Don't worry about freeing memory here, everything will be released
* automatically as soon we return from this function. */
return JX9_OK;
}
/*
* string getenv(string $varname)
* Gets the value of an environment variable.
* Parameters
* $varname
* The variable name.
* Return
* Returns the value of the environment variable varname, or FALSE if the environment
* variable varname does not exist.
*/
static int jx9Vfs_getenv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zEnv;
jx9_vfs *pVfs;
int iLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xGetenv == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the environment variable */
zEnv = jx9_value_to_string(apArg[0], &iLen);
/* Set a boolean FALSE as the default return value */
jx9_result_bool(pCtx, 0);
if( iLen < 1 ){
/* Empty string */
return JX9_OK;
}
/* Perform the requested operation */
pVfs->xGetenv(zEnv, pCtx);
return JX9_OK;
}
/*
* bool putenv(string $settings)
* Set the value of an environment variable.
* Parameters
* $setting
* The setting, like "FOO=BAR"
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_putenv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zName, *zValue;
char *zSettings, *zEnd;
jx9_vfs *pVfs;
int iLen, rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the setting variable */
zSettings = (char *)jx9_value_to_string(apArg[0], &iLen);
if( iLen < 1 ){
/* Empty string, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Parse the setting */
zEnd = &zSettings[iLen];
zValue = 0;
zName = zSettings;
while( zSettings < zEnd ){
if( zSettings[0] == '=' ){
/* Null terminate the name */
zSettings[0] = 0;
zValue = &zSettings[1];
break;
}
zSettings++;
}
/* Install the environment variable in the $_Env array */
if( zValue == 0 || zName[0] == 0 || zValue >= zEnd || zName >= zValue ){
/* Invalid settings, retun FALSE */
jx9_result_bool(pCtx, 0);
if( zSettings < zEnd ){
zSettings[0] = '=';
}
return JX9_OK;
}
jx9_vm_config(pCtx->pVm, JX9_VM_CONFIG_ENV_ATTR, zName, zValue, (int)(zEnd-zValue));
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xSetenv == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
zSettings[0] = '=';
return JX9_OK;
}
/* Perform the requested operation */
rc = pVfs->xSetenv(zName, zValue);
jx9_result_bool(pCtx, rc == JX9_OK );
zSettings[0] = '=';
return JX9_OK;
}
/*
* bool touch(string $filename[, int64 $time = time()[, int64 $atime]])
* Sets access and modification time of file.
* Note: On windows
* If the file does not exists, it will not be created.
* Parameters
* $filename
* The name of the file being touched.
* $time
* The touch time. If time is not supplied, the current system time is used.
* $atime
* If present, the access time of the given filename is set to the value of atime.
* Otherwise, it is set to the value passed to the time parameter. If neither are
* present, the current system time is used.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_touch(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_int64 nTime, nAccess;
const char *zFile;
jx9_vfs *pVfs;
int rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xTouch == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
nTime = nAccess = -1;
zFile = jx9_value_to_string(apArg[0], 0);
if( nArg > 1 ){
nTime = jx9_value_to_int64(apArg[1]);
if( nArg > 2 ){
nAccess = jx9_value_to_int64(apArg[1]);
}else{
nAccess = nTime;
}
}
rc = pVfs->xTouch(zFile, nTime, nAccess);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* Path processing functions that do not need access to the VFS layer
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* string dirname(string $path)
* Returns parent directory's path.
* Parameters
* $path
* Target path.
* On Windows, both slash (/) and backslash (\) are used as directory separator character.
* In other environments, it is the forward slash (/).
* Return
* The path of the parent directory. If there are no slashes in path, a dot ('.')
* is returned, indicating the current directory.
*/
static int jx9Builtin_dirname(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath, *zDir;
int iLen, iDirlen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Point to the target path */
zPath = jx9_value_to_string(apArg[0], &iLen);
if( iLen < 1 ){
/* Reuturn "." */
jx9_result_string(pCtx, ".", sizeof(char));
return JX9_OK;
}
/* Perform the requested operation */
zDir = jx9ExtractDirName(zPath, iLen, &iDirlen);
/* Return directory name */
jx9_result_string(pCtx, zDir, iDirlen);
return JX9_OK;
}
/*
* string basename(string $path[, string $suffix ])
* Returns trailing name component of path.
* Parameters
* $path
* Target path.
* On Windows, both slash (/) and backslash (\) are used as directory separator character.
* In other environments, it is the forward slash (/).
* $suffix
* If the name component ends in suffix this will also be cut off.
* Return
* The base name of the given path.
*/
static int jx9Builtin_basename(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath, *zBase, *zEnd;
int c, d, iLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
c = d = '/';
#ifdef __WINNT__
d = '\\';
#endif
/* Point to the target path */
zPath = jx9_value_to_string(apArg[0], &iLen);
if( iLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Perform the requested operation */
zEnd = &zPath[iLen - 1];
/* Ignore trailing '/' */
while( zEnd > zPath && ( (int)zEnd[0] == c || (int)zEnd[0] == d ) ){
zEnd--;
}
iLen = (int)(&zEnd[1]-zPath);
while( zEnd > zPath && ( (int)zEnd[0] != c && (int)zEnd[0] != d ) ){
zEnd--;
}
zBase = (zEnd > zPath) ? &zEnd[1] : zPath;
zEnd = &zPath[iLen];
if( nArg > 1 && jx9_value_is_string(apArg[1]) ){
const char *zSuffix;
int nSuffix;
/* Strip suffix */
zSuffix = jx9_value_to_string(apArg[1], &nSuffix);
if( nSuffix > 0 && nSuffix < iLen && SyMemcmp(&zEnd[-nSuffix], zSuffix, nSuffix) == 0 ){
zEnd -= nSuffix;
}
}
/* Store the basename */
jx9_result_string(pCtx, zBase, (int)(zEnd-zBase));
return JX9_OK;
}
/*
* value pathinfo(string $path [, int $options = PATHINFO_DIRNAME | PATHINFO_BASENAME | PATHINFO_EXTENSION | PATHINFO_FILENAME ])
* Returns information about a file path.
* Parameter
* $path
* The path to be parsed.
* $options
* If present, specifies a specific element to be returned; one of
* PATHINFO_DIRNAME, PATHINFO_BASENAME, PATHINFO_EXTENSION or PATHINFO_FILENAME.
* Return
* If the options parameter is not passed, an associative array containing the following
* elements is returned: dirname, basename, extension (if any), and filename.
* If options is present, returns a string containing the requested element.
*/
typedef struct path_info path_info;
struct path_info
{
SyString sDir; /* Directory [i.e: /var/www] */
SyString sBasename; /* Basename [i.e httpd.conf] */
SyString sExtension; /* File extension [i.e xml, pdf..] */
SyString sFilename; /* Filename */
};
/*
* Extract path fields.
*/
static sxi32 ExtractPathInfo(const char *zPath, int nByte, path_info *pOut)
{
const char *zPtr, *zEnd = &zPath[nByte - 1];
SyString *pCur;
int c, d;
c = d = '/';
#ifdef __WINNT__
d = '\\';
#endif
/* Zero the structure */
SyZero(pOut, sizeof(path_info));
/* Handle special case */
if( nByte == sizeof(char) && ( (int)zPath[0] == c || (int)zPath[0] == d ) ){
#ifdef __WINNT__
SyStringInitFromBuf(&pOut->sDir, "\\", sizeof(char));
#else
SyStringInitFromBuf(&pOut->sDir, "/", sizeof(char));
#endif
return SXRET_OK;
}
/* Extract the basename */
while( zEnd > zPath && ( (int)zEnd[0] != c && (int)zEnd[0] != d ) ){
zEnd--;
}
zPtr = (zEnd > zPath) ? &zEnd[1] : zPath;
zEnd = &zPath[nByte];
/* dirname */
pCur = &pOut->sDir;
SyStringInitFromBuf(pCur, zPath, zPtr-zPath);
if( pCur->nByte > 1 ){
SyStringTrimTrailingChar(pCur, '/');
#ifdef __WINNT__
SyStringTrimTrailingChar(pCur, '\\');
#endif
}else if( (int)zPath[0] == c || (int)zPath[0] == d ){
#ifdef __WINNT__
SyStringInitFromBuf(&pOut->sDir, "\\", sizeof(char));
#else
SyStringInitFromBuf(&pOut->sDir, "/", sizeof(char));
#endif
}
/* basename/filename */
pCur = &pOut->sBasename;
SyStringInitFromBuf(pCur, zPtr, zEnd-zPtr);
SyStringTrimLeadingChar(pCur, '/');
#ifdef __WINNT__
SyStringTrimLeadingChar(pCur, '\\');
#endif
SyStringDupPtr(&pOut->sFilename, pCur);
if( pCur->nByte > 0 ){
/* extension */
zEnd--;
while( zEnd > pCur->zString /*basename*/ && zEnd[0] != '.' ){
zEnd--;
}
if( zEnd > pCur->zString ){
zEnd++; /* Jump leading dot */
SyStringInitFromBuf(&pOut->sExtension, zEnd, &zPath[nByte]-zEnd);
/* Fix filename */
pCur = &pOut->sFilename;
if( pCur->nByte > SyStringLength(&pOut->sExtension) ){
pCur->nByte -= 1 + SyStringLength(&pOut->sExtension);
}
}
}
return SXRET_OK;
}
/*
* value pathinfo(string $path [, int $options = PATHINFO_DIRNAME | PATHINFO_BASENAME | PATHINFO_EXTENSION | PATHINFO_FILENAME ])
* See block comment above.
*/
static int jx9Builtin_pathinfo(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zPath;
path_info sInfo;
SyString *pComp;
int iLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid argument, return the empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Point to the target path */
zPath = jx9_value_to_string(apArg[0], &iLen);
if( iLen < 1 ){
/* Empty string */
jx9_result_string(pCtx, "", 0);
return JX9_OK;
}
/* Extract path info */
ExtractPathInfo(zPath, iLen, &sInfo);
if( nArg > 1 && jx9_value_is_int(apArg[1]) ){
/* Return path component */
int nComp = jx9_value_to_int(apArg[1]);
switch(nComp){
case 1: /* PATHINFO_DIRNAME */
pComp = &sInfo.sDir;
if( pComp->nByte > 0 ){
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}else{
/* Expand the empty string */
jx9_result_string(pCtx, "", 0);
}
break;
case 2: /*PATHINFO_BASENAME*/
pComp = &sInfo.sBasename;
if( pComp->nByte > 0 ){
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}else{
/* Expand the empty string */
jx9_result_string(pCtx, "", 0);
}
break;
case 3: /*PATHINFO_EXTENSION*/
pComp = &sInfo.sExtension;
if( pComp->nByte > 0 ){
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}else{
/* Expand the empty string */
jx9_result_string(pCtx, "", 0);
}
break;
case 4: /*PATHINFO_FILENAME*/
pComp = &sInfo.sFilename;
if( pComp->nByte > 0 ){
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}else{
/* Expand the empty string */
jx9_result_string(pCtx, "", 0);
}
break;
default:
/* Expand the empty string */
jx9_result_string(pCtx, "", 0);
break;
}
}else{
/* Return an associative array */
jx9_value *pArray, *pValue;
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pValue == 0 ){
/* Out of mem, return NULL */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* dirname */
pComp = &sInfo.sDir;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
/* Perform the insertion */
jx9_array_add_strkey_elem(pArray, "dirname", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
/* basername */
pComp = &sInfo.sBasename;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
/* Perform the insertion */
jx9_array_add_strkey_elem(pArray, "basename", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
/* extension */
pComp = &sInfo.sExtension;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
/* Perform the insertion */
jx9_array_add_strkey_elem(pArray, "extension", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
/* filename */
pComp = &sInfo.sFilename;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
/* Perform the insertion */
jx9_array_add_strkey_elem(pArray, "filename", pValue); /* Will make it's own copy */
}
/* Return the created array */
jx9_result_value(pCtx, pArray);
/* Don't worry about freeing memory, everything will be released
* automatically as soon we return from this foreign function.
*/
}
return JX9_OK;
}
/*
* Globbing implementation extracted from the sqlite3 source tree.
* Original author: D. Richard Hipp (http://www.sqlite.org)
* Status: Public Domain
*/
typedef unsigned char u8;
/* An array to map all upper-case characters into their corresponding
** lower-case character.
**
** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
** handle case conversions for the UTF character set since the tables
** involved are nearly as big or bigger than SQLite itself.
*/
static const unsigned char sqlite3UpperToLower[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
122, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161,
162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215,
216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251,
252, 253, 254, 255
};
#define GlogUpperToLower(A) if( A<0x80 ){ A = sqlite3UpperToLower[A]; }
/*
** Assuming zIn points to the first byte of a UTF-8 character,
** advance zIn to point to the first byte of the next UTF-8 character.
*/
#define SQLITE_SKIP_UTF8(zIn) { \
if( (*(zIn++))>=0xc0 ){ \
while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
} \
}
/*
** Compare two UTF-8 strings for equality where the first string can
** potentially be a "glob" expression. Return true (1) if they
** are the same and false (0) if they are different.
**
** Globbing rules:
**
** '*' Matches any sequence of zero or more characters.
**
** '?' Matches exactly one character.
**
** [...] Matches one character from the enclosed list of
** characters.
**
** [^...] Matches one character not in the enclosed list.
**
** With the [...] and [^...] matching, a ']' character can be included
** in the list by making it the first character after '[' or '^'. A
** range of characters can be specified using '-'. Example:
** "[a-z]" matches any single lower-case letter. To match a '-', make
** it the last character in the list.
**
** This routine is usually quick, but can be N**2 in the worst case.
**
** Hints: to match '*' or '?', put them in "[]". Like this:
**
** abc[*]xyz Matches "abc*xyz" only
*/
static int patternCompare(
const u8 *zPattern, /* The glob pattern */
const u8 *zString, /* The string to compare against the glob */
const int esc, /* The escape character */
int noCase
){
int c, c2;
int invert;
int seen;
u8 matchOne = '?';
u8 matchAll = '*';
u8 matchSet = '[';
int prevEscape = 0; /* True if the previous character was 'escape' */
if( !zPattern || !zString ) return 0;
while( (c = jx9Utf8Read(zPattern, 0, &zPattern))!=0 ){
if( !prevEscape && c==matchAll ){
while( (c= jx9Utf8Read(zPattern, 0, &zPattern)) == matchAll
|| c == matchOne ){
if( c==matchOne && jx9Utf8Read(zString, 0, &zString)==0 ){
return 0;
}
}
if( c==0 ){
return 1;
}else if( c==esc ){
c = jx9Utf8Read(zPattern, 0, &zPattern);
if( c==0 ){
return 0;
}
}else if( c==matchSet ){
if( (esc==0) || (matchSet<0x80) ) return 0;
while( *zString && patternCompare(&zPattern[-1], zString, esc, noCase)==0 ){
SQLITE_SKIP_UTF8(zString);
}
return *zString!=0;
}
while( (c2 = jx9Utf8Read(zString, 0, &zString))!=0 ){
if( noCase ){
GlogUpperToLower(c2);
GlogUpperToLower(c);
while( c2 != 0 && c2 != c ){
c2 = jx9Utf8Read(zString, 0, &zString);
GlogUpperToLower(c2);
}
}else{
while( c2 != 0 && c2 != c ){
c2 = jx9Utf8Read(zString, 0, &zString);
}
}
if( c2==0 ) return 0;
if( patternCompare(zPattern, zString, esc, noCase) ) return 1;
}
return 0;
}else if( !prevEscape && c==matchOne ){
if( jx9Utf8Read(zString, 0, &zString)==0 ){
return 0;
}
}else if( c==matchSet ){
int prior_c = 0;
if( esc == 0 ) return 0;
seen = 0;
invert = 0;
c = jx9Utf8Read(zString, 0, &zString);
if( c==0 ) return 0;
c2 = jx9Utf8Read(zPattern, 0, &zPattern);
if( c2=='^' ){
invert = 1;
c2 = jx9Utf8Read(zPattern, 0, &zPattern);
}
if( c2==']' ){
if( c==']' ) seen = 1;
c2 = jx9Utf8Read(zPattern, 0, &zPattern);
}
while( c2 && c2!=']' ){
if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
c2 = jx9Utf8Read(zPattern, 0, &zPattern);
if( c>=prior_c && c<=c2 ) seen = 1;
prior_c = 0;
}else{
if( c==c2 ){
seen = 1;
}
prior_c = c2;
}
c2 = jx9Utf8Read(zPattern, 0, &zPattern);
}
if( c2==0 || (seen ^ invert)==0 ){
return 0;
}
}else if( esc==c && !prevEscape ){
prevEscape = 1;
}else{
c2 = jx9Utf8Read(zString, 0, &zString);
if( noCase ){
GlogUpperToLower(c);
GlogUpperToLower(c2);
}
if( c!=c2 ){
return 0;
}
prevEscape = 0;
}
}
return *zString==0;
}
/*
* Wrapper around patternCompare() defined above.
* See block comment above for more information.
*/
static int Glob(const unsigned char *zPattern, const unsigned char *zString, int iEsc, int CaseCompare)
{
int rc;
if( iEsc < 0 ){
iEsc = '\\';
}
rc = patternCompare(zPattern, zString, iEsc, CaseCompare);
return rc;
}
/*
* bool fnmatch(string $pattern, string $string[, int $flags = 0 ])
* Match filename against a pattern.
* Parameters
* $pattern
* The shell wildcard pattern.
* $string
* The tested string.
* $flags
* A list of possible flags:
* FNM_NOESCAPE Disable backslash escaping.
* FNM_PATHNAME Slash in string only matches slash in the given pattern.
* FNM_PERIOD Leading period in string must be exactly matched by period in the given pattern.
* FNM_CASEFOLD Caseless match.
* Return
* TRUE if there is a match, FALSE otherwise.
*/
static int jx9Builtin_fnmatch(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zPattern;
int iEsc = '\\';
int noCase = 0;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the pattern and the string */
zPattern = jx9_value_to_string(apArg[0], 0);
zString = jx9_value_to_string(apArg[1], 0);
/* Extract the flags if avaialble */
if( nArg > 2 && jx9_value_is_int(apArg[2]) ){
rc = jx9_value_to_int(apArg[2]);
if( rc & 0x01 /*FNM_NOESCAPE*/){
iEsc = 0;
}
if( rc & 0x08 /*FNM_CASEFOLD*/){
noCase = 1;
}
}
/* Go globbing */
rc = Glob((const unsigned char *)zPattern, (const unsigned char *)zString, iEsc, noCase);
/* Globbing result */
jx9_result_bool(pCtx, rc);
return JX9_OK;
}
/*
* bool strglob(string $pattern, string $string)
* Match string against a pattern.
* Parameters
* $pattern
* The shell wildcard pattern.
* $string
* The tested string.
* Return
* TRUE if there is a match, FALSE otherwise.
*/
static int jx9Builtin_strglob(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zString, *zPattern;
int iEsc = '\\';
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the pattern and the string */
zPattern = jx9_value_to_string(apArg[0], 0);
zString = jx9_value_to_string(apArg[1], 0);
/* Go globbing */
rc = Glob((const unsigned char *)zPattern, (const unsigned char *)zString, iEsc, 0);
/* Globbing result */
jx9_result_bool(pCtx, rc);
return JX9_OK;
}
/*
* bool link(string $target, string $link)
* Create a hard link.
* Parameters
* $target
* Target of the link.
* $link
* The link name.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_link(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zTarget, *zLink;
jx9_vfs *pVfs;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xLink == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the given arguments */
zTarget = jx9_value_to_string(apArg[0], 0);
zLink = jx9_value_to_string(apArg[1], 0);
/* Perform the requested operation */
rc = pVfs->xLink(zTarget, zLink, 0/*Not a symbolic link */);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK );
return JX9_OK;
}
/*
* bool symlink(string $target, string $link)
* Creates a symbolic link.
* Parameters
* $target
* Target of the link.
* $link
* The link name.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Vfs_symlink(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zTarget, *zLink;
jx9_vfs *pVfs;
int rc;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xLink == 0 ){
/* IO routine not implemented, return NULL */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS, JX9 is returning FALSE",
jx9_function_name(pCtx)
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the given arguments */
zTarget = jx9_value_to_string(apArg[0], 0);
zLink = jx9_value_to_string(apArg[1], 0);
/* Perform the requested operation */
rc = pVfs->xLink(zTarget, zLink, 1/*A symbolic link */);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK );
return JX9_OK;
}
/*
* int umask([ int $mask ])
* Changes the current umask.
* Parameters
* $mask
* The new umask.
* Return
* umask() without arguments simply returns the current umask.
* Otherwise the old umask is returned.
*/
static int jx9Vfs_umask(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int iOld, iNew;
jx9_vfs *pVfs;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xUmask == 0 ){
/* IO routine not implemented, return -1 */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
jx9_result_int(pCtx, 0);
return JX9_OK;
}
iNew = 0;
if( nArg > 0 ){
iNew = jx9_value_to_int(apArg[0]);
}
/* Perform the requested operation */
iOld = pVfs->xUmask(iNew);
/* Old mask */
jx9_result_int(pCtx, iOld);
return JX9_OK;
}
/*
* string sys_get_temp_dir()
* Returns directory path used for temporary files.
* Parameters
* None
* Return
* Returns the path of the temporary directory.
*/
static int jx9Vfs_sys_get_temp_dir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
/* Set the empty string as the default return value */
jx9_result_string(pCtx, "", 0);
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xTempDir == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented, return "" */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
return JX9_OK;
}
/* Perform the requested operation */
pVfs->xTempDir(pCtx);
return JX9_OK;
}
/*
* string get_current_user()
* Returns the name of the current working user.
* Parameters
* None
* Return
* Returns the name of the current working user.
*/
static int jx9Vfs_get_current_user(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xUsername == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
/* Set a dummy username */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return JX9_OK;
}
/* Perform the requested operation */
pVfs->xUsername(pCtx);
return JX9_OK;
}
/*
* int64 getmypid()
* Gets process ID.
* Parameters
* None
* Return
* Returns the process ID.
*/
static int jx9Vfs_getmypid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_int64 nProcessId;
jx9_vfs *pVfs;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xProcessId == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented, return -1 */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Perform the requested operation */
nProcessId = (jx9_int64)pVfs->xProcessId();
/* Set the result */
jx9_result_int64(pCtx, nProcessId);
return JX9_OK;
}
/*
* int getmyuid()
* Get user ID.
* Parameters
* None
* Return
* Returns the user ID.
*/
static int jx9Vfs_getmyuid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
int nUid;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xUid == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented, return -1 */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Perform the requested operation */
nUid = pVfs->xUid();
/* Set the result */
jx9_result_int(pCtx, nUid);
return JX9_OK;
}
/*
* int getmygid()
* Get group ID.
* Parameters
* None
* Return
* Returns the group ID.
*/
static int jx9Vfs_getmygid(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vfs *pVfs;
int nGid;
/* Point to the underlying vfs */
pVfs = (jx9_vfs *)jx9_context_user_data(pCtx);
if( pVfs == 0 || pVfs->xGid == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* IO routine not implemented, return -1 */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying VFS",
jx9_function_name(pCtx)
);
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Perform the requested operation */
nGid = pVfs->xGid();
/* Set the result */
jx9_result_int(pCtx, nGid);
return JX9_OK;
}
#ifdef __WINNT__
#include <Windows.h>
#elif defined(__UNIXES__)
#include <sys/utsname.h>
#endif
/*
* string uname([ string $mode = "a" ])
* Returns information about the host operating system.
* Parameters
* $mode
* mode is a single character that defines what information is returned:
* 'a': This is the default. Contains all modes in the sequence "s n r v m".
* 's': Operating system name. eg. FreeBSD.
* 'n': Host name. eg. localhost.example.com.
* 'r': Release name. eg. 5.1.2-RELEASE.
* 'v': Version information. Varies a lot between operating systems.
* 'm': Machine type. eg. i386.
* Return
* OS description as a string.
*/
static int jx9Vfs_uname(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
#if defined(__WINNT__)
const char *zName = "Microsoft Windows";
OSVERSIONINFOW sVer;
#elif defined(__UNIXES__)
struct utsname sName;
#endif
const char *zMode = "a";
if( nArg > 0 && jx9_value_is_string(apArg[0]) ){
/* Extract the desired mode */
zMode = jx9_value_to_string(apArg[0], 0);
}
#if defined(__WINNT__)
sVer.dwOSVersionInfoSize = sizeof(sVer);
if( TRUE != GetVersionExW(&sVer)){
jx9_result_string(pCtx, zName, -1);
return JX9_OK;
}
if( sVer.dwPlatformId == VER_PLATFORM_WIN32_NT ){
if( sVer.dwMajorVersion <= 4 ){
zName = "Microsoft Windows NT";
}else if( sVer.dwMajorVersion == 5 ){
switch(sVer.dwMinorVersion){
case 0: zName = "Microsoft Windows 2000"; break;
case 1: zName = "Microsoft Windows XP"; break;
case 2: zName = "Microsoft Windows Server 2003"; break;
}
}else if( sVer.dwMajorVersion == 6){
switch(sVer.dwMinorVersion){
case 0: zName = "Microsoft Windows Vista"; break;
case 1: zName = "Microsoft Windows 7"; break;
case 2: zName = "Microsoft Windows 8"; break;
default: break;
}
}
}
switch(zMode[0]){
case 's':
/* Operating system name */
jx9_result_string(pCtx, zName, -1/* Compute length automatically*/);
break;
case 'n':
/* Host name */
jx9_result_string(pCtx, "localhost", (int)sizeof("localhost")-1);
break;
case 'r':
case 'v':
/* Version information. */
jx9_result_string_format(pCtx, "%u.%u build %u",
sVer.dwMajorVersion, sVer.dwMinorVersion, sVer.dwBuildNumber
);
break;
case 'm':
/* Machine name */
jx9_result_string(pCtx, "x86", (int)sizeof("x86")-1);
break;
default:
jx9_result_string_format(pCtx, "%s localhost %u.%u build %u x86",
zName,
sVer.dwMajorVersion, sVer.dwMinorVersion, sVer.dwBuildNumber
);
break;
}
#elif defined(__UNIXES__)
if( uname(&sName) != 0 ){
jx9_result_string(pCtx, "Unix", (int)sizeof("Unix")-1);
return JX9_OK;
}
switch(zMode[0]){
case 's':
/* Operating system name */
jx9_result_string(pCtx, sName.sysname, -1/* Compute length automatically*/);
break;
case 'n':
/* Host name */
jx9_result_string(pCtx, sName.nodename, -1/* Compute length automatically*/);
break;
case 'r':
/* Release information */
jx9_result_string(pCtx, sName.release, -1/* Compute length automatically*/);
break;
case 'v':
/* Version information. */
jx9_result_string(pCtx, sName.version, -1/* Compute length automatically*/);
break;
case 'm':
/* Machine name */
jx9_result_string(pCtx, sName.machine, -1/* Compute length automatically*/);
break;
default:
jx9_result_string_format(pCtx,
"%s %s %s %s %s",
sName.sysname,
sName.release,
sName.version,
sName.nodename,
sName.machine
);
break;
}
#else
jx9_result_string(pCtx, "Host Operating System/localhost", (int)sizeof("Host Operating System/localhost")-1);
#endif
return JX9_OK;
}
/*
* Section:
* IO stream implementation.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
typedef struct io_private io_private;
struct io_private
{
const jx9_io_stream *pStream; /* Underlying IO device */
void *pHandle; /* IO handle */
/* Unbuffered IO */
SyBlob sBuffer; /* Working buffer */
sxu32 nOfft; /* Current read offset */
sxu32 iMagic; /* Sanity check to avoid misuse */
};
#define IO_PRIVATE_MAGIC 0xFEAC14
/* Make sure we are dealing with a valid io_private instance */
#define IO_PRIVATE_INVALID(IO) ( IO == 0 || IO->iMagic != IO_PRIVATE_MAGIC )
/* Forward declaration */
static void ResetIOPrivate(io_private *pDev);
/*
* bool ftruncate(resource $handle, int64 $size)
* Truncates a file to a given length.
* Parameters
* $handle
* The file pointer.
* Note:
* The handle must be open for writing.
* $size
* The size to truncate to.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Builtin_ftruncate(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xTrunc == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
rc = pStream->xTrunc(pDev->pHandle, jx9_value_to_int64(apArg[1]));
if( rc == JX9_OK ){
/* Discard buffered data */
ResetIOPrivate(pDev);
}
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* int fseek(resource $handle, int $offset[, int $whence = SEEK_SET ])
* Seeks on a file pointer.
* Parameters
* $handle
* A file system pointer resource that is typically created using fopen().
* $offset
* The offset.
* To move to a position before the end-of-file, you need to pass a negative
* value in offset and set whence to SEEK_END.
* whence
* whence values are:
* SEEK_SET - Set position equal to offset bytes.
* SEEK_CUR - Set position to current location plus offset.
* SEEK_END - Set position to end-of-file plus offset.
* Return
* 0 on success, -1 on failure
*/
static int jx9Builtin_fseek(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_int64 iOfft;
int whence;
int rc;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xSeek == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_int(pCtx, -1);
return JX9_OK;
}
/* Extract the offset */
iOfft = jx9_value_to_int64(apArg[1]);
whence = 0;/* SEEK_SET */
if( nArg > 2 && jx9_value_is_int(apArg[2]) ){
whence = jx9_value_to_int(apArg[2]);
}
/* Perform the requested operation */
rc = pStream->xSeek(pDev->pHandle, iOfft, whence);
if( rc == JX9_OK ){
/* Ignore buffered data */
ResetIOPrivate(pDev);
}
/* IO result */
jx9_result_int(pCtx, rc == JX9_OK ? 0 : - 1);
return JX9_OK;
}
/*
* int64 ftell(resource $handle)
* Returns the current position of the file read/write pointer.
* Parameters
* $handle
* The file pointer.
* Return
* Returns the position of the file pointer referenced by handle
* as an integer; i.e., its offset into the file stream.
* FALSE is returned on failure.
*/
static int jx9Builtin_ftell(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_int64 iOfft;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xTell == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
iOfft = pStream->xTell(pDev->pHandle);
/* IO result */
jx9_result_int64(pCtx, iOfft);
return JX9_OK;
}
/*
* bool rewind(resource $handle)
* Rewind the position of a file pointer.
* Parameters
* $handle
* The file pointer.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Builtin_rewind(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xSeek == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
rc = pStream->xSeek(pDev->pHandle, 0, 0/*SEEK_SET*/);
if( rc == JX9_OK ){
/* Ignore buffered data */
ResetIOPrivate(pDev);
}
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool fflush(resource $handle)
* Flushes the output to a file.
* Parameters
* $handle
* The file pointer.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Builtin_fflush(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xSync == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
rc = pStream->xSync(pDev->pHandle);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* bool feof(resource $handle)
* Tests for end-of-file on a file pointer.
* Parameters
* $handle
* The file pointer.
* Return
* Returns TRUE if the file pointer is at EOF.FALSE otherwise
*/
static int jx9Builtin_feof(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
rc = SXERR_EOF;
/* Perform the requested operation */
if( SyBlobLength(&pDev->sBuffer) - pDev->nOfft > 0 ){
/* Data is available */
rc = JX9_OK;
}else{
char zBuf[4096];
jx9_int64 n;
/* Perform a buffered read */
n = pStream->xRead(pDev->pHandle, zBuf, sizeof(zBuf));
if( n > 0 ){
/* Copy buffered data */
SyBlobAppend(&pDev->sBuffer, zBuf, (sxu32)n);
rc = JX9_OK;
}
}
/* EOF or not */
jx9_result_bool(pCtx, rc == SXERR_EOF);
return JX9_OK;
}
/*
* Read n bytes from the underlying IO stream device.
* Return total numbers of bytes readen on success. A number < 1 on failure
* [i.e: IO error ] or EOF.
*/
static jx9_int64 StreamRead(io_private *pDev, void *pBuf, jx9_int64 nLen)
{
const jx9_io_stream *pStream = pDev->pStream;
char *zBuf = (char *)pBuf;
jx9_int64 n, nRead;
n = SyBlobLength(&pDev->sBuffer) - pDev->nOfft;
if( n > 0 ){
if( n > nLen ){
n = nLen;
}
/* Copy the buffered data */
SyMemcpy(SyBlobDataAt(&pDev->sBuffer, pDev->nOfft), pBuf, (sxu32)n);
/* Update the read offset */
pDev->nOfft += (sxu32)n;
if( pDev->nOfft >= SyBlobLength(&pDev->sBuffer) ){
/* Reset the working buffer so that we avoid excessive memory allocation */
SyBlobReset(&pDev->sBuffer);
pDev->nOfft = 0;
}
nLen -= n;
if( nLen < 1 ){
/* All done */
return n;
}
/* Advance the cursor */
zBuf += n;
}
/* Read without buffering */
nRead = pStream->xRead(pDev->pHandle, zBuf, nLen);
if( nRead > 0 ){
n += nRead;
}else if( n < 1 ){
/* EOF or IO error */
return nRead;
}
return n;
}
/*
* Extract a single line from the buffered input.
*/
static sxi32 GetLine(io_private *pDev, jx9_int64 *pLen, const char **pzLine)
{
const char *zIn, *zEnd, *zPtr;
zIn = (const char *)SyBlobDataAt(&pDev->sBuffer, pDev->nOfft);
zEnd = &zIn[SyBlobLength(&pDev->sBuffer)-pDev->nOfft];
zPtr = zIn;
while( zIn < zEnd ){
if( zIn[0] == '\n' ){
/* Line found */
zIn++; /* Include the line ending as requested by the JX9 specification */
*pLen = (jx9_int64)(zIn-zPtr);
*pzLine = zPtr;
return SXRET_OK;
}
zIn++;
}
/* No line were found */
return SXERR_NOTFOUND;
}
/*
* Read a single line from the underlying IO stream device.
*/
static jx9_int64 StreamReadLine(io_private *pDev, const char **pzData, jx9_int64 nMaxLen)
{
const jx9_io_stream *pStream = pDev->pStream;
char zBuf[8192];
jx9_int64 n;
sxi32 rc;
n = 0;
if( pDev->nOfft >= SyBlobLength(&pDev->sBuffer) ){
/* Reset the working buffer so that we avoid excessive memory allocation */
SyBlobReset(&pDev->sBuffer);
pDev->nOfft = 0;
}
if( SyBlobLength(&pDev->sBuffer) - pDev->nOfft > 0 ){
/* Check if there is a line */
rc = GetLine(pDev, &n, pzData);
if( rc == SXRET_OK ){
/* Got line, update the cursor */
pDev->nOfft += (sxu32)n;
return n;
}
}
/* Perform the read operation until a new line is extracted or length
* limit is reached.
*/
for(;;){
n = pStream->xRead(pDev->pHandle, zBuf, (nMaxLen > 0 && nMaxLen < sizeof(zBuf)) ? nMaxLen : sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error */
break;
}
/* Append the data just read */
SyBlobAppend(&pDev->sBuffer, zBuf, (sxu32)n);
/* Try to extract a line */
rc = GetLine(pDev, &n, pzData);
if( rc == SXRET_OK ){
/* Got one, return immediately */
pDev->nOfft += (sxu32)n;
return n;
}
if( nMaxLen > 0 && (SyBlobLength(&pDev->sBuffer) - pDev->nOfft >= nMaxLen) ){
/* Read limit reached, return the available data */
*pzData = (const char *)SyBlobDataAt(&pDev->sBuffer, pDev->nOfft);
n = SyBlobLength(&pDev->sBuffer) - pDev->nOfft;
/* Reset the working buffer */
SyBlobReset(&pDev->sBuffer);
pDev->nOfft = 0;
return n;
}
}
if( SyBlobLength(&pDev->sBuffer) - pDev->nOfft > 0 ){
/* Read limit reached, return the available data */
*pzData = (const char *)SyBlobDataAt(&pDev->sBuffer, pDev->nOfft);
n = SyBlobLength(&pDev->sBuffer) - pDev->nOfft;
/* Reset the working buffer */
SyBlobReset(&pDev->sBuffer);
pDev->nOfft = 0;
}
return n;
}
/*
* Open an IO stream handle.
* Notes on stream:
* According to the JX9 reference manual.
* In its simplest definition, a stream is a resource object which exhibits streamable behavior.
* That is, it can be read from or written to in a linear fashion, and may be able to fseek()
* to an arbitrary locations within the stream.
* A wrapper is additional code which tells the stream how to handle specific protocols/encodings.
* For example, the http wrapper knows how to translate a URL into an HTTP/1.0 request for a file
* on a remote server.
* A stream is referenced as: scheme://target
* scheme(string) - The name of the wrapper to be used. Examples include: file, http...
* If no wrapper is specified, the function default is used (typically file://).
* target - Depends on the wrapper used. For filesystem related streams this is typically a path
* and filename of the desired file. For network related streams this is typically a hostname, often
* with a path appended.
*
* Note that JX9 IO streams looks like JX9 streams but their implementation differ greately.
* Please refer to the official documentation for a full discussion.
* This function return a handle on success. Otherwise null.
*/
JX9_PRIVATE void * jx9StreamOpenHandle(jx9_vm *pVm, const jx9_io_stream *pStream, const char *zFile,
int iFlags, int use_include, jx9_value *pResource, int bPushInclude, int *pNew)
{
void *pHandle = 0; /* cc warning */
SyString sFile;
int rc;
if( pStream == 0 ){
/* No such stream device */
return 0;
}
SyStringInitFromBuf(&sFile, zFile, SyStrlen(zFile));
if( use_include ){
if( sFile.zString[0] == '/' ||
#ifdef __WINNT__
(sFile.nByte > 2 && sFile.zString[1] == ':' && (sFile.zString[2] == '\\' || sFile.zString[2] == '/') ) ||
#endif
(sFile.nByte > 1 && sFile.zString[0] == '.' && sFile.zString[1] == '/') ||
(sFile.nByte > 2 && sFile.zString[0] == '.' && sFile.zString[1] == '.' && sFile.zString[2] == '/') ){
/* Open the file directly */
rc = pStream->xOpen(zFile, iFlags, pResource, &pHandle);
}else{
SyString *pPath;
SyBlob sWorker;
#ifdef __WINNT__
static const int c = '\\';
#else
static const int c = '/';
#endif
/* Init the path builder working buffer */
SyBlobInit(&sWorker, &pVm->sAllocator);
/* Build a path from the set of include path */
SySetResetCursor(&pVm->aPaths);
rc = SXERR_IO;
while( SXRET_OK == SySetGetNextEntry(&pVm->aPaths, (void **)&pPath) ){
/* Build full path */
SyBlobFormat(&sWorker, "%z%c%z", pPath, c, &sFile);
/* Append null terminator */
if( SXRET_OK != SyBlobNullAppend(&sWorker) ){
continue;
}
/* Try to open the file */
rc = pStream->xOpen((const char *)SyBlobData(&sWorker), iFlags, pResource, &pHandle);
if( rc == JX9_OK ){
if( bPushInclude ){
/* Mark as included */
jx9VmPushFilePath(pVm, (const char *)SyBlobData(&sWorker), SyBlobLength(&sWorker), FALSE, pNew);
}
break;
}
/* Reset the working buffer */
SyBlobReset(&sWorker);
/* Check the next path */
}
SyBlobRelease(&sWorker);
}
if( rc == JX9_OK ){
if( bPushInclude ){
/* Mark as included */
jx9VmPushFilePath(pVm, sFile.zString, sFile.nByte, FALSE, pNew);
}
}
}else{
/* Open the URI direcly */
rc = pStream->xOpen(zFile, iFlags, pResource, &pHandle);
}
if( rc != JX9_OK ){
/* IO error */
return 0;
}
/* Return the file handle */
return pHandle;
}
/*
* Read the whole contents of an open IO stream handle [i.e local file/URL..]
* Store the read data in the given BLOB (last argument).
* The read operation is stopped when he hit the EOF or an IO error occurs.
*/
JX9_PRIVATE sxi32 jx9StreamReadWholeFile(void *pHandle, const jx9_io_stream *pStream, SyBlob *pOut)
{
jx9_int64 nRead;
char zBuf[8192]; /* 8K */
int rc;
/* Perform the requested operation */
for(;;){
nRead = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
if( nRead < 1 ){
/* EOF or IO error */
break;
}
/* Append contents */
rc = SyBlobAppend(pOut, zBuf, (sxu32)nRead);
if( rc != SXRET_OK ){
break;
}
}
return SyBlobLength(pOut) > 0 ? SXRET_OK : -1;
}
/*
* Close an open IO stream handle [i.e local file/URI..].
*/
JX9_PRIVATE void jx9StreamCloseHandle(const jx9_io_stream *pStream, void *pHandle)
{
if( pStream->xClose ){
pStream->xClose(pHandle);
}
}
/*
* string fgetc(resource $handle)
* Gets a character from the given file pointer.
* Parameters
* $handle
* The file pointer.
* Return
* Returns a string containing a single character read from the file
* pointed to by handle. Returns FALSE on EOF.
* WARNING
* This operation is extremely slow.Avoid using it.
*/
static int jx9Builtin_fgetc(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int c, n;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
n = (int)StreamRead(pDev, (void *)&c, sizeof(char));
/* IO result */
if( n < 1 ){
/* EOF or error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return the string holding the character */
jx9_result_string(pCtx, (const char *)&c, sizeof(char));
}
return JX9_OK;
}
/*
* string fgets(resource $handle[, int64 $length ])
* Gets line from file pointer.
* Parameters
* $handle
* The file pointer.
* $length
* Reading ends when length - 1 bytes have been read, on a newline
* (which is included in the return value), or on EOF (whichever comes first).
* If no length is specified, it will keep reading from the stream until it reaches
* the end of the line.
* Return
* Returns a string of up to length - 1 bytes read from the file pointed to by handle.
* If there is no more data to read in the file pointer, then FALSE is returned.
* If an error occurs, FALSE is returned.
*/
static int jx9Builtin_fgets(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zLine;
io_private *pDev;
jx9_int64 n, nLen;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = -1;
if( nArg > 1 ){
/* Maximum data to read */
nLen = jx9_value_to_int64(apArg[1]);
}
/* Perform the requested operation */
n = StreamReadLine(pDev, &zLine, nLen);
if( n < 1 ){
/* EOF or IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return the freshly extracted line */
jx9_result_string(pCtx, zLine, (int)n);
}
return JX9_OK;
}
/*
* string fread(resource $handle, int64 $length)
* Binary-safe file read.
* Parameters
* $handle
* The file pointer.
* $length
* Up to length number of bytes read.
* Return
* The data readen on success or FALSE on failure.
*/
static int jx9Builtin_fread(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_int64 nRead;
void *pBuf;
int nLen;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = 4096;
if( nArg > 1 ){
nLen = jx9_value_to_int(apArg[1]);
if( nLen < 1 ){
/* Invalid length, set a default length */
nLen = 4096;
}
}
/* Allocate enough buffer */
pBuf = jx9_context_alloc_chunk(pCtx, (unsigned int)nLen, FALSE, FALSE);
if( pBuf == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
nRead = StreamRead(pDev, pBuf, (jx9_int64)nLen);
if( nRead < 1 ){
/* Nothing read, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Make a copy of the data just read */
jx9_result_string(pCtx, (const char *)pBuf, (int)nRead);
}
/* Release the buffer */
jx9_context_free_chunk(pCtx, pBuf);
return JX9_OK;
}
/*
* array fgetcsv(resource $handle [, int $length = 0
* [, string $delimiter = ', '[, string $enclosure = '"'[, string $escape='\\']]]])
* Gets line from file pointer and parse for CSV fields.
* Parameters
* $handle
* The file pointer.
* $length
* Reading ends when length - 1 bytes have been read, on a newline
* (which is included in the return value), or on EOF (whichever comes first).
* If no length is specified, it will keep reading from the stream until it reaches
* the end of the line.
* $delimiter
* Set the field delimiter (one character only).
* $enclosure
* Set the field enclosure character (one character only).
* $escape
* Set the escape character (one character only). Defaults as a backslash (\)
* Return
* Returns a string of up to length - 1 bytes read from the file pointed to by handle.
* If there is no more data to read in the file pointer, then FALSE is returned.
* If an error occurs, FALSE is returned.
*/
static int jx9Builtin_fgetcsv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zLine;
io_private *pDev;
jx9_int64 n, nLen;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = -1;
if( nArg > 1 ){
/* Maximum data to read */
nLen = jx9_value_to_int64(apArg[1]);
}
/* Perform the requested operation */
n = StreamReadLine(pDev, &zLine, nLen);
if( n < 1 ){
/* EOF or IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
jx9_value *pArray;
int delim = ','; /* Delimiter */
int encl = '"' ; /* Enclosure */
int escape = '\\'; /* Escape character */
if( nArg > 2 ){
const char *zPtr;
int i;
if( jx9_value_is_string(apArg[2]) ){
/* Extract the delimiter */
zPtr = jx9_value_to_string(apArg[2], &i);
if( i > 0 ){
delim = zPtr[0];
}
}
if( nArg > 3 ){
if( jx9_value_is_string(apArg[3]) ){
/* Extract the enclosure */
zPtr = jx9_value_to_string(apArg[3], &i);
if( i > 0 ){
encl = zPtr[0];
}
}
if( nArg > 4 ){
if( jx9_value_is_string(apArg[4]) ){
/* Extract the escape character */
zPtr = jx9_value_to_string(apArg[4], &i);
if( i > 0 ){
escape = zPtr[0];
}
}
}
}
}
/* Create our array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_null(pCtx);
return JX9_OK;
}
/* Parse the raw input */
jx9ProcessCsv(zLine, (int)n, delim, encl, escape, jx9CsvConsumer, pArray);
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
}
return JX9_OK;
}
/*
* string fgetss(resource $handle [, int $length [, string $allowable_tags ]])
* Gets line from file pointer and strip HTML tags.
* Parameters
* $handle
* The file pointer.
* $length
* Reading ends when length - 1 bytes have been read, on a newline
* (which is included in the return value), or on EOF (whichever comes first).
* If no length is specified, it will keep reading from the stream until it reaches
* the end of the line.
* $allowable_tags
* You can use the optional second parameter to specify tags which should not be stripped.
* Return
* Returns a string of up to length - 1 bytes read from the file pointed to by
* handle, with all HTML and JX9 code stripped. If an error occurs, returns FALSE.
*/
static int jx9Builtin_fgetss(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zLine;
io_private *pDev;
jx9_int64 n, nLen;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nLen = -1;
if( nArg > 1 ){
/* Maximum data to read */
nLen = jx9_value_to_int64(apArg[1]);
}
/* Perform the requested operation */
n = StreamReadLine(pDev, &zLine, nLen);
if( n < 1 ){
/* EOF or IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
const char *zTaglist = 0;
int nTaglen = 0;
if( nArg > 2 && jx9_value_is_string(apArg[2]) ){
/* Allowed tag */
zTaglist = jx9_value_to_string(apArg[2], &nTaglen);
}
/* Process data just read */
jx9StripTagsFromString(pCtx, zLine, (int)n, zTaglist, nTaglen);
}
return JX9_OK;
}
/*
* string readdir(resource $dir_handle)
* Read entry from directory handle.
* Parameter
* $dir_handle
* The directory handle resource previously opened with opendir().
* Return
* Returns the filename on success or FALSE on failure.
*/
static int jx9Builtin_readdir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xReadDir == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
jx9_result_bool(pCtx, 0);
/* Perform the requested operation */
rc = pStream->xReadDir(pDev->pHandle, pCtx);
if( rc != JX9_OK ){
/* Return FALSE */
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* void rewinddir(resource $dir_handle)
* Rewind directory handle.
* Parameter
* $dir_handle
* The directory handle resource previously opened with opendir().
* Return
* FALSE on failure.
*/
static int jx9Builtin_rewinddir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xRewindDir == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
pStream->xRewindDir(pDev->pHandle);
return JX9_OK;
}
/* Forward declaration */
static void InitIOPrivate(jx9_vm *pVm, const jx9_io_stream *pStream, io_private *pOut);
static void ReleaseIOPrivate(jx9_context *pCtx, io_private *pDev);
/*
* void closedir(resource $dir_handle)
* Close directory handle.
* Parameter
* $dir_handle
* The directory handle resource previously opened with opendir().
* Return
* FALSE on failure.
*/
static int jx9Builtin_closedir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xCloseDir == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
pStream->xCloseDir(pDev->pHandle);
/* Release the private stucture */
ReleaseIOPrivate(pCtx, pDev);
jx9MemObjRelease(apArg[0]);
return JX9_OK;
}
/*
* resource opendir(string $path[, resource $context])
* Open directory handle.
* Parameters
* $path
* The directory path that is to be opened.
* $context
* A context stream resource.
* Return
* A directory handle resource on success, or FALSE on failure.
*/
static int jx9Builtin_opendir(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zPath;
io_private *pDev;
int iLen, rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a directory path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the target path */
zPath = jx9_value_to_string(apArg[0], &iLen);
/* Try to extract a stream */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zPath, iLen);
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"No stream device is associated with the given path(%s)", zPath);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( pStream->xOpenDir == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device",
jx9_function_name(pCtx), pStream->zName
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Allocate a new IO private instance */
pDev = (io_private *)jx9_context_alloc_chunk(pCtx, sizeof(io_private), TRUE, FALSE);
if( pDev == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Initialize the structure */
InitIOPrivate(pCtx->pVm, pStream, pDev);
/* Open the target directory */
rc = pStream->xOpenDir(zPath, nArg > 1 ? apArg[1] : 0, &pDev->pHandle);
if( rc != JX9_OK ){
/* IO error, return FALSE */
ReleaseIOPrivate(pCtx, pDev);
jx9_result_bool(pCtx, 0);
}else{
/* Return the handle as a resource */
jx9_result_resource(pCtx, pDev);
}
return JX9_OK;
}
/*
* int readfile(string $filename[, bool $use_include_path = false [, resource $context ]])
* Reads a file and writes it to the output buffer.
* Parameters
* $filename
* The filename being read.
* $use_include_path
* You can use the optional second parameter and set it to
* TRUE, if you want to search for the file in the include_path, too.
* $context
* A context stream resource.
* Return
* The number of bytes read from the file on success or FALSE on failure.
*/
static int jx9Builtin_readfile(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int use_include = FALSE;
const jx9_io_stream *pStream;
jx9_int64 n, nRead;
const char *zFile;
char zBuf[8192];
void *pHandle;
int rc, nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( nArg > 1 ){
use_include = jx9_value_to_bool(apArg[1]);
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY,
use_include, nArg > 2 ? apArg[2] : 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
nRead = 0;
for(;;){
n = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error, break immediately */
break;
}
/* Output data */
rc = jx9_context_output(pCtx, zBuf, (int)n);
if( rc == JX9_ABORT ){
break;
}
/* Increment counter */
nRead += n;
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
/* Total number of bytes readen */
jx9_result_int64(pCtx, nRead);
return JX9_OK;
}
/*
* string file_get_contents(string $filename[, bool $use_include_path = false
* [, resource $context [, int $offset = -1 [, int $maxlen ]]]])
* Reads entire file into a string.
* Parameters
* $filename
* The filename being read.
* $use_include_path
* You can use the optional second parameter and set it to
* TRUE, if you want to search for the file in the include_path, too.
* $context
* A context stream resource.
* $offset
* The offset where the reading starts on the original stream.
* $maxlen
* Maximum length of data read. The default is to read until end of file
* is reached. Note that this parameter is applied to the stream processed by the filters.
* Return
* The function returns the read data or FALSE on failure.
*/
static int jx9Builtin_file_get_contents(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
jx9_int64 n, nRead, nMaxlen;
int use_include = FALSE;
const char *zFile;
char zBuf[8192];
void *pHandle;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
nMaxlen = -1;
if( nArg > 1 ){
use_include = jx9_value_to_bool(apArg[1]);
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, use_include, nArg > 2 ? apArg[2] : 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( nArg > 3 ){
/* Extract the offset */
n = jx9_value_to_int64(apArg[3]);
if( n > 0 ){
if( pStream->xSeek ){
/* Seek to the desired offset */
pStream->xSeek(pHandle, n, 0/*SEEK_SET*/);
}
}
if( nArg > 4 ){
/* Maximum data to read */
nMaxlen = jx9_value_to_int64(apArg[4]);
}
}
/* Perform the requested operation */
nRead = 0;
for(;;){
n = pStream->xRead(pHandle, zBuf,
(nMaxlen > 0 && (nMaxlen < sizeof(zBuf))) ? nMaxlen : sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error, break immediately */
break;
}
/* Append data */
jx9_result_string(pCtx, zBuf, (int)n);
/* Increment read counter */
nRead += n;
if( nMaxlen > 0 && nRead >= nMaxlen ){
/* Read limit reached */
break;
}
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
/* Check if we have read something */
if( jx9_context_result_buf_length(pCtx) < 1 ){
/* Nothing read, return FALSE */
jx9_result_bool(pCtx, 0);
}
return JX9_OK;
}
/*
* int file_put_contents(string $filename, mixed $data[, int $flags = 0[, resource $context]])
* Write a string to a file.
* Parameters
* $filename
* Path to the file where to write the data.
* $data
* The data to write(Must be a string).
* $flags
* The value of flags can be any combination of the following
* flags, joined with the binary OR (|) operator.
* FILE_USE_INCLUDE_PATH Search for filename in the include directory. See include_path for more information.
* FILE_APPEND If file filename already exists, append the data to the file instead of overwriting it.
* LOCK_EX Acquire an exclusive lock on the file while proceeding to the writing.
* context
* A context stream resource.
* Return
* The function returns the number of bytes that were written to the file, or FALSE on failure.
*/
static int jx9Builtin_file_put_contents(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
int use_include = FALSE;
const jx9_io_stream *pStream;
const char *zFile;
const char *zData;
int iOpenFlags;
void *pHandle;
int iFlags;
int nLen;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Data to write */
zData = jx9_value_to_string(apArg[1], &nLen);
if( nLen < 1 ){
/* Nothing to write, return immediately */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Try to open the file in read-write mode */
iOpenFlags = JX9_IO_OPEN_CREATE|JX9_IO_OPEN_RDWR|JX9_IO_OPEN_TRUNC;
/* Extract the flags */
iFlags = 0;
if( nArg > 2 ){
iFlags = jx9_value_to_int(apArg[2]);
if( iFlags & 0x01 /*FILE_USE_INCLUDE_PATH*/){
use_include = TRUE;
}
if( iFlags & 0x08 /* FILE_APPEND */){
/* If the file already exists, append the data to the file
* instead of overwriting it.
*/
iOpenFlags &= ~JX9_IO_OPEN_TRUNC;
/* Append mode */
iOpenFlags |= JX9_IO_OPEN_APPEND;
}
}
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, iOpenFlags, use_include,
nArg > 3 ? apArg[3] : 0, FALSE, FALSE);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( pStream->xWrite ){
jx9_int64 n;
if( (iFlags & 0x01/* LOCK_EX */) && pStream->xLock ){
/* Try to acquire an exclusive lock */
pStream->xLock(pHandle, 1/* LOCK_EX */);
}
/* Perform the write operation */
n = pStream->xWrite(pHandle, (const void *)zData, nLen);
if( n < 1 ){
/* IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Total number of bytes written */
jx9_result_int64(pCtx, n);
}
}else{
/* Read-only stream */
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR,
"Read-only stream(%s): Cannot perform write operation",
pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
}
/* Close the handle */
jx9StreamCloseHandle(pStream, pHandle);
return JX9_OK;
}
/*
* array file(string $filename[, int $flags = 0[, resource $context]])
* Reads entire file into an array.
* Parameters
* $filename
* The filename being read.
* $flags
* The optional parameter flags can be one, or more, of the following constants:
* FILE_USE_INCLUDE_PATH
* Search for the file in the include_path.
* FILE_IGNORE_NEW_LINES
* Do not add newline at the end of each array element
* FILE_SKIP_EMPTY_LINES
* Skip empty lines
* $context
* A context stream resource.
* Return
* The function returns the read data or FALSE on failure.
*/
static int jx9Builtin_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zFile, *zPtr, *zEnd, *zBuf;
jx9_value *pArray, *pLine;
const jx9_io_stream *pStream;
int use_include = 0;
io_private *pDev;
jx9_int64 n;
int iFlags;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Allocate a new IO private instance */
pDev = (io_private *)jx9_context_alloc_chunk(pCtx, sizeof(io_private), TRUE, FALSE);
if( pDev == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Initialize the structure */
InitIOPrivate(pCtx->pVm, pStream, pDev);
iFlags = 0;
if( nArg > 1 ){
iFlags = jx9_value_to_int(apArg[1]);
}
if( iFlags & 0x01 /*FILE_USE_INCLUDE_PATH*/ ){
use_include = TRUE;
}
/* Create the array and the working value */
pArray = jx9_context_new_array(pCtx);
pLine = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pLine == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Try to open the file in read-only mode */
pDev->pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, use_include, nArg > 2 ? apArg[2] : 0, FALSE, 0);
if( pDev->pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
/* Don't worry about freeing memory, everything will be released automatically
* as soon we return from this function.
*/
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
/* Try to extract a line */
n = StreamReadLine(pDev, &zBuf, -1);
if( n < 1 ){
/* EOF or IO error */
break;
}
/* Reset the cursor */
jx9_value_reset_string_cursor(pLine);
/* Remove line ending if requested by the caller */
zPtr = zBuf;
zEnd = &zBuf[n];
if( iFlags & 0x02 /* FILE_IGNORE_NEW_LINES */ ){
/* Ignore trailig lines */
while( zPtr < zEnd && (zEnd[-1] == '\n'
#ifdef __WINNT__
|| zEnd[-1] == '\r'
#endif
)){
n--;
zEnd--;
}
}
if( iFlags & 0x04 /* FILE_SKIP_EMPTY_LINES */ ){
/* Ignore empty lines */
while( zPtr < zEnd && (unsigned char)zPtr[0] < 0xc0 && SyisSpace(zPtr[0]) ){
zPtr++;
}
if( zPtr >= zEnd ){
/* Empty line */
continue;
}
}
jx9_value_string(pLine, zBuf, (int)(zEnd-zBuf));
/* Insert line */
jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pLine);
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pDev->pHandle);
/* Release the io_private instance */
ReleaseIOPrivate(pCtx, pDev);
/* Return the created array */
jx9_result_value(pCtx, pArray);
return JX9_OK;
}
/*
* bool copy(string $source, string $dest[, resource $context ] )
* Makes a copy of the file source to dest.
* Parameters
* $source
* Path to the source file.
* $dest
* The destination path. If dest is a URL, the copy operation
* may fail if the wrapper does not support overwriting of existing files.
* $context
* A context stream resource.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Builtin_copy(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pSin, *pSout;
const char *zFile;
char zBuf[8192];
void *pIn, *pOut;
jx9_int64 n;
int nLen;
if( nArg < 2 || !jx9_value_is_string(apArg[0]) || !jx9_value_is_string(apArg[1])){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a source and a destination path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the source name */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pSin = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pSin == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Try to open the source file in a read-only mode */
pIn = jx9StreamOpenHandle(pCtx->pVm, pSin, zFile, JX9_IO_OPEN_RDONLY, FALSE, nArg > 2 ? apArg[2] : 0, FALSE, 0);
if( pIn == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening source: '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the destination name */
zFile = jx9_value_to_string(apArg[1], &nLen);
/* Point to the target IO stream device */
pSout = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pSout == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
jx9StreamCloseHandle(pSin, pIn);
return JX9_OK;
}
if( pSout->xWrite == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pSin->zName
);
jx9_result_bool(pCtx, 0);
jx9StreamCloseHandle(pSin, pIn);
return JX9_OK;
}
/* Try to open the destination file in a read-write mode */
pOut = jx9StreamOpenHandle(pCtx->pVm, pSout, zFile,
JX9_IO_OPEN_CREATE|JX9_IO_OPEN_TRUNC|JX9_IO_OPEN_RDWR, FALSE, nArg > 2 ? apArg[2] : 0, FALSE, 0);
if( pOut == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening destination: '%s'", zFile);
jx9_result_bool(pCtx, 0);
jx9StreamCloseHandle(pSin, pIn);
return JX9_OK;
}
/* Perform the requested operation */
for(;;){
/* Read from source */
n = pSin->xRead(pIn, zBuf, sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error, break immediately */
break;
}
/* Write to dest */
n = pSout->xWrite(pOut, zBuf, n);
if( n < 1 ){
/* IO error, break immediately */
break;
}
}
/* Close the streams */
jx9StreamCloseHandle(pSin, pIn);
jx9StreamCloseHandle(pSout, pOut);
/* Return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* array fstat(resource $handle)
* Gets information about a file using an open file pointer.
* Parameters
* $handle
* The file pointer.
* Return
* Returns an array with the statistics of the file or FALSE on failure.
*/
static int jx9Builtin_fstat(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray, *pValue;
const jx9_io_stream *pStream;
io_private *pDev;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/* Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xStat == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Create the array and the working value */
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pValue == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
pStream->xStat(pDev->pHandle, pArray, pValue);
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
/* Don't worry about freeing memory here, everything will be
* released automatically as soon we return from this function.
*/
return JX9_OK;
}
/*
* int fwrite(resource $handle, string $string[, int $length])
* Writes the contents of string to the file stream pointed to by handle.
* Parameters
* $handle
* The file pointer.
* $string
* The string that is to be written.
* $length
* If the length argument is given, writing will stop after length bytes have been written
* or the end of string is reached, whichever comes first.
* Return
* Returns the number of bytes written, or FALSE on error.
*/
static int jx9Builtin_fwrite(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zString;
io_private *pDev;
int nLen, n;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/* Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xWrite == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the data to write */
zString = jx9_value_to_string(apArg[1], &nLen);
if( nArg > 2 ){
/* Maximum data length to write */
n = jx9_value_to_int(apArg[2]);
if( n >= 0 && n < nLen ){
nLen = n;
}
}
if( nLen < 1 ){
/* Nothing to write */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
n = (int)pStream->xWrite(pDev->pHandle, (const void *)zString, nLen);
if( n < 0 ){
/* IO error, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* #Bytes written */
jx9_result_int(pCtx, n);
}
return JX9_OK;
}
/*
* bool flock(resource $handle, int $operation)
* Portable advisory file locking.
* Parameters
* $handle
* The file pointer.
* $operation
* operation is one of the following:
* LOCK_SH to acquire a shared lock (reader).
* LOCK_EX to acquire an exclusive lock (writer).
* LOCK_UN to release a lock (shared or exclusive).
* Return
* Returns TRUE on success or FALSE on failure.
*/
static int jx9Builtin_flock(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
int nLock;
int rc;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xLock == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Requested lock operation */
nLock = jx9_value_to_int(apArg[1]);
/* Lock operation */
rc = pStream->xLock(pDev->pHandle, nLock);
/* IO result */
jx9_result_bool(pCtx, rc == JX9_OK);
return JX9_OK;
}
/*
* int fpassthru(resource $handle)
* Output all remaining data on a file pointer.
* Parameters
* $handle
* The file pointer.
* Return
* Total number of characters read from handle and passed through
* to the output on success or FALSE on failure.
*/
static int jx9Builtin_fpassthru(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_int64 n, nRead;
char zBuf[8192];
int rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Perform the requested operation */
nRead = 0;
for(;;){
n = StreamRead(pDev, zBuf, sizeof(zBuf));
if( n < 1 ){
/* Error or EOF */
break;
}
/* Increment the read counter */
nRead += n;
/* Output data */
rc = jx9_context_output(pCtx, zBuf, (int)nRead /* FIXME: 64-bit issues */);
if( rc == JX9_ABORT ){
/* Consumer callback request an operation abort */
break;
}
}
/* Total number of bytes readen */
jx9_result_int64(pCtx, nRead);
return JX9_OK;
}
/* CSV reader/writer private data */
struct csv_data
{
int delimiter; /* Delimiter. Default ', ' */
int enclosure; /* Enclosure. Default '"'*/
io_private *pDev; /* Open stream handle */
int iCount; /* Counter */
};
/*
* The following callback is used by the fputcsv() function inorder to iterate
* throw array entries and output CSV data based on the current key and it's
* associated data.
*/
static int csv_write_callback(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
struct csv_data *pData = (struct csv_data *)pUserData;
const char *zData;
int nLen, c2;
sxu32 n;
/* Point to the raw data */
zData = jx9_value_to_string(pValue, &nLen);
if( nLen < 1 ){
/* Nothing to write */
return JX9_OK;
}
if( pData->iCount > 0 ){
/* Write the delimiter */
pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)&pData->delimiter, sizeof(char));
}
n = 1;
c2 = 0;
if( SyByteFind(zData, (sxu32)nLen, pData->delimiter, 0) == SXRET_OK ||
SyByteFind(zData, (sxu32)nLen, pData->enclosure, &n) == SXRET_OK ){
c2 = 1;
if( n == 0 ){
c2 = 2;
}
/* Write the enclosure */
pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)&pData->enclosure, sizeof(char));
if( c2 > 1 ){
pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)&pData->enclosure, sizeof(char));
}
}
/* Write the data */
if( pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)zData, (jx9_int64)nLen) < 1 ){
SXUNUSED(pKey); /* cc warning */
return JX9_ABORT;
}
if( c2 > 0 ){
/* Write the enclosure */
pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)&pData->enclosure, sizeof(char));
if( c2 > 1 ){
pData->pDev->pStream->xWrite(pData->pDev->pHandle, (const void *)&pData->enclosure, sizeof(char));
}
}
pData->iCount++;
return JX9_OK;
}
/*
* int fputcsv(resource $handle, array $fields[, string $delimiter = ', '[, string $enclosure = '"' ]])
* Format line as CSV and write to file pointer.
* Parameters
* $handle
* Open file handle.
* $fields
* An array of values.
* $delimiter
* The optional delimiter parameter sets the field delimiter (one character only).
* $enclosure
* The optional enclosure parameter sets the field enclosure (one character only).
*/
static int jx9Builtin_fputcsv(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
struct csv_data sCsv;
io_private *pDev;
char *zEol;
int eolen;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) || !jx9_value_is_json_array(apArg[1]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Missing/Invalid arguments");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 || pStream->xWrite == 0){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Set default csv separator */
sCsv.delimiter = ',';
sCsv.enclosure = '"';
sCsv.pDev = pDev;
sCsv.iCount = 0;
if( nArg > 2 ){
/* User delimiter */
const char *z;
int n;
z = jx9_value_to_string(apArg[2], &n);
if( n > 0 ){
sCsv.delimiter = z[0];
}
if( nArg > 3 ){
z = jx9_value_to_string(apArg[3], &n);
if( n > 0 ){
sCsv.enclosure = z[0];
}
}
}
/* Iterate throw array entries and write csv data */
jx9_array_walk(apArg[1], csv_write_callback, &sCsv);
/* Write a line ending */
#ifdef __WINNT__
zEol = "\r\n";
eolen = (int)sizeof("\r\n")-1;
#else
/* Assume UNIX LF */
zEol = "\n";
eolen = (int)sizeof(char);
#endif
pDev->pStream->xWrite(pDev->pHandle, (const void *)zEol, eolen);
return JX9_OK;
}
/*
* fprintf, vfprintf private data.
* An instance of the following structure is passed to the formatted
* input consumer callback defined below.
*/
typedef struct fprintf_data fprintf_data;
struct fprintf_data
{
io_private *pIO; /* IO stream */
jx9_int64 nCount; /* Total number of bytes written */
};
/*
* Callback [i.e: Formatted input consumer] for the fprintf function.
*/
static int fprintfConsumer(jx9_context *pCtx, const char *zInput, int nLen, void *pUserData)
{
fprintf_data *pFdata = (fprintf_data *)pUserData;
jx9_int64 n;
/* Write the formatted data */
n = pFdata->pIO->pStream->xWrite(pFdata->pIO->pHandle, (const void *)zInput, nLen);
if( n < 1 ){
SXUNUSED(pCtx); /* cc warning */
/* IO error, abort immediately */
return SXERR_ABORT;
}
/* Increment counter */
pFdata->nCount += n;
return JX9_OK;
}
/*
* int fprintf(resource $handle, string $format[, mixed $args [, mixed $... ]])
* Write a formatted string to a stream.
* Parameters
* $handle
* The file pointer.
* $format
* String format (see sprintf()).
* Return
* The length of the written string.
*/
static int jx9Builtin_fprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
fprintf_data sFdata;
const char *zFormat;
io_private *pDev;
int nLen;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) || !jx9_value_is_string(apArg[1]) ){
/* Missing/Invalid arguments, return zero */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Invalid arguments");
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
if( pDev->pStream == 0 || pDev->pStream->xWrite == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device",
jx9_function_name(pCtx), pDev->pStream ? pDev->pStream->zName : "null_stream"
);
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[1], &nLen);
if( nLen < 1 ){
/* Empty string, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Prepare our private data */
sFdata.nCount = 0;
sFdata.pIO = pDev;
/* Format the string */
jx9InputFormat(fprintfConsumer, pCtx, zFormat, nLen, nArg - 1, &apArg[1], (void *)&sFdata, FALSE);
/* Return total number of bytes written */
jx9_result_int64(pCtx, sFdata.nCount);
return JX9_OK;
}
/*
* int vfprintf(resource $handle, string $format, array $args)
* Write a formatted string to a stream.
* Parameters
* $handle
* The file pointer.
* $format
* String format (see sprintf()).
* $args
* User arguments.
* Return
* The length of the written string.
*/
static int jx9Builtin_vfprintf(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
fprintf_data sFdata;
const char *zFormat;
jx9_hashmap *pMap;
io_private *pDev;
SySet sArg;
int n, nLen;
if( nArg < 3 || !jx9_value_is_resource(apArg[0]) || !jx9_value_is_string(apArg[1]) || !jx9_value_is_json_array(apArg[2]) ){
/* Missing/Invalid arguments, return zero */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Invalid arguments");
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
if( pDev->pStream == 0 || pDev->pStream->xWrite == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device",
jx9_function_name(pCtx), pDev->pStream ? pDev->pStream->zName : "null_stream"
);
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Extract the string format */
zFormat = jx9_value_to_string(apArg[1], &nLen);
if( nLen < 1 ){
/* Empty string, return zero */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to hashmap */
pMap = (jx9_hashmap *)apArg[2]->x.pOther;
/* Extract arguments from the hashmap */
n = jx9HashmapValuesToSet(pMap, &sArg);
/* Prepare our private data */
sFdata.nCount = 0;
sFdata.pIO = pDev;
/* Format the string */
jx9InputFormat(fprintfConsumer, pCtx, zFormat, nLen, n, (jx9_value **)SySetBasePtr(&sArg), (void *)&sFdata, TRUE);
/* Return total number of bytes written*/
jx9_result_int64(pCtx, sFdata.nCount);
SySetRelease(&sArg);
return JX9_OK;
}
/*
* Convert open modes (string passed to the fopen() function) [i.e: 'r', 'w+', 'a', ...] into JX9 flags.
* According to the JX9 reference manual:
* The mode parameter specifies the type of access you require to the stream. It may be any of the following
* 'r' Open for reading only; place the file pointer at the beginning of the file.
* 'r+' Open for reading and writing; place the file pointer at the beginning of the file.
* 'w' Open for writing only; place the file pointer at the beginning of the file and truncate the file
* to zero length. If the file does not exist, attempt to create it.
* 'w+' Open for reading and writing; place the file pointer at the beginning of the file and truncate
* the file to zero length. If the file does not exist, attempt to create it.
* 'a' Open for writing only; place the file pointer at the end of the file. If the file does not
* exist, attempt to create it.
* 'a+' Open for reading and writing; place the file pointer at the end of the file. If the file does
* not exist, attempt to create it.
* 'x' Create and open for writing only; place the file pointer at the beginning of the file. If the file
* already exists,
* the fopen() call will fail by returning FALSE and generating an error of level E_WARNING. If the file
* does not exist attempt to create it. This is equivalent to specifying O_EXCL|O_CREAT flags for
* the underlying open(2) system call.
* 'x+' Create and open for reading and writing; otherwise it has the same behavior as 'x'.
* 'c' Open the file for writing only. If the file does not exist, it is created. If it exists, it is neither truncated
* (as opposed to 'w'), nor the call to this function fails (as is the case with 'x'). The file pointer
* is positioned on the beginning of the file.
* This may be useful if it's desired to get an advisory lock (see flock()) before attempting to modify the file
* as using 'w' could truncate the file before the lock was obtained (if truncation is desired, ftruncate() can
* be used after the lock is requested).
* 'c+' Open the file for reading and writing; otherwise it has the same behavior as 'c'.
*/
static int StrModeToFlags(jx9_context *pCtx, const char *zMode, int nLen)
{
const char *zEnd = &zMode[nLen];
int iFlag = 0;
int c;
if( nLen < 1 ){
/* Open in a read-only mode */
return JX9_IO_OPEN_RDONLY;
}
c = zMode[0];
if( c == 'r' || c == 'R' ){
/* Read-only access */
iFlag = JX9_IO_OPEN_RDONLY;
zMode++; /* Advance */
if( zMode < zEnd ){
c = zMode[0];
if( c == '+' || c == 'w' || c == 'W' ){
/* Read+Write access */
iFlag = JX9_IO_OPEN_RDWR;
}
}
}else if( c == 'w' || c == 'W' ){
/* Overwrite mode.
* If the file does not exists, try to create it
*/
iFlag = JX9_IO_OPEN_WRONLY|JX9_IO_OPEN_TRUNC|JX9_IO_OPEN_CREATE;
zMode++; /* Advance */
if( zMode < zEnd ){
c = zMode[0];
if( c == '+' || c == 'r' || c == 'R' ){
/* Read+Write access */
iFlag &= ~JX9_IO_OPEN_WRONLY;
iFlag |= JX9_IO_OPEN_RDWR;
}
}
}else if( c == 'a' || c == 'A' ){
/* Append mode (place the file pointer at the end of the file).
* Create the file if it does not exists.
*/
iFlag = JX9_IO_OPEN_WRONLY|JX9_IO_OPEN_APPEND|JX9_IO_OPEN_CREATE;
zMode++; /* Advance */
if( zMode < zEnd ){
c = zMode[0];
if( c == '+' ){
/* Read-Write access */
iFlag &= ~JX9_IO_OPEN_WRONLY;
iFlag |= JX9_IO_OPEN_RDWR;
}
}
}else if( c == 'x' || c == 'X' ){
/* Exclusive access.
* If the file already exists, return immediately with a failure code.
* Otherwise create a new file.
*/
iFlag = JX9_IO_OPEN_WRONLY|JX9_IO_OPEN_EXCL;
zMode++; /* Advance */
if( zMode < zEnd ){
c = zMode[0];
if( c == '+' || c == 'r' || c == 'R' ){
/* Read-Write access */
iFlag &= ~JX9_IO_OPEN_WRONLY;
iFlag |= JX9_IO_OPEN_RDWR;
}
}
}else if( c == 'c' || c == 'C' ){
/* Overwrite mode.Create the file if it does not exists.*/
iFlag = JX9_IO_OPEN_WRONLY|JX9_IO_OPEN_CREATE;
zMode++; /* Advance */
if( zMode < zEnd ){
c = zMode[0];
if( c == '+' ){
/* Read-Write access */
iFlag &= ~JX9_IO_OPEN_WRONLY;
iFlag |= JX9_IO_OPEN_RDWR;
}
}
}else{
/* Invalid mode. Assume a read only open */
jx9_context_throw_error(pCtx, JX9_CTX_NOTICE, "Invalid open mode, JX9 is assuming a Read-Only open");
iFlag = JX9_IO_OPEN_RDONLY;
}
while( zMode < zEnd ){
c = zMode[0];
if( c == 'b' || c == 'B' ){
iFlag &= ~JX9_IO_OPEN_TEXT;
iFlag |= JX9_IO_OPEN_BINARY;
}else if( c == 't' || c == 'T' ){
iFlag &= ~JX9_IO_OPEN_BINARY;
iFlag |= JX9_IO_OPEN_TEXT;
}
zMode++;
}
return iFlag;
}
/*
* Initialize the IO private structure.
*/
static void InitIOPrivate(jx9_vm *pVm, const jx9_io_stream *pStream, io_private *pOut)
{
pOut->pStream = pStream;
SyBlobInit(&pOut->sBuffer, &pVm->sAllocator);
pOut->nOfft = 0;
/* Set the magic number */
pOut->iMagic = IO_PRIVATE_MAGIC;
}
/*
* Release the IO private structure.
*/
static void ReleaseIOPrivate(jx9_context *pCtx, io_private *pDev)
{
SyBlobRelease(&pDev->sBuffer);
pDev->iMagic = 0x2126; /* Invalid magic number so we can detetct misuse */
/* Release the whole structure */
jx9_context_free_chunk(pCtx, pDev);
}
/*
* Reset the IO private structure.
*/
static void ResetIOPrivate(io_private *pDev)
{
SyBlobReset(&pDev->sBuffer);
pDev->nOfft = 0;
}
/* Forward declaration */
static int is_jx9_stream(const jx9_io_stream *pStream);
/*
* resource fopen(string $filename, string $mode [, bool $use_include_path = false[, resource $context ]])
* Open a file, a URL or any other IO stream.
* Parameters
* $filename
* If filename is of the form "scheme://...", it is assumed to be a URL and JX9 will search
* for a protocol handler (also known as a wrapper) for that scheme. If no scheme is given
* then a regular file is assumed.
* $mode
* The mode parameter specifies the type of access you require to the stream
* See the block comment associated with the StrModeToFlags() for the supported
* modes.
* $use_include_path
* You can use the optional second parameter and set it to
* TRUE, if you want to search for the file in the include_path, too.
* $context
* A context stream resource.
* Return
* File handle on success or FALSE on failure.
*/
static int jx9Builtin_fopen(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zUri, *zMode;
jx9_value *pResource;
io_private *pDev;
int iLen, imLen;
int iOpenFlags;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path or URL");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the URI and the desired access mode */
zUri = jx9_value_to_string(apArg[0], &iLen);
if( nArg > 1 ){
zMode = jx9_value_to_string(apArg[1], &imLen);
}else{
/* Set a default read-only mode */
zMode = "r";
imLen = (int)sizeof(char);
}
/* Try to extract a stream */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zUri, iLen);
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"No stream device is associated with the given URI(%s)", zUri);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Allocate a new IO private instance */
pDev = (io_private *)jx9_context_alloc_chunk(pCtx, sizeof(io_private), TRUE, FALSE);
if( pDev == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pResource = 0;
if( nArg > 3 ){
pResource = apArg[3];
}else if( is_jx9_stream(pStream) ){
/* TICKET 1433-80: The jx9:// stream need a jx9_value to access the underlying
* virtual machine.
*/
pResource = apArg[0];
}
/* Initialize the structure */
InitIOPrivate(pCtx->pVm, pStream, pDev);
/* Convert open mode to JX9 flags */
iOpenFlags = StrModeToFlags(pCtx, zMode, imLen);
/* Try to get a handle */
pDev->pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zUri, iOpenFlags,
nArg > 2 ? jx9_value_to_bool(apArg[2]) : FALSE, pResource, FALSE, 0);
if( pDev->pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zUri);
jx9_result_bool(pCtx, 0);
jx9_context_free_chunk(pCtx, pDev);
return JX9_OK;
}
/* All done, return the io_private instance as a resource */
jx9_result_resource(pCtx, pDev);
return JX9_OK;
}
/*
* bool fclose(resource $handle)
* Closes an open file pointer
* Parameters
* $handle
* The file pointer.
* Return
* TRUE on success or FALSE on failure.
*/
static int jx9Builtin_fclose(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
io_private *pDev;
jx9_vm *pVm;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract our private data */
pDev = (io_private *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid io_private instance */
if( IO_PRIVATE_INVALID(pDev) ){
/*Expecting an IO handle */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting an IO handle");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the target IO stream device */
pStream = pDev->pStream;
if( pStream == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING,
"IO routine(%s) not implemented in the underlying stream(%s) device, JX9 is returning FALSE",
jx9_function_name(pCtx), pStream ? pStream->zName : "null_stream"
);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the VM that own this context */
pVm = pCtx->pVm;
/* TICKET 1433-62: Keep the STDIN/STDOUT/STDERR handles open */
if( pDev != pVm->pStdin && pDev != pVm->pStdout && pDev != pVm->pStderr ){
/* Perform the requested operation */
jx9StreamCloseHandle(pStream, pDev->pHandle);
/* Release the IO private structure */
ReleaseIOPrivate(pCtx, pDev);
/* Invalidate the resource handle */
jx9_value_release(apArg[0]);
}
/* Return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
#if !defined(JX9_DISABLE_HASH_FUNC)
/*
* MD5/SHA1 digest consumer.
*/
static int vfsHashConsumer(const void *pData, unsigned int nLen, void *pUserData)
{
/* Append hex chunk verbatim */
jx9_result_string((jx9_context *)pUserData, (const char *)pData, (int)nLen);
return SXRET_OK;
}
/*
* string md5_file(string $uri[, bool $raw_output = false ])
* Calculates the md5 hash of a given file.
* Parameters
* $uri
* Target URI (file(/path/to/something) or URL(http://www.symisc.net/))
* $raw_output
* When TRUE, returns the digest in raw binary format with a length of 16.
* Return
* Return the MD5 digest on success or FALSE on failure.
*/
static int jx9Builtin_md5_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
unsigned char zDigest[16];
int raw_output = FALSE;
const char *zFile;
MD5Context sCtx;
char zBuf[8192];
void *pHandle;
jx9_int64 n;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( nArg > 1 ){
raw_output = jx9_value_to_bool(apArg[1]);
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, FALSE, 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Init the MD5 context */
MD5Init(&sCtx);
/* Perform the requested operation */
for(;;){
n = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error, break immediately */
break;
}
MD5Update(&sCtx, (const unsigned char *)zBuf, (unsigned int)n);
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
/* Extract the digest */
MD5Final(zDigest, &sCtx);
if( raw_output ){
/* Output raw digest */
jx9_result_string(pCtx, (const char *)zDigest, sizeof(zDigest));
}else{
/* Perform a binary to hex conversion */
SyBinToHexConsumer((const void *)zDigest, sizeof(zDigest), vfsHashConsumer, pCtx);
}
return JX9_OK;
}
/*
* string sha1_file(string $uri[, bool $raw_output = false ])
* Calculates the SHA1 hash of a given file.
* Parameters
* $uri
* Target URI (file(/path/to/something) or URL(http://www.symisc.net/))
* $raw_output
* When TRUE, returns the digest in raw binary format with a length of 20.
* Return
* Return the SHA1 digest on success or FALSE on failure.
*/
static int jx9Builtin_sha1_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
unsigned char zDigest[20];
int raw_output = FALSE;
const char *zFile;
SHA1Context sCtx;
char zBuf[8192];
void *pHandle;
jx9_int64 n;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( nArg > 1 ){
raw_output = jx9_value_to_bool(apArg[1]);
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, FALSE, 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Init the SHA1 context */
SHA1Init(&sCtx);
/* Perform the requested operation */
for(;;){
n = pStream->xRead(pHandle, zBuf, sizeof(zBuf));
if( n < 1 ){
/* EOF or IO error, break immediately */
break;
}
SHA1Update(&sCtx, (const unsigned char *)zBuf, (unsigned int)n);
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
/* Extract the digest */
SHA1Final(&sCtx, zDigest);
if( raw_output ){
/* Output raw digest */
jx9_result_string(pCtx, (const char *)zDigest, sizeof(zDigest));
}else{
/* Perform a binary to hex conversion */
SyBinToHexConsumer((const void *)zDigest, sizeof(zDigest), vfsHashConsumer, pCtx);
}
return JX9_OK;
}
#endif /* JX9_DISABLE_HASH_FUNC */
/*
* array parse_ini_file(string $filename[, bool $process_sections = false [, int $scanner_mode = INI_SCANNER_NORMAL ]] )
* Parse a configuration file.
* Parameters
* $filename
* The filename of the ini file being parsed.
* $process_sections
* By setting the process_sections parameter to TRUE, you get a multidimensional array
* with the section names and settings included.
* The default for process_sections is FALSE.
* $scanner_mode
* Can either be INI_SCANNER_NORMAL (default) or INI_SCANNER_RAW.
* If INI_SCANNER_RAW is supplied, then option values will not be parsed.
* Return
* The settings are returned as an associative array on success.
* Otherwise is returned.
*/
static int jx9Builtin_parse_ini_file(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
const char *zFile;
SyBlob sContents;
void *pHandle;
int nLen;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, FALSE, 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
SyBlobInit(&sContents, &pCtx->pVm->sAllocator);
/* Read the whole file */
jx9StreamReadWholeFile(pHandle, pStream, &sContents);
if( SyBlobLength(&sContents) < 1 ){
/* Empty buffer, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Process the raw INI buffer */
jx9ParseIniString(pCtx, (const char *)SyBlobData(&sContents), SyBlobLength(&sContents),
nArg > 1 ? jx9_value_to_bool(apArg[1]) : 0);
}
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
/* Release the working buffer */
SyBlobRelease(&sContents);
return JX9_OK;
}
/*
* Section:
* ZIP archive processing.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
typedef struct zip_raw_data zip_raw_data;
struct zip_raw_data
{
int iType; /* Where the raw data is stored */
union raw_data{
struct mmap_data{
void *pMap; /* Memory mapped data */
jx9_int64 nSize; /* Map size */
const jx9_vfs *pVfs; /* Underlying vfs */
}mmap;
SyBlob sBlob; /* Memory buffer */
}raw;
};
#define ZIP_RAW_DATA_MMAPED 1 /* Memory mapped ZIP raw data */
#define ZIP_RAW_DATA_MEMBUF 2 /* ZIP raw data stored in a dynamically
* allocated memory chunk.
*/
/*
* mixed zip_open(string $filename)
* Opens a new zip archive for reading.
* Parameters
* $filename
* The file name of the ZIP archive to open.
* Return
* A resource handle for later use with zip_read() and zip_close() or FALSE on failure.
*/
static int jx9Builtin_zip_open(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const jx9_io_stream *pStream;
SyArchive *pArchive;
zip_raw_data *pRaw;
const char *zFile;
SyBlob *pContents;
void *pHandle;
int nLen;
sxi32 rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Expecting a file path");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the file path */
zFile = jx9_value_to_string(apArg[0], &nLen);
/* Point to the target IO stream device */
pStream = jx9VmGetStreamDevice(pCtx->pVm, &zFile, nLen);
if( pStream == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "No such stream device, JX9 is returning FALSE");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Create an in-memory archive */
pArchive = (SyArchive *)jx9_context_alloc_chunk(pCtx, sizeof(SyArchive)+sizeof(zip_raw_data), TRUE, FALSE);
if( pArchive == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pRaw = (zip_raw_data *)&pArchive[1];
/* Initialize the archive */
SyArchiveInit(pArchive, &pCtx->pVm->sAllocator, 0, 0);
/* Extract the default stream */
if( pStream == pCtx->pVm->pDefStream /* file:// stream*/){
const jx9_vfs *pVfs;
/* Try to get a memory view of the whole file since ZIP files
* tends to be very big this days, this is a huge performance win.
*/
pVfs = jx9ExportBuiltinVfs();
if( pVfs && pVfs->xMmap ){
rc = pVfs->xMmap(zFile, &pRaw->raw.mmap.pMap, &pRaw->raw.mmap.nSize);
if( rc == JX9_OK ){
/* Nice, Extract the whole archive */
rc = SyZipExtractFromBuf(pArchive, (const char *)pRaw->raw.mmap.pMap, (sxu32)pRaw->raw.mmap.nSize);
if( rc != SXRET_OK ){
if( pVfs->xUnmap ){
pVfs->xUnmap(pRaw->raw.mmap.pMap, pRaw->raw.mmap.nSize);
}
/* Release the allocated chunk */
jx9_context_free_chunk(pCtx, pArchive);
/* Something goes wrong with this ZIP archive, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Archive successfully opened */
pRaw->iType = ZIP_RAW_DATA_MMAPED;
pRaw->raw.mmap.pVfs = pVfs;
goto success;
}
}
/* FALL THROUGH */
}
/* Try to open the file in read-only mode */
pHandle = jx9StreamOpenHandle(pCtx->pVm, pStream, zFile, JX9_IO_OPEN_RDONLY, FALSE, 0, FALSE, 0);
if( pHandle == 0 ){
jx9_context_throw_error_format(pCtx, JX9_CTX_ERR, "IO error while opening '%s'", zFile);
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
pContents = &pRaw->raw.sBlob;
SyBlobInit(pContents, &pCtx->pVm->sAllocator);
/* Read the whole file */
jx9StreamReadWholeFile(pHandle, pStream, pContents);
/* Assume an invalid ZIP file */
rc = SXERR_INVALID;
if( SyBlobLength(pContents) > 0 ){
/* Extract archive entries */
rc = SyZipExtractFromBuf(pArchive, (const char *)SyBlobData(pContents), SyBlobLength(pContents));
}
pRaw->iType = ZIP_RAW_DATA_MEMBUF;
/* Close the stream */
jx9StreamCloseHandle(pStream, pHandle);
if( rc != SXRET_OK ){
/* Release the working buffer */
SyBlobRelease(pContents);
/* Release the allocated chunk */
jx9_context_free_chunk(pCtx, pArchive);
/* Something goes wrong with this ZIP archive, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
success:
/* Reset the loop cursor */
SyArchiveResetLoopCursor(pArchive);
/* Return the in-memory archive as a resource handle */
jx9_result_resource(pCtx, pArchive);
return JX9_OK;
}
/*
* void zip_close(resource $zip)
* Close an in-memory ZIP archive.
* Parameters
* $zip
* A ZIP file previously opened with zip_open().
* Return
* null.
*/
static int jx9Builtin_zip_close(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchive *pArchive;
zip_raw_data *pRaw;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
return JX9_OK;
}
/* Point to the in-memory archive */
pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid ZIP archive */
if( SXARCH_INVALID(pArchive) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
return JX9_OK;
}
/* Release the archive */
SyArchiveRelease(pArchive);
pRaw = (zip_raw_data *)&pArchive[1];
if( pRaw->iType == ZIP_RAW_DATA_MEMBUF ){
SyBlobRelease(&pRaw->raw.sBlob);
}else{
const jx9_vfs *pVfs = pRaw->raw.mmap.pVfs;
if( pVfs->xUnmap ){
/* Unmap the memory view */
pVfs->xUnmap(pRaw->raw.mmap.pMap, pRaw->raw.mmap.nSize);
}
}
/* Release the memory chunk */
jx9_context_free_chunk(pCtx, pArchive);
return JX9_OK;
}
/*
* mixed zip_read(resource $zip)
* Reads the next entry from an in-memory ZIP archive.
* Parameters
* $zip
* A ZIP file previously opened with zip_open().
* Return
* A directory entry resource for later use with the zip_entry_... functions
* or FALSE if there are no more entries to read, or an error code if an error occurred.
*/
static int jx9Builtin_zip_read(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pNext = 0; /* cc warning */
SyArchive *pArchive;
sxi32 rc;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the in-memory archive */
pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid ZIP archive */
if( SXARCH_INVALID(pArchive) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the next entry */
rc = SyArchiveGetNextEntry(pArchive, &pNext);
if( rc != SXRET_OK ){
/* No more entries in the central directory, return FALSE */
jx9_result_bool(pCtx, 0);
}else{
/* Return as a resource handle */
jx9_result_resource(pCtx, pNext);
/* Point to the ZIP raw data */
pNext->pUserData = (void *)&pArchive[1];
}
return JX9_OK;
}
/*
* bool zip_entry_open(resource $zip, resource $zip_entry[, string $mode ])
* Open a directory entry for reading
* Parameters
* $zip
* A ZIP file previously opened with zip_open().
* $zip_entry
* A directory entry returned by zip_read().
* $mode
* Not used
* Return
* A directory entry resource for later use with the zip_entry_... functions
* or FALSE if there are no more entries to read, or an error code if an error occurred.
*/
static int jx9Builtin_zip_entry_open(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
SyArchive *pArchive;
if( nArg < 2 || !jx9_value_is_resource(apArg[0]) || !jx9_value_is_resource(apArg[1]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Point to the in-memory archive */
pArchive = (SyArchive *)jx9_value_to_resource(apArg[0]);
/* Make sure we are dealing with a valid ZIP archive */
if( SXARCH_INVALID(pArchive) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[1]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* All done. Actually this function is a no-op, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* bool zip_entry_close(resource $zip_entry)
* Close a directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* Returns TRUE on success or FALSE on failure.
*/
static int jx9Builtin_zip_entry_close(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Reset the read cursor */
pEntry->nReadCount = 0;
/*All done. Actually this function is a no-op, return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* string zip_entry_name(resource $zip_entry)
* Retrieve the name of a directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* The name of the directory entry.
*/
static int jx9Builtin_zip_entry_name(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
SyString *pName;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return entry name */
pName = &pEntry->sFileName;
jx9_result_string(pCtx, pName->zString, (int)pName->nByte);
return JX9_OK;
}
/*
* int64 zip_entry_filesize(resource $zip_entry)
* Retrieve the actual file size of a directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* The size of the directory entry.
*/
static int jx9Builtin_zip_entry_filesize(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return entry size */
jx9_result_int64(pCtx, (jx9_int64)pEntry->nByte);
return JX9_OK;
}
/*
* int64 zip_entry_compressedsize(resource $zip_entry)
* Retrieve the compressed size of a directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* The compressed size.
*/
static int jx9Builtin_zip_entry_compressedsize(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Return entry compressed size */
jx9_result_int64(pCtx, (jx9_int64)pEntry->nByteCompr);
return JX9_OK;
}
/*
* string zip_entry_read(resource $zip_entry[, int $length])
* Reads from an open directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* $length
* The number of bytes to return. If not specified, this function
* will attempt to read 1024 bytes.
* Return
* Returns the data read, or FALSE if the end of the file is reached.
*/
static int jx9Builtin_zip_entry_read(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
zip_raw_data *pRaw;
const char *zData;
int iLength;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
zData = 0;
if( pEntry->nReadCount >= pEntry->nByteCompr ){
/* No more data to read, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Set a default read length */
iLength = 1024;
if( nArg > 1 ){
iLength = jx9_value_to_int(apArg[1]);
if( iLength < 1 ){
iLength = 1024;
}
}
if( (sxu32)iLength > pEntry->nByteCompr - pEntry->nReadCount ){
iLength = (int)(pEntry->nByteCompr - pEntry->nReadCount);
}
/* Return the entry contents */
pRaw = (zip_raw_data *)pEntry->pUserData;
if( pRaw->iType == ZIP_RAW_DATA_MEMBUF ){
zData = (const char *)SyBlobDataAt(&pRaw->raw.sBlob, (pEntry->nOfft+pEntry->nReadCount));
}else{
const char *zMap = (const char *)pRaw->raw.mmap.pMap;
/* Memory mmaped chunk */
zData = &zMap[pEntry->nOfft+pEntry->nReadCount];
}
/* Increment the read counter */
pEntry->nReadCount += iLength;
/* Return the raw data */
jx9_result_string(pCtx, zData, iLength);
return JX9_OK;
}
/*
* bool zip_entry_reset_cursor(resource $zip_entry)
* Reset the read cursor of an open directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* TRUE on success, FALSE on failure.
*/
static int jx9Builtin_zip_entry_reset_cursor(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Reset the cursor */
pEntry->nReadCount = 0;
/* Return TRUE */
jx9_result_bool(pCtx, 1);
return JX9_OK;
}
/*
* string zip_entry_compressionmethod(resource $zip_entry)
* Retrieve the compression method of a directory entry.
* Parameters
* $zip_entry
* A directory entry returned by zip_read().
* Return
* The compression method on success or FALSE on failure.
*/
static int jx9Builtin_zip_entry_compressionmethod(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyArchiveEntry *pEntry;
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Make sure we are dealing with a valid ZIP archive entry */
pEntry = (SyArchiveEntry *)jx9_value_to_resource(apArg[0]);
if( SXARCH_ENTRY_INVALID(pEntry) ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Expecting a ZIP archive entry");
/* return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
switch(pEntry->nComprMeth){
case 0:
/* No compression;entry is stored */
jx9_result_string(pCtx, "stored", (int)sizeof("stored")-1);
break;
case 8:
/* Entry is deflated (Default compression algorithm) */
jx9_result_string(pCtx, "deflate", (int)sizeof("deflate")-1);
break;
/* Exotic compression algorithms */
case 1:
jx9_result_string(pCtx, "shrunk", (int)sizeof("shrunk")-1);
break;
case 2:
case 3:
case 4:
case 5:
/* Entry is reduced */
jx9_result_string(pCtx, "reduced", (int)sizeof("reduced")-1);
break;
case 6:
/* Entry is imploded */
jx9_result_string(pCtx, "implode", (int)sizeof("implode")-1);
break;
default:
jx9_result_string(pCtx, "unknown", (int)sizeof("unknown")-1);
break;
}
return JX9_OK;
}
#endif /* #ifndef JX9_DISABLE_BUILTIN_FUNC*/
/* NULL VFS [i.e: a no-op VFS]*/
static const jx9_vfs null_vfs = {
"null_vfs",
JX9_VFS_VERSION,
0, /* int (*xChdir)(const char *) */
0, /* int (*xChroot)(const char *); */
0, /* int (*xGetcwd)(jx9_context *) */
0, /* int (*xMkdir)(const char *, int, int) */
0, /* int (*xRmdir)(const char *) */
0, /* int (*xIsdir)(const char *) */
0, /* int (*xRename)(const char *, const char *) */
0, /*int (*xRealpath)(const char *, jx9_context *)*/
0, /* int (*xSleep)(unsigned int) */
0, /* int (*xUnlink)(const char *) */
0, /* int (*xFileExists)(const char *) */
0, /*int (*xChmod)(const char *, int)*/
0, /*int (*xChown)(const char *, const char *)*/
0, /*int (*xChgrp)(const char *, const char *)*/
0, /* jx9_int64 (*xFreeSpace)(const char *) */
0, /* jx9_int64 (*xTotalSpace)(const char *) */
0, /* jx9_int64 (*xFileSize)(const char *) */
0, /* jx9_int64 (*xFileAtime)(const char *) */
0, /* jx9_int64 (*xFileMtime)(const char *) */
0, /* jx9_int64 (*xFileCtime)(const char *) */
0, /* int (*xStat)(const char *, jx9_value *, jx9_value *) */
0, /* int (*xlStat)(const char *, jx9_value *, jx9_value *) */
0, /* int (*xIsfile)(const char *) */
0, /* int (*xIslink)(const char *) */
0, /* int (*xReadable)(const char *) */
0, /* int (*xWritable)(const char *) */
0, /* int (*xExecutable)(const char *) */
0, /* int (*xFiletype)(const char *, jx9_context *) */
0, /* int (*xGetenv)(const char *, jx9_context *) */
0, /* int (*xSetenv)(const char *, const char *) */
0, /* int (*xTouch)(const char *, jx9_int64, jx9_int64) */
0, /* int (*xMmap)(const char *, void **, jx9_int64 *) */
0, /* void (*xUnmap)(void *, jx9_int64); */
0, /* int (*xLink)(const char *, const char *, int) */
0, /* int (*xUmask)(int) */
0, /* void (*xTempDir)(jx9_context *) */
0, /* unsigned int (*xProcessId)(void) */
0, /* int (*xUid)(void) */
0, /* int (*xGid)(void) */
0, /* void (*xUsername)(jx9_context *) */
0 /* int (*xExec)(const char *, jx9_context *) */
};
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_DISK_IO
#ifdef __WINNT__
/*
* Windows VFS implementation for the JX9 engine.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/* What follows here is code that is specific to windows systems. */
#include <Windows.h>
/*
** Convert a UTF-8 string to microsoft unicode (UTF-16?).
**
** Space to hold the returned string is obtained from HeapAlloc().
** Taken from the sqlite3 source tree
** status: Public Domain
*/
static WCHAR *jx9utf8ToUnicode(const char *zFilename){
int nChar;
WCHAR *zWideFilename;
nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, 0, 0);
zWideFilename = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, nChar*sizeof(zWideFilename[0]));
if( zWideFilename == 0 ){
return 0;
}
nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
if( nChar==0 ){
HeapFree(GetProcessHeap(), 0, zWideFilename);
return 0;
}
return zWideFilename;
}
/*
** Convert a UTF-8 filename into whatever form the underlying
** operating system wants filenames in.Space to hold the result
** is obtained from HeapAlloc() and must be freed by the calling
** function.
** Taken from the sqlite3 source tree
** status: Public Domain
*/
static void *jx9convertUtf8Filename(const char *zFilename){
void *zConverted;
zConverted = jx9utf8ToUnicode(zFilename);
return zConverted;
}
/*
** Convert microsoft unicode to UTF-8. Space to hold the returned string is
** obtained from HeapAlloc().
** Taken from the sqlite3 source tree
** status: Public Domain
*/
static char *jx9unicodeToUtf8(const WCHAR *zWideFilename){
char *zFilename;
int nByte;
nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
zFilename = (char *)HeapAlloc(GetProcessHeap(), 0, nByte);
if( zFilename == 0 ){
return 0;
}
nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte, 0, 0);
if( nByte == 0 ){
HeapFree(GetProcessHeap(), 0, zFilename);
return 0;
}
return zFilename;
}
/* int (*xchdir)(const char *) */
static int WinVfs_chdir(const char *zPath)
{
void * pConverted;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
rc = SetCurrentDirectoryW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
return rc ? JX9_OK : -1;
}
/* int (*xGetcwd)(jx9_context *) */
static int WinVfs_getcwd(jx9_context *pCtx)
{
WCHAR zDir[2048];
char *zConverted;
DWORD rc;
/* Get the current directory */
rc = GetCurrentDirectoryW(sizeof(zDir), zDir);
if( rc < 1 ){
return -1;
}
zConverted = jx9unicodeToUtf8(zDir);
if( zConverted == 0 ){
return -1;
}
jx9_result_string(pCtx, zConverted, -1/*Compute length automatically*/); /* Will make it's own copy */
HeapFree(GetProcessHeap(), 0, zConverted);
return JX9_OK;
}
/* int (*xMkdir)(const char *, int, int) */
static int WinVfs_mkdir(const char *zPath, int mode, int recursive)
{
void * pConverted;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
mode= 0; /* MSVC warning */
recursive = 0;
rc = CreateDirectoryW((LPCWSTR)pConverted, 0);
HeapFree(GetProcessHeap(), 0, pConverted);
return rc ? JX9_OK : -1;
}
/* int (*xRmdir)(const char *) */
static int WinVfs_rmdir(const char *zPath)
{
void * pConverted;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
rc = RemoveDirectoryW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
return rc ? JX9_OK : -1;
}
/* int (*xIsdir)(const char *) */
static int WinVfs_isdir(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
return (dwAttr & FILE_ATTRIBUTE_DIRECTORY) ? JX9_OK : -1;
}
/* int (*xRename)(const char *, const char *) */
static int WinVfs_Rename(const char *zOld, const char *zNew)
{
void *pOld, *pNew;
BOOL rc = 0;
pOld = jx9convertUtf8Filename(zOld);
if( pOld == 0 ){
return -1;
}
pNew = jx9convertUtf8Filename(zNew);
if( pNew ){
rc = MoveFileW((LPCWSTR)pOld, (LPCWSTR)pNew);
}
HeapFree(GetProcessHeap(), 0, pOld);
if( pNew ){
HeapFree(GetProcessHeap(), 0, pNew);
}
return rc ? JX9_OK : - 1;
}
/* int (*xRealpath)(const char *, jx9_context *) */
static int WinVfs_Realpath(const char *zPath, jx9_context *pCtx)
{
WCHAR zTemp[2048];
void *pPath;
char *zReal;
DWORD n;
pPath = jx9convertUtf8Filename(zPath);
if( pPath == 0 ){
return -1;
}
n = GetFullPathNameW((LPCWSTR)pPath, 0, 0, 0);
if( n > 0 ){
if( n >= sizeof(zTemp) ){
n = sizeof(zTemp) - 1;
}
GetFullPathNameW((LPCWSTR)pPath, n, zTemp, 0);
}
HeapFree(GetProcessHeap(), 0, pPath);
if( !n ){
return -1;
}
zReal = jx9unicodeToUtf8(zTemp);
if( zReal == 0 ){
return -1;
}
jx9_result_string(pCtx, zReal, -1); /* Will make it's own copy */
HeapFree(GetProcessHeap(), 0, zReal);
return JX9_OK;
}
/* int (*xSleep)(unsigned int) */
static int WinVfs_Sleep(unsigned int uSec)
{
Sleep(uSec/1000/*uSec per Millisec */);
return JX9_OK;
}
/* int (*xUnlink)(const char *) */
static int WinVfs_unlink(const char *zPath)
{
void * pConverted;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
rc = DeleteFileW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
return rc ? JX9_OK : - 1;
}
/* jx9_int64 (*xFreeSpace)(const char *) */
static jx9_int64 WinVfs_DiskFreeSpace(const char *zPath)
{
#ifdef _WIN32_WCE
/* GetDiskFreeSpace is not supported under WINCE */
SXUNUSED(zPath);
return 0;
#else
DWORD dwSectPerClust, dwBytesPerSect, dwFreeClusters, dwTotalClusters;
void * pConverted;
WCHAR *p;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return 0;
}
p = (WCHAR *)pConverted;
for(;*p;p++){
if( *p == '\\' || *p == '/'){
*p = '\0';
break;
}
}
rc = GetDiskFreeSpaceW((LPCWSTR)pConverted, &dwSectPerClust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters);
if( !rc ){
return 0;
}
return (jx9_int64)dwFreeClusters * dwSectPerClust * dwBytesPerSect;
#endif
}
/* jx9_int64 (*xTotalSpace)(const char *) */
static jx9_int64 WinVfs_DiskTotalSpace(const char *zPath)
{
#ifdef _WIN32_WCE
/* GetDiskFreeSpace is not supported under WINCE */
SXUNUSED(zPath);
return 0;
#else
DWORD dwSectPerClust, dwBytesPerSect, dwFreeClusters, dwTotalClusters;
void * pConverted;
WCHAR *p;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return 0;
}
p = (WCHAR *)pConverted;
for(;*p;p++){
if( *p == '\\' || *p == '/'){
*p = '\0';
break;
}
}
rc = GetDiskFreeSpaceW((LPCWSTR)pConverted, &dwSectPerClust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters);
if( !rc ){
return 0;
}
return (jx9_int64)dwTotalClusters * dwSectPerClust * dwBytesPerSect;
#endif
}
/* int (*xFileExists)(const char *) */
static int WinVfs_FileExists(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
return JX9_OK;
}
/* Open a file in a read-only mode */
static HANDLE OpenReadOnly(LPCWSTR pPath)
{
DWORD dwType = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
DWORD dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
DWORD dwAccess = GENERIC_READ;
DWORD dwCreate = OPEN_EXISTING;
HANDLE pHandle;
pHandle = CreateFileW(pPath, dwAccess, dwShare, 0, dwCreate, dwType, 0);
if( pHandle == INVALID_HANDLE_VALUE){
return 0;
}
return pHandle;
}
/* jx9_int64 (*xFileSize)(const char *) */
static jx9_int64 WinVfs_FileSize(const char *zPath)
{
DWORD dwLow, dwHigh;
void * pConverted;
jx9_int64 nSize;
HANDLE pHandle;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Open the file in read-only mode */
pHandle = OpenReadOnly((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( pHandle ){
dwLow = GetFileSize(pHandle, &dwHigh);
nSize = dwHigh;
nSize <<= 32;
nSize += dwLow;
CloseHandle(pHandle);
}else{
nSize = -1;
}
return nSize;
}
#define TICKS_PER_SECOND 10000000
#define EPOCH_DIFFERENCE 11644473600LL
/* Convert Windows timestamp to UNIX timestamp */
static jx9_int64 convertWindowsTimeToUnixTime(LPFILETIME pTime)
{
jx9_int64 input, temp;
input = pTime->dwHighDateTime;
input <<= 32;
input += pTime->dwLowDateTime;
temp = input / TICKS_PER_SECOND; /*convert from 100ns intervals to seconds*/
temp = temp - EPOCH_DIFFERENCE; /*subtract number of seconds between epochs*/
return temp;
}
/* Convert UNIX timestamp to Windows timestamp */
static void convertUnixTimeToWindowsTime(jx9_int64 nUnixtime, LPFILETIME pOut)
{
jx9_int64 result = EPOCH_DIFFERENCE;
result += nUnixtime;
result *= 10000000LL;
pOut->dwHighDateTime = (DWORD)(nUnixtime>>32);
pOut->dwLowDateTime = (DWORD)nUnixtime;
}
/* int (*xTouch)(const char *, jx9_int64, jx9_int64) */
static int WinVfs_Touch(const char *zPath, jx9_int64 touch_time, jx9_int64 access_time)
{
FILETIME sTouch, sAccess;
void *pConverted;
void *pHandle;
BOOL rc = 0;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
pHandle = OpenReadOnly((LPCWSTR)pConverted);
if( pHandle ){
if( touch_time < 0 ){
GetSystemTimeAsFileTime(&sTouch);
}else{
convertUnixTimeToWindowsTime(touch_time, &sTouch);
}
if( access_time < 0 ){
/* Use the touch time */
sAccess = sTouch; /* Structure assignment */
}else{
convertUnixTimeToWindowsTime(access_time, &sAccess);
}
rc = SetFileTime(pHandle, &sTouch, &sAccess, 0);
/* Close the handle */
CloseHandle(pHandle);
}
HeapFree(GetProcessHeap(), 0, pConverted);
return rc ? JX9_OK : -1;
}
/* jx9_int64 (*xFileAtime)(const char *) */
static jx9_int64 WinVfs_FileAtime(const char *zPath)
{
BY_HANDLE_FILE_INFORMATION sInfo;
void * pConverted;
jx9_int64 atime;
HANDLE pHandle;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Open the file in read-only mode */
pHandle = OpenReadOnly((LPCWSTR)pConverted);
if( pHandle ){
BOOL rc;
rc = GetFileInformationByHandle(pHandle, &sInfo);
if( rc ){
atime = convertWindowsTimeToUnixTime(&sInfo.ftLastAccessTime);
}else{
atime = -1;
}
CloseHandle(pHandle);
}else{
atime = -1;
}
HeapFree(GetProcessHeap(), 0, pConverted);
return atime;
}
/* jx9_int64 (*xFileMtime)(const char *) */
static jx9_int64 WinVfs_FileMtime(const char *zPath)
{
BY_HANDLE_FILE_INFORMATION sInfo;
void * pConverted;
jx9_int64 mtime;
HANDLE pHandle;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Open the file in read-only mode */
pHandle = OpenReadOnly((LPCWSTR)pConverted);
if( pHandle ){
BOOL rc;
rc = GetFileInformationByHandle(pHandle, &sInfo);
if( rc ){
mtime = convertWindowsTimeToUnixTime(&sInfo.ftLastWriteTime);
}else{
mtime = -1;
}
CloseHandle(pHandle);
}else{
mtime = -1;
}
HeapFree(GetProcessHeap(), 0, pConverted);
return mtime;
}
/* jx9_int64 (*xFileCtime)(const char *) */
static jx9_int64 WinVfs_FileCtime(const char *zPath)
{
BY_HANDLE_FILE_INFORMATION sInfo;
void * pConverted;
jx9_int64 ctime;
HANDLE pHandle;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Open the file in read-only mode */
pHandle = OpenReadOnly((LPCWSTR)pConverted);
if( pHandle ){
BOOL rc;
rc = GetFileInformationByHandle(pHandle, &sInfo);
if( rc ){
ctime = convertWindowsTimeToUnixTime(&sInfo.ftCreationTime);
}else{
ctime = -1;
}
CloseHandle(pHandle);
}else{
ctime = -1;
}
HeapFree(GetProcessHeap(), 0, pConverted);
return ctime;
}
/* int (*xStat)(const char *, jx9_value *, jx9_value *) */
/* int (*xlStat)(const char *, jx9_value *, jx9_value *) */
static int WinVfs_Stat(const char *zPath, jx9_value *pArray, jx9_value *pWorker)
{
BY_HANDLE_FILE_INFORMATION sInfo;
void *pConverted;
HANDLE pHandle;
BOOL rc;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Open the file in read-only mode */
pHandle = OpenReadOnly((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( pHandle == 0 ){
return -1;
}
rc = GetFileInformationByHandle(pHandle, &sInfo);
CloseHandle(pHandle);
if( !rc ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)sInfo.dwVolumeSerialNumber);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */
/* ino */
jx9_value_int64(pWorker, (jx9_int64)(((jx9_int64)sInfo.nFileIndexHigh << 32) | sInfo.nFileIndexLow));
jx9_array_add_strkey_elem(pArray, "ino", pWorker); /* Will make it's own copy */
/* mode */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "mode", pWorker);
/* nlink */
jx9_value_int(pWorker, (int)sInfo.nNumberOfLinks);
jx9_array_add_strkey_elem(pArray, "nlink", pWorker); /* Will make it's own copy */
/* uid, gid, rdev */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "uid", pWorker);
jx9_array_add_strkey_elem(pArray, "gid", pWorker);
jx9_array_add_strkey_elem(pArray, "rdev", pWorker);
/* size */
jx9_value_int64(pWorker, (jx9_int64)(((jx9_int64)sInfo.nFileSizeHigh << 32) | sInfo.nFileSizeLow));
jx9_array_add_strkey_elem(pArray, "size", pWorker); /* Will make it's own copy */
/* atime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftLastAccessTime));
jx9_array_add_strkey_elem(pArray, "atime", pWorker); /* Will make it's own copy */
/* mtime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftLastWriteTime));
jx9_array_add_strkey_elem(pArray, "mtime", pWorker); /* Will make it's own copy */
/* ctime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftCreationTime));
jx9_array_add_strkey_elem(pArray, "ctime", pWorker); /* Will make it's own copy */
/* blksize, blocks */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "blksize", pWorker);
jx9_array_add_strkey_elem(pArray, "blocks", pWorker);
return JX9_OK;
}
/* int (*xIsfile)(const char *) */
static int WinVfs_isfile(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
return (dwAttr & (FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE)) ? JX9_OK : -1;
}
/* int (*xIslink)(const char *) */
static int WinVfs_islink(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
return (dwAttr & FILE_ATTRIBUTE_REPARSE_POINT) ? JX9_OK : -1;
}
/* int (*xWritable)(const char *) */
static int WinVfs_iswritable(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
if( (dwAttr & (FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_NORMAL)) == 0 ){
/* Not a regular file */
return -1;
}
if( dwAttr & FILE_ATTRIBUTE_READONLY ){
/* Read-only file */
return -1;
}
/* File is writable */
return JX9_OK;
}
/* int (*xExecutable)(const char *) */
static int WinVfs_isexecutable(const char *zPath)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
return -1;
}
if( (dwAttr & FILE_ATTRIBUTE_NORMAL) == 0 ){
/* Not a regular file */
return -1;
}
/* File is executable */
return JX9_OK;
}
/* int (*xFiletype)(const char *, jx9_context *) */
static int WinVfs_Filetype(const char *zPath, jx9_context *pCtx)
{
void * pConverted;
DWORD dwAttr;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
/* Expand 'unknown' */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return -1;
}
dwAttr = GetFileAttributesW((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( dwAttr == INVALID_FILE_ATTRIBUTES ){
/* Expand 'unknown' */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return -1;
}
if(dwAttr & (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_NORMAL|FILE_ATTRIBUTE_ARCHIVE) ){
jx9_result_string(pCtx, "file", sizeof("file")-1);
}else if(dwAttr & FILE_ATTRIBUTE_DIRECTORY){
jx9_result_string(pCtx, "dir", sizeof("dir")-1);
}else if(dwAttr & FILE_ATTRIBUTE_REPARSE_POINT){
jx9_result_string(pCtx, "link", sizeof("link")-1);
}else if(dwAttr & (FILE_ATTRIBUTE_DEVICE)){
jx9_result_string(pCtx, "block", sizeof("block")-1);
}else{
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
}
return JX9_OK;
}
/* int (*xGetenv)(const char *, jx9_context *) */
static int WinVfs_Getenv(const char *zVar, jx9_context *pCtx)
{
char zValue[1024];
DWORD n;
/*
* According to MSDN
* If lpBuffer is not large enough to hold the data, the return
* value is the buffer size, in characters, required to hold the
* string and its terminating null character and the contents
* of lpBuffer are undefined.
*/
n = sizeof(zValue);
SyMemcpy("Undefined", zValue, sizeof("Undefined")-1);
/* Extract the environment value */
n = GetEnvironmentVariableA(zVar, zValue, sizeof(zValue));
if( !n ){
/* No such variable*/
return -1;
}
jx9_result_string(pCtx, zValue, (int)n);
return JX9_OK;
}
/* int (*xSetenv)(const char *, const char *) */
static int WinVfs_Setenv(const char *zName, const char *zValue)
{
BOOL rc;
rc = SetEnvironmentVariableA(zName, zValue);
return rc ? JX9_OK : -1;
}
/* int (*xMmap)(const char *, void **, jx9_int64 *) */
static int WinVfs_Mmap(const char *zPath, void **ppMap, jx9_int64 *pSize)
{
DWORD dwSizeLow, dwSizeHigh;
HANDLE pHandle, pMapHandle;
void *pConverted, *pView;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
pHandle = OpenReadOnly((LPCWSTR)pConverted);
HeapFree(GetProcessHeap(), 0, pConverted);
if( pHandle == 0 ){
return -1;
}
/* Get the file size */
dwSizeLow = GetFileSize(pHandle, &dwSizeHigh);
/* Create the mapping */
pMapHandle = CreateFileMappingW(pHandle, 0, PAGE_READONLY, dwSizeHigh, dwSizeLow, 0);
if( pMapHandle == 0 ){
CloseHandle(pHandle);
return -1;
}
*pSize = ((jx9_int64)dwSizeHigh << 32) | dwSizeLow;
/* Obtain the view */
pView = MapViewOfFile(pMapHandle, FILE_MAP_READ, 0, 0, (SIZE_T)(*pSize));
if( pView ){
/* Let the upper layer point to the view */
*ppMap = pView;
}
/* Close the handle
* According to MSDN it's OK the close the HANDLES.
*/
CloseHandle(pMapHandle);
CloseHandle(pHandle);
return pView ? JX9_OK : -1;
}
/* void (*xUnmap)(void *, jx9_int64) */
static void WinVfs_Unmap(void *pView, jx9_int64 nSize)
{
nSize = 0; /* Compiler warning */
UnmapViewOfFile(pView);
}
/* void (*xTempDir)(jx9_context *) */
static void WinVfs_TempDir(jx9_context *pCtx)
{
CHAR zTemp[1024];
DWORD n;
n = GetTempPathA(sizeof(zTemp), zTemp);
if( n < 1 ){
/* Assume the default windows temp directory */
jx9_result_string(pCtx, "C:\\Windows\\Temp", -1/*Compute length automatically*/);
}else{
jx9_result_string(pCtx, zTemp, (int)n);
}
}
/* unsigned int (*xProcessId)(void) */
static unsigned int WinVfs_ProcessId(void)
{
DWORD nID = 0;
#ifndef __MINGW32__
nID = GetProcessId(GetCurrentProcess());
#endif /* __MINGW32__ */
return (unsigned int)nID;
}
/* Export the windows vfs */
static const jx9_vfs sWinVfs = {
"Windows_vfs",
JX9_VFS_VERSION,
WinVfs_chdir, /* int (*xChdir)(const char *) */
0, /* int (*xChroot)(const char *); */
WinVfs_getcwd, /* int (*xGetcwd)(jx9_context *) */
WinVfs_mkdir, /* int (*xMkdir)(const char *, int, int) */
WinVfs_rmdir, /* int (*xRmdir)(const char *) */
WinVfs_isdir, /* int (*xIsdir)(const char *) */
WinVfs_Rename, /* int (*xRename)(const char *, const char *) */
WinVfs_Realpath, /*int (*xRealpath)(const char *, jx9_context *)*/
WinVfs_Sleep, /* int (*xSleep)(unsigned int) */
WinVfs_unlink, /* int (*xUnlink)(const char *) */
WinVfs_FileExists, /* int (*xFileExists)(const char *) */
0, /*int (*xChmod)(const char *, int)*/
0, /*int (*xChown)(const char *, const char *)*/
0, /*int (*xChgrp)(const char *, const char *)*/
WinVfs_DiskFreeSpace, /* jx9_int64 (*xFreeSpace)(const char *) */
WinVfs_DiskTotalSpace, /* jx9_int64 (*xTotalSpace)(const char *) */
WinVfs_FileSize, /* jx9_int64 (*xFileSize)(const char *) */
WinVfs_FileAtime, /* jx9_int64 (*xFileAtime)(const char *) */
WinVfs_FileMtime, /* jx9_int64 (*xFileMtime)(const char *) */
WinVfs_FileCtime, /* jx9_int64 (*xFileCtime)(const char *) */
WinVfs_Stat, /* int (*xStat)(const char *, jx9_value *, jx9_value *) */
WinVfs_Stat, /* int (*xlStat)(const char *, jx9_value *, jx9_value *) */
WinVfs_isfile, /* int (*xIsfile)(const char *) */
WinVfs_islink, /* int (*xIslink)(const char *) */
WinVfs_isfile, /* int (*xReadable)(const char *) */
WinVfs_iswritable, /* int (*xWritable)(const char *) */
WinVfs_isexecutable, /* int (*xExecutable)(const char *) */
WinVfs_Filetype, /* int (*xFiletype)(const char *, jx9_context *) */
WinVfs_Getenv, /* int (*xGetenv)(const char *, jx9_context *) */
WinVfs_Setenv, /* int (*xSetenv)(const char *, const char *) */
WinVfs_Touch, /* int (*xTouch)(const char *, jx9_int64, jx9_int64) */
WinVfs_Mmap, /* int (*xMmap)(const char *, void **, jx9_int64 *) */
WinVfs_Unmap, /* void (*xUnmap)(void *, jx9_int64); */
0, /* int (*xLink)(const char *, const char *, int) */
0, /* int (*xUmask)(int) */
WinVfs_TempDir, /* void (*xTempDir)(jx9_context *) */
WinVfs_ProcessId, /* unsigned int (*xProcessId)(void) */
0, /* int (*xUid)(void) */
0, /* int (*xGid)(void) */
0, /* void (*xUsername)(jx9_context *) */
0 /* int (*xExec)(const char *, jx9_context *) */
};
/* Windows file IO */
#ifndef INVALID_SET_FILE_POINTER
# define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
/* int (*xOpen)(const char *, int, jx9_value *, void **) */
static int WinFile_Open(const char *zPath, int iOpenMode, jx9_value *pResource, void **ppHandle)
{
DWORD dwType = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS;
DWORD dwAccess = GENERIC_READ;
DWORD dwShare, dwCreate;
void *pConverted;
HANDLE pHandle;
pConverted = jx9convertUtf8Filename(zPath);
if( pConverted == 0 ){
return -1;
}
/* Set the desired flags according to the open mode */
if( iOpenMode & JX9_IO_OPEN_CREATE ){
/* Open existing file, or create if it doesn't exist */
dwCreate = OPEN_ALWAYS;
if( iOpenMode & JX9_IO_OPEN_TRUNC ){
/* If the specified file exists and is writable, the function overwrites the file */
dwCreate = CREATE_ALWAYS;
}
}else if( iOpenMode & JX9_IO_OPEN_EXCL ){
/* Creates a new file, only if it does not already exist.
* If the file exists, it fails.
*/
dwCreate = CREATE_NEW;
}else if( iOpenMode & JX9_IO_OPEN_TRUNC ){
/* Opens a file and truncates it so that its size is zero bytes
* The file must exist.
*/
dwCreate = TRUNCATE_EXISTING;
}else{
/* Opens a file, only if it exists. */
dwCreate = OPEN_EXISTING;
}
if( iOpenMode & JX9_IO_OPEN_RDWR ){
/* Read+Write access */
dwAccess |= GENERIC_WRITE;
}else if( iOpenMode & JX9_IO_OPEN_WRONLY ){
/* Write only access */
dwAccess = GENERIC_WRITE;
}
if( iOpenMode & JX9_IO_OPEN_APPEND ){
/* Append mode */
dwAccess = FILE_APPEND_DATA;
}
if( iOpenMode & JX9_IO_OPEN_TEMP ){
/* File is temporary */
dwType = FILE_ATTRIBUTE_TEMPORARY;
}
dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
pHandle = CreateFileW((LPCWSTR)pConverted, dwAccess, dwShare, 0, dwCreate, dwType, 0);
HeapFree(GetProcessHeap(), 0, pConverted);
if( pHandle == INVALID_HANDLE_VALUE){
SXUNUSED(pResource); /* MSVC warning */
return -1;
}
/* Make the handle accessible to the upper layer */
*ppHandle = (void *)pHandle;
return JX9_OK;
}
/* An instance of the following structure is used to record state information
* while iterating throw directory entries.
*/
typedef struct WinDir_Info WinDir_Info;
struct WinDir_Info
{
HANDLE pDirHandle;
void *pPath;
WIN32_FIND_DATAW sInfo;
int rc;
};
/* int (*xOpenDir)(const char *, jx9_value *, void **) */
static int WinDir_Open(const char *zPath, jx9_value *pResource, void **ppHandle)
{
WinDir_Info *pDirInfo;
void *pConverted;
char *zPrep;
sxu32 n;
/* Prepare the path */
n = SyStrlen(zPath);
zPrep = (char *)HeapAlloc(GetProcessHeap(), 0, n+sizeof("\\*")+4);
if( zPrep == 0 ){
return -1;
}
SyMemcpy((const void *)zPath, zPrep, n);
zPrep[n] = '\\';
zPrep[n+1] = '*';
zPrep[n+2] = 0;
pConverted = jx9convertUtf8Filename(zPrep);
HeapFree(GetProcessHeap(), 0, zPrep);
if( pConverted == 0 ){
return -1;
}
/* Allocate a new instance */
pDirInfo = (WinDir_Info *)HeapAlloc(GetProcessHeap(), 0, sizeof(WinDir_Info));
if( pDirInfo == 0 ){
pResource = 0; /* Compiler warning */
return -1;
}
pDirInfo->rc = SXRET_OK;
pDirInfo->pDirHandle = FindFirstFileW((LPCWSTR)pConverted, &pDirInfo->sInfo);
if( pDirInfo->pDirHandle == INVALID_HANDLE_VALUE ){
/* Cannot open directory */
HeapFree(GetProcessHeap(), 0, pConverted);
HeapFree(GetProcessHeap(), 0, pDirInfo);
return -1;
}
/* Save the path */
pDirInfo->pPath = pConverted;
/* Save our structure */
*ppHandle = pDirInfo;
return JX9_OK;
}
/* void (*xCloseDir)(void *) */
static void WinDir_Close(void *pUserData)
{
WinDir_Info *pDirInfo = (WinDir_Info *)pUserData;
if( pDirInfo->pDirHandle != INVALID_HANDLE_VALUE ){
FindClose(pDirInfo->pDirHandle);
}
HeapFree(GetProcessHeap(), 0, pDirInfo->pPath);
HeapFree(GetProcessHeap(), 0, pDirInfo);
}
/* void (*xClose)(void *); */
static void WinFile_Close(void *pUserData)
{
HANDLE pHandle = (HANDLE)pUserData;
CloseHandle(pHandle);
}
/* int (*xReadDir)(void *, jx9_context *) */
static int WinDir_Read(void *pUserData, jx9_context *pCtx)
{
WinDir_Info *pDirInfo = (WinDir_Info *)pUserData;
LPWIN32_FIND_DATAW pData;
char *zName;
BOOL rc;
sxu32 n;
if( pDirInfo->rc != SXRET_OK ){
/* No more entry to process */
return -1;
}
pData = &pDirInfo->sInfo;
for(;;){
zName = jx9unicodeToUtf8(pData->cFileName);
if( zName == 0 ){
/* Out of memory */
return -1;
}
n = SyStrlen(zName);
/* Ignore '.' && '..' */
if( n > sizeof("..")-1 || zName[0] != '.' || ( n == sizeof("..")-1 && zName[1] != '.') ){
break;
}
HeapFree(GetProcessHeap(), 0, zName);
rc = FindNextFileW(pDirInfo->pDirHandle, &pDirInfo->sInfo);
if( !rc ){
return -1;
}
}
/* Return the current file name */
jx9_result_string(pCtx, zName, -1);
HeapFree(GetProcessHeap(), 0, zName);
/* Point to the next entry */
rc = FindNextFileW(pDirInfo->pDirHandle, &pDirInfo->sInfo);
if( !rc ){
pDirInfo->rc = SXERR_EOF;
}
return JX9_OK;
}
/* void (*xRewindDir)(void *) */
static void WinDir_RewindDir(void *pUserData)
{
WinDir_Info *pDirInfo = (WinDir_Info *)pUserData;
FindClose(pDirInfo->pDirHandle);
pDirInfo->pDirHandle = FindFirstFileW((LPCWSTR)pDirInfo->pPath, &pDirInfo->sInfo);
if( pDirInfo->pDirHandle == INVALID_HANDLE_VALUE ){
pDirInfo->rc = SXERR_EOF;
}else{
pDirInfo->rc = SXRET_OK;
}
}
/* jx9_int64 (*xRead)(void *, void *, jx9_int64); */
static jx9_int64 WinFile_Read(void *pOS, void *pBuffer, jx9_int64 nDatatoRead)
{
HANDLE pHandle = (HANDLE)pOS;
DWORD nRd;
BOOL rc;
rc = ReadFile(pHandle, pBuffer, (DWORD)nDatatoRead, &nRd, 0);
if( !rc ){
/* EOF or IO error */
return -1;
}
return (jx9_int64)nRd;
}
/* jx9_int64 (*xWrite)(void *, const void *, jx9_int64); */
static jx9_int64 WinFile_Write(void *pOS, const void *pBuffer, jx9_int64 nWrite)
{
const char *zData = (const char *)pBuffer;
HANDLE pHandle = (HANDLE)pOS;
jx9_int64 nCount;
DWORD nWr;
BOOL rc;
nWr = 0;
nCount = 0;
for(;;){
if( nWrite < 1 ){
break;
}
rc = WriteFile(pHandle, zData, (DWORD)nWrite, &nWr, 0);
if( !rc ){
/* IO error */
break;
}
nWrite -= nWr;
nCount += nWr;
zData += nWr;
}
if( nWrite > 0 ){
return -1;
}
return nCount;
}
/* int (*xSeek)(void *, jx9_int64, int) */
static int WinFile_Seek(void *pUserData, jx9_int64 iOfft, int whence)
{
HANDLE pHandle = (HANDLE)pUserData;
DWORD dwMove, dwNew;
LONG nHighOfft;
switch(whence){
case 1:/*SEEK_CUR*/
dwMove = FILE_CURRENT;
break;
case 2: /* SEEK_END */
dwMove = FILE_END;
break;
case 0: /* SEEK_SET */
default:
dwMove = FILE_BEGIN;
break;
}
nHighOfft = (LONG)(iOfft >> 32);
dwNew = SetFilePointer(pHandle, (LONG)iOfft, &nHighOfft, dwMove);
if( dwNew == INVALID_SET_FILE_POINTER ){
return -1;
}
return JX9_OK;
}
/* int (*xLock)(void *, int) */
static int WinFile_Lock(void *pUserData, int lock_type)
{
HANDLE pHandle = (HANDLE)pUserData;
static DWORD dwLo = 0, dwHi = 0; /* xx: MT-SAFE */
OVERLAPPED sDummy;
BOOL rc;
SyZero(&sDummy, sizeof(sDummy));
/* Get the file size */
if( lock_type < 1 ){
/* Unlock the file */
rc = UnlockFileEx(pHandle, 0, dwLo, dwHi, &sDummy);
}else{
DWORD dwFlags = LOCKFILE_FAIL_IMMEDIATELY; /* Shared non-blocking lock by default*/
/* Lock the file */
if( lock_type == 1 /* LOCK_EXCL */ ){
dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
}
dwLo = GetFileSize(pHandle, &dwHi);
rc = LockFileEx(pHandle, dwFlags, 0, dwLo, dwHi, &sDummy);
}
return rc ? JX9_OK : -1 /* Lock error */;
}
/* jx9_int64 (*xTell)(void *) */
static jx9_int64 WinFile_Tell(void *pUserData)
{
HANDLE pHandle = (HANDLE)pUserData;
DWORD dwNew;
dwNew = SetFilePointer(pHandle, 0, 0, FILE_CURRENT/* SEEK_CUR */);
if( dwNew == INVALID_SET_FILE_POINTER ){
return -1;
}
return (jx9_int64)dwNew;
}
/* int (*xTrunc)(void *, jx9_int64) */
static int WinFile_Trunc(void *pUserData, jx9_int64 nOfft)
{
HANDLE pHandle = (HANDLE)pUserData;
LONG HighOfft;
DWORD dwNew;
BOOL rc;
HighOfft = (LONG)(nOfft >> 32);
dwNew = SetFilePointer(pHandle, (LONG)nOfft, &HighOfft, FILE_BEGIN);
if( dwNew == INVALID_SET_FILE_POINTER ){
return -1;
}
rc = SetEndOfFile(pHandle);
return rc ? JX9_OK : -1;
}
/* int (*xSync)(void *); */
static int WinFile_Sync(void *pUserData)
{
HANDLE pHandle = (HANDLE)pUserData;
BOOL rc;
rc = FlushFileBuffers(pHandle);
return rc ? JX9_OK : - 1;
}
/* int (*xStat)(void *, jx9_value *, jx9_value *) */
static int WinFile_Stat(void *pUserData, jx9_value *pArray, jx9_value *pWorker)
{
BY_HANDLE_FILE_INFORMATION sInfo;
HANDLE pHandle = (HANDLE)pUserData;
BOOL rc;
rc = GetFileInformationByHandle(pHandle, &sInfo);
if( !rc ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)sInfo.dwVolumeSerialNumber);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */
/* ino */
jx9_value_int64(pWorker, (jx9_int64)(((jx9_int64)sInfo.nFileIndexHigh << 32) | sInfo.nFileIndexLow));
jx9_array_add_strkey_elem(pArray, "ino", pWorker); /* Will make it's own copy */
/* mode */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "mode", pWorker);
/* nlink */
jx9_value_int(pWorker, (int)sInfo.nNumberOfLinks);
jx9_array_add_strkey_elem(pArray, "nlink", pWorker); /* Will make it's own copy */
/* uid, gid, rdev */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "uid", pWorker);
jx9_array_add_strkey_elem(pArray, "gid", pWorker);
jx9_array_add_strkey_elem(pArray, "rdev", pWorker);
/* size */
jx9_value_int64(pWorker, (jx9_int64)(((jx9_int64)sInfo.nFileSizeHigh << 32) | sInfo.nFileSizeLow));
jx9_array_add_strkey_elem(pArray, "size", pWorker); /* Will make it's own copy */
/* atime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftLastAccessTime));
jx9_array_add_strkey_elem(pArray, "atime", pWorker); /* Will make it's own copy */
/* mtime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftLastWriteTime));
jx9_array_add_strkey_elem(pArray, "mtime", pWorker); /* Will make it's own copy */
/* ctime */
jx9_value_int64(pWorker, convertWindowsTimeToUnixTime(&sInfo.ftCreationTime));
jx9_array_add_strkey_elem(pArray, "ctime", pWorker); /* Will make it's own copy */
/* blksize, blocks */
jx9_value_int(pWorker, 0);
jx9_array_add_strkey_elem(pArray, "blksize", pWorker);
jx9_array_add_strkey_elem(pArray, "blocks", pWorker);
return JX9_OK;
}
/* Export the file:// stream */
static const jx9_io_stream sWinFileStream = {
"file", /* Stream name */
JX9_IO_STREAM_VERSION,
WinFile_Open, /* xOpen */
WinDir_Open, /* xOpenDir */
WinFile_Close, /* xClose */
WinDir_Close, /* xCloseDir */
WinFile_Read, /* xRead */
WinDir_Read, /* xReadDir */
WinFile_Write, /* xWrite */
WinFile_Seek, /* xSeek */
WinFile_Lock, /* xLock */
WinDir_RewindDir, /* xRewindDir */
WinFile_Tell, /* xTell */
WinFile_Trunc, /* xTrunc */
WinFile_Sync, /* xSeek */
WinFile_Stat /* xStat */
};
#elif defined(__UNIXES__)
/*
* UNIX VFS implementation for the JX9 engine.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
#include <sys/types.h>
#include <limits.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/uio.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/file.h>
#include <pwd.h>
#include <grp.h>
#include <dirent.h>
#include <utime.h>
#include <stdio.h>
#include <stdlib.h>
/* int (*xchdir)(const char *) */
static int UnixVfs_chdir(const char *zPath)
{
int rc;
rc = chdir(zPath);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xGetcwd)(jx9_context *) */
static int UnixVfs_getcwd(jx9_context *pCtx)
{
char zBuf[4096];
char *zDir;
/* Get the current directory */
zDir = getcwd(zBuf, sizeof(zBuf));
if( zDir == 0 ){
return -1;
}
jx9_result_string(pCtx, zDir, -1/*Compute length automatically*/);
return JX9_OK;
}
/* int (*xMkdir)(const char *, int, int) */
static int UnixVfs_mkdir(const char *zPath, int mode, int recursive)
{
int rc;
rc = mkdir(zPath, mode);
recursive = 0; /* cc warning */
return rc == 0 ? JX9_OK : -1;
}
/* int (*xRmdir)(const char *) */
static int UnixVfs_rmdir(const char *zPath)
{
int rc;
rc = rmdir(zPath);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xIsdir)(const char *) */
static int UnixVfs_isdir(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
rc = S_ISDIR(st.st_mode);
return rc ? JX9_OK : -1 ;
}
/* int (*xRename)(const char *, const char *) */
static int UnixVfs_Rename(const char *zOld, const char *zNew)
{
int rc;
rc = rename(zOld, zNew);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xRealpath)(const char *, jx9_context *) */
static int UnixVfs_Realpath(const char *zPath, jx9_context *pCtx)
{
#ifndef JX9_UNIX_OLD_LIBC
char *zReal;
zReal = realpath(zPath, 0);
if( zReal == 0 ){
return -1;
}
jx9_result_string(pCtx, zReal, -1/*Compute length automatically*/);
/* Release the allocated buffer */
free(zReal);
return JX9_OK;
#else
zPath = 0; /* cc warning */
pCtx = 0;
return -1;
#endif
}
/* int (*xSleep)(unsigned int) */
static int UnixVfs_Sleep(unsigned int uSec)
{
usleep(uSec);
return JX9_OK;
}
/* int (*xUnlink)(const char *) */
static int UnixVfs_unlink(const char *zPath)
{
int rc;
rc = unlink(zPath);
return rc == 0 ? JX9_OK : -1 ;
}
/* int (*xFileExists)(const char *) */
static int UnixVfs_FileExists(const char *zPath)
{
int rc;
rc = access(zPath, F_OK);
return rc == 0 ? JX9_OK : -1;
}
/* jx9_int64 (*xFileSize)(const char *) */
static jx9_int64 UnixVfs_FileSize(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
return (jx9_int64)st.st_size;
}
/* int (*xTouch)(const char *, jx9_int64, jx9_int64) */
static int UnixVfs_Touch(const char *zPath, jx9_int64 touch_time, jx9_int64 access_time)
{
struct utimbuf ut;
int rc;
ut.actime = (time_t)access_time;
ut.modtime = (time_t)touch_time;
rc = utime(zPath, &ut);
if( rc != 0 ){
return -1;
}
return JX9_OK;
}
/* jx9_int64 (*xFileAtime)(const char *) */
static jx9_int64 UnixVfs_FileAtime(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
return (jx9_int64)st.st_atime;
}
/* jx9_int64 (*xFileMtime)(const char *) */
static jx9_int64 UnixVfs_FileMtime(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
return (jx9_int64)st.st_mtime;
}
/* jx9_int64 (*xFileCtime)(const char *) */
static jx9_int64 UnixVfs_FileCtime(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
return (jx9_int64)st.st_ctime;
}
/* int (*xStat)(const char *, jx9_value *, jx9_value *) */
static int UnixVfs_Stat(const char *zPath, jx9_value *pArray, jx9_value *pWorker)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)st.st_dev);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */
/* ino */
jx9_value_int64(pWorker, (jx9_int64)st.st_ino);
jx9_array_add_strkey_elem(pArray, "ino", pWorker); /* Will make it's own copy */
/* mode */
jx9_value_int(pWorker, (int)st.st_mode);
jx9_array_add_strkey_elem(pArray, "mode", pWorker);
/* nlink */
jx9_value_int(pWorker, (int)st.st_nlink);
jx9_array_add_strkey_elem(pArray, "nlink", pWorker); /* Will make it's own copy */
/* uid, gid, rdev */
jx9_value_int(pWorker, (int)st.st_uid);
jx9_array_add_strkey_elem(pArray, "uid", pWorker);
jx9_value_int(pWorker, (int)st.st_gid);
jx9_array_add_strkey_elem(pArray, "gid", pWorker);
jx9_value_int(pWorker, (int)st.st_rdev);
jx9_array_add_strkey_elem(pArray, "rdev", pWorker);
/* size */
jx9_value_int64(pWorker, (jx9_int64)st.st_size);
jx9_array_add_strkey_elem(pArray, "size", pWorker); /* Will make it's own copy */
/* atime */
jx9_value_int64(pWorker, (jx9_int64)st.st_atime);
jx9_array_add_strkey_elem(pArray, "atime", pWorker); /* Will make it's own copy */
/* mtime */
jx9_value_int64(pWorker, (jx9_int64)st.st_mtime);
jx9_array_add_strkey_elem(pArray, "mtime", pWorker); /* Will make it's own copy */
/* ctime */
jx9_value_int64(pWorker, (jx9_int64)st.st_ctime);
jx9_array_add_strkey_elem(pArray, "ctime", pWorker); /* Will make it's own copy */
/* blksize, blocks */
jx9_value_int(pWorker, (int)st.st_blksize);
jx9_array_add_strkey_elem(pArray, "blksize", pWorker);
jx9_value_int(pWorker, (int)st.st_blocks);
jx9_array_add_strkey_elem(pArray, "blocks", pWorker);
return JX9_OK;
}
/* int (*xlStat)(const char *, jx9_value *, jx9_value *) */
static int UnixVfs_lStat(const char *zPath, jx9_value *pArray, jx9_value *pWorker)
{
struct stat st;
int rc;
rc = lstat(zPath, &st);
if( rc != 0 ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)st.st_dev);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */
/* ino */
jx9_value_int64(pWorker, (jx9_int64)st.st_ino);
jx9_array_add_strkey_elem(pArray, "ino", pWorker); /* Will make it's own copy */
/* mode */
jx9_value_int(pWorker, (int)st.st_mode);
jx9_array_add_strkey_elem(pArray, "mode", pWorker);
/* nlink */
jx9_value_int(pWorker, (int)st.st_nlink);
jx9_array_add_strkey_elem(pArray, "nlink", pWorker); /* Will make it's own copy */
/* uid, gid, rdev */
jx9_value_int(pWorker, (int)st.st_uid);
jx9_array_add_strkey_elem(pArray, "uid", pWorker);
jx9_value_int(pWorker, (int)st.st_gid);
jx9_array_add_strkey_elem(pArray, "gid", pWorker);
jx9_value_int(pWorker, (int)st.st_rdev);
jx9_array_add_strkey_elem(pArray, "rdev", pWorker);
/* size */
jx9_value_int64(pWorker, (jx9_int64)st.st_size);
jx9_array_add_strkey_elem(pArray, "size", pWorker); /* Will make it's own copy */
/* atime */
jx9_value_int64(pWorker, (jx9_int64)st.st_atime);
jx9_array_add_strkey_elem(pArray, "atime", pWorker); /* Will make it's own copy */
/* mtime */
jx9_value_int64(pWorker, (jx9_int64)st.st_mtime);
jx9_array_add_strkey_elem(pArray, "mtime", pWorker); /* Will make it's own copy */
/* ctime */
jx9_value_int64(pWorker, (jx9_int64)st.st_ctime);
jx9_array_add_strkey_elem(pArray, "ctime", pWorker); /* Will make it's own copy */
/* blksize, blocks */
jx9_value_int(pWorker, (int)st.st_blksize);
jx9_array_add_strkey_elem(pArray, "blksize", pWorker);
jx9_value_int(pWorker, (int)st.st_blocks);
jx9_array_add_strkey_elem(pArray, "blocks", pWorker);
return JX9_OK;
}
/* int (*xChmod)(const char *, int) */
static int UnixVfs_Chmod(const char *zPath, int mode)
{
int rc;
rc = chmod(zPath, (mode_t)mode);
return rc == 0 ? JX9_OK : - 1;
}
/* int (*xChown)(const char *, const char *) */
static int UnixVfs_Chown(const char *zPath, const char *zUser)
{
#ifndef JX9_UNIX_STATIC_BUILD
struct passwd *pwd;
uid_t uid;
int rc;
pwd = getpwnam(zUser); /* Try getting UID for username */
if (pwd == 0) {
return -1;
}
uid = pwd->pw_uid;
rc = chown(zPath, uid, -1);
return rc == 0 ? JX9_OK : -1;
#else
SXUNUSED(zPath);
SXUNUSED(zUser);
return -1;
#endif /* JX9_UNIX_STATIC_BUILD */
}
/* int (*xChgrp)(const char *, const char *) */
static int UnixVfs_Chgrp(const char *zPath, const char *zGroup)
{
#ifndef JX9_UNIX_STATIC_BUILD
struct group *group;
gid_t gid;
int rc;
group = getgrnam(zGroup);
if (group == 0) {
return -1;
}
gid = group->gr_gid;
rc = chown(zPath, -1, gid);
return rc == 0 ? JX9_OK : -1;
#else
SXUNUSED(zPath);
SXUNUSED(zGroup);
return -1;
#endif /* JX9_UNIX_STATIC_BUILD */
}
/* int (*xIsfile)(const char *) */
static int UnixVfs_isfile(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
rc = S_ISREG(st.st_mode);
return rc ? JX9_OK : -1 ;
}
/* int (*xIslink)(const char *) */
static int UnixVfs_islink(const char *zPath)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
return -1;
}
rc = S_ISLNK(st.st_mode);
return rc ? JX9_OK : -1 ;
}
/* int (*xReadable)(const char *) */
static int UnixVfs_isreadable(const char *zPath)
{
int rc;
rc = access(zPath, R_OK);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xWritable)(const char *) */
static int UnixVfs_iswritable(const char *zPath)
{
int rc;
rc = access(zPath, W_OK);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xExecutable)(const char *) */
static int UnixVfs_isexecutable(const char *zPath)
{
int rc;
rc = access(zPath, X_OK);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xFiletype)(const char *, jx9_context *) */
static int UnixVfs_Filetype(const char *zPath, jx9_context *pCtx)
{
struct stat st;
int rc;
rc = stat(zPath, &st);
if( rc != 0 ){
/* Expand 'unknown' */
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
return -1;
}
if(S_ISREG(st.st_mode) ){
jx9_result_string(pCtx, "file", sizeof("file")-1);
}else if(S_ISDIR(st.st_mode)){
jx9_result_string(pCtx, "dir", sizeof("dir")-1);
}else if(S_ISLNK(st.st_mode)){
jx9_result_string(pCtx, "link", sizeof("link")-1);
}else if(S_ISBLK(st.st_mode)){
jx9_result_string(pCtx, "block", sizeof("block")-1);
}else if(S_ISSOCK(st.st_mode)){
jx9_result_string(pCtx, "socket", sizeof("socket")-1);
}else if(S_ISFIFO(st.st_mode)){
jx9_result_string(pCtx, "fifo", sizeof("fifo")-1);
}else{
jx9_result_string(pCtx, "unknown", sizeof("unknown")-1);
}
return JX9_OK;
}
/* int (*xGetenv)(const char *, jx9_context *) */
static int UnixVfs_Getenv(const char *zVar, jx9_context *pCtx)
{
char *zEnv;
zEnv = getenv(zVar);
if( zEnv == 0 ){
return -1;
}
jx9_result_string(pCtx, zEnv, -1/*Compute length automatically*/);
return JX9_OK;
}
/* int (*xSetenv)(const char *, const char *) */
static int UnixVfs_Setenv(const char *zName, const char *zValue)
{
int rc;
rc = setenv(zName, zValue, 1);
return rc == 0 ? JX9_OK : -1;
}
/* int (*xMmap)(const char *, void **, jx9_int64 *) */
static int UnixVfs_Mmap(const char *zPath, void **ppMap, jx9_int64 *pSize)
{
struct stat st;
void *pMap;
int fd;
int rc;
/* Open the file in a read-only mode */
fd = open(zPath, O_RDONLY);
if( fd < 0 ){
return -1;
}
/* stat the handle */
fstat(fd, &st);
/* Obtain a memory view of the whole file */
pMap = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE|MAP_FILE, fd, 0);
rc = JX9_OK;
if( pMap == MAP_FAILED ){
rc = -1;
}else{
/* Point to the memory view */
*ppMap = pMap;
*pSize = (jx9_int64)st.st_size;
}
close(fd);
return rc;
}
/* void (*xUnmap)(void *, jx9_int64) */
static void UnixVfs_Unmap(void *pView, jx9_int64 nSize)
{
munmap(pView, (size_t)nSize);
}
/* void (*xTempDir)(jx9_context *) */
static void UnixVfs_TempDir(jx9_context *pCtx)
{
static const char *azDirs[] = {
"/var/tmp",
"/usr/tmp",
"/usr/local/tmp"
};
unsigned int i;
struct stat buf;
const char *zDir;
zDir = getenv("TMPDIR");
if( zDir && zDir[0] != 0 && !access(zDir, 07) ){
jx9_result_string(pCtx, zDir, -1);
return;
}
for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){
zDir=azDirs[i];
if( zDir==0 ) continue;
if( stat(zDir, &buf) ) continue;
if( !S_ISDIR(buf.st_mode) ) continue;
if( access(zDir, 07) ) continue;
/* Got one */
jx9_result_string(pCtx, zDir, -1);
return;
}
/* Default temp dir */
jx9_result_string(pCtx, "/tmp", (int)sizeof("/tmp")-1);
}
/* unsigned int (*xProcessId)(void) */
static unsigned int UnixVfs_ProcessId(void)
{
return (unsigned int)getpid();
}
/* int (*xUid)(void) */
static int UnixVfs_uid(void)
{
return (int)getuid();
}
/* int (*xGid)(void) */
static int UnixVfs_gid(void)
{
return (int)getgid();
}
/* int (*xUmask)(int) */
static int UnixVfs_Umask(int new_mask)
{
int old_mask;
old_mask = umask(new_mask);
return old_mask;
}
/* void (*xUsername)(jx9_context *) */
static void UnixVfs_Username(jx9_context *pCtx)
{
#ifndef JX9_UNIX_STATIC_BUILD
struct passwd *pwd;
uid_t uid;
uid = getuid();
pwd = getpwuid(uid); /* Try getting UID for username */
if (pwd == 0) {
return;
}
/* Return the username */
jx9_result_string(pCtx, pwd->pw_name, -1);
#else
jx9_result_string(pCtx, "Unknown", -1);
#endif /* JX9_UNIX_STATIC_BUILD */
return;
}
/* int (*xLink)(const char *, const char *, int) */
static int UnixVfs_link(const char *zSrc, const char *zTarget, int is_sym)
{
int rc;
if( is_sym ){
/* Symbolic link */
rc = symlink(zSrc, zTarget);
}else{
/* Hard link */
rc = link(zSrc, zTarget);
}
return rc == 0 ? JX9_OK : -1;
}
/* int (*xChroot)(const char *) */
static int UnixVfs_chroot(const char *zRootDir)
{
int rc;
rc = chroot(zRootDir);
return rc == 0 ? JX9_OK : -1;
}
/* Export the UNIX vfs */
static const jx9_vfs sUnixVfs = {
"Unix_vfs",
JX9_VFS_VERSION,
UnixVfs_chdir, /* int (*xChdir)(const char *) */
UnixVfs_chroot, /* int (*xChroot)(const char *); */
UnixVfs_getcwd, /* int (*xGetcwd)(jx9_context *) */
UnixVfs_mkdir, /* int (*xMkdir)(const char *, int, int) */
UnixVfs_rmdir, /* int (*xRmdir)(const char *) */
UnixVfs_isdir, /* int (*xIsdir)(const char *) */
UnixVfs_Rename, /* int (*xRename)(const char *, const char *) */
UnixVfs_Realpath, /*int (*xRealpath)(const char *, jx9_context *)*/
UnixVfs_Sleep, /* int (*xSleep)(unsigned int) */
UnixVfs_unlink, /* int (*xUnlink)(const char *) */
UnixVfs_FileExists, /* int (*xFileExists)(const char *) */
UnixVfs_Chmod, /*int (*xChmod)(const char *, int)*/
UnixVfs_Chown, /*int (*xChown)(const char *, const char *)*/
UnixVfs_Chgrp, /*int (*xChgrp)(const char *, const char *)*/
0, /* jx9_int64 (*xFreeSpace)(const char *) */
0, /* jx9_int64 (*xTotalSpace)(const char *) */
UnixVfs_FileSize, /* jx9_int64 (*xFileSize)(const char *) */
UnixVfs_FileAtime, /* jx9_int64 (*xFileAtime)(const char *) */
UnixVfs_FileMtime, /* jx9_int64 (*xFileMtime)(const char *) */
UnixVfs_FileCtime, /* jx9_int64 (*xFileCtime)(const char *) */
UnixVfs_Stat, /* int (*xStat)(const char *, jx9_value *, jx9_value *) */
UnixVfs_lStat, /* int (*xlStat)(const char *, jx9_value *, jx9_value *) */
UnixVfs_isfile, /* int (*xIsfile)(const char *) */
UnixVfs_islink, /* int (*xIslink)(const char *) */
UnixVfs_isreadable, /* int (*xReadable)(const char *) */
UnixVfs_iswritable, /* int (*xWritable)(const char *) */
UnixVfs_isexecutable, /* int (*xExecutable)(const char *) */
UnixVfs_Filetype, /* int (*xFiletype)(const char *, jx9_context *) */
UnixVfs_Getenv, /* int (*xGetenv)(const char *, jx9_context *) */
UnixVfs_Setenv, /* int (*xSetenv)(const char *, const char *) */
UnixVfs_Touch, /* int (*xTouch)(const char *, jx9_int64, jx9_int64) */
UnixVfs_Mmap, /* int (*xMmap)(const char *, void **, jx9_int64 *) */
UnixVfs_Unmap, /* void (*xUnmap)(void *, jx9_int64); */
UnixVfs_link, /* int (*xLink)(const char *, const char *, int) */
UnixVfs_Umask, /* int (*xUmask)(int) */
UnixVfs_TempDir, /* void (*xTempDir)(jx9_context *) */
UnixVfs_ProcessId, /* unsigned int (*xProcessId)(void) */
UnixVfs_uid, /* int (*xUid)(void) */
UnixVfs_gid, /* int (*xGid)(void) */
UnixVfs_Username, /* void (*xUsername)(jx9_context *) */
0 /* int (*xExec)(const char *, jx9_context *) */
};
/* UNIX File IO */
#define JX9_UNIX_OPEN_MODE 0640 /* Default open mode */
/* int (*xOpen)(const char *, int, jx9_value *, void **) */
static int UnixFile_Open(const char *zPath, int iOpenMode, jx9_value *pResource, void **ppHandle)
{
int iOpen = O_RDONLY;
int fd;
/* Set the desired flags according to the open mode */
if( iOpenMode & JX9_IO_OPEN_CREATE ){
/* Open existing file, or create if it doesn't exist */
iOpen = O_CREAT;
if( iOpenMode & JX9_IO_OPEN_TRUNC ){
/* If the specified file exists and is writable, the function overwrites the file */
iOpen |= O_TRUNC;
SXUNUSED(pResource); /* cc warning */
}
}else if( iOpenMode & JX9_IO_OPEN_EXCL ){
/* Creates a new file, only if it does not already exist.
* If the file exists, it fails.
*/
iOpen = O_CREAT|O_EXCL;
}else if( iOpenMode & JX9_IO_OPEN_TRUNC ){
/* Opens a file and truncates it so that its size is zero bytes
* The file must exist.
*/
iOpen = O_RDWR|O_TRUNC;
}
if( iOpenMode & JX9_IO_OPEN_RDWR ){
/* Read+Write access */
iOpen &= ~O_RDONLY;
iOpen |= O_RDWR;
}else if( iOpenMode & JX9_IO_OPEN_WRONLY ){
/* Write only access */
iOpen &= ~O_RDONLY;
iOpen |= O_WRONLY;
}
if( iOpenMode & JX9_IO_OPEN_APPEND ){
/* Append mode */
iOpen |= O_APPEND;
}
#ifdef O_TEMP
if( iOpenMode & JX9_IO_OPEN_TEMP ){
/* File is temporary */
iOpen |= O_TEMP;
}
#endif
/* Open the file now */
fd = open(zPath, iOpen, JX9_UNIX_OPEN_MODE);
if( fd < 0 ){
/* IO error */
return -1;
}
/* Save the handle */
*ppHandle = SX_INT_TO_PTR(fd);
return JX9_OK;
}
/* int (*xOpenDir)(const char *, jx9_value *, void **) */
static int UnixDir_Open(const char *zPath, jx9_value *pResource, void **ppHandle)
{
DIR *pDir;
/* Open the target directory */
pDir = opendir(zPath);
if( pDir == 0 ){
pResource = 0; /* Compiler warning */
return -1;
}
/* Save our structure */
*ppHandle = pDir;
return JX9_OK;
}
/* void (*xCloseDir)(void *) */
static void UnixDir_Close(void *pUserData)
{
closedir((DIR *)pUserData);
}
/* void (*xClose)(void *); */
static void UnixFile_Close(void *pUserData)
{
close(SX_PTR_TO_INT(pUserData));
}
/* int (*xReadDir)(void *, jx9_context *) */
static int UnixDir_Read(void *pUserData, jx9_context *pCtx)
{
DIR *pDir = (DIR *)pUserData;
struct dirent *pEntry;
char *zName = 0; /* cc warning */
sxu32 n = 0;
for(;;){
pEntry = readdir(pDir);
if( pEntry == 0 ){
/* No more entries to process */
return -1;
}
zName = pEntry->d_name;
n = SyStrlen(zName);
/* Ignore '.' && '..' */
if( n > sizeof("..")-1 || zName[0] != '.' || ( n == sizeof("..")-1 && zName[1] != '.') ){
break;
}
/* Next entry */
}
/* Return the current file name */
jx9_result_string(pCtx, zName, (int)n);
return JX9_OK;
}
/* void (*xRewindDir)(void *) */
static void UnixDir_Rewind(void *pUserData)
{
rewinddir((DIR *)pUserData);
}
/* jx9_int64 (*xRead)(void *, void *, jx9_int64); */
static jx9_int64 UnixFile_Read(void *pUserData, void *pBuffer, jx9_int64 nDatatoRead)
{
ssize_t nRd;
nRd = read(SX_PTR_TO_INT(pUserData), pBuffer, (size_t)nDatatoRead);
if( nRd < 1 ){
/* EOF or IO error */
return -1;
}
return (jx9_int64)nRd;
}
/* jx9_int64 (*xWrite)(void *, const void *, jx9_int64); */
static jx9_int64 UnixFile_Write(void *pUserData, const void *pBuffer, jx9_int64 nWrite)
{
const char *zData = (const char *)pBuffer;
int fd = SX_PTR_TO_INT(pUserData);
jx9_int64 nCount;
ssize_t nWr;
nCount = 0;
for(;;){
if( nWrite < 1 ){
break;
}
nWr = write(fd, zData, (size_t)nWrite);
if( nWr < 1 ){
/* IO error */
break;
}
nWrite -= nWr;
nCount += nWr;
zData += nWr;
}
if( nWrite > 0 ){
return -1;
}
return nCount;
}
/* int (*xSeek)(void *, jx9_int64, int) */
static int UnixFile_Seek(void *pUserData, jx9_int64 iOfft, int whence)
{
off_t iNew;
switch(whence){
case 1:/*SEEK_CUR*/
whence = SEEK_CUR;
break;
case 2: /* SEEK_END */
whence = SEEK_END;
break;
case 0: /* SEEK_SET */
default:
whence = SEEK_SET;
break;
}
iNew = lseek(SX_PTR_TO_INT(pUserData), (off_t)iOfft, whence);
if( iNew < 0 ){
return -1;
}
return JX9_OK;
}
/* int (*xLock)(void *, int) */
static int UnixFile_Lock(void *pUserData, int lock_type)
{
int fd = SX_PTR_TO_INT(pUserData);
int rc = JX9_OK; /* cc warning */
if( lock_type < 0 ){
/* Unlock the file */
rc = flock(fd, LOCK_UN);
}else{
if( lock_type == 1 ){
/* Exculsive lock */
rc = flock(fd, LOCK_EX);
}else{
/* Shared lock */
rc = flock(fd, LOCK_SH);
}
}
return !rc ? JX9_OK : -1;
}
/* jx9_int64 (*xTell)(void *) */
static jx9_int64 UnixFile_Tell(void *pUserData)
{
off_t iNew;
iNew = lseek(SX_PTR_TO_INT(pUserData), 0, SEEK_CUR);
return (jx9_int64)iNew;
}
/* int (*xTrunc)(void *, jx9_int64) */
static int UnixFile_Trunc(void *pUserData, jx9_int64 nOfft)
{
int rc;
rc = ftruncate(SX_PTR_TO_INT(pUserData), (off_t)nOfft);
if( rc != 0 ){
return -1;
}
return JX9_OK;
}
/* int (*xSync)(void *); */
static int UnixFile_Sync(void *pUserData)
{
int rc;
rc = fsync(SX_PTR_TO_INT(pUserData));
return rc == 0 ? JX9_OK : - 1;
}
/* int (*xStat)(void *, jx9_value *, jx9_value *) */
static int UnixFile_Stat(void *pUserData, jx9_value *pArray, jx9_value *pWorker)
{
struct stat st;
int rc;
rc = fstat(SX_PTR_TO_INT(pUserData), &st);
if( rc != 0 ){
return -1;
}
/* dev */
jx9_value_int64(pWorker, (jx9_int64)st.st_dev);
jx9_array_add_strkey_elem(pArray, "dev", pWorker); /* Will make it's own copy */
/* ino */
jx9_value_int64(pWorker, (jx9_int64)st.st_ino);
jx9_array_add_strkey_elem(pArray, "ino", pWorker); /* Will make it's own copy */
/* mode */
jx9_value_int(pWorker, (int)st.st_mode);
jx9_array_add_strkey_elem(pArray, "mode", pWorker);
/* nlink */
jx9_value_int(pWorker, (int)st.st_nlink);
jx9_array_add_strkey_elem(pArray, "nlink", pWorker); /* Will make it's own copy */
/* uid, gid, rdev */
jx9_value_int(pWorker, (int)st.st_uid);
jx9_array_add_strkey_elem(pArray, "uid", pWorker);
jx9_value_int(pWorker, (int)st.st_gid);
jx9_array_add_strkey_elem(pArray, "gid", pWorker);
jx9_value_int(pWorker, (int)st.st_rdev);
jx9_array_add_strkey_elem(pArray, "rdev", pWorker);
/* size */
jx9_value_int64(pWorker, (jx9_int64)st.st_size);
jx9_array_add_strkey_elem(pArray, "size", pWorker); /* Will make it's own copy */
/* atime */
jx9_value_int64(pWorker, (jx9_int64)st.st_atime);
jx9_array_add_strkey_elem(pArray, "atime", pWorker); /* Will make it's own copy */
/* mtime */
jx9_value_int64(pWorker, (jx9_int64)st.st_mtime);
jx9_array_add_strkey_elem(pArray, "mtime", pWorker); /* Will make it's own copy */
/* ctime */
jx9_value_int64(pWorker, (jx9_int64)st.st_ctime);
jx9_array_add_strkey_elem(pArray, "ctime", pWorker); /* Will make it's own copy */
/* blksize, blocks */
jx9_value_int(pWorker, (int)st.st_blksize);
jx9_array_add_strkey_elem(pArray, "blksize", pWorker);
jx9_value_int(pWorker, (int)st.st_blocks);
jx9_array_add_strkey_elem(pArray, "blocks", pWorker);
return JX9_OK;
}
/* Export the file:// stream */
static const jx9_io_stream sUnixFileStream = {
"file", /* Stream name */
JX9_IO_STREAM_VERSION,
UnixFile_Open, /* xOpen */
UnixDir_Open, /* xOpenDir */
UnixFile_Close, /* xClose */
UnixDir_Close, /* xCloseDir */
UnixFile_Read, /* xRead */
UnixDir_Read, /* xReadDir */
UnixFile_Write, /* xWrite */
UnixFile_Seek, /* xSeek */
UnixFile_Lock, /* xLock */
UnixDir_Rewind, /* xRewindDir */
UnixFile_Tell, /* xTell */
UnixFile_Trunc, /* xTrunc */
UnixFile_Sync, /* xSeek */
UnixFile_Stat /* xStat */
};
#endif /* __WINNT__/__UNIXES__ */
#endif /* JX9_DISABLE_DISK_IO */
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/*
* Export the builtin vfs.
* Return a pointer to the builtin vfs if available.
* Otherwise return the null_vfs [i.e: a no-op vfs] instead.
* Note:
* The built-in vfs is always available for Windows/UNIX systems.
* Note:
* If the engine is compiled with the JX9_DISABLE_DISK_IO/JX9_DISABLE_BUILTIN_FUNC
* directives defined then this function return the null_vfs instead.
*/
JX9_PRIVATE const jx9_vfs * jx9ExportBuiltinVfs(void)
{
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifdef JX9_DISABLE_DISK_IO
return &null_vfs;
#else
#ifdef __WINNT__
return &sWinVfs;
#elif defined(__UNIXES__)
return &sUnixVfs;
#else
return &null_vfs;
#endif /* __WINNT__/__UNIXES__ */
#endif /*JX9_DISABLE_DISK_IO*/
#else
return &null_vfs;
#endif /* JX9_DISABLE_BUILTIN_FUNC */
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_DISK_IO
/*
* The following defines are mostly used by the UNIX built and have
* no particular meaning on windows.
*/
#ifndef STDIN_FILENO
#define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
#define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
#define STDERR_FILENO 2
#endif
/*
* jx9:// Accessing various I/O streams
* According to the JX9 langage reference manual
* JX9 provides a number of miscellaneous I/O streams that allow access to JX9's own input
* and output streams, the standard input, output and error file descriptors.
* jx9://stdin, jx9://stdout and jx9://stderr:
* Allow direct access to the corresponding input or output stream of the JX9 process.
* The stream references a duplicate file descriptor, so if you open jx9://stdin and later
* close it, you close only your copy of the descriptor-the actual stream referenced by STDIN is unaffected.
* jx9://stdin is read-only, whereas jx9://stdout and jx9://stderr are write-only.
* jx9://output
* jx9://output is a write-only stream that allows you to write to the output buffer
* mechanism in the same way as print and print.
*/
typedef struct jx9_stream_data jx9_stream_data;
/* Supported IO streams */
#define JX9_IO_STREAM_STDIN 1 /* jx9://stdin */
#define JX9_IO_STREAM_STDOUT 2 /* jx9://stdout */
#define JX9_IO_STREAM_STDERR 3 /* jx9://stderr */
#define JX9_IO_STREAM_OUTPUT 4 /* jx9://output */
/* The following structure is the private data associated with the jx9:// stream */
struct jx9_stream_data
{
jx9_vm *pVm; /* VM that own this instance */
int iType; /* Stream type */
union{
void *pHandle; /* Stream handle */
jx9_output_consumer sConsumer; /* VM output consumer */
}x;
};
/*
* Allocate a new instance of the jx9_stream_data structure.
*/
static jx9_stream_data * JX9StreamDataInit(jx9_vm *pVm, int iType)
{
jx9_stream_data *pData;
if( pVm == 0 ){
return 0;
}
/* Allocate a new instance */
pData = (jx9_stream_data *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(jx9_stream_data));
if( pData == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pData, sizeof(jx9_stream_data));
/* Initialize fields */
pData->iType = iType;
if( iType == JX9_IO_STREAM_OUTPUT ){
/* Point to the default VM consumer routine. */
pData->x.sConsumer = pVm->sVmConsumer;
}else{
#ifdef __WINNT__
DWORD nChannel;
switch(iType){
case JX9_IO_STREAM_STDOUT: nChannel = STD_OUTPUT_HANDLE; break;
case JX9_IO_STREAM_STDERR: nChannel = STD_ERROR_HANDLE; break;
default:
nChannel = STD_INPUT_HANDLE;
break;
}
pData->x.pHandle = GetStdHandle(nChannel);
#else
/* Assume an UNIX system */
int ifd = STDIN_FILENO;
switch(iType){
case JX9_IO_STREAM_STDOUT: ifd = STDOUT_FILENO; break;
case JX9_IO_STREAM_STDERR: ifd = STDERR_FILENO; break;
default:
break;
}
pData->x.pHandle = SX_INT_TO_PTR(ifd);
#endif
}
pData->pVm = pVm;
return pData;
}
/*
* Implementation of the jx9:// IO streams routines
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/* int (*xOpen)(const char *, int, jx9_value *, void **) */
static int JX9StreamData_Open(const char *zName, int iMode, jx9_value *pResource, void ** ppHandle)
{
jx9_stream_data *pData;
SyString sStream;
SyStringInitFromBuf(&sStream, zName, SyStrlen(zName));
/* Trim leading and trailing white spaces */
SyStringFullTrim(&sStream);
/* Stream to open */
if( SyStrnicmp(sStream.zString, "stdin", sizeof("stdin")-1) == 0 ){
iMode = JX9_IO_STREAM_STDIN;
}else if( SyStrnicmp(sStream.zString, "output", sizeof("output")-1) == 0 ){
iMode = JX9_IO_STREAM_OUTPUT;
}else if( SyStrnicmp(sStream.zString, "stdout", sizeof("stdout")-1) == 0 ){
iMode = JX9_IO_STREAM_STDOUT;
}else if( SyStrnicmp(sStream.zString, "stderr", sizeof("stderr")-1) == 0 ){
iMode = JX9_IO_STREAM_STDERR;
}else{
/* unknown stream name */
return -1;
}
/* Create our handle */
pData = JX9StreamDataInit(pResource?pResource->pVm:0, iMode);
if( pData == 0 ){
return -1;
}
/* Make the handle public */
*ppHandle = (void *)pData;
return JX9_OK;
}
/* jx9_int64 (*xRead)(void *, void *, jx9_int64) */
static jx9_int64 JX9StreamData_Read(void *pHandle, void *pBuffer, jx9_int64 nDatatoRead)
{
jx9_stream_data *pData = (jx9_stream_data *)pHandle;
if( pData == 0 ){
return -1;
}
if( pData->iType != JX9_IO_STREAM_STDIN ){
/* Forbidden */
return -1;
}
#ifdef __WINNT__
{
DWORD nRd;
BOOL rc;
rc = ReadFile(pData->x.pHandle, pBuffer, (DWORD)nDatatoRead, &nRd, 0);
if( !rc ){
/* IO error */
return -1;
}
return (jx9_int64)nRd;
}
#elif defined(__UNIXES__)
{
ssize_t nRd;
int fd;
fd = SX_PTR_TO_INT(pData->x.pHandle);
nRd = read(fd, pBuffer, (size_t)nDatatoRead);
if( nRd < 1 ){
return -1;
}
return (jx9_int64)nRd;
}
#else
return -1;
#endif
}
/* jx9_int64 (*xWrite)(void *, const void *, jx9_int64) */
static jx9_int64 JX9StreamData_Write(void *pHandle, const void *pBuf, jx9_int64 nWrite)
{
jx9_stream_data *pData = (jx9_stream_data *)pHandle;
if( pData == 0 ){
return -1;
}
if( pData->iType == JX9_IO_STREAM_STDIN ){
/* Forbidden */
return -1;
}else if( pData->iType == JX9_IO_STREAM_OUTPUT ){
jx9_output_consumer *pCons = &pData->x.sConsumer;
int rc;
/* Call the vm output consumer */
rc = pCons->xConsumer(pBuf, (unsigned int)nWrite, pCons->pUserData);
if( rc == JX9_ABORT ){
return -1;
}
return nWrite;
}
#ifdef __WINNT__
{
DWORD nWr;
BOOL rc;
rc = WriteFile(pData->x.pHandle, pBuf, (DWORD)nWrite, &nWr, 0);
if( !rc ){
/* IO error */
return -1;
}
return (jx9_int64)nWr;
}
#elif defined(__UNIXES__)
{
ssize_t nWr;
int fd;
fd = SX_PTR_TO_INT(pData->x.pHandle);
nWr = write(fd, pBuf, (size_t)nWrite);
if( nWr < 1 ){
return -1;
}
return (jx9_int64)nWr;
}
#else
return -1;
#endif
}
/* void (*xClose)(void *) */
static void JX9StreamData_Close(void *pHandle)
{
jx9_stream_data *pData = (jx9_stream_data *)pHandle;
jx9_vm *pVm;
if( pData == 0 ){
return;
}
pVm = pData->pVm;
/* Free the instance */
SyMemBackendFree(&pVm->sAllocator, pData);
}
/* Export the jx9:// stream */
static const jx9_io_stream sjx9Stream = {
"jx9",
JX9_IO_STREAM_VERSION,
JX9StreamData_Open, /* xOpen */
0, /* xOpenDir */
JX9StreamData_Close, /* xClose */
0, /* xCloseDir */
JX9StreamData_Read, /* xRead */
0, /* xReadDir */
JX9StreamData_Write, /* xWrite */
0, /* xSeek */
0, /* xLock */
0, /* xRewindDir */
0, /* xTell */
0, /* xTrunc */
0, /* xSeek */
0 /* xStat */
};
#endif /* JX9_DISABLE_DISK_IO */
/*
* Return TRUE if we are dealing with the jx9:// stream.
* FALSE otherwise.
*/
static int is_jx9_stream(const jx9_io_stream *pStream)
{
#ifndef JX9_DISABLE_DISK_IO
return pStream == &sjx9Stream;
#else
SXUNUSED(pStream); /* cc warning */
return 0;
#endif /* JX9_DISABLE_DISK_IO */
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/*
* Export the IO routines defined above and the built-in IO streams
* [i.e: file://, jx9://].
* Note:
* If the engine is compiled with the JX9_DISABLE_BUILTIN_FUNC directive
* defined then this function is a no-op.
*/
JX9_PRIVATE sxi32 jx9RegisterIORoutine(jx9_vm *pVm)
{
#ifndef JX9_DISABLE_BUILTIN_FUNC
/* VFS functions */
static const jx9_builtin_func aVfsFunc[] = {
{"chdir", jx9Vfs_chdir },
{"chroot", jx9Vfs_chroot },
{"getcwd", jx9Vfs_getcwd },
{"rmdir", jx9Vfs_rmdir },
{"is_dir", jx9Vfs_is_dir },
{"mkdir", jx9Vfs_mkdir },
{"rename", jx9Vfs_rename },
{"realpath", jx9Vfs_realpath},
{"sleep", jx9Vfs_sleep },
{"usleep", jx9Vfs_usleep },
{"unlink", jx9Vfs_unlink },
{"delete", jx9Vfs_unlink },
{"chmod", jx9Vfs_chmod },
{"chown", jx9Vfs_chown },
{"chgrp", jx9Vfs_chgrp },
{"disk_free_space", jx9Vfs_disk_free_space },
{"disk_total_space", jx9Vfs_disk_total_space},
{"file_exists", jx9Vfs_file_exists },
{"filesize", jx9Vfs_file_size },
{"fileatime", jx9Vfs_file_atime },
{"filemtime", jx9Vfs_file_mtime },
{"filectime", jx9Vfs_file_ctime },
{"is_file", jx9Vfs_is_file },
{"is_link", jx9Vfs_is_link },
{"is_readable", jx9Vfs_is_readable },
{"is_writable", jx9Vfs_is_writable },
{"is_executable", jx9Vfs_is_executable},
{"filetype", jx9Vfs_filetype },
{"stat", jx9Vfs_stat },
{"lstat", jx9Vfs_lstat },
{"getenv", jx9Vfs_getenv },
{"setenv", jx9Vfs_putenv },
{"putenv", jx9Vfs_putenv },
{"touch", jx9Vfs_touch },
{"link", jx9Vfs_link },
{"symlink", jx9Vfs_symlink },
{"umask", jx9Vfs_umask },
{"sys_get_temp_dir", jx9Vfs_sys_get_temp_dir },
{"get_current_user", jx9Vfs_get_current_user },
{"getpid", jx9Vfs_getmypid },
{"getuid", jx9Vfs_getmyuid },
{"getgid", jx9Vfs_getmygid },
{"uname", jx9Vfs_uname},
/* Path processing */
{"dirname", jx9Builtin_dirname },
{"basename", jx9Builtin_basename },
{"pathinfo", jx9Builtin_pathinfo },
{"strglob", jx9Builtin_strglob },
{"fnmatch", jx9Builtin_fnmatch },
/* ZIP processing */
{"zip_open", jx9Builtin_zip_open },
{"zip_close", jx9Builtin_zip_close},
{"zip_read", jx9Builtin_zip_read },
{"zip_entry_open", jx9Builtin_zip_entry_open },
{"zip_entry_close", jx9Builtin_zip_entry_close},
{"zip_entry_name", jx9Builtin_zip_entry_name },
{"zip_entry_filesize", jx9Builtin_zip_entry_filesize },
{"zip_entry_compressedsize", jx9Builtin_zip_entry_compressedsize },
{"zip_entry_read", jx9Builtin_zip_entry_read },
{"zip_entry_reset_cursor", jx9Builtin_zip_entry_reset_cursor},
{"zip_entry_compressionmethod", jx9Builtin_zip_entry_compressionmethod}
};
/* IO stream functions */
static const jx9_builtin_func aIOFunc[] = {
{"ftruncate", jx9Builtin_ftruncate },
{"fseek", jx9Builtin_fseek },
{"ftell", jx9Builtin_ftell },
{"rewind", jx9Builtin_rewind },
{"fflush", jx9Builtin_fflush },
{"feof", jx9Builtin_feof },
{"fgetc", jx9Builtin_fgetc },
{"fgets", jx9Builtin_fgets },
{"fread", jx9Builtin_fread },
{"fgetcsv", jx9Builtin_fgetcsv},
{"fgetss", jx9Builtin_fgetss },
{"readdir", jx9Builtin_readdir},
{"rewinddir", jx9Builtin_rewinddir },
{"closedir", jx9Builtin_closedir},
{"opendir", jx9Builtin_opendir },
{"readfile", jx9Builtin_readfile},
{"file_get_contents", jx9Builtin_file_get_contents},
{"file_put_contents", jx9Builtin_file_put_contents},
{"file", jx9Builtin_file },
{"copy", jx9Builtin_copy },
{"fstat", jx9Builtin_fstat },
{"fwrite", jx9Builtin_fwrite },
{"fputs", jx9Builtin_fwrite },
{"flock", jx9Builtin_flock },
{"fclose", jx9Builtin_fclose },
{"fopen", jx9Builtin_fopen },
{"fpassthru", jx9Builtin_fpassthru },
{"fputcsv", jx9Builtin_fputcsv },
{"fprintf", jx9Builtin_fprintf },
#if !defined(JX9_DISABLE_HASH_FUNC)
{"md5_file", jx9Builtin_md5_file},
{"sha1_file", jx9Builtin_sha1_file},
#endif /* JX9_DISABLE_HASH_FUNC */
{"parse_ini_file", jx9Builtin_parse_ini_file},
{"vfprintf", jx9Builtin_vfprintf}
};
const jx9_io_stream *pFileStream = 0;
sxu32 n = 0;
/* Register the functions defined above */
for( n = 0 ; n < SX_ARRAYSIZE(aVfsFunc) ; ++n ){
jx9_create_function(&(*pVm), aVfsFunc[n].zName, aVfsFunc[n].xFunc, (void *)pVm->pEngine->pVfs);
}
for( n = 0 ; n < SX_ARRAYSIZE(aIOFunc) ; ++n ){
jx9_create_function(&(*pVm), aIOFunc[n].zName, aIOFunc[n].xFunc, pVm);
}
#ifndef JX9_DISABLE_DISK_IO
/* Register the file stream if available */
#ifdef __WINNT__
pFileStream = &sWinFileStream;
#elif defined(__UNIXES__)
pFileStream = &sUnixFileStream;
#endif
/* Install the jx9:// stream */
jx9_vm_config(pVm, JX9_VM_CONFIG_IO_STREAM, &sjx9Stream);
#endif /* JX9_DISABLE_DISK_IO */
if( pFileStream ){
/* Install the file:// stream */
jx9_vm_config(pVm, JX9_VM_CONFIG_IO_STREAM, pFileStream);
}
#else
SXUNUSED(pVm); /* cc warning */
#endif /* JX9_DISABLE_BUILTIN_FUNC */
return SXRET_OK;
}
/*
* Export the STDIN handle.
*/
JX9_PRIVATE void * jx9ExportStdin(jx9_vm *pVm)
{
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_DISK_IO
if( pVm->pStdin == 0 ){
io_private *pIn;
/* Allocate an IO private instance */
pIn = (io_private *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(io_private));
if( pIn == 0 ){
return 0;
}
InitIOPrivate(pVm, &sjx9Stream, pIn);
/* Initialize the handle */
pIn->pHandle = JX9StreamDataInit(pVm, JX9_IO_STREAM_STDIN);
/* Install the STDIN stream */
pVm->pStdin = pIn;
return pIn;
}else{
/* NULL or STDIN */
return pVm->pStdin;
}
#else
return 0;
#endif
#else
SXUNUSED(pVm); /* cc warning */
return 0;
#endif
}
/*
* Export the STDOUT handle.
*/
JX9_PRIVATE void * jx9ExportStdout(jx9_vm *pVm)
{
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_DISK_IO
if( pVm->pStdout == 0 ){
io_private *pOut;
/* Allocate an IO private instance */
pOut = (io_private *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(io_private));
if( pOut == 0 ){
return 0;
}
InitIOPrivate(pVm, &sjx9Stream, pOut);
/* Initialize the handle */
pOut->pHandle = JX9StreamDataInit(pVm, JX9_IO_STREAM_STDOUT);
/* Install the STDOUT stream */
pVm->pStdout = pOut;
return pOut;
}else{
/* NULL or STDOUT */
return pVm->pStdout;
}
#else
return 0;
#endif
#else
SXUNUSED(pVm); /* cc warning */
return 0;
#endif
}
/*
* Export the STDERR handle.
*/
JX9_PRIVATE void * jx9ExportStderr(jx9_vm *pVm)
{
#ifndef JX9_DISABLE_BUILTIN_FUNC
#ifndef JX9_DISABLE_DISK_IO
if( pVm->pStderr == 0 ){
io_private *pErr;
/* Allocate an IO private instance */
pErr = (io_private *)SyMemBackendAlloc(&pVm->sAllocator, sizeof(io_private));
if( pErr == 0 ){
return 0;
}
InitIOPrivate(pVm, &sjx9Stream, pErr);
/* Initialize the handle */
pErr->pHandle = JX9StreamDataInit(pVm, JX9_IO_STREAM_STDERR);
/* Install the STDERR stream */
pVm->pStderr = pErr;
return pErr;
}else{
/* NULL or STDERR */
return pVm->pStderr;
}
#else
return 0;
#endif
#else
SXUNUSED(pVm); /* cc warning */
return 0;
#endif
}
/*
* ----------------------------------------------------------
* File: jx9_vm.c
* MD5: beca4be65a9a49c932c356d7680034c9
* ----------------------------------------------------------
*/
/*
* Symisc JX9: A Highly Efficient Embeddable Scripting Engine Based on JSON.
* Copyright (C) 2012-2013, Symisc Systems http://jx9.symisc.net/
* Version 1.7.2
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://jx9.symisc.net/
*/
/* $SymiscID: jx9_vm.c v1.0 FreeBSD 2012-12-09 00:19 stable <chm@symisc.net> $ */
#ifndef JX9_AMALGAMATION
#include "jx9Int.h"
#endif
/*
* The code in this file implements execution method of the JX9 Virtual Machine.
* The JX9 compiler (implemented in 'compiler.c' and 'parse.c') generates a bytecode program
* which is then executed by the virtual machine implemented here to do the work of the JX9
* statements.
* JX9 bytecode programs are similar in form to assembly language. The program consists
* of a linear sequence of operations .Each operation has an opcode and 3 operands.
* Operands P1 and P2 are integers where the first is signed while the second is unsigned.
* Operand P3 is an arbitrary pointer specific to each instruction. The P2 operand is usually
* the jump destination used by the OP_JMP, OP_JZ, OP_JNZ, ... instructions.
* Opcodes will typically ignore one or more operands. Many opcodes ignore all three operands.
* Computation results are stored on a stack. Each entry on the stack is of type jx9_value.
* JX9 uses the jx9_value object to represent all values that can be stored in a JX9 variable.
* Since JX9 uses dynamic typing for the values it stores. Values stored in jx9_value objects
* can be integers, floating point values, strings, arrays, object instances (object in the JX9 jargon)
* and so on.
* Internally, the JX9 virtual machine manipulates nearly all values as jx9_values structures.
* Each jx9_value may cache multiple representations(string, integer etc.) of the same value.
* An implicit conversion from one type to the other occurs as necessary.
* Most of the code in this file is taken up by the [VmByteCodeExec()] function which does
* the work of interpreting a JX9 bytecode program. But other routines are also provided
* to help in building up a program instruction by instruction.
*/
/*
* Each active virtual machine frame is represented by an instance
* of the following structure.
* VM Frame hold local variables and other stuff related to function call.
*/
struct VmFrame
{
VmFrame *pParent; /* Parent frame or NULL if global scope */
void *pUserData; /* Upper layer private data associated with this frame */
SySet sLocal; /* Local variables container (VmSlot instance) */
jx9_vm *pVm; /* VM that own this frame */
SyHash hVar; /* Variable hashtable for fast lookup */
SySet sArg; /* Function arguments container */
sxi32 iFlags; /* Frame configuration flags (See below)*/
sxu32 iExceptionJump; /* Exception jump destination */
};
/*
* When a user defined variable is garbage collected, memory object index
* is stored in an instance of the following structure and put in the free object
* table so that it can be reused again without allocating a new memory object.
*/
typedef struct VmSlot VmSlot;
struct VmSlot
{
sxu32 nIdx; /* Index in pVm->aMemObj[] */
void *pUserData; /* Upper-layer private data */
};
/*
* Each parsed URI is recorded and stored in an instance of the following structure.
* This structure and it's related routines are taken verbatim from the xHT project
* [A modern embeddable HTTP engine implementing all the RFC2616 methods]
* the xHT project is developed internally by Symisc Systems.
*/
typedef struct SyhttpUri SyhttpUri;
struct SyhttpUri
{
SyString sHost; /* Hostname or IP address */
SyString sPort; /* Port number */
SyString sPath; /* Mandatory resource path passed verbatim (Not decoded) */
SyString sQuery; /* Query part */
SyString sFragment; /* Fragment part */
SyString sScheme; /* Scheme */
SyString sUser; /* Username */
SyString sPass; /* Password */
SyString sRaw; /* Raw URI */
};
/*
* An instance of the following structure is used to record all MIME headers seen
* during a HTTP interaction.
* This structure and it's related routines are taken verbatim from the xHT project
* [A modern embeddable HTTP engine implementing all the RFC2616 methods]
* the xHT project is developed internally by Symisc Systems.
*/
typedef struct SyhttpHeader SyhttpHeader;
struct SyhttpHeader
{
SyString sName; /* Header name [i.e:"Content-Type", "Host", "User-Agent"]. NOT NUL TERMINATED */
SyString sValue; /* Header values [i.e: "text/html"]. NOT NUL TERMINATED */
};
/*
* Supported HTTP methods.
*/
#define HTTP_METHOD_GET 1 /* GET */
#define HTTP_METHOD_HEAD 2 /* HEAD */
#define HTTP_METHOD_POST 3 /* POST */
#define HTTP_METHOD_PUT 4 /* PUT */
#define HTTP_METHOD_OTHR 5 /* Other HTTP methods [i.e: DELETE, TRACE, OPTIONS...]*/
/*
* Supported HTTP protocol version.
*/
#define HTTP_PROTO_10 1 /* HTTP/1.0 */
#define HTTP_PROTO_11 2 /* HTTP/1.1 */
/*
* Register a constant and it's associated expansion callback so that
* it can be expanded from the target JX9 program.
* The constant expansion mechanism under JX9 is extremely powerful yet
* simple and work as follows:
* Each registered constant have a C procedure associated with it.
* This procedure known as the constant expansion callback is responsible
* of expanding the invoked constant to the desired value, for example:
* The C procedure associated with the "__PI__" constant expands to 3.14 (the value of PI).
* The "__OS__" constant procedure expands to the name of the host Operating Systems
* (Windows, Linux, ...) and so on.
* Please refer to the official documentation for additional information.
*/
JX9_PRIVATE sxi32 jx9VmRegisterConstant(
jx9_vm *pVm, /* Target VM */
const SyString *pName, /* Constant name */
ProcConstant xExpand, /* Constant expansion callback */
void *pUserData /* Last argument to xExpand() */
)
{
jx9_constant *pCons;
SyHashEntry *pEntry;
char *zDupName;
sxi32 rc;
pEntry = SyHashGet(&pVm->hConstant, (const void *)pName->zString, pName->nByte);
if( pEntry ){
/* Overwrite the old definition and return immediately */
pCons = (jx9_constant *)pEntry->pUserData;
pCons->xExpand = xExpand;
pCons->pUserData = pUserData;
return SXRET_OK;
}
/* Allocate a new constant instance */
pCons = (jx9_constant *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_constant));
if( pCons == 0 ){
return 0;
}
/* Duplicate constant name */
zDupName = SyMemBackendStrDup(&pVm->sAllocator, pName->zString, pName->nByte);
if( zDupName == 0 ){
SyMemBackendPoolFree(&pVm->sAllocator, pCons);
return 0;
}
/* Install the constant */
SyStringInitFromBuf(&pCons->sName, zDupName, pName->nByte);
pCons->xExpand = xExpand;
pCons->pUserData = pUserData;
rc = SyHashInsert(&pVm->hConstant, (const void *)zDupName, SyStringLength(&pCons->sName), pCons);
if( rc != SXRET_OK ){
SyMemBackendFree(&pVm->sAllocator, zDupName);
SyMemBackendPoolFree(&pVm->sAllocator, pCons);
return rc;
}
/* All done, constant can be invoked from JX9 code */
return SXRET_OK;
}
/*
* Allocate a new foreign function instance.
* This function return SXRET_OK on success. Any other
* return value indicates failure.
* Please refer to the official documentation for an introduction to
* the foreign function mechanism.
*/
static sxi32 jx9NewForeignFunction(
jx9_vm *pVm, /* Target VM */
const SyString *pName, /* Foreign function name */
ProcHostFunction xFunc, /* Foreign function implementation */
void *pUserData, /* Foreign function private data */
jx9_user_func **ppOut /* OUT: VM image of the foreign function */
)
{
jx9_user_func *pFunc;
char *zDup;
/* Allocate a new user function */
pFunc = (jx9_user_func *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_user_func));
if( pFunc == 0 ){
return SXERR_MEM;
}
/* Duplicate function name */
zDup = SyMemBackendStrDup(&pVm->sAllocator, pName->zString, pName->nByte);
if( zDup == 0 ){
SyMemBackendPoolFree(&pVm->sAllocator, pFunc);
return SXERR_MEM;
}
/* Zero the structure */
SyZero(pFunc, sizeof(jx9_user_func));
/* Initialize structure fields */
SyStringInitFromBuf(&pFunc->sName, zDup, pName->nByte);
pFunc->pVm = pVm;
pFunc->xFunc = xFunc;
pFunc->pUserData = pUserData;
SySetInit(&pFunc->aAux, &pVm->sAllocator, sizeof(jx9_aux_data));
/* Write a pointer to the new function */
*ppOut = pFunc;
return SXRET_OK;
}
/*
* Install a foreign function and it's associated callback so that
* it can be invoked from the target JX9 code.
* This function return SXRET_OK on successful registration. Any other
* return value indicates failure.
* Please refer to the official documentation for an introduction to
* the foreign function mechanism.
*/
JX9_PRIVATE sxi32 jx9VmInstallForeignFunction(
jx9_vm *pVm, /* Target VM */
const SyString *pName, /* Foreign function name */
ProcHostFunction xFunc, /* Foreign function implementation */
void *pUserData /* Foreign function private data */
)
{
jx9_user_func *pFunc;
SyHashEntry *pEntry;
sxi32 rc;
/* Overwrite any previously registered function with the same name */
pEntry = SyHashGet(&pVm->hHostFunction, pName->zString, pName->nByte);
if( pEntry ){
pFunc = (jx9_user_func *)pEntry->pUserData;
pFunc->pUserData = pUserData;
pFunc->xFunc = xFunc;
SySetReset(&pFunc->aAux);
return SXRET_OK;
}
/* Create a new user function */
rc = jx9NewForeignFunction(&(*pVm), &(*pName), xFunc, pUserData, &pFunc);
if( rc != SXRET_OK ){
return rc;
}
/* Install the function in the corresponding hashtable */
rc = SyHashInsert(&pVm->hHostFunction, SyStringData(&pFunc->sName), pName->nByte, pFunc);
if( rc != SXRET_OK ){
SyMemBackendFree(&pVm->sAllocator, (void *)SyStringData(&pFunc->sName));
SyMemBackendPoolFree(&pVm->sAllocator, pFunc);
return rc;
}
/* User function successfully installed */
return SXRET_OK;
}
/*
* Initialize a VM function.
*/
JX9_PRIVATE sxi32 jx9VmInitFuncState(
jx9_vm *pVm, /* Target VM */
jx9_vm_func *pFunc, /* Target Fucntion */
const char *zName, /* Function name */
sxu32 nByte, /* zName length */
sxi32 iFlags, /* Configuration flags */
void *pUserData /* Function private data */
)
{
/* Zero the structure */
SyZero(pFunc, sizeof(jx9_vm_func));
/* Initialize structure fields */
/* Arguments container */
SySetInit(&pFunc->aArgs, &pVm->sAllocator, sizeof(jx9_vm_func_arg));
/* Static variable container */
SySetInit(&pFunc->aStatic, &pVm->sAllocator, sizeof(jx9_vm_func_static_var));
/* Bytecode container */
SySetInit(&pFunc->aByteCode, &pVm->sAllocator, sizeof(VmInstr));
/* Preallocate some instruction slots */
SySetAlloc(&pFunc->aByteCode, 0x10);
pFunc->iFlags = iFlags;
pFunc->pUserData = pUserData;
SyStringInitFromBuf(&pFunc->sName, zName, nByte);
return SXRET_OK;
}
/*
* Install a user defined function in the corresponding VM container.
*/
JX9_PRIVATE sxi32 jx9VmInstallUserFunction(
jx9_vm *pVm, /* Target VM */
jx9_vm_func *pFunc, /* Target function */
SyString *pName /* Function name */
)
{
SyHashEntry *pEntry;
sxi32 rc;
if( pName == 0 ){
/* Use the built-in name */
pName = &pFunc->sName;
}
/* Check for duplicates (functions with the same name) first */
pEntry = SyHashGet(&pVm->hFunction, pName->zString, pName->nByte);
if( pEntry ){
jx9_vm_func *pLink = (jx9_vm_func *)pEntry->pUserData;
if( pLink != pFunc ){
/* Link */
pFunc->pNextName = pLink;
pEntry->pUserData = pFunc;
}
return SXRET_OK;
}
/* First time seen */
pFunc->pNextName = 0;
rc = SyHashInsert(&pVm->hFunction, pName->zString, pName->nByte, pFunc);
return rc;
}
/*
* Instruction builder interface.
*/
JX9_PRIVATE sxi32 jx9VmEmitInstr(
jx9_vm *pVm, /* Target VM */
sxi32 iOp, /* Operation to perform */
sxi32 iP1, /* First operand */
sxu32 iP2, /* Second operand */
void *p3, /* Third operand */
sxu32 *pIndex /* Instruction index. NULL otherwise */
)
{
VmInstr sInstr;
sxi32 rc;
/* Fill the VM instruction */
sInstr.iOp = (sxu8)iOp;
sInstr.iP1 = iP1;
sInstr.iP2 = iP2;
sInstr.p3 = p3;
if( pIndex ){
/* Instruction index in the bytecode array */
*pIndex = SySetUsed(pVm->pByteContainer);
}
/* Finally, record the instruction */
rc = SySetPut(pVm->pByteContainer, (const void *)&sInstr);
if( rc != SXRET_OK ){
jx9GenCompileError(&pVm->sCodeGen, E_ERROR, 1, "Fatal, Cannot emit instruction due to a memory failure");
/* Fall throw */
}
return rc;
}
/*
* Swap the current bytecode container with the given one.
*/
JX9_PRIVATE sxi32 jx9VmSetByteCodeContainer(jx9_vm *pVm, SySet *pContainer)
{
if( pContainer == 0 ){
/* Point to the default container */
pVm->pByteContainer = &pVm->aByteCode;
}else{
/* Change container */
pVm->pByteContainer = &(*pContainer);
}
return SXRET_OK;
}
/*
* Return the current bytecode container.
*/
JX9_PRIVATE SySet * jx9VmGetByteCodeContainer(jx9_vm *pVm)
{
return pVm->pByteContainer;
}
/*
* Extract the VM instruction rooted at nIndex.
*/
JX9_PRIVATE VmInstr * jx9VmGetInstr(jx9_vm *pVm, sxu32 nIndex)
{
VmInstr *pInstr;
pInstr = (VmInstr *)SySetAt(pVm->pByteContainer, nIndex);
return pInstr;
}
/*
* Return the total number of VM instructions recorded so far.
*/
JX9_PRIVATE sxu32 jx9VmInstrLength(jx9_vm *pVm)
{
return SySetUsed(pVm->pByteContainer);
}
/*
* Pop the last VM instruction.
*/
JX9_PRIVATE VmInstr * jx9VmPopInstr(jx9_vm *pVm)
{
return (VmInstr *)SySetPop(pVm->pByteContainer);
}
/*
* Peek the last VM instruction.
*/
JX9_PRIVATE VmInstr * jx9VmPeekInstr(jx9_vm *pVm)
{
return (VmInstr *)SySetPeek(pVm->pByteContainer);
}
/*
* Allocate a new virtual machine frame.
*/
static VmFrame * VmNewFrame(
jx9_vm *pVm, /* Target VM */
void *pUserData /* Upper-layer private data */
)
{
VmFrame *pFrame;
/* Allocate a new vm frame */
pFrame = (VmFrame *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(VmFrame));
if( pFrame == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pFrame, sizeof(VmFrame));
/* Initialize frame fields */
pFrame->pUserData = pUserData;
pFrame->pVm = pVm;
SyHashInit(&pFrame->hVar, &pVm->sAllocator, 0, 0);
SySetInit(&pFrame->sArg, &pVm->sAllocator, sizeof(VmSlot));
SySetInit(&pFrame->sLocal, &pVm->sAllocator, sizeof(VmSlot));
return pFrame;
}
/*
* Enter a VM frame.
*/
static sxi32 VmEnterFrame(
jx9_vm *pVm, /* Target VM */
void *pUserData, /* Upper-layer private data */
VmFrame **ppFrame /* OUT: Top most active frame */
)
{
VmFrame *pFrame;
/* Allocate a new frame */
pFrame = VmNewFrame(&(*pVm), pUserData);
if( pFrame == 0 ){
return SXERR_MEM;
}
/* Link to the list of active VM frame */
pFrame->pParent = pVm->pFrame;
pVm->pFrame = pFrame;
if( ppFrame ){
/* Write a pointer to the new VM frame */
*ppFrame = pFrame;
}
return SXRET_OK;
}
/*
* Link a foreign variable with the TOP most active frame.
* Refer to the JX9_OP_UPLINK instruction implementation for more
* information.
*/
static sxi32 VmFrameLink(jx9_vm *pVm,SyString *pName)
{
VmFrame *pTarget, *pFrame;
SyHashEntry *pEntry = 0;
sxi32 rc;
/* Point to the upper frame */
pFrame = pVm->pFrame;
pTarget = pFrame;
pFrame = pTarget->pParent;
while( pFrame ){
/* Query the current frame */
pEntry = SyHashGet(&pFrame->hVar, (const void *)pName->zString, pName->nByte);
if( pEntry ){
/* Variable found */
break;
}
/* Point to the upper frame */
pFrame = pFrame->pParent;
}
if( pEntry == 0 ){
/* Inexistant variable */
return SXERR_NOTFOUND;
}
/* Link to the current frame */
rc = SyHashInsert(&pTarget->hVar, pEntry->pKey, pEntry->nKeyLen, pEntry->pUserData);
return rc;
}
/*
* Leave the top-most active frame.
*/
static void VmLeaveFrame(jx9_vm *pVm)
{
VmFrame *pFrame = pVm->pFrame;
if( pFrame ){
/* Unlink from the list of active VM frame */
pVm->pFrame = pFrame->pParent;
if( pFrame->pParent ){
VmSlot *aSlot;
sxu32 n;
/* Restore local variable to the free pool so that they can be reused again */
aSlot = (VmSlot *)SySetBasePtr(&pFrame->sLocal);
for(n = 0 ; n < SySetUsed(&pFrame->sLocal) ; ++n ){
/* Unset the local variable */
jx9VmUnsetMemObj(&(*pVm), aSlot[n].nIdx);
}
}
/* Release internal containers */
SyHashRelease(&pFrame->hVar);
SySetRelease(&pFrame->sArg);
SySetRelease(&pFrame->sLocal);
/* Release the whole structure */
SyMemBackendPoolFree(&pVm->sAllocator, pFrame);
}
}
/*
* Compare two functions signature and return the comparison result.
*/
static int VmOverloadCompare(SyString *pFirst, SyString *pSecond)
{
const char *zSend = &pSecond->zString[pSecond->nByte];
const char *zFend = &pFirst->zString[pFirst->nByte];
const char *zSin = pSecond->zString;
const char *zFin = pFirst->zString;
const char *zPtr = zFin;
for(;;){
if( zFin >= zFend || zSin >= zSend ){
break;
}
if( zFin[0] != zSin[0] ){
/* mismatch */
break;
}
zFin++;
zSin++;
}
return (int)(zFin-zPtr);
}
/*
* Select the appropriate VM function for the current call context.
* This is the implementation of the powerful 'function overloading' feature
* introduced by the version 2 of the JX9 engine.
* Refer to the official documentation for more information.
*/
static jx9_vm_func * VmOverload(
jx9_vm *pVm, /* Target VM */
jx9_vm_func *pList, /* Linked list of candidates for overloading */
jx9_value *aArg, /* Array of passed arguments */
int nArg /* Total number of passed arguments */
)
{
int iTarget, i, j, iCur, iMax;
jx9_vm_func *apSet[10]; /* Maximum number of candidates */
jx9_vm_func *pLink;
SyString sArgSig;
SyBlob sSig;
pLink = pList;
i = 0;
/* Put functions expecting the same number of passed arguments */
while( i < (int)SX_ARRAYSIZE(apSet) ){
if( pLink == 0 ){
break;
}
if( (int)SySetUsed(&pLink->aArgs) == nArg ){
/* Candidate for overloading */
apSet[i++] = pLink;
}
/* Point to the next entry */
pLink = pLink->pNextName;
}
if( i < 1 ){
/* No candidates, return the head of the list */
return pList;
}
if( nArg < 1 || i < 2 ){
/* Return the only candidate */
return apSet[0];
}
/* Calculate function signature */
SyBlobInit(&sSig, &pVm->sAllocator);
for( j = 0 ; j < nArg ; j++ ){
int c = 'n'; /* null */
if( aArg[j].iFlags & MEMOBJ_HASHMAP ){
/* Hashmap */
c = 'h';
}else if( aArg[j].iFlags & MEMOBJ_BOOL ){
/* bool */
c = 'b';
}else if( aArg[j].iFlags & MEMOBJ_INT ){
/* int */
c = 'i';
}else if( aArg[j].iFlags & MEMOBJ_STRING ){
/* String */
c = 's';
}else if( aArg[j].iFlags & MEMOBJ_REAL ){
/* Float */
c = 'f';
}
if( c > 0 ){
SyBlobAppend(&sSig, (const void *)&c, sizeof(char));
}
}
SyStringInitFromBuf(&sArgSig, SyBlobData(&sSig), SyBlobLength(&sSig));
iTarget = 0;
iMax = -1;
/* Select the appropriate function */
for( j = 0 ; j < i ; j++ ){
/* Compare the two signatures */
iCur = VmOverloadCompare(&sArgSig, &apSet[j]->sSignature);
if( iCur > iMax ){
iMax = iCur;
iTarget = j;
}
}
SyBlobRelease(&sSig);
/* Appropriate function for the current call context */
return apSet[iTarget];
}
/*
* Dummy read-only buffer used for slot reservation.
*/
static const char zDummy[sizeof(jx9_value)] = { 0 }; /* Must be >= sizeof(jx9_value) */
/*
* Reserve a constant memory object.
* Return a pointer to the raw jx9_value on success. NULL on failure.
*/
JX9_PRIVATE jx9_value * jx9VmReserveConstObj(jx9_vm *pVm, sxu32 *pIndex)
{
jx9_value *pObj;
sxi32 rc;
if( pIndex ){
/* Object index in the object table */
*pIndex = SySetUsed(&pVm->aLitObj);
}
/* Reserve a slot for the new object */
rc = SySetPut(&pVm->aLitObj, (const void *)zDummy);
if( rc != SXRET_OK ){
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here.
*/
return 0;
}
pObj = (jx9_value *)SySetPeek(&pVm->aLitObj);
return pObj;
}
/*
* Reserve a memory object.
* Return a pointer to the raw jx9_value on success. NULL on failure.
*/
static jx9_value * VmReserveMemObj(jx9_vm *pVm, sxu32 *pIndex)
{
jx9_value *pObj;
sxi32 rc;
if( pIndex ){
/* Object index in the object table */
*pIndex = SySetUsed(&pVm->aMemObj);
}
/* Reserve a slot for the new object */
rc = SySetPut(&pVm->aMemObj, (const void *)zDummy);
if( rc != SXRET_OK ){
/* If the supplied memory subsystem is so sick that we are unable to allocate
* a tiny chunk of memory, there is no much we can do here.
*/
return 0;
}
pObj = (jx9_value *)SySetPeek(&pVm->aMemObj);
return pObj;
}
/* Forward declaration */
static sxi32 VmEvalChunk(jx9_vm *pVm, jx9_context *pCtx, SyString *pChunk, int iFlags, int bTrueReturn);
/*
* Built-in functions that cannot be implemented directly as foreign functions.
*/
#define JX9_BUILTIN_LIB \
"function scandir(string $directory, int $sort_order = SCANDIR_SORT_ASCENDING)"\
"{"\
" if( func_num_args() < 1 ){ return FALSE; }"\
" $aDir = [];"\
" $pHandle = opendir($directory);"\
" if( $pHandle == FALSE ){ return FALSE; }"\
" while(FALSE !== ($pEntry = readdir($pHandle)) ){"\
" $aDir[] = $pEntry;"\
" }"\
" closedir($pHandle);"\
" if( $sort_order == SCANDIR_SORT_DESCENDING ){"\
" rsort($aDir);"\
" }else if( $sort_order == SCANDIR_SORT_ASCENDING ){"\
" sort($aDir);"\
" }"\
" return $aDir;"\
"}"\
"function glob(string $pattern, int $iFlags = 0){"\
"/* Open the target directory */"\
"$zDir = dirname($pattern);"\
"if(!is_string($zDir) ){ $zDir = './'; }"\
"$pHandle = opendir($zDir);"\
"if( $pHandle == FALSE ){"\
" /* IO error while opening the current directory, return FALSE */"\
" return FALSE;"\
"}"\
"$pattern = basename($pattern);"\
"$pArray = []; /* Empty array */"\
"/* Loop throw available entries */"\
"while( FALSE !== ($pEntry = readdir($pHandle)) ){"\
" /* Use the built-in strglob function which is a Symisc eXtension for wildcard comparison*/"\
" $rc = strglob($pattern, $pEntry);"\
" if( $rc ){"\
" if( is_dir($pEntry) ){"\
" if( $iFlags & GLOB_MARK ){"\
" /* Adds a slash to each directory returned */"\
" $pEntry .= DIRECTORY_SEPARATOR;"\
" }"\
" }else if( $iFlags & GLOB_ONLYDIR ){"\
" /* Not a directory, ignore */"\
" continue;"\
" }"\
" /* Add the entry */"\
" $pArray[] = $pEntry;"\
" }"\
" }"\
"/* Close the handle */"\
"closedir($pHandle);"\
"if( ($iFlags & GLOB_NOSORT) == 0 ){"\
" /* Sort the array */"\
" sort($pArray);"\
"}"\
"if( ($iFlags & GLOB_NOCHECK) && sizeof($pArray) < 1 ){"\
" /* Return the search pattern if no files matching were found */"\
" $pArray[] = $pattern;"\
"}"\
"/* Return the created array */"\
"return $pArray;"\
"}"\
"/* Creates a temporary file */"\
"function tmpfile(){"\
" /* Extract the temp directory */"\
" $zTempDir = sys_get_temp_dir();"\
" if( strlen($zTempDir) < 1 ){"\
" /* Use the current dir */"\
" $zTempDir = '.';"\
" }"\
" /* Create the file */"\
" $pHandle = fopen($zTempDir.DIRECTORY_SEPARATOR.'JX9'.rand_str(12), 'w+');"\
" return $pHandle;"\
"}"\
"/* Creates a temporary filename */"\
"function tempnam(string $zDir = sys_get_temp_dir() /* Symisc eXtension */, string $zPrefix = 'JX9')"\
"{"\
" return $zDir.DIRECTORY_SEPARATOR.$zPrefix.rand_str(12);"\
"}"\
"function max(){"\
" $pArgs = func_get_args();"\
" if( sizeof($pArgs) < 1 ){"\
" return null;"\
" }"\
" if( sizeof($pArgs) < 2 ){"\
" $pArg = $pArgs[0];"\
" if( !is_array($pArg) ){"\
" return $pArg; "\
" }"\
" if( sizeof($pArg) < 1 ){"\
" return null;"\
" }"\
" $pArg = array_copy($pArgs[0]);"\
" reset($pArg);"\
" $max = current($pArg);"\
" while( FALSE !== ($val = next($pArg)) ){"\
" if( $val > $max ){"\
" $max = $val;"\
" }"\
" }"\
" return $max;"\
" }"\
" $max = $pArgs[0];"\
" for( $i = 1; $i < sizeof($pArgs) ; ++$i ){"\
" $val = $pArgs[$i];"\
"if( $val > $max ){"\
" $max = $val;"\
"}"\
" }"\
" return $max;"\
"}"\
"function min(){"\
" $pArgs = func_get_args();"\
" if( sizeof($pArgs) < 1 ){"\
" return null;"\
" }"\
" if( sizeof($pArgs) < 2 ){"\
" $pArg = $pArgs[0];"\
" if( !is_array($pArg) ){"\
" return $pArg; "\
" }"\
" if( sizeof($pArg) < 1 ){"\
" return null;"\
" }"\
" $pArg = array_copy($pArgs[0]);"\
" reset($pArg);"\
" $min = current($pArg);"\
" while( FALSE !== ($val = next($pArg)) ){"\
" if( $val < $min ){"\
" $min = $val;"\
" }"\
" }"\
" return $min;"\
" }"\
" $min = $pArgs[0];"\
" for( $i = 1; $i < sizeof($pArgs) ; ++$i ){"\
" $val = $pArgs[$i];"\
"if( $val < $min ){"\
" $min = $val;"\
" }"\
" }"\
" return $min;"\
"}"
/*
* Initialize a freshly allocated JX9 Virtual Machine so that we can
* start compiling the target JX9 program.
*/
JX9_PRIVATE sxi32 jx9VmInit(
jx9_vm *pVm, /* Initialize this */
jx9 *pEngine /* Master engine */
)
{
SyString sBuiltin;
jx9_value *pObj;
sxi32 rc;
/* Zero the structure */
SyZero(pVm, sizeof(jx9_vm));
/* Initialize VM fields */
pVm->pEngine = &(*pEngine);
SyMemBackendInitFromParent(&pVm->sAllocator, &pEngine->sAllocator);
/* Instructions containers */
SySetInit(&pVm->aByteCode, &pVm->sAllocator, sizeof(VmInstr));
SySetAlloc(&pVm->aByteCode, 0xFF);
pVm->pByteContainer = &pVm->aByteCode;
/* Object containers */
SySetInit(&pVm->aMemObj, &pVm->sAllocator, sizeof(jx9_value));
SySetAlloc(&pVm->aMemObj, 0xFF);
/* Virtual machine internal containers */
SyBlobInit(&pVm->sConsumer, &pVm->sAllocator);
SyBlobInit(&pVm->sWorker, &pVm->sAllocator);
SyBlobInit(&pVm->sArgv, &pVm->sAllocator);
SySetInit(&pVm->aLitObj, &pVm->sAllocator, sizeof(jx9_value));
SySetAlloc(&pVm->aLitObj, 0xFF);
SyHashInit(&pVm->hHostFunction, &pVm->sAllocator, 0, 0);
SyHashInit(&pVm->hFunction, &pVm->sAllocator, 0, 0);
SyHashInit(&pVm->hConstant, &pVm->sAllocator, 0, 0);
SyHashInit(&pVm->hSuper, &pVm->sAllocator, 0, 0);
SySetInit(&pVm->aFreeObj, &pVm->sAllocator, sizeof(VmSlot));
/* Configuration containers */
SySetInit(&pVm->aFiles, &pVm->sAllocator, sizeof(SyString));
SySetInit(&pVm->aPaths, &pVm->sAllocator, sizeof(SyString));
SySetInit(&pVm->aIncluded, &pVm->sAllocator, sizeof(SyString));
SySetInit(&pVm->aIOstream, &pVm->sAllocator, sizeof(jx9_io_stream *));
/* Error callbacks containers */
jx9MemObjInit(&(*pVm), &pVm->sAssertCallback);
/* Set a default recursion limit */
#if defined(__WINNT__) || defined(__UNIXES__)
pVm->nMaxDepth = 32;
#else
pVm->nMaxDepth = 16;
#endif
/* Default assertion flags */
pVm->iAssertFlags = JX9_ASSERT_WARNING; /* Issue a warning for each failed assertion */
/* PRNG context */
SyRandomnessInit(&pVm->sPrng, 0, 0);
/* Install the null constant */
pObj = jx9VmReserveConstObj(&(*pVm), 0);
if( pObj == 0 ){
rc = SXERR_MEM;
goto Err;
}
jx9MemObjInit(pVm, pObj);
/* Install the boolean TRUE constant */
pObj = jx9VmReserveConstObj(&(*pVm), 0);
if( pObj == 0 ){
rc = SXERR_MEM;
goto Err;
}
jx9MemObjInitFromBool(pVm, pObj, 1);
/* Install the boolean FALSE constant */
pObj = jx9VmReserveConstObj(&(*pVm), 0);
if( pObj == 0 ){
rc = SXERR_MEM;
goto Err;
}
jx9MemObjInitFromBool(pVm, pObj, 0);
/* Create the global frame */
rc = VmEnterFrame(&(*pVm), 0, 0);
if( rc != SXRET_OK ){
goto Err;
}
/* Initialize the code generator */
rc = jx9InitCodeGenerator(pVm, pEngine->xConf.xErr, pEngine->xConf.pErrData);
if( rc != SXRET_OK ){
goto Err;
}
/* VM correctly initialized, set the magic number */
pVm->nMagic = JX9_VM_INIT;
SyStringInitFromBuf(&sBuiltin,JX9_BUILTIN_LIB, sizeof(JX9_BUILTIN_LIB)-1);
/* Compile the built-in library */
VmEvalChunk(&(*pVm), 0, &sBuiltin, 0, FALSE);
/* Reset the code generator */
jx9ResetCodeGenerator(&(*pVm), pEngine->xConf.xErr, pEngine->xConf.pErrData);
return SXRET_OK;
Err:
SyMemBackendRelease(&pVm->sAllocator);
return rc;
}
/*
* Default VM output consumer callback.That is, all VM output is redirected to this
* routine which store the output in an internal blob.
* The output can be extracted later after program execution [jx9_vm_exec()] via
* the [jx9_vm_config()] interface with a configuration verb set to
* jx9VM_CONFIG_EXTRACT_OUTPUT.
* Refer to the official docurmentation for additional information.
* Note that for performance reason it's preferable to install a VM output
* consumer callback via (jx9VM_CONFIG_OUTPUT) rather than waiting for the VM
* to finish executing and extracting the output.
*/
JX9_PRIVATE sxi32 jx9VmBlobConsumer(
const void *pOut, /* VM Generated output*/
unsigned int nLen, /* Generated output length */
void *pUserData /* User private data */
)
{
sxi32 rc;
/* Store the output in an internal BLOB */
rc = SyBlobAppend((SyBlob *)pUserData, pOut, nLen);
return rc;
}
#define VM_STACK_GUARD 16
/*
* Allocate a new operand stack so that we can start executing
* our compiled JX9 program.
* Return a pointer to the operand stack (array of jx9_values)
* on success. NULL (Fatal error) on failure.
*/
static jx9_value * VmNewOperandStack(
jx9_vm *pVm, /* Target VM */
sxu32 nInstr /* Total numer of generated bytecode instructions */
)
{
jx9_value *pStack;
/* No instruction ever pushes more than a single element onto the
** stack and the stack never grows on successive executions of the
** same loop. So the total number of instructions is an upper bound
** on the maximum stack depth required.
**
** Allocation all the stack space we will ever need.
*/
nInstr += VM_STACK_GUARD;
pStack = (jx9_value *)SyMemBackendAlloc(&pVm->sAllocator, nInstr * sizeof(jx9_value));
if( pStack == 0 ){
return 0;
}
/* Initialize the operand stack */
while( nInstr > 0 ){
jx9MemObjInit(&(*pVm), &pStack[nInstr - 1]);
--nInstr;
}
/* Ready for bytecode execution */
return pStack;
}
/* Forward declaration */
static sxi32 VmRegisterSpecialFunction(jx9_vm *pVm);
/*
* Prepare the Virtual Machine for bytecode execution.
* This routine gets called by the JX9 engine after
* successful compilation of the target JX9 program.
*/
JX9_PRIVATE sxi32 jx9VmMakeReady(
jx9_vm *pVm /* Target VM */
)
{
sxi32 rc;
if( pVm->nMagic != JX9_VM_INIT ){
/* Initialize your VM first */
return SXERR_CORRUPT;
}
/* Mark the VM ready for bytecode execution */
pVm->nMagic = JX9_VM_RUN;
/* Release the code generator now we have compiled our program */
jx9ResetCodeGenerator(pVm, 0, 0);
/* Emit the DONE instruction */
rc = jx9VmEmitInstr(&(*pVm), JX9_OP_DONE, 0, 0, 0, 0);
if( rc != SXRET_OK ){
return SXERR_MEM;
}
/* Script return value */
jx9MemObjInit(&(*pVm), &pVm->sExec); /* Assume a NULL return value */
/* Allocate a new operand stack */
pVm->aOps = VmNewOperandStack(&(*pVm), SySetUsed(pVm->pByteContainer));
if( pVm->aOps == 0 ){
return SXERR_MEM;
}
/* Set the default VM output consumer callback and it's
* private data. */
pVm->sVmConsumer.xConsumer = jx9VmBlobConsumer;
pVm->sVmConsumer.pUserData = &pVm->sConsumer;
/* Register special functions first [i.e: print, func_get_args(), die, etc.] */
rc = VmRegisterSpecialFunction(&(*pVm));
if( rc != SXRET_OK ){
/* Don't worry about freeing memory, everything will be released shortly */
return rc;
}
/* Create superglobals [i.e: $GLOBALS, $_GET, $_POST...] */
rc = jx9HashmapLoadBuiltin(&(*pVm));
if( rc != SXRET_OK ){
/* Don't worry about freeing memory, everything will be released shortly */
return rc;
}
/* Register built-in constants [i.e: JX9_EOL, JX9_OS...] */
jx9RegisterBuiltInConstant(&(*pVm));
/* Register built-in functions [i.e: is_null(), array_diff(), strlen(), etc.] */
jx9RegisterBuiltInFunction(&(*pVm));
/* VM is ready for bytecode execution */
return SXRET_OK;
}
/*
* Reset a Virtual Machine to it's initial state.
*/
JX9_PRIVATE sxi32 jx9VmReset(jx9_vm *pVm)
{
if( pVm->nMagic != JX9_VM_RUN && pVm->nMagic != JX9_VM_EXEC ){
return SXERR_CORRUPT;
}
/* TICKET 1433-003: As of this version, the VM is automatically reset */
SyBlobReset(&pVm->sConsumer);
jx9MemObjRelease(&pVm->sExec);
/* Set the ready flag */
pVm->nMagic = JX9_VM_RUN;
return SXRET_OK;
}
/*
* Release a Virtual Machine.
* Every virtual machine must be destroyed in order to avoid memory leaks.
*/
JX9_PRIVATE sxi32 jx9VmRelease(jx9_vm *pVm)
{
/* Set the stale magic number */
pVm->nMagic = JX9_VM_STALE;
/* Release the private memory subsystem */
SyMemBackendRelease(&pVm->sAllocator);
return SXRET_OK;
}
/*
* Initialize a foreign function call context.
* The context in which a foreign function executes is stored in a jx9_context object.
* A pointer to a jx9_context object is always first parameter to application-defined foreign
* functions.
* The application-defined foreign function implementation will pass this pointer through into
* calls to dozens of interfaces, these includes jx9_result_int(), jx9_result_string(), jx9_result_value(),
* jx9_context_new_scalar(), jx9_context_alloc_chunk(), jx9_context_output(), jx9_context_throw_error()
* and many more. Refer to the C/C++ Interfaces documentation for additional information.
*/
static sxi32 VmInitCallContext(
jx9_context *pOut, /* Call Context */
jx9_vm *pVm, /* Target VM */
jx9_user_func *pFunc, /* Foreign function to execute shortly */
jx9_value *pRet, /* Store return value here*/
sxi32 iFlags /* Control flags */
)
{
pOut->pFunc = pFunc;
pOut->pVm = pVm;
SySetInit(&pOut->sVar, &pVm->sAllocator, sizeof(jx9_value *));
SySetInit(&pOut->sChunk, &pVm->sAllocator, sizeof(jx9_aux_data));
/* Assume a null return value */
MemObjSetType(pRet, MEMOBJ_NULL);
pOut->pRet = pRet;
pOut->iFlags = iFlags;
return SXRET_OK;
}
/*
* Release a foreign function call context and cleanup the mess
* left behind.
*/
static void VmReleaseCallContext(jx9_context *pCtx)
{
sxu32 n;
if( SySetUsed(&pCtx->sVar) > 0 ){
jx9_value **apObj = (jx9_value **)SySetBasePtr(&pCtx->sVar);
for( n = 0 ; n < SySetUsed(&pCtx->sVar) ; ++n ){
if( apObj[n] == 0 ){
/* Already released */
continue;
}
jx9MemObjRelease(apObj[n]);
SyMemBackendPoolFree(&pCtx->pVm->sAllocator, apObj[n]);
}
SySetRelease(&pCtx->sVar);
}
if( SySetUsed(&pCtx->sChunk) > 0 ){
jx9_aux_data *aAux;
void *pChunk;
/* Automatic release of dynamically allocated chunk
* using [jx9_context_alloc_chunk()].
*/
aAux = (jx9_aux_data *)SySetBasePtr(&pCtx->sChunk);
for( n = 0; n < SySetUsed(&pCtx->sChunk) ; ++n ){
pChunk = aAux[n].pAuxData;
/* Release the chunk */
if( pChunk ){
SyMemBackendFree(&pCtx->pVm->sAllocator, pChunk);
}
}
SySetRelease(&pCtx->sChunk);
}
}
/*
* Release a jx9_value allocated from the body of a foreign function.
* Refer to [jx9_context_release_value()] for additional information.
*/
JX9_PRIVATE void jx9VmReleaseContextValue(
jx9_context *pCtx, /* Call context */
jx9_value *pValue /* Release this value */
)
{
if( pValue == 0 ){
/* NULL value is a harmless operation */
return;
}
if( SySetUsed(&pCtx->sVar) > 0 ){
jx9_value **apObj = (jx9_value **)SySetBasePtr(&pCtx->sVar);
sxu32 n;
for( n = 0 ; n < SySetUsed(&pCtx->sVar) ; ++n ){
if( apObj[n] == pValue ){
jx9MemObjRelease(pValue);
SyMemBackendPoolFree(&pCtx->pVm->sAllocator, pValue);
/* Mark as released */
apObj[n] = 0;
break;
}
}
}
}
/*
* Pop and release as many memory object from the operand stack.
*/
static void VmPopOperand(
jx9_value **ppTos, /* Operand stack */
sxi32 nPop /* Total number of memory objects to pop */
)
{
jx9_value *pTos = *ppTos;
while( nPop > 0 ){
jx9MemObjRelease(pTos);
pTos--;
nPop--;
}
/* Top of the stack */
*ppTos = pTos;
}
/*
* Reserve a memory object.
* Return a pointer to the raw jx9_value on success. NULL on failure.
*/
JX9_PRIVATE jx9_value * jx9VmReserveMemObj(jx9_vm *pVm,sxu32 *pIdx)
{
jx9_value *pObj = 0;
VmSlot *pSlot;
sxu32 nIdx;
/* Check for a free slot */
nIdx = SXU32_HIGH; /* cc warning */
pSlot = (VmSlot *)SySetPop(&pVm->aFreeObj);
if( pSlot ){
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pSlot->nIdx);
nIdx = pSlot->nIdx;
}
if( pObj == 0 ){
/* Reserve a new memory object */
pObj = VmReserveMemObj(&(*pVm), &nIdx);
if( pObj == 0 ){
return 0;
}
}
/* Set a null default value */
jx9MemObjInit(&(*pVm), pObj);
if( pIdx ){
*pIdx = nIdx;
}
pObj->nIdx = nIdx;
return pObj;
}
/*
* Extract a variable value from the top active VM frame.
* Return a pointer to the variable value on success.
* NULL otherwise (non-existent variable/Out-of-memory, ...).
*/
static jx9_value * VmExtractMemObj(
jx9_vm *pVm, /* Target VM */
const SyString *pName, /* Variable name */
int bDup, /* True to duplicate variable name */
int bCreate /* True to create the variable if non-existent */
)
{
int bNullify = FALSE;
SyHashEntry *pEntry;
VmFrame *pFrame;
jx9_value *pObj;
sxu32 nIdx;
sxi32 rc;
/* Point to the top active frame */
pFrame = pVm->pFrame;
/* Perform the lookup */
if( pName == 0 || pName->nByte < 1 ){
static const SyString sAnnon = { " " , sizeof(char) };
pName = &sAnnon;
/* Always nullify the object */
bNullify = TRUE;
bDup = FALSE;
}
/* Check the superglobals table first */
pEntry = SyHashGet(&pVm->hSuper, (const void *)pName->zString, pName->nByte);
if( pEntry == 0 ){
/* Query the top active frame */
pEntry = SyHashGet(&pFrame->hVar, (const void *)pName->zString, pName->nByte);
if( pEntry == 0 ){
char *zName = (char *)pName->zString;
VmSlot sLocal;
if( !bCreate ){
/* Do not create the variable, return NULL */
return 0;
}
/* No such variable, automatically create a new one and install
* it in the current frame.
*/
pObj = jx9VmReserveMemObj(&(*pVm),&nIdx);
if( pObj == 0 ){
return 0;
}
if( bDup ){
/* Duplicate name */
zName = SyMemBackendStrDup(&pVm->sAllocator, pName->zString, pName->nByte);
if( zName == 0 ){
return 0;
}
}
/* Link to the top active VM frame */
rc = SyHashInsert(&pFrame->hVar, zName, pName->nByte, SX_INT_TO_PTR(nIdx));
if( rc != SXRET_OK ){
/* Return the slot to the free pool */
sLocal.nIdx = nIdx;
sLocal.pUserData = 0;
SySetPut(&pVm->aFreeObj, (const void *)&sLocal);
return 0;
}
if( pFrame->pParent != 0 ){
/* Local variable */
sLocal.nIdx = nIdx;
SySetPut(&pFrame->sLocal, (const void *)&sLocal);
}
}else{
/* Extract variable contents */
nIdx = (sxu32)SX_PTR_TO_INT(pEntry->pUserData);
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
if( bNullify && pObj ){
jx9MemObjRelease(pObj);
}
}
}else{
/* Superglobal */
nIdx = (sxu32)SX_PTR_TO_INT(pEntry->pUserData);
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
}
return pObj;
}
/*
* Extract a superglobal variable such as $_GET, $_POST, $_HEADERS, ....
* Return a pointer to the variable value on success.NULL otherwise.
*/
static jx9_value * VmExtractSuper(
jx9_vm *pVm, /* Target VM */
const char *zName, /* Superglobal name: NOT NULL TERMINATED */
sxu32 nByte /* zName length */
)
{
SyHashEntry *pEntry;
jx9_value *pValue;
sxu32 nIdx;
/* Query the superglobal table */
pEntry = SyHashGet(&pVm->hSuper, (const void *)zName, nByte);
if( pEntry == 0 ){
/* No such entry */
return 0;
}
/* Extract the superglobal index in the global object pool */
nIdx = SX_PTR_TO_INT(pEntry->pUserData);
/* Extract the variable value */
pValue = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
return pValue;
}
/*
* Perform a raw hashmap insertion.
* Refer to the [jx9VmConfigure()] implementation for additional information.
*/
static sxi32 VmHashmapInsert(
jx9_hashmap *pMap, /* Target hashmap */
const char *zKey, /* Entry key */
int nKeylen, /* zKey length*/
const char *zData, /* Entry data */
int nLen /* zData length */
)
{
jx9_value sKey,sValue;
jx9_value *pKey;
sxi32 rc;
pKey = 0;
jx9MemObjInit(pMap->pVm, &sKey);
jx9MemObjInitFromString(pMap->pVm, &sValue, 0);
if( zKey ){
if( nKeylen < 0 ){
nKeylen = (int)SyStrlen(zKey);
}
jx9MemObjStringAppend(&sKey, zKey, (sxu32)nKeylen);
pKey = &sKey;
}
if( zData ){
if( nLen < 0 ){
/* Compute length automatically */
nLen = (int)SyStrlen(zData);
}
jx9MemObjStringAppend(&sValue, zData, (sxu32)nLen);
}
/* Perform the insertion */
rc = jx9HashmapInsert(&(*pMap),pKey,&sValue);
jx9MemObjRelease(&sKey);
jx9MemObjRelease(&sValue);
return rc;
}
/* Forward declaration */
static sxi32 VmHttpProcessRequest(jx9_vm *pVm, const char *zRequest, int nByte);
/*
* Configure a working virtual machine instance.
*
* This routine is used to configure a JX9 virtual machine obtained by a prior
* successful call to one of the compile interface such as jx9_compile()
* jx9_compile_v2() or jx9_compile_file().
* The second argument to this function is an integer configuration option
* that determines what property of the JX9 virtual machine is to be configured.
* Subsequent arguments vary depending on the configuration option in the second
* argument. There are many verbs but the most important are JX9_VM_CONFIG_OUTPUT,
* JX9_VM_CONFIG_HTTP_REQUEST and JX9_VM_CONFIG_ARGV_ENTRY.
* Refer to the official documentation for the list of allowed verbs.
*/
JX9_PRIVATE sxi32 jx9VmConfigure(
jx9_vm *pVm, /* Target VM */
sxi32 nOp, /* Configuration verb */
va_list ap /* Subsequent option arguments */
)
{
sxi32 rc = SXRET_OK;
switch(nOp){
case JX9_VM_CONFIG_OUTPUT: {
ProcConsumer xConsumer = va_arg(ap, ProcConsumer);
void *pUserData = va_arg(ap, void *);
/* VM output consumer callback */
#ifdef UNTRUST
if( xConsumer == 0 ){
rc = SXERR_CORRUPT;
break;
}
#endif
/* Install the output consumer */
pVm->sVmConsumer.xConsumer = xConsumer;
pVm->sVmConsumer.pUserData = pUserData;
break;
}
case JX9_VM_CONFIG_IMPORT_PATH: {
/* Import path */
const char *zPath;
SyString sPath;
zPath = va_arg(ap, const char *);
#if defined(UNTRUST)
if( zPath == 0 ){
rc = SXERR_EMPTY;
break;
}
#endif
SyStringInitFromBuf(&sPath, zPath, SyStrlen(zPath));
/* Remove trailing slashes and backslashes */
#ifdef __WINNT__
SyStringTrimTrailingChar(&sPath, '\\');
#endif
SyStringTrimTrailingChar(&sPath, '/');
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sPath);
if( sPath.nByte > 0 ){
/* Store the path in the corresponding conatiner */
rc = SySetPut(&pVm->aPaths, (const void *)&sPath);
}
break;
}
case JX9_VM_CONFIG_ERR_REPORT:
/* Run-Time Error report */
pVm->bErrReport = 1;
break;
case JX9_VM_CONFIG_RECURSION_DEPTH:{
/* Recursion depth */
int nDepth = va_arg(ap, int);
if( nDepth > 2 && nDepth < 1024 ){
pVm->nMaxDepth = nDepth;
}
break;
}
case JX9_VM_OUTPUT_LENGTH: {
/* VM output length in bytes */
sxu32 *pOut = va_arg(ap, sxu32 *);
#ifdef UNTRUST
if( pOut == 0 ){
rc = SXERR_CORRUPT;
break;
}
#endif
*pOut = pVm->nOutputLen;
break;
}
case JX9_VM_CONFIG_CREATE_VAR: {
/* Create a new superglobal/global variable */
const char *zName = va_arg(ap, const char *);
jx9_value *pValue = va_arg(ap, jx9_value *);
SyHashEntry *pEntry;
jx9_value *pObj;
sxu32 nByte;
sxu32 nIdx;
#ifdef UNTRUST
if( SX_EMPTY_STR(zName) || pValue == 0 ){
rc = SXERR_CORRUPT;
break;
}
#endif
nByte = SyStrlen(zName);
/* Check if the superglobal is already installed */
pEntry = SyHashGet(&pVm->hSuper, (const void *)zName, nByte);
if( pEntry ){
/* Variable already installed */
nIdx = SX_PTR_TO_INT(pEntry->pUserData);
/* Extract contents */
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
if( pObj ){
/* Overwrite old contents */
jx9MemObjStore(pValue, pObj);
}
}else{
/* Install a new variable */
pObj = jx9VmReserveMemObj(&(*pVm),&nIdx);
if( pObj == 0 ){
rc = SXERR_MEM;
break;
}
/* Copy value */
jx9MemObjStore(pValue, pObj);
/* Install the superglobal */
rc = SyHashInsert(&pVm->hSuper, (const void *)zName, nByte, SX_INT_TO_PTR(nIdx));
}
break;
}
case JX9_VM_CONFIG_SERVER_ATTR:
case JX9_VM_CONFIG_ENV_ATTR: {
const char *zKey = va_arg(ap, const char *);
const char *zValue = va_arg(ap, const char *);
int nLen = va_arg(ap, int);
jx9_hashmap *pMap;
jx9_value *pValue;
if( nOp == JX9_VM_CONFIG_ENV_ATTR ){
/* Extract the $_ENV superglobal */
pValue = VmExtractSuper(&(*pVm), "_ENV", sizeof("_ENV")-1);
}else{
/* Extract the $_SERVER superglobal */
pValue = VmExtractSuper(&(*pVm), "_SERVER", sizeof("_SERVER")-1);
}
if( pValue == 0 || (pValue->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* No such entry */
rc = SXERR_NOTFOUND;
break;
}
/* Point to the hashmap */
pMap = (jx9_hashmap *)pValue->x.pOther;
/* Perform the insertion */
rc = VmHashmapInsert(pMap, zKey, -1, zValue, nLen);
break;
}
case JX9_VM_CONFIG_ARGV_ENTRY:{
/* Script arguments */
const char *zValue = va_arg(ap, const char *);
jx9_hashmap *pMap;
jx9_value *pValue;
/* Extract the $argv array */
pValue = VmExtractSuper(&(*pVm), "argv", sizeof("argv")-1);
if( pValue == 0 || (pValue->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* No such entry */
rc = SXERR_NOTFOUND;
break;
}
/* Point to the hashmap */
pMap = (jx9_hashmap *)pValue->x.pOther;
/* Perform the insertion */
rc = VmHashmapInsert(pMap, 0, 0, zValue,-1);
if( rc == SXRET_OK && zValue && zValue[0] != 0 ){
if( pMap->nEntry > 1 ){
/* Append space separator first */
SyBlobAppend(&pVm->sArgv, (const void *)" ", sizeof(char));
}
SyBlobAppend(&pVm->sArgv, (const void *)zValue,SyStrlen(zValue));
}
break;
}
case JX9_VM_CONFIG_EXEC_VALUE: {
/* Script return value */
jx9_value **ppValue = va_arg(ap, jx9_value **);
#ifdef UNTRUST
if( ppValue == 0 ){
rc = SXERR_CORRUPT;
break;
}
#endif
*ppValue = &pVm->sExec;
break;
}
case JX9_VM_CONFIG_IO_STREAM: {
/* Register an IO stream device */
const jx9_io_stream *pStream = va_arg(ap, const jx9_io_stream *);
/* Make sure we are dealing with a valid IO stream */
if( pStream == 0 || pStream->zName == 0 || pStream->zName[0] == 0 ||
pStream->xOpen == 0 || pStream->xRead == 0 ){
/* Invalid stream */
rc = SXERR_INVALID;
break;
}
if( pVm->pDefStream == 0 && SyStrnicmp(pStream->zName, "file", sizeof("file")-1) == 0 ){
/* Make the 'file://' stream the defaut stream device */
pVm->pDefStream = pStream;
}
/* Insert in the appropriate container */
rc = SySetPut(&pVm->aIOstream, (const void *)&pStream);
break;
}
case JX9_VM_CONFIG_EXTRACT_OUTPUT: {
/* Point to the VM internal output consumer buffer */
const void **ppOut = va_arg(ap, const void **);
unsigned int *pLen = va_arg(ap, unsigned int *);
#ifdef UNTRUST
if( ppOut == 0 || pLen == 0 ){
rc = SXERR_CORRUPT;
break;
}
#endif
*ppOut = SyBlobData(&pVm->sConsumer);
*pLen = SyBlobLength(&pVm->sConsumer);
break;
}
case JX9_VM_CONFIG_HTTP_REQUEST:{
/* Raw HTTP request*/
const char *zRequest = va_arg(ap, const char *);
int nByte = va_arg(ap, int);
if( SX_EMPTY_STR(zRequest) ){
rc = SXERR_EMPTY;
break;
}
if( nByte < 0 ){
/* Compute length automatically */
nByte = (int)SyStrlen(zRequest);
}
/* Process the request */
rc = VmHttpProcessRequest(&(*pVm), zRequest, nByte);
break;
}
default:
/* Unknown configuration option */
rc = SXERR_UNKNOWN;
break;
}
return rc;
}
/* Forward declaration */
static const char * VmInstrToString(sxi32 nOp);
/*
* This routine is used to dump JX9 bytecode instructions to a human readable
* format.
* The dump is redirected to the given consumer callback which is responsible
* of consuming the generated dump perhaps redirecting it to its standard output
* (STDOUT).
*/
static sxi32 VmByteCodeDump(
SySet *pByteCode, /* Bytecode container */
ProcConsumer xConsumer, /* Dump consumer callback */
void *pUserData /* Last argument to xConsumer() */
)
{
static const char zDump[] = {
"====================================================\n"
"JX9 VM Dump Copyright (C) 2012-2013 Symisc Systems\n"
" http://jx9.symisc.net/\n"
"====================================================\n"
};
VmInstr *pInstr, *pEnd;
sxi32 rc = SXRET_OK;
sxu32 n;
/* Point to the JX9 instructions */
pInstr = (VmInstr *)SySetBasePtr(pByteCode);
pEnd = &pInstr[SySetUsed(pByteCode)];
n = 0;
xConsumer((const void *)zDump, sizeof(zDump)-1, pUserData);
/* Dump instructions */
for(;;){
if( pInstr >= pEnd ){
/* No more instructions */
break;
}
/* Format and call the consumer callback */
rc = SyProcFormat(xConsumer, pUserData, "%s %8d %8u %#8x [%u]\n",
VmInstrToString(pInstr->iOp), pInstr->iP1, pInstr->iP2,
SX_PTR_TO_INT(pInstr->p3), n);
if( rc != SXRET_OK ){
/* Consumer routine request an operation abort */
return rc;
}
++n;
pInstr++; /* Next instruction in the stream */
}
return rc;
}
/*
* Consume a generated run-time error message by invoking the VM output
* consumer callback.
*/
static sxi32 VmCallErrorHandler(jx9_vm *pVm, SyBlob *pMsg)
{
jx9_output_consumer *pCons = &pVm->sVmConsumer;
sxi32 rc = SXRET_OK;
/* Append a new line */
#ifdef __WINNT__
SyBlobAppend(pMsg, "\r\n", sizeof("\r\n")-1);
#else
SyBlobAppend(pMsg, "\n", sizeof(char));
#endif
/* Invoke the output consumer callback */
rc = pCons->xConsumer(SyBlobData(pMsg), SyBlobLength(pMsg), pCons->pUserData);
/* Increment output length */
pVm->nOutputLen += SyBlobLength(pMsg);
return rc;
}
/*
* Throw a run-time error and invoke the supplied VM output consumer callback.
* Refer to the implementation of [jx9_context_throw_error()] for additional
* information.
*/
JX9_PRIVATE sxi32 jx9VmThrowError(
jx9_vm *pVm, /* Target VM */
SyString *pFuncName, /* Function name. NULL otherwise */
sxi32 iErr, /* Severity level: [i.e: Error, Warning or Notice]*/
const char *zMessage /* Null terminated error message */
)
{
SyBlob *pWorker = &pVm->sWorker;
SyString *pFile;
char *zErr;
sxi32 rc;
if( !pVm->bErrReport ){
/* Don't bother reporting errors */
return SXRET_OK;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Peek the processed file if available */
pFile = (SyString *)SySetPeek(&pVm->aFiles);
if( pFile ){
/* Append file name */
SyBlobAppend(pWorker, pFile->zString, pFile->nByte);
SyBlobAppend(pWorker, (const void *)" ", sizeof(char));
}
zErr = "Error: ";
switch(iErr){
case JX9_CTX_WARNING: zErr = "Warning: "; break;
case JX9_CTX_NOTICE: zErr = "Notice: "; break;
default:
iErr = JX9_CTX_ERR;
break;
}
SyBlobAppend(pWorker, zErr, SyStrlen(zErr));
if( pFuncName ){
/* Append function name first */
SyBlobAppend(pWorker, pFuncName->zString, pFuncName->nByte);
SyBlobAppend(pWorker, "(): ", sizeof("(): ")-1);
}
SyBlobAppend(pWorker, zMessage, SyStrlen(zMessage));
/* Consume the error message */
rc = VmCallErrorHandler(&(*pVm), pWorker);
return rc;
}
/*
* Format and throw a run-time error and invoke the supplied VM output consumer callback.
* Refer to the implementation of [jx9_context_throw_error_format()] for additional
* information.
*/
static sxi32 VmThrowErrorAp(
jx9_vm *pVm, /* Target VM */
SyString *pFuncName, /* Function name. NULL otherwise */
sxi32 iErr, /* Severity level: [i.e: Error, Warning or Notice] */
const char *zFormat, /* Format message */
va_list ap /* Variable list of arguments */
)
{
SyBlob *pWorker = &pVm->sWorker;
SyString *pFile;
char *zErr;
sxi32 rc;
if( !pVm->bErrReport ){
/* Don't bother reporting errors */
return SXRET_OK;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Peek the processed file if available */
pFile = (SyString *)SySetPeek(&pVm->aFiles);
if( pFile ){
/* Append file name */
SyBlobAppend(pWorker, pFile->zString, pFile->nByte);
SyBlobAppend(pWorker, (const void *)" ", sizeof(char));
}
zErr = "Error: ";
switch(iErr){
case JX9_CTX_WARNING: zErr = "Warning: "; break;
case JX9_CTX_NOTICE: zErr = "Notice: "; break;
default:
iErr = JX9_CTX_ERR;
break;
}
SyBlobAppend(pWorker, zErr, SyStrlen(zErr));
if( pFuncName ){
/* Append function name first */
SyBlobAppend(pWorker, pFuncName->zString, pFuncName->nByte);
SyBlobAppend(pWorker, "(): ", sizeof("(): ")-1);
}
SyBlobFormatAp(pWorker, zFormat, ap);
/* Consume the error message */
rc = VmCallErrorHandler(&(*pVm), pWorker);
return rc;
}
/*
* Format and throw a run-time error and invoke the supplied VM output consumer callback.
* Refer to the implementation of [jx9_context_throw_error_format()] for additional
* information.
* ------------------------------------
* Simple boring wrapper function.
* ------------------------------------
*/
static sxi32 VmErrorFormat(jx9_vm *pVm, sxi32 iErr, const char *zFormat, ...)
{
va_list ap;
sxi32 rc;
va_start(ap, zFormat);
rc = VmThrowErrorAp(&(*pVm), 0, iErr, zFormat, ap);
va_end(ap);
return rc;
}
/*
* Format and throw a run-time error and invoke the supplied VM output consumer callback.
* Refer to the implementation of [jx9_context_throw_error_format()] for additional
* information.
* ------------------------------------
* Simple boring wrapper function.
* ------------------------------------
*/
JX9_PRIVATE sxi32 jx9VmThrowErrorAp(jx9_vm *pVm, SyString *pFuncName, sxi32 iErr, const char *zFormat, va_list ap)
{
sxi32 rc;
rc = VmThrowErrorAp(&(*pVm), &(*pFuncName), iErr, zFormat, ap);
return rc;
}
/* Forward declaration */
static sxi32 VmLocalExec(jx9_vm *pVm,SySet *pByteCode,jx9_value *pResult);
/*
* Execute as much of a JX9 bytecode program as we can then return.
*
* [jx9VmMakeReady()] must be called before this routine in order to
* close the program with a final OP_DONE and to set up the default
* consumer routines and other stuff. Refer to the implementation
* of [jx9VmMakeReady()] for additional information.
* If the installed VM output consumer callback ever returns JX9_ABORT
* then the program execution is halted.
* After this routine has finished, [jx9VmRelease()] or [jx9VmReset()]
* should be used respectively to clean up the mess that was left behind
* or to reset the VM to it's initial state.
*/
static sxi32 VmByteCodeExec(
jx9_vm *pVm, /* Target VM */
VmInstr *aInstr, /* JX9 bytecode program */
jx9_value *pStack, /* Operand stack */
int nTos, /* Top entry in the operand stack (usually -1) */
jx9_value *pResult /* Store program return value here. NULL otherwise */
)
{
VmInstr *pInstr;
jx9_value *pTos;
SySet aArg;
sxi32 pc;
sxi32 rc;
/* Argument container */
SySetInit(&aArg, &pVm->sAllocator, sizeof(jx9_value *));
if( nTos < 0 ){
pTos = &pStack[-1];
}else{
pTos = &pStack[nTos];
}
pc = 0;
/* Execute as much as we can */
for(;;){
/* Fetch the instruction to execute */
pInstr = &aInstr[pc];
rc = SXRET_OK;
/*
* What follows here is a massive switch statement where each case implements a
* separate instruction in the virtual machine. If we follow the usual
* indentation convention each case should be indented by 6 spaces. But
* that is a lot of wasted space on the left margin. So the code within
* the switch statement will break with convention and be flush-left.
*/
switch(pInstr->iOp){
/*
* DONE: P1 * *
*
* Program execution completed: Clean up the mess left behind
* and return immediately.
*/
case JX9_OP_DONE:
if( pInstr->iP1 ){
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( pResult ){
/* Execution result */
jx9MemObjStore(pTos, pResult);
}
VmPopOperand(&pTos, 1);
}
goto Done;
/*
* HALT: P1 * *
*
* Program execution aborted: Clean up the mess left behind
* and abort immediately.
*/
case JX9_OP_HALT:
if( pInstr->iP1 ){
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( pTos->iFlags & MEMOBJ_STRING ){
if( SyBlobLength(&pTos->sBlob) > 0 ){
/* Output the exit message */
pVm->sVmConsumer.xConsumer(SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob),
pVm->sVmConsumer.pUserData);
/* Increment output length */
pVm->nOutputLen += SyBlobLength(&pTos->sBlob);
}
}else if(pTos->iFlags & MEMOBJ_INT ){
/* Record exit status */
pVm->iExitStatus = (sxi32)pTos->x.iVal;
}
VmPopOperand(&pTos, 1);
}
goto Abort;
/*
* JMP: * P2 *
*
* Unconditional jump: The next instruction executed will be
* the one at index P2 from the beginning of the program.
*/
case JX9_OP_JMP:
pc = pInstr->iP2 - 1;
break;
/*
* JZ: P1 P2 *
*
* Take the jump if the top value is zero (FALSE jump).Pop the top most
* entry in the stack if P1 is zero.
*/
case JX9_OP_JZ:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Get a boolean value */
if((pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
if( !pTos->x.iVal ){
/* Take the jump */
pc = pInstr->iP2 - 1;
}
if( !pInstr->iP1 ){
VmPopOperand(&pTos, 1);
}
break;
/*
* JNZ: P1 P2 *
*
* Take the jump if the top value is not zero (TRUE jump).Pop the top most
* entry in the stack if P1 is zero.
*/
case JX9_OP_JNZ:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Get a boolean value */
if((pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
if( pTos->x.iVal ){
/* Take the jump */
pc = pInstr->iP2 - 1;
}
if( !pInstr->iP1 ){
VmPopOperand(&pTos, 1);
}
break;
/*
* NOOP: * * *
*
* Do nothing. This instruction is often useful as a jump
* destination.
*/
case JX9_OP_NOOP:
break;
/*
* POP: P1 * *
*
* Pop P1 elements from the operand stack.
*/
case JX9_OP_POP: {
sxi32 n = pInstr->iP1;
if( &pTos[-n+1] < pStack ){
/* TICKET 1433-51 Stack underflow must be handled at run-time */
n = (sxi32)(pTos - pStack);
}
VmPopOperand(&pTos, n);
break;
}
/*
* CVT_INT: * * *
*
* Force the top of the stack to be an integer.
*/
case JX9_OP_CVT_INT:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if((pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_INT);
break;
/*
* CVT_REAL: * * *
*
* Force the top of the stack to be a real.
*/
case JX9_OP_CVT_REAL:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if((pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_REAL);
break;
/*
* CVT_STR: * * *
*
* Force the top of the stack to be a string.
*/
case JX9_OP_CVT_STR:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pTos);
}
break;
/*
* CVT_BOOL: * * *
*
* Force the top of the stack to be a boolean.
*/
case JX9_OP_CVT_BOOL:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( (pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
break;
/*
* CVT_NULL: * * *
*
* Nullify the top of the stack.
*/
case JX9_OP_CVT_NULL:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
jx9MemObjRelease(pTos);
break;
/*
* CVT_NUMC: * * *
*
* Force the top of the stack to be a numeric type (integer, real or both).
*/
case JX9_OP_CVT_NUMC:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a numeric cast */
jx9MemObjToNumeric(pTos);
break;
/*
* CVT_ARRAY: * * *
*
* Force the top of the stack to be a hashmap aka 'array'.
*/
case JX9_OP_CVT_ARRAY:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a hashmap cast */
rc = jx9MemObjToHashmap(pTos);
if( rc != SXRET_OK ){
/* Not so fatal, emit a simple warning */
jx9VmThrowError(&(*pVm), 0, JX9_CTX_WARNING,
"JX9 engine is running out of memory while performing an array cast");
}
break;
/*
* LOADC P1 P2 *
*
* Load a constant [i.e: JX9_EOL, JX9_OS, __TIME__, ...] indexed at P2 in the constant pool.
* If P1 is set, then this constant is candidate for expansion via user installable callbacks.
*/
case JX9_OP_LOADC: {
jx9_value *pObj;
/* Reserve a room */
pTos++;
if( (pObj = (jx9_value *)SySetAt(&pVm->aLitObj, pInstr->iP2)) != 0 ){
if( pInstr->iP1 == 1 && SyBlobLength(&pObj->sBlob) <= 64 ){
SyHashEntry *pEntry;
/* Candidate for expansion via user defined callbacks */
pEntry = SyHashGet(&pVm->hConstant, SyBlobData(&pObj->sBlob), SyBlobLength(&pObj->sBlob));
if( pEntry ){
jx9_constant *pCons = (jx9_constant *)pEntry->pUserData;
/* Set a NULL default value */
MemObjSetType(pTos, MEMOBJ_NULL);
SyBlobReset(&pTos->sBlob);
/* Invoke the callback and deal with the expanded value */
pCons->xExpand(pTos, pCons->pUserData);
/* Mark as constant */
pTos->nIdx = SXU32_HIGH;
break;
}
}
jx9MemObjLoad(pObj, pTos);
}else{
/* Set a NULL value */
MemObjSetType(pTos, MEMOBJ_NULL);
}
/* Mark as constant */
pTos->nIdx = SXU32_HIGH;
break;
}
/*
* LOAD: P1 * P3
*
* Load a variable where it's name is taken from the top of the stack or
* from the P3 operand.
* If P1 is set, then perform a lookup only.In other words do not create
* the variable if non existent and push the NULL constant instead.
*/
case JX9_OP_LOAD:{
jx9_value *pObj;
SyString sName;
if( pInstr->p3 == 0 ){
/* Take the variable name from the top of the stack */
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a string cast */
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pTos);
}
SyStringInitFromBuf(&sName, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
}else{
SyStringInitFromBuf(&sName, pInstr->p3, SyStrlen((const char *)pInstr->p3));
/* Reserve a room for the target object */
pTos++;
}
/* Extract the requested memory object */
pObj = VmExtractMemObj(&(*pVm), &sName, pInstr->p3 ? FALSE : TRUE, pInstr->iP1 != 1);
if( pObj == 0 ){
if( pInstr->iP1 ){
/* Variable not found, load NULL */
if( !pInstr->p3 ){
jx9MemObjRelease(pTos);
}else{
MemObjSetType(pTos, MEMOBJ_NULL);
}
pTos->nIdx = SXU32_HIGH; /* Mark as constant */
break;
}else{
/* Fatal error */
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "Fatal, JX9 engine is running out of memory while loading variable '%z'", &sName);
goto Abort;
}
}
/* Load variable contents */
jx9MemObjLoad(pObj, pTos);
pTos->nIdx = pObj->nIdx;
break;
}
/*
* LOAD_MAP P1 * *
*
* Allocate a new empty hashmap (array in the JX9 jargon) and push it on the stack.
* If the P1 operand is greater than zero then pop P1 elements from the
* stack and insert them (key => value pair) in the new hashmap.
*/
case JX9_OP_LOAD_MAP: {
jx9_hashmap *pMap;
int is_json_object; /* TRUE if we are dealing with a JSON object */
int iIncr = 1;
/* Allocate a new hashmap instance */
pMap = jx9NewHashmap(&(*pVm), 0, 0);
if( pMap == 0 ){
VmErrorFormat(&(*pVm), JX9_CTX_ERR,
"Fatal, JX9 engine is running out of memory while loading JSON array/object at instruction #:%d", pc);
goto Abort;
}
is_json_object = 0;
if( pInstr->iP2 ){
/* JSON object, record that */
pMap->iFlags |= HASHMAP_JSON_OBJECT;
is_json_object = 1;
iIncr = 2;
}
if( pInstr->iP1 > 0 ){
jx9_value *pEntry = &pTos[-pInstr->iP1+1]; /* Point to the first entry */
/* Perform the insertion */
while( pEntry <= pTos ){
/* Standard insertion */
jx9HashmapInsert(pMap,
is_json_object ? pEntry : 0 /* Automatic index assign */,
is_json_object ? &pEntry[1] : pEntry
);
/* Next pair on the stack */
pEntry += iIncr;
}
/* Pop P1 elements */
VmPopOperand(&pTos, pInstr->iP1);
}
/* Push the hashmap */
pTos++;
pTos->x.pOther = pMap;
MemObjSetType(pTos, MEMOBJ_HASHMAP);
break;
}
/*
* LOAD_IDX: P1 P2 *
*
* Load a hasmap entry where it's index (either numeric or string) is taken
* from the stack.
* If the index does not refer to a valid element, then push the NULL constant
* instead.
*/
case JX9_OP_LOAD_IDX: {
jx9_hashmap_node *pNode = 0; /* cc warning */
jx9_hashmap *pMap = 0;
jx9_value *pIdx;
pIdx = 0;
if( pInstr->iP1 == 0 ){
if( !pInstr->iP2){
/* No available index, load NULL */
if( pTos >= pStack ){
jx9MemObjRelease(pTos);
}else{
/* TICKET 1433-020: Empty stack */
pTos++;
MemObjSetType(pTos, MEMOBJ_NULL);
pTos->nIdx = SXU32_HIGH;
}
/* Emit a notice */
jx9VmThrowError(&(*pVm), 0, JX9_CTX_NOTICE,
"JSON Array/Object: Attempt to access an undefined member, JX9 is loading NULL");
break;
}
}else{
pIdx = pTos;
pTos--;
}
if( pTos->iFlags & MEMOBJ_STRING ){
/* String access */
if( pIdx ){
sxu32 nOfft;
if( (pIdx->iFlags & MEMOBJ_INT) == 0 ){
/* Force an int cast */
jx9MemObjToInteger(pIdx);
}
nOfft = (sxu32)pIdx->x.iVal;
if( nOfft >= SyBlobLength(&pTos->sBlob) ){
/* Invalid offset, load null */
jx9MemObjRelease(pTos);
}else{
const char *zData = (const char *)SyBlobData(&pTos->sBlob);
int c = zData[nOfft];
jx9MemObjRelease(pTos);
MemObjSetType(pTos, MEMOBJ_STRING);
SyBlobAppend(&pTos->sBlob, (const void *)&c, sizeof(char));
}
}else{
/* No available index, load NULL */
MemObjSetType(pTos, MEMOBJ_NULL);
}
break;
}
if( pInstr->iP2 && (pTos->iFlags & MEMOBJ_HASHMAP) == 0 ){
if( pTos->nIdx != SXU32_HIGH ){
jx9_value *pObj;
if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjToHashmap(pObj);
jx9MemObjLoad(pObj, pTos);
}
}
}
rc = SXERR_NOTFOUND; /* Assume the index is invalid */
if( pTos->iFlags & MEMOBJ_HASHMAP ){
/* Point to the hashmap */
pMap = (jx9_hashmap *)pTos->x.pOther;
if( pIdx ){
/* Load the desired entry */
rc = jx9HashmapLookup(pMap, pIdx, &pNode);
}
if( rc != SXRET_OK && pInstr->iP2 ){
/* Create a new empty entry */
rc = jx9HashmapInsert(pMap, pIdx, 0);
if( rc == SXRET_OK ){
/* Point to the last inserted entry */
pNode = pMap->pLast;
}
}
}
if( pIdx ){
jx9MemObjRelease(pIdx);
}
if( rc == SXRET_OK ){
/* Load entry contents */
if( pMap->iRef < 2 ){
/* TICKET 1433-42: Array will be deleted shortly, so we will make a copy
* of the entry value, rather than pointing to it.
*/
pTos->nIdx = SXU32_HIGH;
jx9HashmapExtractNodeValue(pNode, pTos, TRUE);
}else{
pTos->nIdx = pNode->nValIdx;
jx9HashmapExtractNodeValue(pNode, pTos, FALSE);
jx9HashmapUnref(pMap);
}
}else{
/* No such entry, load NULL */
jx9MemObjRelease(pTos);
pTos->nIdx = SXU32_HIGH;
}
break;
}
/*
* STORE * P2 P3
*
* Perform a store (Assignment) operation.
*/
case JX9_OP_STORE: {
jx9_value *pObj;
SyString sName;
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( pInstr->iP2 ){
sxu32 nIdx;
/* Member store operation */
nIdx = pTos->nIdx;
VmPopOperand(&pTos, 1);
if( nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR,
"Cannot perform assignment on a constant object attribute, JX9 is loading NULL");
pTos->nIdx = SXU32_HIGH;
}else{
/* Point to the desired memory object */
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
if( pObj ){
/* Perform the store operation */
jx9MemObjStore(pTos, pObj);
}
}
break;
}else if( pInstr->p3 == 0 ){
/* Take the variable name from the next on the stack */
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pTos);
}
SyStringInitFromBuf(&sName, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
pTos--;
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
}else{
SyStringInitFromBuf(&sName, pInstr->p3, SyStrlen((const char *)pInstr->p3));
}
/* Extract the desired variable and if not available dynamically create it */
pObj = VmExtractMemObj(&(*pVm), &sName, pInstr->p3 ? FALSE : TRUE, TRUE);
if( pObj == 0 ){
VmErrorFormat(&(*pVm), JX9_CTX_ERR,
"Fatal, JX9 engine is running out of memory while loading variable '%z'", &sName);
goto Abort;
}
if( !pInstr->p3 ){
jx9MemObjRelease(&pTos[1]);
}
/* Perform the store operation */
jx9MemObjStore(pTos, pObj);
break;
}
/*
* STORE_IDX: P1 * P3
*
* Perfrom a store operation an a hashmap entry.
*/
case JX9_OP_STORE_IDX: {
jx9_hashmap *pMap = 0; /* cc warning */
jx9_value *pKey;
sxu32 nIdx;
if( pInstr->iP1 ){
/* Key is next on stack */
pKey = pTos;
pTos--;
}else{
pKey = 0;
}
nIdx = pTos->nIdx;
if( pTos->iFlags & MEMOBJ_HASHMAP ){
/* Hashmap already loaded */
pMap = (jx9_hashmap *)pTos->x.pOther;
if( pMap->iRef < 2 ){
/* TICKET 1433-48: Prevent garbage collection */
pMap->iRef = 2;
}
}else{
jx9_value *pObj;
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx);
if( pObj == 0 ){
if( pKey ){
jx9MemObjRelease(pKey);
}
VmPopOperand(&pTos, 1);
break;
}
/* Phase#1: Load the array */
if( (pObj->iFlags & MEMOBJ_STRING) ){
VmPopOperand(&pTos, 1);
if( (pTos->iFlags&MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pTos);
}
if( pKey == 0 ){
/* Append string */
if( SyBlobLength(&pTos->sBlob) > 0 ){
SyBlobAppend(&pObj->sBlob, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
}
}else{
sxu32 nOfft;
if((pKey->iFlags & MEMOBJ_INT)){
/* Force an int cast */
jx9MemObjToInteger(pKey);
}
nOfft = (sxu32)pKey->x.iVal;
if( nOfft < SyBlobLength(&pObj->sBlob) && SyBlobLength(&pTos->sBlob) > 0 ){
const char *zBlob = (const char *)SyBlobData(&pTos->sBlob);
char *zData = (char *)SyBlobData(&pObj->sBlob);
zData[nOfft] = zBlob[0];
}else{
if( SyBlobLength(&pTos->sBlob) >= sizeof(char) ){
/* Perform an append operation */
SyBlobAppend(&pObj->sBlob, SyBlobData(&pTos->sBlob), sizeof(char));
}
}
}
if( pKey ){
jx9MemObjRelease(pKey);
}
break;
}else if( (pObj->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* Force a hashmap cast */
rc = jx9MemObjToHashmap(pObj);
if( rc != SXRET_OK ){
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "Fatal, JX9 engine is running out of memory while creating a new array");
goto Abort;
}
}
pMap = (jx9_hashmap *)pObj->x.pOther;
}
VmPopOperand(&pTos, 1);
/* Phase#2: Perform the insertion */
jx9HashmapInsert(pMap, pKey, pTos);
if( pKey ){
jx9MemObjRelease(pKey);
}
break;
}
/*
* INCR: P1 * *
*
* Force a numeric cast and increment the top of the stack by 1.
* If the P1 operand is set then perform a duplication of the top of
* the stack and increment after that.
*/
case JX9_OP_INCR:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( (pTos->iFlags & (MEMOBJ_HASHMAP|MEMOBJ_RES)) == 0 ){
if( pTos->nIdx != SXU32_HIGH ){
jx9_value *pObj;
if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
/* Force a numeric cast */
jx9MemObjToNumeric(pObj);
if( pObj->iFlags & MEMOBJ_REAL ){
pObj->x.rVal++;
/* Try to get an integer representation */
jx9MemObjTryInteger(pTos);
}else{
pObj->x.iVal++;
MemObjSetType(pTos, MEMOBJ_INT);
}
if( pInstr->iP1 ){
/* Pre-icrement */
jx9MemObjStore(pObj, pTos);
}
}
}else{
if( pInstr->iP1 ){
/* Force a numeric cast */
jx9MemObjToNumeric(pTos);
/* Pre-increment */
if( pTos->iFlags & MEMOBJ_REAL ){
pTos->x.rVal++;
/* Try to get an integer representation */
jx9MemObjTryInteger(pTos);
}else{
pTos->x.iVal++;
MemObjSetType(pTos, MEMOBJ_INT);
}
}
}
}
break;
/*
* DECR: P1 * *
*
* Force a numeric cast and decrement the top of the stack by 1.
* If the P1 operand is set then perform a duplication of the top of the stack
* and decrement after that.
*/
case JX9_OP_DECR:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( (pTos->iFlags & (MEMOBJ_HASHMAP|MEMOBJ_RES|MEMOBJ_NULL)) == 0 ){
/* Force a numeric cast */
jx9MemObjToNumeric(pTos);
if( pTos->nIdx != SXU32_HIGH ){
jx9_value *pObj;
if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
/* Force a numeric cast */
jx9MemObjToNumeric(pObj);
if( pObj->iFlags & MEMOBJ_REAL ){
pObj->x.rVal--;
/* Try to get an integer representation */
jx9MemObjTryInteger(pTos);
}else{
pObj->x.iVal--;
MemObjSetType(pTos, MEMOBJ_INT);
}
if( pInstr->iP1 ){
/* Pre-icrement */
jx9MemObjStore(pObj, pTos);
}
}
}else{
if( pInstr->iP1 ){
/* Pre-increment */
if( pTos->iFlags & MEMOBJ_REAL ){
pTos->x.rVal--;
/* Try to get an integer representation */
jx9MemObjTryInteger(pTos);
}else{
pTos->x.iVal--;
MemObjSetType(pTos, MEMOBJ_INT);
}
}
}
}
break;
/*
* UMINUS: * * *
*
* Perform a unary minus operation.
*/
case JX9_OP_UMINUS:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a numeric (integer, real or both) cast */
jx9MemObjToNumeric(pTos);
if( pTos->iFlags & MEMOBJ_REAL ){
pTos->x.rVal = -pTos->x.rVal;
}
if( pTos->iFlags & MEMOBJ_INT ){
pTos->x.iVal = -pTos->x.iVal;
}
break;
/*
* UPLUS: * * *
*
* Perform a unary plus operation.
*/
case JX9_OP_UPLUS:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a numeric (integer, real or both) cast */
jx9MemObjToNumeric(pTos);
if( pTos->iFlags & MEMOBJ_REAL ){
pTos->x.rVal = +pTos->x.rVal;
}
if( pTos->iFlags & MEMOBJ_INT ){
pTos->x.iVal = +pTos->x.iVal;
}
break;
/*
* OP_LNOT: * * *
*
* Interpret the top of the stack as a boolean value. Replace it
* with its complement.
*/
case JX9_OP_LNOT:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force a boolean cast */
if( (pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
pTos->x.iVal = !pTos->x.iVal;
break;
/*
* OP_BITNOT: * * *
*
* Interpret the top of the stack as an value.Replace it
* with its ones-complement.
*/
case JX9_OP_BITNOT:
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
/* Force an integer cast */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
pTos->x.iVal = ~pTos->x.iVal;
break;
/* OP_MUL * * *
* OP_MUL_STORE * * *
*
* Pop the top two elements from the stack, multiply them together,
* and push the result back onto the stack.
*/
case JX9_OP_MUL:
case JX9_OP_MUL_STORE: {
jx9_value *pNos = &pTos[-1];
/* Force the operand to be numeric */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
jx9MemObjToNumeric(pTos);
jx9MemObjToNumeric(pNos);
/* Perform the requested operation */
if( MEMOBJ_REAL & (pTos->iFlags|pNos->iFlags) ){
/* Floating point arithemic */
jx9_real a, b, r;
if( (pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
if( (pNos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pNos);
}
a = pNos->x.rVal;
b = pTos->x.rVal;
r = a * b;
/* Push the result */
pNos->x.rVal = r;
MemObjSetType(pNos, MEMOBJ_REAL);
/* Try to get an integer representation */
jx9MemObjTryInteger(pNos);
}else{
/* Integer arithmetic */
sxi64 a, b, r;
a = pNos->x.iVal;
b = pTos->x.iVal;
r = a * b;
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
}
if( pInstr->iOp == JX9_OP_MUL_STORE ){
jx9_value *pObj;
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
}
VmPopOperand(&pTos, 1);
break;
}
/* OP_ADD * * *
*
* Pop the top two elements from the stack, add them together,
* and push the result back onto the stack.
*/
case JX9_OP_ADD:{
jx9_value *pNos = &pTos[-1];
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Perform the addition */
jx9MemObjAdd(pNos, pTos, FALSE);
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_ADD_STORE * * *
*
* Pop the top two elements from the stack, add them together,
* and push the result back onto the stack.
*/
case JX9_OP_ADD_STORE:{
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
sxu32 nIdx;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Perform the addition */
nIdx = pTos->nIdx;
jx9MemObjAdd(pTos, pNos, TRUE);
/* Peform the store operation */
if( nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nIdx)) != 0 ){
jx9MemObjStore(pTos, pObj);
}
/* Ticket 1433-35: Perform a stack dup */
jx9MemObjStore(pTos, pNos);
VmPopOperand(&pTos, 1);
break;
}
/* OP_SUB * * *
*
* Pop the top two elements from the stack, subtract the
* first (what was next on the stack) from the second (the
* top of the stack) and push the result back onto the stack.
*/
case JX9_OP_SUB: {
jx9_value *pNos = &pTos[-1];
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
if( MEMOBJ_REAL & (pTos->iFlags|pNos->iFlags) ){
/* Floating point arithemic */
jx9_real a, b, r;
if( (pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
if( (pNos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pNos);
}
a = pNos->x.rVal;
b = pTos->x.rVal;
r = a - b;
/* Push the result */
pNos->x.rVal = r;
MemObjSetType(pNos, MEMOBJ_REAL);
/* Try to get an integer representation */
jx9MemObjTryInteger(pNos);
}else{
/* Integer arithmetic */
sxi64 a, b, r;
a = pNos->x.iVal;
b = pTos->x.iVal;
r = a - b;
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
}
VmPopOperand(&pTos, 1);
break;
}
/* OP_SUB_STORE * * *
*
* Pop the top two elements from the stack, subtract the
* first (what was next on the stack) from the second (the
* top of the stack) and push the result back onto the stack.
*/
case JX9_OP_SUB_STORE: {
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
if( MEMOBJ_REAL & (pTos->iFlags|pNos->iFlags) ){
/* Floating point arithemic */
jx9_real a, b, r;
if( (pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
if( (pNos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pNos);
}
a = pTos->x.rVal;
b = pNos->x.rVal;
r = a - b;
/* Push the result */
pNos->x.rVal = r;
MemObjSetType(pNos, MEMOBJ_REAL);
/* Try to get an integer representation */
jx9MemObjTryInteger(pNos);
}else{
/* Integer arithmetic */
sxi64 a, b, r;
a = pTos->x.iVal;
b = pNos->x.iVal;
r = a - b;
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
}
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_MOD * * *
*
* Pop the top two elements from the stack, divide the
* first (what was next on the stack) from the second (the
* top of the stack) and push the remainder after division
* onto the stack.
* Note: Only integer arithemtic is allowed.
*/
case JX9_OP_MOD:{
jx9_value *pNos = &pTos[-1];
sxi64 a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pNos->x.iVal;
b = pTos->x.iVal;
if( b == 0 ){
r = 0;
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "Division by zero %qd%%0", a);
/* goto Abort; */
}else{
r = a%b;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_MOD_STORE * * *
*
* Pop the top two elements from the stack, divide the
* first (what was next on the stack) from the second (the
* top of the stack) and push the remainder after division
* onto the stack.
* Note: Only integer arithemtic is allowed.
*/
case JX9_OP_MOD_STORE: {
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
sxi64 a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pTos->x.iVal;
b = pNos->x.iVal;
if( b == 0 ){
r = 0;
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "Division by zero %qd%%0", a);
/* goto Abort; */
}else{
r = a%b;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_DIV * * *
*
* Pop the top two elements from the stack, divide the
* first (what was next on the stack) from the second (the
* top of the stack) and push the result onto the stack.
* Note: Only floating point arithemtic is allowed.
*/
case JX9_OP_DIV:{
jx9_value *pNos = &pTos[-1];
jx9_real a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be real */
if( (pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
if( (pNos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pNos);
}
/* Perform the requested operation */
a = pNos->x.rVal;
b = pTos->x.rVal;
if( b == 0 ){
/* Division by zero */
r = 0;
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Division by zero");
/* goto Abort; */
}else{
r = a/b;
/* Push the result */
pNos->x.rVal = r;
MemObjSetType(pNos, MEMOBJ_REAL);
/* Try to get an integer representation */
jx9MemObjTryInteger(pNos);
}
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_DIV_STORE * * *
*
* Pop the top two elements from the stack, divide the
* first (what was next on the stack) from the second (the
* top of the stack) and push the result onto the stack.
* Note: Only floating point arithemtic is allowed.
*/
case JX9_OP_DIV_STORE:{
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
jx9_real a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be real */
if( (pTos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pTos);
}
if( (pNos->iFlags & MEMOBJ_REAL) == 0 ){
jx9MemObjToReal(pNos);
}
/* Perform the requested operation */
a = pTos->x.rVal;
b = pNos->x.rVal;
if( b == 0 ){
/* Division by zero */
r = 0;
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "Division by zero %qd/0", a);
/* goto Abort; */
}else{
r = a/b;
/* Push the result */
pNos->x.rVal = r;
MemObjSetType(pNos, MEMOBJ_REAL);
/* Try to get an integer representation */
jx9MemObjTryInteger(pNos);
}
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
VmPopOperand(&pTos, 1);
break;
}
/* OP_BAND * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise AND of the
* two elements.
*/
/* OP_BOR * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise OR of the
* two elements.
*/
/* OP_BXOR * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise XOR of the
* two elements.
*/
case JX9_OP_BAND:
case JX9_OP_BOR:
case JX9_OP_BXOR:{
jx9_value *pNos = &pTos[-1];
sxi64 a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pNos->x.iVal;
b = pTos->x.iVal;
switch(pInstr->iOp){
case JX9_OP_BOR_STORE:
case JX9_OP_BOR: r = a|b; break;
case JX9_OP_BXOR_STORE:
case JX9_OP_BXOR: r = a^b; break;
case JX9_OP_BAND_STORE:
case JX9_OP_BAND:
default: r = a&b; break;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
VmPopOperand(&pTos, 1);
break;
}
/* OP_BAND_STORE * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise AND of the
* two elements.
*/
/* OP_BOR_STORE * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise OR of the
* two elements.
*/
/* OP_BXOR_STORE * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the bit-wise XOR of the
* two elements.
*/
case JX9_OP_BAND_STORE:
case JX9_OP_BOR_STORE:
case JX9_OP_BXOR_STORE:{
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
sxi64 a, b, r;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pTos->x.iVal;
b = pNos->x.iVal;
switch(pInstr->iOp){
case JX9_OP_BOR_STORE:
case JX9_OP_BOR: r = a|b; break;
case JX9_OP_BXOR_STORE:
case JX9_OP_BXOR: r = a^b; break;
case JX9_OP_BAND_STORE:
case JX9_OP_BAND:
default: r = a&b; break;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
VmPopOperand(&pTos, 1);
break;
}
/* OP_SHL * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the second element shifted
* left by N bits where N is the top element on the stack.
* Note: Only integer arithmetic is allowed.
*/
/* OP_SHR * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the second element shifted
* right by N bits where N is the top element on the stack.
* Note: Only integer arithmetic is allowed.
*/
case JX9_OP_SHL:
case JX9_OP_SHR: {
jx9_value *pNos = &pTos[-1];
sxi64 a, r;
sxi32 b;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pNos->x.iVal;
b = (sxi32)pTos->x.iVal;
if( pInstr->iOp == JX9_OP_SHL ){
r = a << b;
}else{
r = a >> b;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
VmPopOperand(&pTos, 1);
break;
}
/* OP_SHL_STORE * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the second element shifted
* left by N bits where N is the top element on the stack.
* Note: Only integer arithmetic is allowed.
*/
/* OP_SHR_STORE * * *
*
* Pop the top two elements from the stack. Convert both elements
* to integers. Push back onto the stack the second element shifted
* right by N bits where N is the top element on the stack.
* Note: Only integer arithmetic is allowed.
*/
case JX9_OP_SHL_STORE:
case JX9_OP_SHR_STORE: {
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
sxi64 a, r;
sxi32 b;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force the operands to be integer */
if( (pTos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pTos);
}
if( (pNos->iFlags & MEMOBJ_INT) == 0 ){
jx9MemObjToInteger(pNos);
}
/* Perform the requested operation */
a = pTos->x.iVal;
b = (sxi32)pNos->x.iVal;
if( pInstr->iOp == JX9_OP_SHL_STORE ){
r = a << b;
}else{
r = a >> b;
}
/* Push the result */
pNos->x.iVal = r;
MemObjSetType(pNos, MEMOBJ_INT);
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pNos, pObj);
}
VmPopOperand(&pTos, 1);
break;
}
/* CAT: P1 * *
*
* Pop P1 elements from the stack. Concatenate them togeher and push the result
* back.
*/
case JX9_OP_CAT:{
jx9_value *pNos, *pCur;
if( pInstr->iP1 < 1 ){
pNos = &pTos[-1];
}else{
pNos = &pTos[-pInstr->iP1+1];
}
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force a string cast */
if( (pNos->iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pNos);
}
pCur = &pNos[1];
while( pCur <= pTos ){
if( (pCur->iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pCur);
}
/* Perform the concatenation */
if( SyBlobLength(&pCur->sBlob) > 0 ){
jx9MemObjStringAppend(pNos, (const char *)SyBlobData(&pCur->sBlob), SyBlobLength(&pCur->sBlob));
}
SyBlobRelease(&pCur->sBlob);
pCur++;
}
pTos = pNos;
break;
}
/* CAT_STORE: * * *
*
* Pop two elements from the stack. Concatenate them togeher and push the result
* back.
*/
case JX9_OP_CAT_STORE:{
jx9_value *pNos = &pTos[-1];
jx9_value *pObj;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
if((pTos->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pTos);
}
if((pNos->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pNos);
}
/* Perform the concatenation (Reverse order) */
if( SyBlobLength(&pNos->sBlob) > 0 ){
jx9MemObjStringAppend(pTos, (const char *)SyBlobData(&pNos->sBlob), SyBlobLength(&pNos->sBlob));
}
/* Perform the store operation */
if( pTos->nIdx == SXU32_HIGH ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "Cannot perform assignment on a constant object attribute");
}else if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pTos->nIdx)) != 0 ){
jx9MemObjStore(pTos, pObj);
}
jx9MemObjStore(pTos, pNos);
VmPopOperand(&pTos, 1);
break;
}
/* OP_AND: * * *
*
* Pop two values off the stack. Take the logical AND of the
* two values and push the resulting boolean value back onto the
* stack.
*/
/* OP_OR: * * *
*
* Pop two values off the stack. Take the logical OR of the
* two values and push the resulting boolean value back onto the
* stack.
*/
case JX9_OP_LAND:
case JX9_OP_LOR: {
jx9_value *pNos = &pTos[-1];
sxi32 v1, v2; /* 0==TRUE, 1==FALSE, 2==UNKNOWN or NULL */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force a boolean cast */
if((pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
if((pNos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pNos);
}
v1 = pNos->x.iVal == 0 ? 1 : 0;
v2 = pTos->x.iVal == 0 ? 1 : 0;
if( pInstr->iOp == JX9_OP_LAND ){
static const unsigned char and_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
v1 = and_logic[v1*3+v2];
}else{
static const unsigned char or_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
v1 = or_logic[v1*3+v2];
}
if( v1 == 2 ){
v1 = 1;
}
VmPopOperand(&pTos, 1);
pTos->x.iVal = v1 == 0 ? 1 : 0;
MemObjSetType(pTos, MEMOBJ_BOOL);
break;
}
/* OP_LXOR: * * *
*
* Pop two values off the stack. Take the logical XOR of the
* two values and push the resulting boolean value back onto the
* stack.
* According to the JX9 language reference manual:
* $a xor $b is evaluated to TRUE if either $a or $b is
* TRUE, but not both.
*/
case JX9_OP_LXOR:{
jx9_value *pNos = &pTos[-1];
sxi32 v = 0;
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
/* Force a boolean cast */
if((pTos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pTos);
}
if((pNos->iFlags & MEMOBJ_BOOL) == 0 ){
jx9MemObjToBool(pNos);
}
if( (pNos->x.iVal && !pTos->x.iVal) || (pTos->x.iVal && !pNos->x.iVal) ){
v = 1;
}
VmPopOperand(&pTos, 1);
pTos->x.iVal = v;
MemObjSetType(pTos, MEMOBJ_BOOL);
break;
}
/* OP_EQ P1 P2 P3
*
* Pop the top two elements from the stack. If they are equal, then
* jump to instruction P2. Otherwise, continue to the next instruction.
* If P2 is zero, do not jump. Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*/
/* OP_NEQ P1 P2 P3
*
* Pop the top two elements from the stack. If they are not equal, then
* jump to instruction P2. Otherwise, continue to the next instruction.
* If P2 is zero, do not jump. Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*/
case JX9_OP_EQ:
case JX9_OP_NEQ: {
jx9_value *pNos = &pTos[-1];
/* Perform the comparison and act accordingly */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
rc = jx9MemObjCmp(pNos, pTos, FALSE, 0);
if( pInstr->iOp == JX9_OP_EQ ){
rc = rc == 0;
}else{
rc = rc != 0;
}
VmPopOperand(&pTos, 1);
if( !pInstr->iP2 ){
/* Push comparison result without taking the jump */
jx9MemObjRelease(pTos);
pTos->x.iVal = rc;
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_BOOL);
}else{
if( rc ){
/* Jump to the desired location */
pc = pInstr->iP2 - 1;
VmPopOperand(&pTos, 1);
}
}
break;
}
/* OP_TEQ P1 P2 *
*
* Pop the top two elements from the stack. If they have the same type and are equal
* then jump to instruction P2. Otherwise, continue to the next instruction.
* If P2 is zero, do not jump. Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*/
case JX9_OP_TEQ: {
jx9_value *pNos = &pTos[-1];
/* Perform the comparison and act accordingly */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
rc = jx9MemObjCmp(pNos, pTos, TRUE, 0) == 0;
VmPopOperand(&pTos, 1);
if( !pInstr->iP2 ){
/* Push comparison result without taking the jump */
jx9MemObjRelease(pTos);
pTos->x.iVal = rc;
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_BOOL);
}else{
if( rc ){
/* Jump to the desired location */
pc = pInstr->iP2 - 1;
VmPopOperand(&pTos, 1);
}
}
break;
}
/* OP_TNE P1 P2 *
*
* Pop the top two elements from the stack.If they are not equal an they are not
* of the same type, then jump to instruction P2. Otherwise, continue to the next
* instruction.
* If P2 is zero, do not jump. Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*
*/
case JX9_OP_TNE: {
jx9_value *pNos = &pTos[-1];
/* Perform the comparison and act accordingly */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
rc = jx9MemObjCmp(pNos, pTos, TRUE, 0) != 0;
VmPopOperand(&pTos, 1);
if( !pInstr->iP2 ){
/* Push comparison result without taking the jump */
jx9MemObjRelease(pTos);
pTos->x.iVal = rc;
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_BOOL);
}else{
if( rc ){
/* Jump to the desired location */
pc = pInstr->iP2 - 1;
VmPopOperand(&pTos, 1);
}
}
break;
}
/* OP_LT P1 P2 P3
*
* Pop the top two elements from the stack. If the second element (the top of stack)
* is less than the first (next on stack), then jump to instruction P2.Otherwise
* continue to the next instruction. In other words, jump if pNos<pTos.
* If P2 is zero, do not jump.Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*
*/
/* OP_LE P1 P2 P3
*
* Pop the top two elements from the stack. If the second element (the top of stack)
* is less than or equal to the first (next on stack), then jump to instruction P2.
* Otherwise continue to the next instruction. In other words, jump if pNos<pTos.
* If P2 is zero, do not jump.Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*
*/
case JX9_OP_LT:
case JX9_OP_LE: {
jx9_value *pNos = &pTos[-1];
/* Perform the comparison and act accordingly */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
rc = jx9MemObjCmp(pNos, pTos, FALSE, 0);
if( pInstr->iOp == JX9_OP_LE ){
rc = rc < 1;
}else{
rc = rc < 0;
}
VmPopOperand(&pTos, 1);
if( !pInstr->iP2 ){
/* Push comparison result without taking the jump */
jx9MemObjRelease(pTos);
pTos->x.iVal = rc;
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_BOOL);
}else{
if( rc ){
/* Jump to the desired location */
pc = pInstr->iP2 - 1;
VmPopOperand(&pTos, 1);
}
}
break;
}
/* OP_GT P1 P2 P3
*
* Pop the top two elements from the stack. If the second element (the top of stack)
* is greater than the first (next on stack), then jump to instruction P2.Otherwise
* continue to the next instruction. In other words, jump if pNos<pTos.
* If P2 is zero, do not jump.Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*
*/
/* OP_GE P1 P2 P3
*
* Pop the top two elements from the stack. If the second element (the top of stack)
* is greater than or equal to the first (next on stack), then jump to instruction P2.
* Otherwise continue to the next instruction. In other words, jump if pNos<pTos.
* If P2 is zero, do not jump.Instead, push a boolean 1 (TRUE) onto the
* stack if the jump would have been taken, or a 0 (FALSE) if not.
*
*/
case JX9_OP_GT:
case JX9_OP_GE: {
jx9_value *pNos = &pTos[-1];
/* Perform the comparison and act accordingly */
#ifdef UNTRUST
if( pNos < pStack ){
goto Abort;
}
#endif
rc = jx9MemObjCmp(pNos, pTos, FALSE, 0);
if( pInstr->iOp == JX9_OP_GE ){
rc = rc >= 0;
}else{
rc = rc > 0;
}
VmPopOperand(&pTos, 1);
if( !pInstr->iP2 ){
/* Push comparison result without taking the jump */
jx9MemObjRelease(pTos);
pTos->x.iVal = rc;
/* Invalidate any prior representation */
MemObjSetType(pTos, MEMOBJ_BOOL);
}else{
if( rc ){
/* Jump to the desired location */
pc = pInstr->iP2 - 1;
VmPopOperand(&pTos, 1);
}
}
break;
}
/*
* OP_FOREACH_INIT * P2 P3
* Prepare a foreach step.
*/
case JX9_OP_FOREACH_INIT: {
jx9_foreach_info *pInfo = (jx9_foreach_info *)pInstr->p3;
void *pName;
#ifdef UNTRUST
if( pTos < pStack ){
goto Abort;
}
#endif
if( SyStringLength(&pInfo->sValue) < 1 ){
/* Take the variable name from the top of the stack */
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pTos);
}
/* Duplicate name */
if( SyBlobLength(&pTos->sBlob) > 0 ){
pName = SyMemBackendDup(&pVm->sAllocator, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
SyStringInitFromBuf(&pInfo->sValue, pName, SyBlobLength(&pTos->sBlob));
}
VmPopOperand(&pTos, 1);
}
if( (pInfo->iFlags & JX9_4EACH_STEP_KEY) && SyStringLength(&pInfo->sKey) < 1 ){
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pTos);
}
/* Duplicate name */
if( SyBlobLength(&pTos->sBlob) > 0 ){
pName = SyMemBackendDup(&pVm->sAllocator, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
SyStringInitFromBuf(&pInfo->sKey, pName, SyBlobLength(&pTos->sBlob));
}
VmPopOperand(&pTos, 1);
}
/* Make sure we are dealing with a hashmap [i.e. JSON array or object ]*/
if( (pTos->iFlags & (MEMOBJ_HASHMAP)) == 0 || SyStringLength(&pInfo->sValue) < 1 ){
/* Jump out of the loop */
if( (pTos->iFlags & MEMOBJ_NULL) == 0 ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_WARNING,
"Invalid argument supplied for the foreach statement, expecting JSON array or object instance");
}
pc = pInstr->iP2 - 1;
}else{
jx9_foreach_step *pStep;
pStep = (jx9_foreach_step *)SyMemBackendPoolAlloc(&pVm->sAllocator, sizeof(jx9_foreach_step));
if( pStep == 0 ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "JX9 is running out of memory while preparing the 'foreach' step");
/* Jump out of the loop */
pc = pInstr->iP2 - 1;
}else{
/* Zero the structure */
SyZero(pStep, sizeof(jx9_foreach_step));
/* Prepare the step */
pStep->iFlags = pInfo->iFlags;
if( pTos->iFlags & MEMOBJ_HASHMAP ){
jx9_hashmap *pMap = (jx9_hashmap *)pTos->x.pOther;
/* Reset the internal loop cursor */
jx9HashmapResetLoopCursor(pMap);
/* Mark the step */
pStep->pMap = pMap;
pMap->iRef++;
}
}
if( SXRET_OK != SySetPut(&pInfo->aStep, (const void *)&pStep) ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR, "JX9 is running out of memory while preparing the 'foreach' step");
SyMemBackendPoolFree(&pVm->sAllocator, pStep);
/* Jump out of the loop */
pc = pInstr->iP2 - 1;
}
}
VmPopOperand(&pTos, 1);
break;
}
/*
* OP_FOREACH_STEP * P2 P3
* Perform a foreach step. Jump to P2 at the end of the step.
*/
case JX9_OP_FOREACH_STEP: {
jx9_foreach_info *pInfo = (jx9_foreach_info *)pInstr->p3;
jx9_foreach_step **apStep, *pStep;
jx9_hashmap_node *pNode;
jx9_hashmap *pMap;
jx9_value *pValue;
/* Peek the last step */
apStep = (jx9_foreach_step **)SySetBasePtr(&pInfo->aStep);
pStep = apStep[SySetUsed(&pInfo->aStep) - 1];
pMap = pStep->pMap;
/* Extract the current node value */
pNode = jx9HashmapGetNextEntry(pMap);
if( pNode == 0 ){
/* No more entry to process */
pc = pInstr->iP2 - 1; /* Jump to this destination */
/* Automatically reset the loop cursor */
jx9HashmapResetLoopCursor(pMap);
/* Cleanup the mess left behind */
SyMemBackendPoolFree(&pVm->sAllocator, pStep);
SySetPop(&pInfo->aStep);
jx9HashmapUnref(pMap);
}else{
if( (pStep->iFlags & JX9_4EACH_STEP_KEY) && SyStringLength(&pInfo->sKey) > 0 ){
jx9_value *pKey = VmExtractMemObj(&(*pVm), &pInfo->sKey, FALSE, TRUE);
if( pKey ){
jx9HashmapExtractNodeKey(pNode, pKey);
}
}
/* Make a copy of the entry value */
pValue = VmExtractMemObj(&(*pVm), &pInfo->sValue, FALSE, TRUE);
if( pValue ){
jx9HashmapExtractNodeValue(pNode, pValue, TRUE);
}
}
break;
}
/*
* OP_MEMBER P1 P2
* Load JSON object entry on the stack.
*/
case JX9_OP_MEMBER: {
jx9_hashmap_node *pNode = 0; /* cc warning */
jx9_hashmap *pMap = 0;
jx9_value *pIdx;
pIdx = pTos;
pTos--;
rc = SXERR_NOTFOUND; /* Assume the index is invalid */
if( pTos->iFlags & MEMOBJ_HASHMAP ){
/* Point to the hashmap */
pMap = (jx9_hashmap *)pTos->x.pOther;
/* Load the desired entry */
rc = jx9HashmapLookup(pMap, pIdx, &pNode);
}
jx9MemObjRelease(pIdx);
if( rc == SXRET_OK ){
/* Load entry contents */
if( pMap->iRef < 2 ){
/* TICKET 1433-42: Array will be deleted shortly, so we will make a copy
* of the entry value, rather than pointing to it.
*/
pTos->nIdx = SXU32_HIGH;
jx9HashmapExtractNodeValue(pNode, pTos, TRUE);
}else{
pTos->nIdx = pNode->nValIdx;
jx9HashmapExtractNodeValue(pNode, pTos, FALSE);
jx9HashmapUnref(pMap);
}
}else{
/* No such entry, load NULL */
jx9MemObjRelease(pTos);
pTos->nIdx = SXU32_HIGH;
}
break;
}
/*
* OP_SWITCH * * P3
* This is the bytecode implementation of the complex switch() JX9 construct.
*/
case JX9_OP_SWITCH: {
jx9_switch *pSwitch = (jx9_switch *)pInstr->p3;
jx9_case_expr *aCase, *pCase;
jx9_value sValue, sCaseValue;
sxu32 n, nEntry;
#ifdef UNTRUST
if( pSwitch == 0 || pTos < pStack ){
goto Abort;
}
#endif
/* Point to the case table */
aCase = (jx9_case_expr *)SySetBasePtr(&pSwitch->aCaseExpr);
nEntry = SySetUsed(&pSwitch->aCaseExpr);
/* Select the appropriate case block to execute */
jx9MemObjInit(pVm, &sValue);
jx9MemObjInit(pVm, &sCaseValue);
for( n = 0 ; n < nEntry ; ++n ){
pCase = &aCase[n];
jx9MemObjLoad(pTos, &sValue);
/* Execute the case expression first */
VmLocalExec(pVm,&pCase->aByteCode, &sCaseValue);
/* Compare the two expression */
rc = jx9MemObjCmp(&sValue, &sCaseValue, FALSE, 0);
jx9MemObjRelease(&sValue);
jx9MemObjRelease(&sCaseValue);
if( rc == 0 ){
/* Value match, jump to this block */
pc = pCase->nStart - 1;
break;
}
}
VmPopOperand(&pTos, 1);
if( n >= nEntry ){
/* No approprite case to execute, jump to the default case */
if( pSwitch->nDefault > 0 ){
pc = pSwitch->nDefault - 1;
}else{
/* No default case, jump out of this switch */
pc = pSwitch->nOut - 1;
}
}
break;
}
/*
* OP_UPLINK P1 * *
* Link a variable to the top active VM frame.
* This is used to implement the 'uplink' JX9 construct.
*/
case JX9_OP_UPLINK: {
if( pVm->pFrame->pParent ){
jx9_value *pLink = &pTos[-pInstr->iP1+1];
SyString sName;
/* Perform the link */
while( pLink <= pTos ){
if((pLink->iFlags & MEMOBJ_STRING) == 0 ){
/* Force a string cast */
jx9MemObjToString(pLink);
}
SyStringInitFromBuf(&sName, SyBlobData(&pLink->sBlob), SyBlobLength(&pLink->sBlob));
if( sName.nByte > 0 ){
VmFrameLink(&(*pVm), &sName);
}
pLink++;
}
}
VmPopOperand(&pTos, pInstr->iP1);
break;
}
/*
* OP_CALL P1 * *
* Call a JX9 or a foreign function and push the return value of the called
* function on the stack.
*/
case JX9_OP_CALL: {
jx9_value *pArg = &pTos[-pInstr->iP1];
SyHashEntry *pEntry;
SyString sName;
/* Extract function name */
if( (pTos->iFlags & MEMOBJ_STRING) == 0 ){
/* Raise exception: Invalid function name */
VmErrorFormat(&(*pVm), JX9_CTX_WARNING, "Invalid function name, JX9 is returning NULL.");
/* Pop given arguments */
if( pInstr->iP1 > 0 ){
VmPopOperand(&pTos, pInstr->iP1);
}
/* Assume a null return value so that the program continue it's execution normally */
jx9MemObjRelease(pTos);
break;
}
SyStringInitFromBuf(&sName, SyBlobData(&pTos->sBlob), SyBlobLength(&pTos->sBlob));
/* Check for a compiled function first */
pEntry = SyHashGet(&pVm->hFunction, (const void *)sName.zString, sName.nByte);
if( pEntry ){
jx9_vm_func_arg *aFormalArg;
jx9_value *pFrameStack;
jx9_vm_func *pVmFunc;
VmFrame *pFrame;
jx9_value *pObj;
VmSlot sArg;
sxu32 n;
pVmFunc = (jx9_vm_func *)pEntry->pUserData;
/* Check The recursion limit */
if( pVm->nRecursionDepth > pVm->nMaxDepth ){
VmErrorFormat(&(*pVm), JX9_CTX_ERR,
"Recursion limit reached while invoking user function '%z', JX9 will set a NULL return value",
&pVmFunc->sName);
/* Pop given arguments */
if( pInstr->iP1 > 0 ){
VmPopOperand(&pTos, pInstr->iP1);
}
/* Assume a null return value so that the program continue it's execution normally */
jx9MemObjRelease(pTos);
break;
}
if( pVmFunc->pNextName ){
/* Function is candidate for overloading, select the appropriate function to call */
pVmFunc = VmOverload(&(*pVm), pVmFunc, pArg, (int)(pTos-pArg));
}
/* Extract the formal argument set */
aFormalArg = (jx9_vm_func_arg *)SySetBasePtr(&pVmFunc->aArgs);
/* Create a new VM frame */
rc = VmEnterFrame(&(*pVm),pVmFunc,&pFrame);
if( rc != SXRET_OK ){
/* Raise exception: Out of memory */
VmErrorFormat(&(*pVm), JX9_CTX_ERR,
"JX9 is running out of memory while calling function '%z', JX9 is returning NULL.",
&pVmFunc->sName);
/* Pop given arguments */
if( pInstr->iP1 > 0 ){
VmPopOperand(&pTos, pInstr->iP1);
}
/* Assume a null return value so that the program continue it's execution normally */
jx9MemObjRelease(pTos);
break;
}
if( SySetUsed(&pVmFunc->aStatic) > 0 ){
jx9_vm_func_static_var *pStatic, *aStatic;
/* Install static variables */
aStatic = (jx9_vm_func_static_var *)SySetBasePtr(&pVmFunc->aStatic);
for( n = 0 ; n < SySetUsed(&pVmFunc->aStatic) ; ++n ){
pStatic = &aStatic[n];
if( pStatic->nIdx == SXU32_HIGH ){
/* Initialize the static variables */
pObj = VmReserveMemObj(&(*pVm), &pStatic->nIdx);
if( pObj ){
/* Assume a NULL initialization value */
jx9MemObjInit(&(*pVm), pObj);
if( SySetUsed(&pStatic->aByteCode) > 0 ){
/* Evaluate initialization expression (Any complex expression) */
VmLocalExec(&(*pVm), &pStatic->aByteCode, pObj);
}
pObj->nIdx = pStatic->nIdx;
}else{
continue;
}
}
/* Install in the current frame */
SyHashInsert(&pFrame->hVar, SyStringData(&pStatic->sName), SyStringLength(&pStatic->sName),
SX_INT_TO_PTR(pStatic->nIdx));
}
}
/* Push arguments in the local frame */
n = 0;
while( pArg < pTos ){
if( n < SySetUsed(&pVmFunc->aArgs) ){
if( (pArg->iFlags & MEMOBJ_NULL) && SySetUsed(&aFormalArg[n].aByteCode) > 0 ){
/* NULL values are redirected to default arguments */
rc = VmLocalExec(&(*pVm), &aFormalArg[n].aByteCode, pArg);
if( rc == JX9_ABORT ){
goto Abort;
}
}
/* Make sure the given arguments are of the correct type */
if( aFormalArg[n].nType > 0 ){
if( ((pArg->iFlags & aFormalArg[n].nType) == 0) ){
ProcMemObjCast xCast = jx9MemObjCastMethod(aFormalArg[n].nType);
/* Cast to the desired type */
if( xCast ){
xCast(pArg);
}
}
}
/* Pass by value, make a copy of the given argument */
pObj = VmExtractMemObj(&(*pVm), &aFormalArg[n].sName, FALSE, TRUE);
}else{
char zName[32];
SyString sName;
/* Set a dummy name */
sName.nByte = SyBufferFormat(zName, sizeof(zName), "[%u]apArg", n);
sName.zString = zName;
/* Annonymous argument */
pObj = VmExtractMemObj(&(*pVm), &sName, TRUE, TRUE);
}
if( pObj ){
jx9MemObjStore(pArg, pObj);
/* Insert argument index */
sArg.nIdx = pObj->nIdx;
sArg.pUserData = 0;
SySetPut(&pFrame->sArg, (const void *)&sArg);
}
jx9MemObjRelease(pArg);
pArg++;
++n;
}
/* Process default values */
while( n < SySetUsed(&pVmFunc->aArgs) ){
if( SySetUsed(&aFormalArg[n].aByteCode) > 0 ){
pObj = VmExtractMemObj(&(*pVm), &aFormalArg[n].sName, FALSE, TRUE);
if( pObj ){
/* Evaluate the default value and extract it's result */
rc = VmLocalExec(&(*pVm), &aFormalArg[n].aByteCode, pObj);
if( rc == JX9_ABORT ){
goto Abort;
}
/* Insert argument index */
sArg.nIdx = pObj->nIdx;
sArg.pUserData = 0;
SySetPut(&pFrame->sArg, (const void *)&sArg);
/* Make sure the default argument is of the correct type */
if( aFormalArg[n].nType > 0 && ((pObj->iFlags & aFormalArg[n].nType) == 0) ){
ProcMemObjCast xCast = jx9MemObjCastMethod(aFormalArg[n].nType);
/* Cast to the desired type */
xCast(pObj);
}
}
}
++n;
}
/* Pop arguments, function name from the operand stack and assume the function
* does not return anything.
*/
jx9MemObjRelease(pTos);
pTos = &pTos[-pInstr->iP1];
/* Allocate a new operand stack and evaluate the function body */
pFrameStack = VmNewOperandStack(&(*pVm), SySetUsed(&pVmFunc->aByteCode));
if( pFrameStack == 0 ){
/* Raise exception: Out of memory */
VmErrorFormat(&(*pVm), JX9_CTX_ERR, "JX9 is running out of memory while calling function '%z', JX9 is returning NULL.",
&pVmFunc->sName);
if( pInstr->iP1 > 0 ){
VmPopOperand(&pTos, pInstr->iP1);
}
break;
}
/* Increment nesting level */
pVm->nRecursionDepth++;
/* Execute function body */
rc = VmByteCodeExec(&(*pVm), (VmInstr *)SySetBasePtr(&pVmFunc->aByteCode), pFrameStack, -1, pTos);
/* Decrement nesting level */
pVm->nRecursionDepth--;
/* Free the operand stack */
SyMemBackendFree(&pVm->sAllocator, pFrameStack);
/* Leave the frame */
VmLeaveFrame(&(*pVm));
if( rc == JX9_ABORT ){
/* Abort processing immeditaley */
goto Abort;
}
}else{
jx9_user_func *pFunc;
jx9_context sCtx;
jx9_value sRet;
/* Look for an installed foreign function */
pEntry = SyHashGet(&pVm->hHostFunction, (const void *)sName.zString, sName.nByte);
if( pEntry == 0 ){
/* Call to undefined function */
VmErrorFormat(&(*pVm), JX9_CTX_WARNING, "Call to undefined function '%z', JX9 is returning NULL.", &sName);
/* Pop given arguments */
if( pInstr->iP1 > 0 ){
VmPopOperand(&pTos, pInstr->iP1);
}
/* Assume a null return value so that the program continue it's execution normally */
jx9MemObjRelease(pTos);
break;
}
pFunc = (jx9_user_func *)pEntry->pUserData;
/* Start collecting function arguments */
SySetReset(&aArg);
while( pArg < pTos ){
SySetPut(&aArg, (const void *)&pArg);
pArg++;
}
/* Assume a null return value */
jx9MemObjInit(&(*pVm), &sRet);
/* Init the call context */
VmInitCallContext(&sCtx, &(*pVm), pFunc, &sRet, 0);
/* Call the foreign function */
rc = pFunc->xFunc(&sCtx, (int)SySetUsed(&aArg), (jx9_value **)SySetBasePtr(&aArg));
/* Release the call context */
VmReleaseCallContext(&sCtx);
if( rc == JX9_ABORT ){
goto Abort;
}
if( pInstr->iP1 > 0 ){
/* Pop function name and arguments */
VmPopOperand(&pTos, pInstr->iP1);
}
/* Save foreign function return value */
jx9MemObjStore(&sRet, pTos);
jx9MemObjRelease(&sRet);
}
break;
}
/*
* OP_CONSUME: P1 * *
* Consume (Invoke the installed VM output consumer callback) and POP P1 elements from the stack.
*/
case JX9_OP_CONSUME: {
jx9_output_consumer *pCons = &pVm->sVmConsumer;
jx9_value *pCur, *pOut = pTos;
pOut = &pTos[-pInstr->iP1 + 1];
pCur = pOut;
/* Start the consume process */
while( pOut <= pTos ){
/* Force a string cast */
if( (pOut->iFlags & MEMOBJ_STRING) == 0 ){
jx9MemObjToString(pOut);
}
if( SyBlobLength(&pOut->sBlob) > 0 ){
/*SyBlobNullAppend(&pOut->sBlob);*/
/* Invoke the output consumer callback */
rc = pCons->xConsumer(SyBlobData(&pOut->sBlob), SyBlobLength(&pOut->sBlob), pCons->pUserData);
/* Increment output length */
pVm->nOutputLen += SyBlobLength(&pOut->sBlob);
SyBlobRelease(&pOut->sBlob);
if( rc == SXERR_ABORT ){
/* Output consumer callback request an operation abort. */
goto Abort;
}
}
pOut++;
}
pTos = &pCur[-1];
break;
}
} /* Switch() */
pc++; /* Next instruction in the stream */
} /* For(;;) */
Done:
SySetRelease(&aArg);
return SXRET_OK;
Abort:
SySetRelease(&aArg);
while( pTos >= pStack ){
jx9MemObjRelease(pTos);
pTos--;
}
return JX9_ABORT;
}
/*
* Execute as much of a local JX9 bytecode program as we can then return.
* This function is a wrapper around [VmByteCodeExec()].
* See block-comment on that function for additional information.
*/
static sxi32 VmLocalExec(jx9_vm *pVm, SySet *pByteCode,jx9_value *pResult)
{
jx9_value *pStack;
sxi32 rc;
/* Allocate a new operand stack */
pStack = VmNewOperandStack(&(*pVm), SySetUsed(pByteCode));
if( pStack == 0 ){
return SXERR_MEM;
}
/* Execute the program */
rc = VmByteCodeExec(&(*pVm), (VmInstr *)SySetBasePtr(pByteCode), pStack, -1, &(*pResult));
/* Free the operand stack */
SyMemBackendFree(&pVm->sAllocator, pStack);
/* Execution result */
return rc;
}
/*
* Execute as much of a JX9 bytecode program as we can then return.
* This function is a wrapper around [VmByteCodeExec()].
* See block-comment on that function for additional information.
*/
JX9_PRIVATE sxi32 jx9VmByteCodeExec(jx9_vm *pVm)
{
/* Make sure we are ready to execute this program */
if( pVm->nMagic != JX9_VM_RUN ){
return pVm->nMagic == JX9_VM_EXEC ? SXERR_LOCKED /* Locked VM */ : SXERR_CORRUPT; /* Stale VM */
}
/* Set the execution magic number */
pVm->nMagic = JX9_VM_EXEC;
/* Execute the program */
VmByteCodeExec(&(*pVm), (VmInstr *)SySetBasePtr(pVm->pByteContainer), pVm->aOps, -1, &pVm->sExec);
/*
* TICKET 1433-100: Do not remove the JX9_VM_EXEC magic number
* so that any following call to [jx9_vm_exec()] without calling
* [jx9_vm_reset()] first would fail.
*/
return SXRET_OK;
}
/*
* Extract a memory object (i.e. a variable) from the running script.
* This function must be called after calling jx9_vm_exec(). Otherwise
* NULL is returned.
*/
JX9_PRIVATE jx9_value * jx9VmExtractVariable(jx9_vm *pVm,SyString *pVar)
{
jx9_value *pValue;
if( pVm->nMagic != JX9_VM_EXEC ){
/* call jx9_vm_exec() first */
return 0;
}
/* Perform the lookup */
pValue = VmExtractMemObj(pVm,pVar,FALSE,FALSE);
/* Lookup result */
return pValue;
}
/*
* Invoke the installed VM output consumer callback to consume
* the desired message.
* Refer to the implementation of [jx9_context_output()] defined
* in 'api.c' for additional information.
*/
JX9_PRIVATE sxi32 jx9VmOutputConsume(
jx9_vm *pVm, /* Target VM */
SyString *pString /* Message to output */
)
{
jx9_output_consumer *pCons = &pVm->sVmConsumer;
sxi32 rc = SXRET_OK;
/* Call the output consumer */
if( pString->nByte > 0 ){
rc = pCons->xConsumer((const void *)pString->zString, pString->nByte, pCons->pUserData);
/* Increment output length */
pVm->nOutputLen += pString->nByte;
}
return rc;
}
/*
* Format a message and invoke the installed VM output consumer
* callback to consume the formatted message.
* Refer to the implementation of [jx9_context_output_format()] defined
* in 'api.c' for additional information.
*/
JX9_PRIVATE sxi32 jx9VmOutputConsumeAp(
jx9_vm *pVm, /* Target VM */
const char *zFormat, /* Formatted message to output */
va_list ap /* Variable list of arguments */
)
{
jx9_output_consumer *pCons = &pVm->sVmConsumer;
sxi32 rc = SXRET_OK;
SyBlob sWorker;
/* Format the message and call the output consumer */
SyBlobInit(&sWorker, &pVm->sAllocator);
SyBlobFormatAp(&sWorker, zFormat, ap);
if( SyBlobLength(&sWorker) > 0 ){
/* Consume the formatted message */
rc = pCons->xConsumer(SyBlobData(&sWorker), SyBlobLength(&sWorker), pCons->pUserData);
}
/* Increment output length */
pVm->nOutputLen += SyBlobLength(&sWorker);
/* Release the working buffer */
SyBlobRelease(&sWorker);
return rc;
}
/*
* Return a string representation of the given JX9 OP code.
* This function never fail and always return a pointer
* to a null terminated string.
*/
static const char * VmInstrToString(sxi32 nOp)
{
const char *zOp = "Unknown ";
switch(nOp){
case JX9_OP_DONE: zOp = "DONE "; break;
case JX9_OP_HALT: zOp = "HALT "; break;
case JX9_OP_LOAD: zOp = "LOAD "; break;
case JX9_OP_LOADC: zOp = "LOADC "; break;
case JX9_OP_LOAD_MAP: zOp = "LOAD_MAP "; break;
case JX9_OP_LOAD_IDX: zOp = "LOAD_IDX "; break;
case JX9_OP_NOOP: zOp = "NOOP "; break;
case JX9_OP_JMP: zOp = "JMP "; break;
case JX9_OP_JZ: zOp = "JZ "; break;
case JX9_OP_JNZ: zOp = "JNZ "; break;
case JX9_OP_POP: zOp = "POP "; break;
case JX9_OP_CAT: zOp = "CAT "; break;
case JX9_OP_CVT_INT: zOp = "CVT_INT "; break;
case JX9_OP_CVT_STR: zOp = "CVT_STR "; break;
case JX9_OP_CVT_REAL: zOp = "CVT_REAL "; break;
case JX9_OP_CALL: zOp = "CALL "; break;
case JX9_OP_UMINUS: zOp = "UMINUS "; break;
case JX9_OP_UPLUS: zOp = "UPLUS "; break;
case JX9_OP_BITNOT: zOp = "BITNOT "; break;
case JX9_OP_LNOT: zOp = "LOGNOT "; break;
case JX9_OP_MUL: zOp = "MUL "; break;
case JX9_OP_DIV: zOp = "DIV "; break;
case JX9_OP_MOD: zOp = "MOD "; break;
case JX9_OP_ADD: zOp = "ADD "; break;
case JX9_OP_SUB: zOp = "SUB "; break;
case JX9_OP_SHL: zOp = "SHL "; break;
case JX9_OP_SHR: zOp = "SHR "; break;
case JX9_OP_LT: zOp = "LT "; break;
case JX9_OP_LE: zOp = "LE "; break;
case JX9_OP_GT: zOp = "GT "; break;
case JX9_OP_GE: zOp = "GE "; break;
case JX9_OP_EQ: zOp = "EQ "; break;
case JX9_OP_NEQ: zOp = "NEQ "; break;
case JX9_OP_TEQ: zOp = "TEQ "; break;
case JX9_OP_TNE: zOp = "TNE "; break;
case JX9_OP_BAND: zOp = "BITAND "; break;
case JX9_OP_BXOR: zOp = "BITXOR "; break;
case JX9_OP_BOR: zOp = "BITOR "; break;
case JX9_OP_LAND: zOp = "LOGAND "; break;
case JX9_OP_LOR: zOp = "LOGOR "; break;
case JX9_OP_LXOR: zOp = "LOGXOR "; break;
case JX9_OP_STORE: zOp = "STORE "; break;
case JX9_OP_STORE_IDX: zOp = "STORE_IDX "; break;
case JX9_OP_PULL: zOp = "PULL "; break;
case JX9_OP_SWAP: zOp = "SWAP "; break;
case JX9_OP_YIELD: zOp = "YIELD "; break;
case JX9_OP_CVT_BOOL: zOp = "CVT_BOOL "; break;
case JX9_OP_CVT_NULL: zOp = "CVT_NULL "; break;
case JX9_OP_CVT_ARRAY: zOp = "CVT_JSON "; break;
case JX9_OP_CVT_NUMC: zOp = "CVT_NUMC "; break;
case JX9_OP_INCR: zOp = "INCR "; break;
case JX9_OP_DECR: zOp = "DECR "; break;
case JX9_OP_ADD_STORE: zOp = "ADD_STORE "; break;
case JX9_OP_SUB_STORE: zOp = "SUB_STORE "; break;
case JX9_OP_MUL_STORE: zOp = "MUL_STORE "; break;
case JX9_OP_DIV_STORE: zOp = "DIV_STORE "; break;
case JX9_OP_MOD_STORE: zOp = "MOD_STORE "; break;
case JX9_OP_CAT_STORE: zOp = "CAT_STORE "; break;
case JX9_OP_SHL_STORE: zOp = "SHL_STORE "; break;
case JX9_OP_SHR_STORE: zOp = "SHR_STORE "; break;
case JX9_OP_BAND_STORE: zOp = "BAND_STORE "; break;
case JX9_OP_BOR_STORE: zOp = "BOR_STORE "; break;
case JX9_OP_BXOR_STORE: zOp = "BXOR_STORE "; break;
case JX9_OP_CONSUME: zOp = "CONSUME "; break;
case JX9_OP_MEMBER: zOp = "MEMBER "; break;
case JX9_OP_UPLINK: zOp = "UPLINK "; break;
case JX9_OP_SWITCH: zOp = "SWITCH "; break;
case JX9_OP_FOREACH_INIT:
zOp = "4EACH_INIT "; break;
case JX9_OP_FOREACH_STEP:
zOp = "4EACH_STEP "; break;
default:
break;
}
return zOp;
}
/*
* Dump JX9 bytecodes instructions to a human readable format.
* The xConsumer() callback which is an used defined function
* is responsible of consuming the generated dump.
*/
JX9_PRIVATE sxi32 jx9VmDump(
jx9_vm *pVm, /* Target VM */
ProcConsumer xConsumer, /* Output [i.e: dump] consumer callback */
void *pUserData /* Last argument to xConsumer() */
)
{
sxi32 rc;
rc = VmByteCodeDump(pVm->pByteContainer, xConsumer, pUserData);
return rc;
}
/*
* Default constant expansion callback used by the 'const' statement if used
* outside a object body [i.e: global or function scope].
* Refer to the implementation of [JX9_CompileConstant()] defined
* in 'compile.c' for additional information.
*/
JX9_PRIVATE void jx9VmExpandConstantValue(jx9_value *pVal, void *pUserData)
{
SySet *pByteCode = (SySet *)pUserData;
/* Evaluate and expand constant value */
VmLocalExec((jx9_vm *)SySetGetUserData(pByteCode), pByteCode, (jx9_value *)pVal);
}
/*
* Section:
* Function handling functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* int func_num_args(void)
* Returns the number of arguments passed to the function.
* Parameters
* None.
* Return
* Total number of arguments passed into the current user-defined function
* or -1 if called from the globe scope.
*/
static int vm_builtin_func_num_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
VmFrame *pFrame;
jx9_vm *pVm;
/* Point to the target VM */
pVm = pCtx->pVm;
/* Current frame */
pFrame = pVm->pFrame;
if( pFrame->pParent == 0 ){
SXUNUSED(nArg);
SXUNUSED(apArg);
/* Global frame, return -1 */
jx9_result_int(pCtx, -1);
return SXRET_OK;
}
/* Total number of arguments passed to the enclosing function */
nArg = (int)SySetUsed(&pFrame->sArg);
jx9_result_int(pCtx, nArg);
return SXRET_OK;
}
/*
* value func_get_arg(int $arg_num)
* Return an item from the argument list.
* Parameters
* Argument number(index start from zero).
* Return
* Returns the specified argument or FALSE on error.
*/
static int vm_builtin_func_get_arg(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pObj = 0;
VmSlot *pSlot = 0;
VmFrame *pFrame;
jx9_vm *pVm;
/* Point to the target VM */
pVm = pCtx->pVm;
/* Current frame */
pFrame = pVm->pFrame;
if( nArg < 1 || pFrame->pParent == 0 ){
/* Global frame or Missing arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Extract the desired index */
nArg = jx9_value_to_int(apArg[0]);
if( nArg < 0 || nArg >= (int)SySetUsed(&pFrame->sArg) ){
/* Invalid index, return FALSE */
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Extract the desired argument */
if( (pSlot = (VmSlot *)SySetAt(&pFrame->sArg, (sxu32)nArg)) != 0 ){
if( (pObj = (jx9_value *)SySetAt(&pVm->aMemObj, pSlot->nIdx)) != 0 ){
/* Return the desired argument */
jx9_result_value(pCtx, (jx9_value *)pObj);
}else{
/* No such argument, return false */
jx9_result_bool(pCtx, 0);
}
}else{
/* CAN'T HAPPEN */
jx9_result_bool(pCtx, 0);
}
return SXRET_OK;
}
/*
* array func_get_args(void)
* Returns an array comprising a copy of function's argument list.
* Parameters
* None.
* Return
* Returns an array in which each element is a copy of the corresponding
* member of the current user-defined function's argument list.
* Otherwise FALSE is returned on failure.
*/
static int vm_builtin_func_get_args(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pObj = 0;
jx9_value *pArray;
VmFrame *pFrame;
VmSlot *aSlot;
sxu32 n;
/* Point to the current frame */
pFrame = pCtx->pVm->pFrame;
if( pFrame->pParent == 0 ){
/* Global frame, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_WARNING, "Called in the global scope");
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Create a new array */
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Start filling the array with the given arguments */
aSlot = (VmSlot *)SySetBasePtr(&pFrame->sArg);
for( n = 0; n < SySetUsed(&pFrame->sArg) ; n++ ){
pObj = (jx9_value *)SySetAt(&pCtx->pVm->aMemObj, aSlot[n].nIdx);
if( pObj ){
jx9_array_add_elem(pArray, 0/* Automatic index assign*/, pObj);
}
}
/* Return the freshly created array */
jx9_result_value(pCtx, pArray);
return SXRET_OK;
}
/*
* bool function_exists(string $name)
* Return TRUE if the given function has been defined.
* Parameters
* The name of the desired function.
* Return
* Return TRUE if the given function has been defined.False otherwise
*/
static int vm_builtin_func_exists(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zName;
jx9_vm *pVm;
int nLen;
int res;
if( nArg < 1 ){
/* Missing argument, return FALSE */
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Point to the target VM */
pVm = pCtx->pVm;
/* Extract the function name */
zName = jx9_value_to_string(apArg[0], &nLen);
/* Assume the function is not defined */
res = 0;
/* Perform the lookup */
if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
/* Function is defined */
res = 1;
}
jx9_result_bool(pCtx, res);
return SXRET_OK;
}
/*
* Verify that the contents of a variable can be called as a function.
* [i.e: Whether it is callable or not].
* Return TRUE if callable.FALSE otherwise.
*/
JX9_PRIVATE int jx9VmIsCallable(jx9_vm *pVm, jx9_value *pValue)
{
int res = 0;
if( pValue->iFlags & MEMOBJ_STRING ){
const char *zName;
int nLen;
/* Extract the name */
zName = jx9_value_to_string(pValue, &nLen);
/* Perform the lookup */
if( SyHashGet(&pVm->hFunction, (const void *)zName, (sxu32)nLen) != 0 ||
SyHashGet(&pVm->hHostFunction, (const void *)zName, (sxu32)nLen) != 0 ){
/* Function is callable */
res = 1;
}
}
return res;
}
/*
* bool is_callable(callable $name[, bool $syntax_only = false])
* Verify that the contents of a variable can be called as a function.
* Parameters
* $name
* The callback function to check
* $syntax_only
* If set to TRUE the function only verifies that name might be a function or method.
* It will only reject simple variables that are not strings, or an array that does
* not have a valid structure to be used as a callback. The valid ones are supposed
* to have only 2 entries, the first of which is an object or a string, and the second
* a string.
* Return
* TRUE if name is callable, FALSE otherwise.
*/
static int vm_builtin_is_callable(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_vm *pVm;
int res;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Point to the target VM */
pVm = pCtx->pVm;
/* Perform the requested operation */
res = jx9VmIsCallable(pVm, apArg[0]);
jx9_result_bool(pCtx, res);
return SXRET_OK;
}
/*
* Hash walker callback used by the [get_defined_functions()] function
* defined below.
*/
static int VmHashFuncStep(SyHashEntry *pEntry, void *pUserData)
{
jx9_value *pArray = (jx9_value *)pUserData;
jx9_value sName;
sxi32 rc;
/* Prepare the function name for insertion */
jx9MemObjInitFromString(pArray->pVm, &sName, 0);
jx9MemObjStringAppend(&sName, (const char *)pEntry->pKey, pEntry->nKeyLen);
/* Perform the insertion */
rc = jx9_array_add_elem(pArray, 0/* Automatic index assign */, &sName); /* Will make it's own copy */
jx9MemObjRelease(&sName);
return rc;
}
/*
* array get_defined_functions(void)
* Returns an array of all defined functions.
* Parameter
* None.
* Return
* Returns an multidimensional array containing a list of all defined functions
* both built-in (internal) and user-defined.
* The internal functions will be accessible via $arr["internal"], and the user
* defined ones using $arr["user"].
* Note:
* NULL is returned on failure.
*/
static int vm_builtin_get_defined_func(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray;
/* NOTE:
* Don't worry about freeing memory here, every allocated resource will be released
* automatically by the engine as soon we return from this foreign function.
*/
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* Return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* Fill with the appropriate information */
SyHashForEach(&pCtx->pVm->hHostFunction,VmHashFuncStep,pArray);
/* Fill with the appropriate information */
SyHashForEach(&pCtx->pVm->hFunction, VmHashFuncStep,pArray);
/* Return a copy of the array array */
jx9_result_value(pCtx, pArray);
return SXRET_OK;
}
/*
* Call a user defined or foreign function where the name of the function
* is stored in the pFunc parameter and the given arguments are stored
* in the apArg[] array.
* Return SXRET_OK if the function was successfuly called.Any other
* return value indicates failure.
*/
JX9_PRIVATE sxi32 jx9VmCallUserFunction(
jx9_vm *pVm, /* Target VM */
jx9_value *pFunc, /* Callback name */
int nArg, /* Total number of given arguments */
jx9_value **apArg, /* Callback arguments */
jx9_value *pResult /* Store callback return value here. NULL otherwise */
)
{
jx9_value *aStack;
VmInstr aInstr[2];
int i;
if((pFunc->iFlags & (MEMOBJ_STRING)) == 0 ){
/* Don't bother processing, it's invalid anyway */
if( pResult ){
/* Assume a null return value */
jx9MemObjRelease(pResult);
}
return SXERR_INVALID;
}
/* Create a new operand stack */
aStack = VmNewOperandStack(&(*pVm), 1+nArg);
if( aStack == 0 ){
jx9VmThrowError(&(*pVm), 0, JX9_CTX_ERR,
"JX9 is running out of memory while invoking user callback");
if( pResult ){
/* Assume a null return value */
jx9MemObjRelease(pResult);
}
return SXERR_MEM;
}
/* Fill the operand stack with the given arguments */
for( i = 0 ; i < nArg ; i++ ){
jx9MemObjLoad(apArg[i], &aStack[i]);
aStack[i].nIdx = apArg[i]->nIdx;
}
/* Push the function name */
jx9MemObjLoad(pFunc, &aStack[i]);
aStack[i].nIdx = SXU32_HIGH; /* Mark as constant */
/* Emit the CALL istruction */
aInstr[0].iOp = JX9_OP_CALL;
aInstr[0].iP1 = nArg; /* Total number of given arguments */
aInstr[0].iP2 = 0;
aInstr[0].p3 = 0;
/* Emit the DONE instruction */
aInstr[1].iOp = JX9_OP_DONE;
aInstr[1].iP1 = 1; /* Extract function return value if available */
aInstr[1].iP2 = 0;
aInstr[1].p3 = 0;
/* Execute the function body (if available) */
VmByteCodeExec(&(*pVm), aInstr, aStack, nArg, pResult);
/* Clean up the mess left behind */
SyMemBackendFree(&pVm->sAllocator, aStack);
return JX9_OK;
}
/*
* Call a user defined or foreign function whith a varibale number
* of arguments where the name of the function is stored in the pFunc
* parameter.
* Return SXRET_OK if the function was successfuly called.Any other
* return value indicates failure.
*/
JX9_PRIVATE sxi32 jx9VmCallUserFunctionAp(
jx9_vm *pVm, /* Target VM */
jx9_value *pFunc, /* Callback name */
jx9_value *pResult, /* Store callback return value here. NULL otherwise */
... /* 0 (Zero) or more Callback arguments */
)
{
jx9_value *pArg;
SySet aArg;
va_list ap;
sxi32 rc;
SySetInit(&aArg, &pVm->sAllocator, sizeof(jx9_value *));
/* Copy arguments one after one */
va_start(ap, pResult);
for(;;){
pArg = va_arg(ap, jx9_value *);
if( pArg == 0 ){
break;
}
SySetPut(&aArg, (const void *)&pArg);
}
/* Call the core routine */
rc = jx9VmCallUserFunction(&(*pVm), pFunc, (int)SySetUsed(&aArg), (jx9_value **)SySetBasePtr(&aArg), pResult);
/* Cleanup */
SySetRelease(&aArg);
return rc;
}
/*
* bool defined(string $name)
* Checks whether a given named constant exists.
* Parameter:
* Name of the desired constant.
* Return
* TRUE if the given constant exists.FALSE otherwise.
*/
static int vm_builtin_defined(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zName;
int nLen = 0;
int res = 0;
if( nArg < 1 ){
/* Missing constant name, return FALSE */
jx9_context_throw_error(pCtx,JX9_CTX_NOTICE,"Missing constant name");
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
/* Extract constant name */
zName = jx9_value_to_string(apArg[0], &nLen);
/* Perform the lookup */
if( nLen > 0 && SyHashGet(&pCtx->pVm->hConstant, (const void *)zName, (sxu32)nLen) != 0 ){
/* Already defined */
res = 1;
}
jx9_result_bool(pCtx, res);
return SXRET_OK;
}
/*
* Hash walker callback used by the [get_defined_constants()] function
* defined below.
*/
static int VmHashConstStep(SyHashEntry *pEntry, void *pUserData)
{
jx9_value *pArray = (jx9_value *)pUserData;
jx9_value sName;
sxi32 rc;
/* Prepare the constant name for insertion */
jx9MemObjInitFromString(pArray->pVm, &sName, 0);
jx9MemObjStringAppend(&sName, (const char *)pEntry->pKey, pEntry->nKeyLen);
/* Perform the insertion */
rc = jx9_array_add_elem(pArray, 0, &sName); /* Will make it's own copy */
jx9MemObjRelease(&sName);
return rc;
}
/*
* array get_defined_constants(void)
* Returns an associative array with the names of all defined
* constants.
* Parameters
* NONE.
* Returns
* Returns the names of all the constants currently defined.
*/
static int vm_builtin_get_defined_constants(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
jx9_value *pArray;
/* Create the array first*/
pArray = jx9_context_new_array(pCtx);
if( pArray == 0 ){
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
/* Return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* Fill the array with the defined constants */
SyHashForEach(&pCtx->pVm->hConstant, VmHashConstStep, pArray);
/* Return the created array */
jx9_result_value(pCtx, pArray);
return SXRET_OK;
}
/*
* Section:
* Random numbers/string generators.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* Generate a random 32-bit unsigned integer.
* JX9 use it's own private PRNG which is based on the one
* used by te SQLite3 library.
*/
JX9_PRIVATE sxu32 jx9VmRandomNum(jx9_vm *pVm)
{
sxu32 iNum;
SyRandomness(&pVm->sPrng, (void *)&iNum, sizeof(sxu32));
return iNum;
}
/*
* Generate a random string (English Alphabet) of length nLen.
* Note that the generated string is NOT null terminated.
* JX9 use it's own private PRNG which is based on the one used
* by te SQLite3 library.
*/
JX9_PRIVATE void jx9VmRandomString(jx9_vm *pVm, char *zBuf, int nLen)
{
static const char zBase[] = {"abcdefghijklmnopqrstuvwxyz"}; /* English Alphabet */
int i;
/* Generate a binary string first */
SyRandomness(&pVm->sPrng, zBuf, (sxu32)nLen);
/* Turn the binary string into english based alphabet */
for( i = 0 ; i < nLen ; ++i ){
zBuf[i] = zBase[zBuf[i] % (sizeof(zBase)-1)];
}
}
/*
* int rand()
* Generate a random (unsigned 32-bit) integer.
* Parameter
* $min
* The lowest value to return (default: 0)
* $max
* The highest value to return (default: getrandmax())
* Return
* A pseudo random value between min (or 0) and max (or getrandmax(), inclusive).
* Note:
* JX9 use it's own private PRNG which is based on the one used
* by te SQLite3 library.
*/
static int vm_builtin_rand(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
sxu32 iNum;
/* Generate the random number */
iNum = jx9VmRandomNum(pCtx->pVm);
if( nArg > 1 ){
sxu32 iMin, iMax;
iMin = (sxu32)jx9_value_to_int(apArg[0]);
iMax = (sxu32)jx9_value_to_int(apArg[1]);
if( iMin < iMax ){
sxu32 iDiv = iMax+1-iMin;
if( iDiv > 0 ){
iNum = (iNum % iDiv)+iMin;
}
}else if(iMax > 0 ){
iNum %= iMax;
}
}
/* Return the number */
jx9_result_int64(pCtx, (jx9_int64)iNum);
return SXRET_OK;
}
/*
* int getrandmax(void)
* Show largest possible random value
* Return
* The largest possible random value returned by rand() which is in
* this implementation 0xFFFFFFFF.
* Note:
* JX9 use it's own private PRNG which is based on the one used
* by te SQLite3 library.
*/
static int vm_builtin_getrandmax(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SXUNUSED(nArg); /* cc warning */
SXUNUSED(apArg);
jx9_result_int64(pCtx, SXU32_HIGH);
return SXRET_OK;
}
/*
* string rand_str()
* string rand_str(int $len)
* Generate a random string (English alphabet).
* Parameter
* $len
* Length of the desired string (default: 16, Min: 1, Max: 1024)
* Return
* A pseudo random string.
* Note:
* JX9 use it's own private PRNG which is based on the one used
* by te SQLite3 library.
*/
static int vm_builtin_rand_str(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
char zString[1024];
int iLen = 0x10;
if( nArg > 0 ){
/* Get the desired length */
iLen = jx9_value_to_int(apArg[0]);
if( iLen < 1 || iLen > 1024 ){
/* Default length */
iLen = 0x10;
}
}
/* Generate the random string */
jx9VmRandomString(pCtx->pVm, zString, iLen);
/* Return the generated string */
jx9_result_string(pCtx, zString, iLen); /* Will make it's own copy */
return SXRET_OK;
}
/*
* Section:
* Language construct implementation as foreign functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* void print($string...)
* Output one or more messages.
* Parameters
* $string
* Message to output.
* Return
* NULL.
*/
static int vm_builtin_print(jx9_context *pCtx, int nArg,jx9_value **apArg)
{
const char *zData;
int nDataLen = 0;
jx9_vm *pVm;
int i, rc;
/* Point to the target VM */
pVm = pCtx->pVm;
/* Output */
for( i = 0 ; i < nArg ; ++i ){
zData = jx9_value_to_string(apArg[i], &nDataLen);
if( nDataLen > 0 ){
rc = pVm->sVmConsumer.xConsumer((const void *)zData, (unsigned int)nDataLen, pVm->sVmConsumer.pUserData);
/* Increment output length */
pVm->nOutputLen += nDataLen;
if( rc == SXERR_ABORT ){
/* Output consumer callback request an operation abort */
return JX9_ABORT;
}
}
}
return SXRET_OK;
}
/*
* void exit(string $msg)
* void exit(int $status)
* void die(string $ms)
* void die(int $status)
* Output a message and terminate program execution.
* Parameter
* If status is a string, this function prints the status just before exiting.
* If status is an integer, that value will be used as the exit status
* and not printed
* Return
* NULL
*/
static int vm_builtin_exit(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg > 0 ){
if( jx9_value_is_string(apArg[0]) ){
const char *zData;
int iLen = 0;
/* Print exit message */
zData = jx9_value_to_string(apArg[0], &iLen);
jx9_context_output(pCtx, zData, iLen);
}else if(jx9_value_is_int(apArg[0]) ){
sxi32 iExitStatus;
/* Record exit status code */
iExitStatus = jx9_value_to_int(apArg[0]);
pCtx->pVm->iExitStatus = iExitStatus;
}
}
/* Abort processing immediately */
return JX9_ABORT;
}
/*
* Unset a memory object [i.e: a jx9_value].
*/
JX9_PRIVATE sxi32 jx9VmUnsetMemObj(jx9_vm *pVm,sxu32 nObjIdx)
{
jx9_value *pObj;
pObj = (jx9_value *)SySetAt(&pVm->aMemObj, nObjIdx);
if( pObj ){
VmSlot sFree;
/* Release the object */
jx9MemObjRelease(pObj);
/* Restore to the free list */
sFree.nIdx = nObjIdx;
sFree.pUserData = 0;
SySetPut(&pVm->aFreeObj, (const void *)&sFree);
}
return SXRET_OK;
}
/*
* string gettype($var)
* Get the type of a variable
* Parameters
* $var
* The variable being type checked.
* Return
* String representation of the given variable type.
*/
static int vm_builtin_gettype(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zType = "null";
if( nArg > 0 ){
zType = jx9MemObjTypeDump(apArg[0]);
}
/* Return the variable type */
jx9_result_string(pCtx, zType, -1/*Compute length automatically*/);
return SXRET_OK;
}
/*
* string get_resource_type(resource $handle)
* This function gets the type of the given resource.
* Parameters
* $handle
* The evaluated resource handle.
* Return
* If the given handle is a resource, this function will return a string
* representing its type. If the type is not identified by this function
* the return value will be the string Unknown.
* This function will return FALSE and generate an error if handle
* is not a resource.
*/
static int vm_builtin_get_resource_type(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
if( nArg < 1 || !jx9_value_is_resource(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE*/
jx9_result_bool(pCtx, 0);
return SXRET_OK;
}
jx9_result_string_format(pCtx, "resID_%#x", apArg[0]->x.pOther);
return SXRET_OK;
}
/*
* void dump(expression, ....)
* dump — Dumps information about a variable
* Parameters
* One or more expression to dump.
* Returns
* Nothing.
*/
static int vm_builtin_dump(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyBlob sDump; /* Generated dump is stored here */
int i;
SyBlobInit(&sDump,&pCtx->pVm->sAllocator);
/* Dump one or more expressions */
for( i = 0 ; i < nArg ; i++ ){
jx9_value *pObj = apArg[i];
/* Reset the working buffer */
SyBlobReset(&sDump);
/* Dump the given expression */
jx9MemObjDump(&sDump,pObj);
/* Output */
if( SyBlobLength(&sDump) > 0 ){
jx9_context_output(pCtx, (const char *)SyBlobData(&sDump), (int)SyBlobLength(&sDump));
}
}
/* Release the working buffer */
SyBlobRelease(&sDump);
return SXRET_OK;
}
/*
* Section:
* Version, Credits and Copyright related functions.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Stable.
*/
/*
* string jx9_version(void)
* string jx9_credits(void)
* Returns the running version of the jx9 version.
* Parameters
* None
* Return
* Current jx9 version.
*/
static int vm_builtin_jx9_version(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SXUNUSED(nArg);
SXUNUSED(apArg); /* cc warning */
/* Current engine version, signature and cipyright notice */
jx9_result_string_format(pCtx,"%s %s, %s",JX9_VERSION,JX9_SIG,JX9_COPYRIGHT);
return JX9_OK;
}
/*
* Section:
* URL related routines.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/* Forward declaration */
static sxi32 VmHttpSplitURI(SyhttpUri *pOut, const char *zUri, sxu32 nLen);
/*
* value parse_url(string $url [, int $component = -1 ])
* Parse a URL and return its fields.
* Parameters
* $url
* The URL to parse.
* $component
* Specify one of JX9_URL_SCHEME, JX9_URL_HOST, JX9_URL_PORT, JX9_URL_USER
* JX9_URL_PASS, JX9_URL_PATH, JX9_URL_QUERY or JX9_URL_FRAGMENT to retrieve
* just a specific URL component as a string (except when JX9_URL_PORT is given
* in which case the return value will be an integer).
* Return
* If the component parameter is omitted, an associative array is returned.
* At least one element will be present within the array. Potential keys within
* this array are:
* scheme - e.g. http
* host
* port
* user
* pass
* path
* query - after the question mark ?
* fragment - after the hashmark #
* Note:
* FALSE is returned on failure.
* This function work with relative URL unlike the one shipped
* with the standard JX9 engine.
*/
static int vm_builtin_parse_url(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zStr; /* Input string */
SyString *pComp; /* Pointer to the URI component */
SyhttpUri sURI; /* Parse of the given URI */
int nLen;
sxi32 rc;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract the given URI */
zStr = jx9_value_to_string(apArg[0], &nLen);
if( nLen < 1 ){
/* Nothing to process, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Get a parse */
rc = VmHttpSplitURI(&sURI, zStr, (sxu32)nLen);
if( rc != SXRET_OK ){
/* Malformed input, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( nArg > 1 ){
int nComponent = jx9_value_to_int(apArg[1]);
/* Refer to constant.c for constants values */
switch(nComponent){
case 1: /* JX9_URL_SCHEME */
pComp = &sURI.sScheme;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 2: /* JX9_URL_HOST */
pComp = &sURI.sHost;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 3: /* JX9_URL_PORT */
pComp = &sURI.sPort;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
int iPort = 0;
/* Cast the value to integer */
SyStrToInt32(pComp->zString, pComp->nByte, (void *)&iPort, 0);
jx9_result_int(pCtx, iPort);
}
break;
case 4: /* JX9_URL_USER */
pComp = &sURI.sUser;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 5: /* JX9_URL_PASS */
pComp = &sURI.sPass;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 7: /* JX9_URL_QUERY */
pComp = &sURI.sQuery;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 8: /* JX9_URL_FRAGMENT */
pComp = &sURI.sFragment;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
case 6: /* JX9_URL_PATH */
pComp = &sURI.sPath;
if( pComp->nByte < 1 ){
/* No available value, return NULL */
jx9_result_null(pCtx);
}else{
jx9_result_string(pCtx, pComp->zString, (int)pComp->nByte);
}
break;
default:
/* No such entry, return NULL */
jx9_result_null(pCtx);
break;
}
}else{
jx9_value *pArray, *pValue;
/* Return an associative array */
pArray = jx9_context_new_array(pCtx); /* Empty array */
pValue = jx9_context_new_scalar(pCtx); /* Array value */
if( pArray == 0 || pValue == 0 ){
/* Out of memory */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "jx9 engine is running out of memory");
/* Return false */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Fill the array */
pComp = &sURI.sScheme;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "scheme", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sHost;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "host", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sPort;
if( pComp->nByte > 0 ){
int iPort = 0;/* cc warning */
/* Convert to integer */
SyStrToInt32(pComp->zString, pComp->nByte, (void *)&iPort, 0);
jx9_value_int(pValue, iPort);
jx9_array_add_strkey_elem(pArray, "port", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sUser;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "user", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sPass;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "pass", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sPath;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "path", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sQuery;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "query", pValue); /* Will make it's own copy */
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pValue);
pComp = &sURI.sFragment;
if( pComp->nByte > 0 ){
jx9_value_string(pValue, pComp->zString, (int)pComp->nByte);
jx9_array_add_strkey_elem(pArray, "fragment", pValue); /* Will make it's own copy */
}
/* Return the created array */
jx9_result_value(pCtx, pArray);
/* NOTE:
* Don't worry about freeing 'pValue', everything will be released
* automatically as soon we return from this function.
*/
}
/* All done */
return JX9_OK;
}
/*
* Section:
* Array related routines.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
* Note 2012-5-21 01:04:15:
* Array related functions that need access to the underlying
* virtual machine are implemented here rather than 'hashmap.c'
*/
/*
* The [extract()] function store it's state information in an instance
* of the following structure.
*/
typedef struct extract_aux_data extract_aux_data;
struct extract_aux_data
{
jx9_vm *pVm; /* VM that own this instance */
int iCount; /* Number of variables successfully imported */
const char *zPrefix; /* Prefix name */
int Prefixlen; /* Prefix length */
int iFlags; /* Control flags */
char zWorker[1024]; /* Working buffer */
};
/* Forward declaration */
static int VmExtractCallback(jx9_value *pKey, jx9_value *pValue, void *pUserData);
/*
* int extract(array $var_array[, int $extract_type = EXTR_OVERWRITE[, string $prefix = NULL ]])
* Import variables into the current symbol table from an array.
* Parameters
* $var_array
* An associative array. This function treats keys as variable names and values
* as variable values. For each key/value pair it will create a variable in the current symbol
* table, subject to extract_type and prefix parameters.
* You must use an associative array; a numerically indexed array will not produce results
* unless you use EXTR_PREFIX_ALL or EXTR_PREFIX_INVALID.
* $extract_type
* The way invalid/numeric keys and collisions are treated is determined by the extract_type.
* It can be one of the following values:
* EXTR_OVERWRITE
* If there is a collision, overwrite the existing variable.
* EXTR_SKIP
* If there is a collision, don't overwrite the existing variable.
* EXTR_PREFIX_SAME
* If there is a collision, prefix the variable name with prefix.
* EXTR_PREFIX_ALL
* Prefix all variable names with prefix.
* EXTR_PREFIX_INVALID
* Only prefix invalid/numeric variable names with prefix.
* EXTR_IF_EXISTS
* Only overwrite the variable if it already exists in the current symbol table
* otherwise do nothing.
* This is useful for defining a list of valid variables and then extracting only those
* variables you have defined out of $_REQUEST, for example.
* EXTR_PREFIX_IF_EXISTS
* Only create prefixed variable names if the non-prefixed version of the same variable exists in
* the current symbol table.
* $prefix
* Note that prefix is only required if extract_type is EXTR_PREFIX_SAME, EXTR_PREFIX_ALL
* EXTR_PREFIX_INVALID or EXTR_PREFIX_IF_EXISTS. If the prefixed result is not a valid variable name
* it is not imported into the symbol table. Prefixes are automatically separated from the array key by an
* underscore character.
* Return
* Returns the number of variables successfully imported into the symbol table.
*/
static int vm_builtin_extract(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
extract_aux_data sAux;
jx9_hashmap *pMap;
if( nArg < 1 || !jx9_value_is_json_array(apArg[0]) ){
/* Missing/Invalid arguments, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Point to the target hashmap */
pMap = (jx9_hashmap *)apArg[0]->x.pOther;
if( pMap->nEntry < 1 ){
/* Empty map, return 0 */
jx9_result_int(pCtx, 0);
return JX9_OK;
}
/* Prepare the aux data */
SyZero(&sAux, sizeof(extract_aux_data)-sizeof(sAux.zWorker));
if( nArg > 1 ){
sAux.iFlags = jx9_value_to_int(apArg[1]);
if( nArg > 2 ){
sAux.zPrefix = jx9_value_to_string(apArg[2], &sAux.Prefixlen);
}
}
sAux.pVm = pCtx->pVm;
/* Invoke the worker callback */
jx9HashmapWalk(pMap, VmExtractCallback, &sAux);
/* Number of variables successfully imported */
jx9_result_int(pCtx, sAux.iCount);
return JX9_OK;
}
/*
* Worker callback for the [extract()] function defined
* below.
*/
static int VmExtractCallback(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
extract_aux_data *pAux = (extract_aux_data *)pUserData;
int iFlags = pAux->iFlags;
jx9_vm *pVm = pAux->pVm;
jx9_value *pObj;
SyString sVar;
if( (iFlags & 0x10/* EXTR_PREFIX_INVALID */) && (pKey->iFlags & (MEMOBJ_INT|MEMOBJ_BOOL|MEMOBJ_REAL))){
iFlags |= 0x08; /*EXTR_PREFIX_ALL*/
}
/* Perform a string cast */
jx9MemObjToString(pKey);
if( SyBlobLength(&pKey->sBlob) < 1 ){
/* Unavailable variable name */
return SXRET_OK;
}
sVar.nByte = 0; /* cc warning */
if( (iFlags & 0x08/*EXTR_PREFIX_ALL*/ ) && pAux->Prefixlen > 0 ){
sVar.nByte = (sxu32)SyBufferFormat(pAux->zWorker, sizeof(pAux->zWorker), "%.*s_%.*s",
pAux->Prefixlen, pAux->zPrefix,
SyBlobLength(&pKey->sBlob), SyBlobData(&pKey->sBlob)
);
}else{
sVar.nByte = (sxu32) SyMemcpy(SyBlobData(&pKey->sBlob), pAux->zWorker,
SXMIN(SyBlobLength(&pKey->sBlob), sizeof(pAux->zWorker)));
}
sVar.zString = pAux->zWorker;
/* Try to extract the variable */
pObj = VmExtractMemObj(pVm, &sVar, TRUE, FALSE);
if( pObj ){
/* Collision */
if( iFlags & 0x02 /* EXTR_SKIP */ ){
return SXRET_OK;
}
if( iFlags & 0x04 /* EXTR_PREFIX_SAME */ ){
if( (iFlags & 0x08/*EXTR_PREFIX_ALL*/) || pAux->Prefixlen < 1){
/* Already prefixed */
return SXRET_OK;
}
sVar.nByte = SyBufferFormat(
pAux->zWorker, sizeof(pAux->zWorker),
"%.*s_%.*s",
pAux->Prefixlen, pAux->zPrefix,
SyBlobLength(&pKey->sBlob), SyBlobData(&pKey->sBlob)
);
pObj = VmExtractMemObj(pVm, &sVar, TRUE, TRUE);
}
}else{
/* Create the variable */
pObj = VmExtractMemObj(pVm, &sVar, TRUE, TRUE);
}
if( pObj ){
/* Overwrite the old value */
jx9MemObjStore(pValue, pObj);
/* Increment counter */
pAux->iCount++;
}
return SXRET_OK;
}
/*
* Compile and evaluate a JX9 chunk at run-time.
* Refer to the include language construct implementation for more
* information.
*/
static sxi32 VmEvalChunk(
jx9_vm *pVm, /* Underlying Virtual Machine */
jx9_context *pCtx, /* Call Context */
SyString *pChunk, /* JX9 chunk to evaluate */
int iFlags, /* Compile flag */
int bTrueReturn /* TRUE to return execution result */
)
{
SySet *pByteCode, aByteCode;
ProcConsumer xErr = 0;
void *pErrData = 0;
/* Initialize bytecode container */
SySetInit(&aByteCode, &pVm->sAllocator, sizeof(VmInstr));
SySetAlloc(&aByteCode, 0x20);
/* Reset the code generator */
if( bTrueReturn ){
/* Included file, log compile-time errors */
xErr = pVm->pEngine->xConf.xErr;
pErrData = pVm->pEngine->xConf.pErrData;
}
jx9ResetCodeGenerator(pVm, xErr, pErrData);
/* Swap bytecode container */
pByteCode = pVm->pByteContainer;
pVm->pByteContainer = &aByteCode;
/* Compile the chunk */
jx9CompileScript(pVm, pChunk, iFlags);
if( pVm->sCodeGen.nErr > 0 ){
/* Compilation error, return false */
if( pCtx ){
jx9_result_bool(pCtx, 0);
}
}else{
jx9_value sResult; /* Return value */
if( SXRET_OK != jx9VmEmitInstr(pVm, JX9_OP_DONE, 0, 0, 0, 0) ){
/* Out of memory */
if( pCtx ){
jx9_result_bool(pCtx, 0);
}
goto Cleanup;
}
if( bTrueReturn ){
/* Assume a boolean true return value */
jx9MemObjInitFromBool(pVm, &sResult, 1);
}else{
/* Assume a null return value */
jx9MemObjInit(pVm, &sResult);
}
/* Execute the compiled chunk */
VmLocalExec(pVm, &aByteCode, &sResult);
if( pCtx ){
/* Set the execution result */
jx9_result_value(pCtx, &sResult);
}
jx9MemObjRelease(&sResult);
}
Cleanup:
/* Cleanup the mess left behind */
pVm->pByteContainer = pByteCode;
SySetRelease(&aByteCode);
return SXRET_OK;
}
/*
* Check if a file path is already included.
*/
static int VmIsIncludedFile(jx9_vm *pVm, SyString *pFile)
{
SyString *aEntries;
sxu32 n;
aEntries = (SyString *)SySetBasePtr(&pVm->aIncluded);
/* Perform a linear search */
for( n = 0 ; n < SySetUsed(&pVm->aIncluded) ; ++n ){
if( SyStringCmp(pFile, &aEntries[n], SyMemcmp) == 0 ){
/* Already included */
return TRUE;
}
}
return FALSE;
}
/*
* Push a file path in the appropriate VM container.
*/
JX9_PRIVATE sxi32 jx9VmPushFilePath(jx9_vm *pVm, const char *zPath, int nLen, sxu8 bMain, sxi32 *pNew)
{
SyString sPath;
char *zDup;
#ifdef __WINNT__
char *zCur;
#endif
sxi32 rc;
if( nLen < 0 ){
nLen = SyStrlen(zPath);
}
/* Duplicate the file path first */
zDup = SyMemBackendStrDup(&pVm->sAllocator, zPath, nLen);
if( zDup == 0 ){
return SXERR_MEM;
}
#ifdef __WINNT__
/* Normalize path on windows
* Example:
* Path/To/File.jx9
* becomes
* path\to\file.jx9
*/
zCur = zDup;
while( zCur[0] != 0 ){
if( zCur[0] == '/' ){
zCur[0] = '\\';
}else if( (unsigned char)zCur[0] < 0xc0 && SyisUpper(zCur[0]) ){
int c = SyToLower(zCur[0]);
zCur[0] = (char)c; /* MSVC stupidity */
}
zCur++;
}
#endif
/* Install the file path */
SyStringInitFromBuf(&sPath, zDup, nLen);
if( !bMain ){
if( VmIsIncludedFile(&(*pVm), &sPath) ){
/* Already included */
*pNew = 0;
}else{
/* Insert in the corresponding container */
rc = SySetPut(&pVm->aIncluded, (const void *)&sPath);
if( rc != SXRET_OK ){
SyMemBackendFree(&pVm->sAllocator, zDup);
return rc;
}
*pNew = 1;
}
}
SySetPut(&pVm->aFiles, (const void *)&sPath);
return SXRET_OK;
}
/*
* Compile and Execute a JX9 script at run-time.
* SXRET_OK is returned on sucessful evaluation.Any other return values
* indicates failure.
* Note that the JX9 script to evaluate can be a local or remote file.In
* either cases the [jx9StreamReadWholeFile()] function handle all the underlying
* operations.
* If the [jJX9_DISABLE_BUILTIN_FUNC] compile-time directive is defined, then
* this function is a no-op.
* Refer to the implementation of the include(), import() language
* constructs for more information.
*/
static sxi32 VmExecIncludedFile(
jx9_context *pCtx, /* Call Context */
SyString *pPath, /* Script path or URL*/
int IncludeOnce /* TRUE if called from import() or require_once() */
)
{
sxi32 rc;
#ifndef JX9_DISABLE_BUILTIN_FUNC
const jx9_io_stream *pStream;
SyBlob sContents;
void *pHandle;
jx9_vm *pVm;
int isNew;
/* Initialize fields */
pVm = pCtx->pVm;
SyBlobInit(&sContents, &pVm->sAllocator);
isNew = 0;
/* Extract the associated stream */
pStream = jx9VmGetStreamDevice(pVm, &pPath->zString, pPath->nByte);
/*
* Open the file or the URL [i.e: http://jx9.symisc.net/example/hello.jx9.txt"]
* in a read-only mode.
*/
pHandle = jx9StreamOpenHandle(pVm, pStream,pPath->zString, JX9_IO_OPEN_RDONLY, TRUE, 0, TRUE, &isNew);
if( pHandle == 0 ){
return SXERR_IO;
}
rc = SXRET_OK; /* Stupid cc warning */
if( IncludeOnce && !isNew ){
/* Already included */
rc = SXERR_EXISTS;
}else{
/* Read the whole file contents */
rc = jx9StreamReadWholeFile(pHandle, pStream, &sContents);
if( rc == SXRET_OK ){
SyString sScript;
/* Compile and execute the script */
SyStringInitFromBuf(&sScript, SyBlobData(&sContents), SyBlobLength(&sContents));
VmEvalChunk(pCtx->pVm, &(*pCtx), &sScript, 0, TRUE);
}
}
/* Pop from the set of included file */
(void)SySetPop(&pVm->aFiles);
/* Close the handle */
jx9StreamCloseHandle(pStream, pHandle);
/* Release the working buffer */
SyBlobRelease(&sContents);
#else
pCtx = 0; /* cc warning */
pPath = 0;
IncludeOnce = 0;
rc = SXERR_IO;
#endif /* JX9_DISABLE_BUILTIN_FUNC */
return rc;
}
/* * include:
* According to the JX9 reference manual.
* The include() function includes and evaluates the specified file.
* Files are included based on the file path given or, if none is given
* the include_path specified.If the file isn't found in the include_path
* include() will finally check in the calling script's own directory
* and the current working directory before failing. The include()
* construct will emit a warning if it cannot find a file; this is different
* behavior from require(), which will emit a fatal error.
* If a path is defined — whether absolute (starting with a drive letter
* or \ on Windows, or / on Unix/Linux systems) or relative to the current
* directory (starting with . or ..) — the include_path will be ignored altogether.
* For example, if a filename begins with ../, the parser will look in the parent
* directory to find the requested file.
* When a file is included, the code it contains inherits the variable scope
* of the line on which the include occurs. Any variables available at that line
* in the calling file will be available within the called file, from that point forward.
* However, all functions and objectes defined in the included file have the global scope.
*/
static int vm_builtin_include(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyString sFile;
sxi32 rc;
if( nArg < 1 ){
/* Nothing to evaluate, return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* File to include */
sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
if( sFile.nByte < 1 ){
/* Empty string, return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* Open, compile and execute the desired script */
rc = VmExecIncludedFile(&(*pCtx), &sFile, FALSE);
if( rc != SXRET_OK ){
/* Emit a warning and return false */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
jx9_result_bool(pCtx, 0);
}
return SXRET_OK;
}
/*
* import:
* According to the JX9 reference manual.
* The import() statement includes and evaluates the specified file during
* the execution of the script. This is a behavior similar to the include()
* statement, with the only difference being that if the code from a file has already
* been included, it will not be included again. As the name suggests, it will be included
* just once.
*/
static int vm_builtin_import(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
SyString sFile;
sxi32 rc;
if( nArg < 1 ){
/* Nothing to evaluate, return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* File to include */
sFile.zString = jx9_value_to_string(apArg[0], (int *)&sFile.nByte);
if( sFile.nByte < 1 ){
/* Empty string, return NULL */
jx9_result_null(pCtx);
return SXRET_OK;
}
/* Open, compile and execute the desired script */
rc = VmExecIncludedFile(&(*pCtx), &sFile, TRUE);
if( rc == SXERR_EXISTS ){
/* File already included, return TRUE */
jx9_result_bool(pCtx, 1);
return SXRET_OK;
}
if( rc != SXRET_OK ){
/* Emit a warning and return false */
jx9_context_throw_error_format(pCtx, JX9_CTX_WARNING, "IO error while importing: '%z'", &sFile);
jx9_result_bool(pCtx, 0);
}
return SXRET_OK;
}
/*
* Section:
* Command line arguments processing.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* Check if a short option argument [i.e: -c] is available in the command
* line string. Return a pointer to the start of the stream on success.
* NULL otherwise.
*/
static const char * VmFindShortOpt(int c, const char *zIn, const char *zEnd)
{
while( zIn < zEnd ){
if( zIn[0] == '-' && &zIn[1] < zEnd && (int)zIn[1] == c ){
/* Got one */
return &zIn[1];
}
/* Advance the cursor */
zIn++;
}
/* No such option */
return 0;
}
/*
* Check if a long option argument [i.e: --opt] is available in the command
* line string. Return a pointer to the start of the stream on success.
* NULL otherwise.
*/
static const char * VmFindLongOpt(const char *zLong, int nByte, const char *zIn, const char *zEnd)
{
const char *zOpt;
while( zIn < zEnd ){
if( zIn[0] == '-' && &zIn[1] < zEnd && (int)zIn[1] == '-' ){
zIn += 2;
zOpt = zIn;
while( zIn < zEnd && !SyisSpace(zIn[0]) ){
if( zIn[0] == '=' /* --opt=val */){
break;
}
zIn++;
}
/* Test */
if( (int)(zIn-zOpt) == nByte && SyMemcmp(zOpt, zLong, nByte) == 0 ){
/* Got one, return it's value */
return zIn;
}
}else{
zIn++;
}
}
/* No such option */
return 0;
}
/*
* Long option [i.e: --opt] arguments private data structure.
*/
struct getopt_long_opt
{
const char *zArgIn, *zArgEnd; /* Command line arguments */
jx9_value *pWorker; /* Worker variable*/
jx9_value *pArray; /* getopt() return value */
jx9_context *pCtx; /* Call Context */
};
/* Forward declaration */
static int VmProcessLongOpt(jx9_value *pKey, jx9_value *pValue, void *pUserData);
/*
* Extract short or long argument option values.
*/
static void VmExtractOptArgValue(
jx9_value *pArray, /* getopt() return value */
jx9_value *pWorker, /* Worker variable */
const char *zArg, /* Argument stream */
const char *zArgEnd, /* End of the argument stream */
int need_val, /* TRUE to fetch option argument */
jx9_context *pCtx, /* Call Context */
const char *zName /* Option name */)
{
jx9_value_bool(pWorker, 0);
if( !need_val ){
/*
* Option does not need arguments.
* Insert the option name and a boolean FALSE.
*/
jx9_array_add_strkey_elem(pArray, (const char *)zName, pWorker); /* Will make it's own copy */
}else{
const char *zCur;
/* Extract option argument */
zArg++;
if( zArg < zArgEnd && zArg[0] == '=' ){
zArg++;
}
while( zArg < zArgEnd && (unsigned char)zArg[0] < 0xc0 && SyisSpace(zArg[0]) ){
zArg++;
}
if( zArg >= zArgEnd || zArg[0] == '-' ){
/*
* Argument not found.
* Insert the option name and a boolean FALSE.
*/
jx9_array_add_strkey_elem(pArray, (const char *)zName, pWorker); /* Will make it's own copy */
return;
}
/* Delimit the value */
zCur = zArg;
if( zArg[0] == '\'' || zArg[0] == '"' ){
int d = zArg[0];
/* Delimt the argument */
zArg++;
zCur = zArg;
while( zArg < zArgEnd ){
if( zArg[0] == d && zArg[-1] != '\\' ){
/* Delimiter found, exit the loop */
break;
}
zArg++;
}
/* Save the value */
jx9_value_string(pWorker, zCur, (int)(zArg-zCur));
if( zArg < zArgEnd ){ zArg++; }
}else{
while( zArg < zArgEnd && !SyisSpace(zArg[0]) ){
zArg++;
}
/* Save the value */
jx9_value_string(pWorker, zCur, (int)(zArg-zCur));
}
/*
* Check if we are dealing with multiple values.
* If so, create an array to hold them, rather than a scalar variable.
*/
while( zArg < zArgEnd && (unsigned char)zArg[0] < 0xc0 && SyisSpace(zArg[0]) ){
zArg++;
}
if( zArg < zArgEnd && zArg[0] != '-' ){
jx9_value *pOptArg; /* Array of option arguments */
pOptArg = jx9_context_new_array(pCtx);
if( pOptArg == 0 ){
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "JX9 is running out of memory");
}else{
/* Insert the first value */
jx9_array_add_elem(pOptArg, 0, pWorker); /* Will make it's own copy */
for(;;){
if( zArg >= zArgEnd || zArg[0] == '-' ){
/* No more value */
break;
}
/* Delimit the value */
zCur = zArg;
if( zArg < zArgEnd && zArg[0] == '\\' ){
zArg++;
zCur = zArg;
}
while( zArg < zArgEnd && !SyisSpace(zArg[0]) ){
zArg++;
}
/* Reset the string cursor */
jx9_value_reset_string_cursor(pWorker);
/* Save the value */
jx9_value_string(pWorker, zCur, (int)(zArg-zCur));
/* Insert */
jx9_array_add_elem(pOptArg, 0, pWorker); /* Will make it's own copy */
/* Jump trailing white spaces */
while( zArg < zArgEnd && (unsigned char)zArg[0] < 0xc0 && SyisSpace(zArg[0]) ){
zArg++;
}
}
/* Insert the option arg array */
jx9_array_add_strkey_elem(pArray, (const char *)zName, pOptArg); /* Will make it's own copy */
/* Safely release */
jx9_context_release_value(pCtx, pOptArg);
}
}else{
/* Single value */
jx9_array_add_strkey_elem(pArray, (const char *)zName, pWorker); /* Will make it's own copy */
}
}
}
/*
* array getopt(string $options[, array $longopts ])
* Gets options from the command line argument list.
* Parameters
* $options
* Each character in this string will be used as option characters
* and matched against options passed to the script starting with
* a single hyphen (-). For example, an option string "x" recognizes
* an option -x. Only a-z, A-Z and 0-9 are allowed.
* $longopts
* An array of options. Each element in this array will be used as option
* strings and matched against options passed to the script starting with
* two hyphens (--). For example, an longopts element "opt" recognizes an
* option --opt.
* Return
* This function will return an array of option / argument pairs or FALSE
* on failure.
*/
static int vm_builtin_getopt(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zIn, *zEnd, *zArg, *zArgIn, *zArgEnd;
struct getopt_long_opt sLong;
jx9_value *pArray, *pWorker;
SyBlob *pArg;
int nByte;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return FALSE */
jx9_context_throw_error(pCtx, JX9_CTX_ERR, "Missing/Invalid option arguments");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Extract option arguments */
zIn = jx9_value_to_string(apArg[0], &nByte);
zEnd = &zIn[nByte];
/* Point to the string representation of the $argv[] array */
pArg = &pCtx->pVm->sArgv;
/* Create a new empty array and a worker variable */
pArray = jx9_context_new_array(pCtx);
pWorker = jx9_context_new_scalar(pCtx);
if( pArray == 0 || pWorker == 0 ){
jx9_context_throw_error(pCtx,JX9_CTX_ERR, "JX9 is running out of memory");
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
if( SyBlobLength(pArg) < 1 ){
/* Empty command line, return the empty array*/
jx9_result_value(pCtx, pArray);
/* Everything will be released automatically when we return
* from this function.
*/
return JX9_OK;
}
zArgIn = (const char *)SyBlobData(pArg);
zArgEnd = &zArgIn[SyBlobLength(pArg)];
/* Fill the long option structure */
sLong.pArray = pArray;
sLong.pWorker = pWorker;
sLong.zArgIn = zArgIn;
sLong.zArgEnd = zArgEnd;
sLong.pCtx = pCtx;
/* Start processing */
while( zIn < zEnd ){
int c = zIn[0];
int need_val = 0;
/* Advance the stream cursor */
zIn++;
/* Ignore non-alphanum characters */
if( !SyisAlphaNum(c) ){
continue;
}
if( zIn < zEnd && zIn[0] == ':' ){
zIn++;
need_val = 1;
if( zIn < zEnd && zIn[0] == ':' ){
zIn++;
}
}
/* Find option */
zArg = VmFindShortOpt(c, zArgIn, zArgEnd);
if( zArg == 0 ){
/* No such option */
continue;
}
/* Extract option argument value */
VmExtractOptArgValue(pArray, pWorker, zArg, zArgEnd, need_val, pCtx, (const char *)&c);
}
if( nArg > 1 && jx9_value_is_json_array(apArg[1]) && jx9_array_count(apArg[1]) > 0 ){
/* Process long options */
jx9_array_walk(apArg[1], VmProcessLongOpt, &sLong);
}
/* Return the option array */
jx9_result_value(pCtx, pArray);
/*
* Don't worry about freeing memory, everything will be released
* automatically as soon we return from this foreign function.
*/
return JX9_OK;
}
/*
* Array walker callback used for processing long options values.
*/
static int VmProcessLongOpt(jx9_value *pKey, jx9_value *pValue, void *pUserData)
{
struct getopt_long_opt *pOpt = (struct getopt_long_opt *)pUserData;
const char *zArg, *zOpt, *zEnd;
int need_value = 0;
int nByte;
/* Value must be of type string */
if( !jx9_value_is_string(pValue) ){
/* Simply ignore */
return JX9_OK;
}
zOpt = jx9_value_to_string(pValue, &nByte);
if( nByte < 1 ){
/* Empty string, ignore */
return JX9_OK;
}
zEnd = &zOpt[nByte - 1];
if( zEnd[0] == ':' ){
char *zTerm;
/* Try to extract a value */
need_value = 1;
while( zEnd >= zOpt && zEnd[0] == ':' ){
zEnd--;
}
if( zOpt >= zEnd ){
/* Empty string, ignore */
SXUNUSED(pKey);
return JX9_OK;
}
zEnd++;
zTerm = (char *)zEnd;
zTerm[0] = 0;
}else{
zEnd = &zOpt[nByte];
}
/* Find the option */
zArg = VmFindLongOpt(zOpt, (int)(zEnd-zOpt), pOpt->zArgIn, pOpt->zArgEnd);
if( zArg == 0 ){
/* No such option, return immediately */
return JX9_OK;
}
/* Try to extract a value */
VmExtractOptArgValue(pOpt->pArray, pOpt->pWorker, zArg, pOpt->zArgEnd, need_value, pOpt->pCtx, zOpt);
return JX9_OK;
}
/*
* int utf8_encode(string $input)
* UTF-8 encoding.
* This function encodes the string data to UTF-8, and returns the encoded version.
* UTF-8 is a standard mechanism used by Unicode for encoding wide character values
* into a byte stream. UTF-8 is transparent to plain ASCII characters, is self-synchronized
* (meaning it is possible for a program to figure out where in the bytestream characters start)
* and can be used with normal string comparison functions for sorting and such.
* Notes on UTF-8 (According to SQLite3 authors):
* Byte-0 Byte-1 Byte-2 Byte-3 Value
* 0xxxxxxx 00000000 00000000 0xxxxxxx
* 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx
* 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx
* 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx
* Parameters
* $input
* String to encode or NULL on failure.
* Return
* An UTF-8 encoded string.
*/
static int vm_builtin_utf8_encode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nByte, c, e;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nByte);
if( nByte < 1 ){
/* Empty string, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
zEnd = &zIn[nByte];
/* Start the encoding process */
for(;;){
if( zIn >= zEnd ){
/* End of input */
break;
}
c = zIn[0];
/* Advance the stream cursor */
zIn++;
/* Encode */
if( c<0x00080 ){
e = (c&0xFF);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
}else if( c<0x00800 ){
e = 0xC0 + ((c>>6)&0x1F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + (c & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
}else if( c<0x10000 ){
e = 0xE0 + ((c>>12)&0x0F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + ((c>>6) & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + (c & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
}else{
e = 0xF0 + ((c>>18) & 0x07);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + ((c>>12) & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + ((c>>6) & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
e = 0x80 + (c & 0x3F);
jx9_result_string(pCtx, (const char *)&e, (int)sizeof(char));
}
}
/* All done */
return JX9_OK;
}
/*
* UTF-8 decoding routine extracted from the sqlite3 source tree.
* Original author: D. Richard Hipp (http://www.sqlite.org)
* Status: Public Domain
*/
/*
** This lookup table is used to help decode the first byte of
** a multi-byte UTF8 character.
*/
static const unsigned char UtfTrans1[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
};
/*
** Translate a single UTF-8 character. Return the unicode value.
**
** During translation, assume that the byte that zTerm points
** is a 0x00.
**
** Write a pointer to the next unread byte back into *pzNext.
**
** Notes On Invalid UTF-8:
**
** * This routine never allows a 7-bit character (0x00 through 0x7f) to
** be encoded as a multi-byte character. Any multi-byte character that
** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
**
** * This routine never allows a UTF16 surrogate value to be encoded.
** If a multi-byte character attempts to encode a value between
** 0xd800 and 0xe000 then it is rendered as 0xfffd.
**
** * Bytes in the range of 0x80 through 0xbf which occur as the first
** byte of a character are interpreted as single-byte characters
** and rendered as themselves even though they are technically
** invalid characters.
**
** * This routine accepts an infinite number of different UTF8 encodings
** for unicode values 0x80 and greater. It do not change over-length
** encodings to 0xfffd as some systems recommend.
*/
#define READ_UTF8(zIn, zTerm, c) \
c = *(zIn++); \
if( c>=0xc0 ){ \
c = UtfTrans1[c-0xc0]; \
while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
c = (c<<6) + (0x3f & *(zIn++)); \
} \
if( c<0x80 \
|| (c&0xFFFFF800)==0xD800 \
|| (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \
}
JX9_PRIVATE int jx9Utf8Read(
const unsigned char *z, /* First byte of UTF-8 character */
const unsigned char *zTerm, /* Pretend this byte is 0x00 */
const unsigned char **pzNext /* Write first byte past UTF-8 char here */
){
int c;
READ_UTF8(z, zTerm, c);
*pzNext = z;
return c;
}
/*
* string utf8_decode(string $data)
* This function decodes data, assumed to be UTF-8 encoded, to unicode.
* Parameters
* data
* An UTF-8 encoded string.
* Return
* Unicode decoded string or NULL on failure.
*/
static int vm_builtin_utf8_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const unsigned char *zIn, *zEnd;
int nByte, c;
if( nArg < 1 ){
/* Missing arguments, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the target string */
zIn = (const unsigned char *)jx9_value_to_string(apArg[0], &nByte);
if( nByte < 1 ){
/* Empty string, return null */
jx9_result_null(pCtx);
return JX9_OK;
}
zEnd = &zIn[nByte];
/* Start the decoding process */
while( zIn < zEnd ){
c = jx9Utf8Read(zIn, zEnd, &zIn);
if( c == 0x0 ){
break;
}
jx9_result_string(pCtx, (const char *)&c, (int)sizeof(char));
}
return JX9_OK;
}
/*
* string json_encode(mixed $value)
* Returns a string containing the JSON representation of value.
* Parameters
* $value
* The value being encoded. Can be any type except a resource.
* Return
* Returns a JSON encoded string on success. FALSE otherwise
*/
static int vm_builtin_json_encode(jx9_context *pCtx,int nArg,jx9_value **apArg)
{
SyBlob sBlob;
if( nArg < 1 ){
/* Missing arguments, return FALSE */
jx9_result_bool(pCtx, 0);
return JX9_OK;
}
/* Init the working buffer */
SyBlobInit(&sBlob,&pCtx->pVm->sAllocator);
/* Perform the encoding operation */
jx9JsonSerialize(apArg[0],&sBlob);
/* Return the serialized value */
jx9_result_string(pCtx,(const char *)SyBlobData(&sBlob),(int)SyBlobLength(&sBlob));
/* Cleanup */
SyBlobRelease(&sBlob);
/* All done */
return JX9_OK;
}
/*
* mixed json_decode(string $json)
* Takes a JSON encoded string and converts it into a JX9 variable.
* Parameters
* $json
* The json string being decoded.
* Return
* The value encoded in json in appropriate JX9 type. Values true, false and null (case-insensitive)
* are returned as TRUE, FALSE and NULL respectively. NULL is returned if the json cannot be decoded
* or if the encoded data is deeper than the recursion limit.
*/
static int vm_builtin_json_decode(jx9_context *pCtx, int nArg, jx9_value **apArg)
{
const char *zJSON;
int nByte;
if( nArg < 1 || !jx9_value_is_string(apArg[0]) ){
/* Missing/Invalid arguments, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the JSON string */
zJSON = jx9_value_to_string(apArg[0], &nByte);
if( nByte < 1 ){
/* Empty string, return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Decode the raw JSON */
jx9JsonDecode(pCtx,zJSON,nByte);
return JX9_OK;
}
/* Table of built-in VM functions. */
static const jx9_builtin_func aVmFunc[] = {
/* JSON Encoding/Decoding */
{ "json_encode", vm_builtin_json_encode },
{ "json_decode", vm_builtin_json_decode },
/* Functions calls */
{ "func_num_args" , vm_builtin_func_num_args },
{ "func_get_arg" , vm_builtin_func_get_arg },
{ "func_get_args" , vm_builtin_func_get_args },
{ "function_exists", vm_builtin_func_exists },
{ "is_callable" , vm_builtin_is_callable },
{ "get_defined_functions", vm_builtin_get_defined_func },
/* Constants management */
{ "defined", vm_builtin_defined },
{ "get_defined_constants", vm_builtin_get_defined_constants },
/* Random numbers/strings generators */
{ "rand", vm_builtin_rand },
{ "rand_str", vm_builtin_rand_str },
{ "getrandmax", vm_builtin_getrandmax },
/* Language constructs functions */
{ "print", vm_builtin_print },
{ "exit", vm_builtin_exit },
{ "die", vm_builtin_exit },
/* Variable handling functions */
{ "gettype", vm_builtin_gettype },
{ "get_resource_type", vm_builtin_get_resource_type},
/* Variable dumping */
{ "dump", vm_builtin_dump },
/* Release info */
{"jx9_version", vm_builtin_jx9_version },
{"jx9_credits", vm_builtin_jx9_version },
{"jx9_info", vm_builtin_jx9_version },
{"jx9_copyright", vm_builtin_jx9_version },
/* hashmap */
{"extract", vm_builtin_extract },
/* URL related function */
{"parse_url", vm_builtin_parse_url },
/* UTF-8 encoding/decoding */
{"utf8_encode", vm_builtin_utf8_encode},
{"utf8_decode", vm_builtin_utf8_decode},
/* Command line processing */
{"getopt", vm_builtin_getopt },
/* Files/URI inclusion facility */
{ "include", vm_builtin_include },
{ "import", vm_builtin_import }
};
/*
* Register the built-in VM functions defined above.
*/
static sxi32 VmRegisterSpecialFunction(jx9_vm *pVm)
{
sxi32 rc;
sxu32 n;
for( n = 0 ; n < SX_ARRAYSIZE(aVmFunc) ; ++n ){
/* Note that these special functions have access
* to the underlying virtual machine as their
* private data.
*/
rc = jx9_create_function(&(*pVm), aVmFunc[n].zName, aVmFunc[n].xFunc, &(*pVm));
if( rc != SXRET_OK ){
return rc;
}
}
return SXRET_OK;
}
#ifndef JX9_DISABLE_BUILTIN_FUNC
/*
* Extract the IO stream device associated with a given scheme.
* Return a pointer to an instance of jx9_io_stream when the scheme
* have an associated IO stream registered with it. NULL otherwise.
* If no scheme:// is avalilable then the file:// scheme is assumed.
* For more information on how to register IO stream devices, please
* refer to the official documentation.
*/
JX9_PRIVATE const jx9_io_stream * jx9VmGetStreamDevice(
jx9_vm *pVm, /* Target VM */
const char **pzDevice, /* Full path, URI, ... */
int nByte /* *pzDevice length*/
)
{
const char *zIn, *zEnd, *zCur, *zNext;
jx9_io_stream **apStream, *pStream;
SyString sDev, sCur;
sxu32 n, nEntry;
int rc;
/* Check if a scheme [i.e: file://, http://, zip://...] is available */
zNext = zCur = zIn = *pzDevice;
zEnd = &zIn[nByte];
while( zIn < zEnd ){
if( zIn < &zEnd[-3]/*://*/ && zIn[0] == ':' && zIn[1] == '/' && zIn[2] == '/' ){
/* Got one */
zNext = &zIn[sizeof("://")-1];
break;
}
/* Advance the cursor */
zIn++;
}
if( zIn >= zEnd ){
/* No such scheme, return the default stream */
return pVm->pDefStream;
}
SyStringInitFromBuf(&sDev, zCur, zIn-zCur);
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sDev);
/* Perform a linear lookup on the installed stream devices */
apStream = (jx9_io_stream **)SySetBasePtr(&pVm->aIOstream);
nEntry = SySetUsed(&pVm->aIOstream);
for( n = 0 ; n < nEntry ; n++ ){
pStream = apStream[n];
SyStringInitFromBuf(&sCur, pStream->zName, SyStrlen(pStream->zName));
/* Perfrom a case-insensitive comparison */
rc = SyStringCmp(&sDev, &sCur, SyStrnicmp);
if( rc == 0 ){
/* Stream device found */
*pzDevice = zNext;
return pStream;
}
}
/* No such stream, return NULL */
return 0;
}
#endif /* JX9_DISABLE_BUILTIN_FUNC */
/*
* Section:
* HTTP/URI related routines.
* Authors:
* Symisc Systems, devel@symisc.net.
* Copyright (C) Symisc Systems, http://jx9.symisc.net
* Status:
* Stable.
*/
/*
* URI Parser: Split an URI into components [i.e: Host, Path, Query, ...].
* URI syntax: [method:/][/[user[:pwd]@]host[:port]/][document]
* This almost, but not quite, RFC1738 URI syntax.
* This routine is not a validator, it does not check for validity
* nor decode URI parts, the only thing this routine does is splitting
* the input to its fields.
* Upper layer are responsible of decoding and validating URI parts.
* On success, this function populate the "SyhttpUri" structure passed
* as the first argument. Otherwise SXERR_* is returned when a malformed
* input is encountered.
*/
static sxi32 VmHttpSplitURI(SyhttpUri *pOut, const char *zUri, sxu32 nLen)
{
const char *zEnd = &zUri[nLen];
sxu8 bHostOnly = FALSE;
sxu8 bIPv6 = FALSE ;
const char *zCur;
SyString *pComp;
sxu32 nPos = 0;
sxi32 rc;
/* Zero the structure first */
SyZero(pOut, sizeof(SyhttpUri));
/* Remove leading and trailing white spaces */
SyStringInitFromBuf(&pOut->sRaw, zUri, nLen);
SyStringFullTrim(&pOut->sRaw);
/* Find the first '/' separator */
rc = SyByteFind(zUri, (sxu32)(zEnd - zUri), '/', &nPos);
if( rc != SXRET_OK ){
/* Assume a host name only */
zCur = zEnd;
bHostOnly = TRUE;
goto ProcessHost;
}
zCur = &zUri[nPos];
if( zUri != zCur && zCur[-1] == ':' ){
/* Extract a scheme:
* Not that we can get an invalid scheme here.
* Fortunately the caller can discard any URI by comparing this scheme with its
* registered schemes and will report the error as soon as his comparison function
* fail.
*/
pComp = &pOut->sScheme;
SyStringInitFromBuf(pComp, zUri, (sxu32)(zCur - zUri - 1));
SyStringLeftTrim(pComp);
}
if( zCur[1] != '/' ){
if( zCur == zUri || zCur[-1] == ':' ){
/* No authority */
goto PathSplit;
}
/* There is something here , we will assume its an authority
* and someone has forgot the two prefix slashes "//",
* sooner or later we will detect if we are dealing with a malicious
* user or not, but now assume we are dealing with an authority
* and let the caller handle all the validation process.
*/
goto ProcessHost;
}
zUri = &zCur[2];
zCur = zEnd;
rc = SyByteFind(zUri, (sxu32)(zEnd - zUri), '/', &nPos);
if( rc == SXRET_OK ){
zCur = &zUri[nPos];
}
ProcessHost:
/* Extract user information if present */
rc = SyByteFind(zUri, (sxu32)(zCur - zUri), '@', &nPos);
if( rc == SXRET_OK ){
if( nPos > 0 ){
sxu32 nPassOfft; /* Password offset */
pComp = &pOut->sUser;
SyStringInitFromBuf(pComp, zUri, nPos);
/* Extract the password if available */
rc = SyByteFind(zUri, (sxu32)(zCur - zUri), ':', &nPassOfft);
if( rc == SXRET_OK && nPassOfft < nPos){
pComp->nByte = nPassOfft;
pComp = &pOut->sPass;
pComp->zString = &zUri[nPassOfft+sizeof(char)];
pComp->nByte = nPos - nPassOfft - 1;
}
/* Update the cursor */
zUri = &zUri[nPos+1];
}else{
zUri++;
}
}
pComp = &pOut->sHost;
while( zUri < zCur && SyisSpace(zUri[0])){
zUri++;
}
SyStringInitFromBuf(pComp, zUri, (sxu32)(zCur - zUri));
if( pComp->zString[0] == '[' ){
/* An IPv6 Address: Make a simple naive test
*/
zUri++; pComp->zString++; pComp->nByte = 0;
while( ((unsigned char)zUri[0] < 0xc0 && SyisHex(zUri[0])) || zUri[0] == ':' ){
zUri++; pComp->nByte++;
}
if( zUri[0] != ']' ){
return SXERR_CORRUPT; /* Malformed IPv6 address */
}
zUri++;
bIPv6 = TRUE;
}
/* Extract a port number if available */
rc = SyByteFind(zUri, (sxu32)(zCur - zUri), ':', &nPos);
if( rc == SXRET_OK ){
if( bIPv6 == FALSE ){
pComp->nByte = (sxu32)(&zUri[nPos] - zUri);
}
pComp = &pOut->sPort;
SyStringInitFromBuf(pComp, &zUri[nPos+1], (sxu32)(zCur - &zUri[nPos+1]));
}
if( bHostOnly == TRUE ){
return SXRET_OK;
}
PathSplit:
zUri = zCur;
pComp = &pOut->sPath;
SyStringInitFromBuf(pComp, zUri, (sxu32)(zEnd-zUri));
if( pComp->nByte == 0 ){
return SXRET_OK; /* Empty path */
}
if( SXRET_OK == SyByteFind(zUri, (sxu32)(zEnd-zUri), '?', &nPos) ){
pComp->nByte = nPos; /* Update path length */
pComp = &pOut->sQuery;
SyStringInitFromBuf(pComp, &zUri[nPos+1], (sxu32)(zEnd-&zUri[nPos+1]));
}
if( SXRET_OK == SyByteFind(zUri, (sxu32)(zEnd-zUri), '#', &nPos) ){
/* Update path or query length */
if( pComp == &pOut->sPath ){
pComp->nByte = nPos;
}else{
if( &zUri[nPos] < (char *)SyStringData(pComp) ){
/* Malformed syntax : Query must be present before fragment */
return SXERR_SYNTAX;
}
pComp->nByte -= (sxu32)(zEnd - &zUri[nPos]);
}
pComp = &pOut->sFragment;
SyStringInitFromBuf(pComp, &zUri[nPos+1], (sxu32)(zEnd-&zUri[nPos+1]))
}
return SXRET_OK;
}
/*
* Extract a single line from a raw HTTP request.
* Return SXRET_OK on success, SXERR_EOF when end of input
* and SXERR_MORE when more input is needed.
*/
static sxi32 VmGetNextLine(SyString *pCursor, SyString *pCurrent)
{
const char *zIn;
sxu32 nPos;
/* Jump leading white spaces */
SyStringLeftTrim(pCursor);
if( pCursor->nByte < 1 ){
SyStringInitFromBuf(pCurrent, 0, 0);
return SXERR_EOF; /* End of input */
}
zIn = SyStringData(pCursor);
if( SXRET_OK != SyByteListFind(pCursor->zString, pCursor->nByte, "\r\n", &nPos) ){
/* Line not found, tell the caller to read more input from source */
SyStringDupPtr(pCurrent, pCursor);
return SXERR_MORE;
}
pCurrent->zString = zIn;
pCurrent->nByte = nPos;
/* advance the cursor so we can call this routine again */
pCursor->zString = &zIn[nPos];
pCursor->nByte -= nPos;
return SXRET_OK;
}
/*
* Split a single MIME header into a name value pair.
* This function return SXRET_OK, SXERR_CONTINUE on success.
* Otherwise SXERR_NEXT is returned when a malformed header
* is encountered.
* Note: This function handle also mult-line headers.
*/
static sxi32 VmHttpProcessOneHeader(SyhttpHeader *pHdr, SyhttpHeader *pLast, const char *zLine, sxu32 nLen)
{
SyString *pName;
sxu32 nPos;
sxi32 rc;
if( nLen < 1 ){
return SXERR_NEXT;
}
/* Check for multi-line header */
if( pLast && (zLine[-1] == ' ' || zLine[-1] == '\t') ){
SyString *pTmp = &pLast->sValue;
SyStringFullTrim(pTmp);
if( pTmp->nByte == 0 ){
SyStringInitFromBuf(pTmp, zLine, nLen);
}else{
/* Update header value length */
pTmp->nByte = (sxu32)(&zLine[nLen] - pTmp->zString);
}
/* Simply tell the caller to reset its states and get another line */
return SXERR_CONTINUE;
}
/* Split the header */
pName = &pHdr->sName;
rc = SyByteFind(zLine, nLen, ':', &nPos);
if(rc != SXRET_OK ){
return SXERR_NEXT; /* Malformed header;Check the next entry */
}
SyStringInitFromBuf(pName, zLine, nPos);
SyStringFullTrim(pName);
/* Extract a header value */
SyStringInitFromBuf(&pHdr->sValue, &zLine[nPos + 1], nLen - nPos - 1);
/* Remove leading and trailing whitespaces */
SyStringFullTrim(&pHdr->sValue);
return SXRET_OK;
}
/*
* Extract all MIME headers associated with a HTTP request.
* After processing the first line of a HTTP request, the following
* routine is called in order to extract MIME headers.
* This function return SXRET_OK on success, SXERR_MORE when it needs
* more inputs.
* Note: Any malformed header is simply discarded.
*/
static sxi32 VmHttpExtractHeaders(SyString *pRequest, SySet *pOut)
{
SyhttpHeader *pLast = 0;
SyString sCurrent;
SyhttpHeader sHdr;
sxu8 bEol;
sxi32 rc;
if( SySetUsed(pOut) > 0 ){
pLast = (SyhttpHeader *)SySetAt(pOut, SySetUsed(pOut)-1);
}
bEol = FALSE;
for(;;){
SyZero(&sHdr, sizeof(SyhttpHeader));
/* Extract a single line from the raw HTTP request */
rc = VmGetNextLine(pRequest, &sCurrent);
if(rc != SXRET_OK ){
if( sCurrent.nByte < 1 ){
break;
}
bEol = TRUE;
}
/* Process the header */
if( SXRET_OK == VmHttpProcessOneHeader(&sHdr, pLast, sCurrent.zString, sCurrent.nByte)){
if( SXRET_OK != SySetPut(pOut, (const void *)&sHdr) ){
break;
}
/* Retrieve the last parsed header so we can handle multi-line header
* in case we face one of them.
*/
pLast = (SyhttpHeader *)SySetPeek(pOut);
}
if( bEol ){
break;
}
} /* for(;;) */
return SXRET_OK;
}
/*
* Process the first line of a HTTP request.
* This routine perform the following operations
* 1) Extract the HTTP method.
* 2) Split the request URI to it's fields [ie: host, path, query, ...].
* 3) Extract the HTTP protocol version.
*/
static sxi32 VmHttpProcessFirstLine(
SyString *pRequest, /* Raw HTTP request */
sxi32 *pMethod, /* OUT: HTTP method */
SyhttpUri *pUri, /* OUT: Parse of the URI */
sxi32 *pProto /* OUT: HTTP protocol */
)
{
static const char *azMethods[] = { "get", "post", "head", "put"};
static const sxi32 aMethods[] = { HTTP_METHOD_GET, HTTP_METHOD_POST, HTTP_METHOD_HEAD, HTTP_METHOD_PUT};
const char *zIn, *zEnd, *zPtr;
SyString sLine;
sxu32 nLen;
sxi32 rc;
/* Extract the first line and update the pointer */
rc = VmGetNextLine(pRequest, &sLine);
if( rc != SXRET_OK ){
return rc;
}
if ( sLine.nByte < 1 ){
/* Empty HTTP request */
return SXERR_EMPTY;
}
/* Delimit the line and ignore trailing and leading white spaces */
zIn = sLine.zString;
zEnd = &zIn[sLine.nByte];
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
zIn++;
}
/* Extract the HTTP method */
zPtr = zIn;
while( zIn < zEnd && !SyisSpace(zIn[0]) ){
zIn++;
}
*pMethod = HTTP_METHOD_OTHR;
if( zIn > zPtr ){
sxu32 i;
nLen = (sxu32)(zIn-zPtr);
for( i = 0 ; i < SX_ARRAYSIZE(azMethods) ; ++i ){
if( SyStrnicmp(azMethods[i], zPtr, nLen) == 0 ){
*pMethod = aMethods[i];
break;
}
}
}
/* Jump trailing white spaces */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
zIn++;
}
/* Extract the request URI */
zPtr = zIn;
while( zIn < zEnd && !SyisSpace(zIn[0]) ){
zIn++;
}
if( zIn > zPtr ){
nLen = (sxu32)(zIn-zPtr);
/* Split raw URI to it's fields */
VmHttpSplitURI(pUri, zPtr, nLen);
}
/* Jump trailing white spaces */
while( zIn < zEnd && (unsigned char)zIn[0] < 0xc0 && SyisSpace(zIn[0]) ){
zIn++;
}
/* Extract the HTTP version */
zPtr = zIn;
while( zIn < zEnd && !SyisSpace(zIn[0]) ){
zIn++;
}
*pProto = HTTP_PROTO_11; /* HTTP/1.1 */
rc = 1;
if( zIn > zPtr ){
rc = SyStrnicmp(zPtr, "http/1.0", (sxu32)(zIn-zPtr));
}
if( !rc ){
*pProto = HTTP_PROTO_10; /* HTTP/1.0 */
}
return SXRET_OK;
}
/*
* Tokenize, decode and split a raw query encoded as: "x-www-form-urlencoded"
* into a name value pair.
* Note that this encoding is implicit in GET based requests.
* After the tokenization process, register the decoded queries
* in the $_GET/$_POST/$_REQUEST superglobals arrays.
*/
static sxi32 VmHttpSplitEncodedQuery(
jx9_vm *pVm, /* Target VM */
SyString *pQuery, /* Raw query to decode */
SyBlob *pWorker, /* Working buffer */
int is_post /* TRUE if we are dealing with a POST request */
)
{
const char *zEnd = &pQuery->zString[pQuery->nByte];
const char *zIn = pQuery->zString;
jx9_value *pGet, *pRequest;
SyString sName, sValue;
const char *zPtr;
sxu32 nBlobOfft;
/* Extract superglobals */
if( is_post ){
/* $_POST superglobal */
pGet = VmExtractSuper(&(*pVm), "_POST", sizeof("_POST")-1);
}else{
/* $_GET superglobal */
pGet = VmExtractSuper(&(*pVm), "_GET", sizeof("_GET")-1);
}
pRequest = VmExtractSuper(&(*pVm), "_REQUEST", sizeof("_REQUEST")-1);
/* Split up the raw query */
for(;;){
/* Jump leading white spaces */
while(zIn < zEnd && SyisSpace(zIn[0]) ){
zIn++;
}
if( zIn >= zEnd ){
break;
}
zPtr = zIn;
while( zPtr < zEnd && zPtr[0] != '=' && zPtr[0] != '&' && zPtr[0] != ';' ){
zPtr++;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Decode the entry */
SyUriDecode(zIn, (sxu32)(zPtr-zIn), jx9VmBlobConsumer, pWorker, TRUE);
/* Save the entry */
sName.nByte = SyBlobLength(pWorker);
sValue.zString = 0;
sValue.nByte = 0;
if( zPtr < zEnd && zPtr[0] == '=' ){
zPtr++;
zIn = zPtr;
/* Store field value */
while( zPtr < zEnd && zPtr[0] != '&' && zPtr[0] != ';' ){
zPtr++;
}
if( zPtr > zIn ){
/* Decode the value */
nBlobOfft = SyBlobLength(pWorker);
SyUriDecode(zIn, (sxu32)(zPtr-zIn), jx9VmBlobConsumer, pWorker, TRUE);
sValue.zString = (const char *)SyBlobDataAt(pWorker, nBlobOfft);
sValue.nByte = SyBlobLength(pWorker) - nBlobOfft;
}
/* Synchronize pointers */
zIn = zPtr;
}
sName.zString = (const char *)SyBlobData(pWorker);
/* Install the decoded query in the $_GET/$_REQUEST array */
if( pGet && (pGet->iFlags & MEMOBJ_HASHMAP) ){
VmHashmapInsert((jx9_hashmap *)pGet->x.pOther,
sName.zString, (int)sName.nByte,
sValue.zString, (int)sValue.nByte
);
}
if( pRequest && (pRequest->iFlags & MEMOBJ_HASHMAP) ){
VmHashmapInsert((jx9_hashmap *)pRequest->x.pOther,
sName.zString, (int)sName.nByte,
sValue.zString, (int)sValue.nByte
);
}
/* Advance the pointer */
zIn = &zPtr[1];
}
/* All done*/
return SXRET_OK;
}
/*
* Extract MIME header value from the given set.
* Return header value on success. NULL otherwise.
*/
static SyString * VmHttpExtractHeaderValue(SySet *pSet, const char *zMime, sxu32 nByte)
{
SyhttpHeader *aMime, *pMime;
SyString sMime;
sxu32 n;
SyStringInitFromBuf(&sMime, zMime, nByte);
/* Point to the MIME entries */
aMime = (SyhttpHeader *)SySetBasePtr(pSet);
/* Perform the lookup */
for( n = 0 ; n < SySetUsed(pSet) ; ++n ){
pMime = &aMime[n];
if( SyStringCmp(&sMime, &pMime->sName, SyStrnicmp) == 0 ){
/* Header found, return it's associated value */
return &pMime->sValue;
}
}
/* No such MIME header */
return 0;
}
/*
* Tokenize and decode a raw "Cookie:" MIME header into a name value pair
* and insert it's fields [i.e name, value] in the $_COOKIE superglobal.
*/
static sxi32 VmHttpPorcessCookie(jx9_vm *pVm, SyBlob *pWorker, const char *zIn, sxu32 nByte)
{
const char *zPtr, *zDelimiter, *zEnd = &zIn[nByte];
SyString sName, sValue;
jx9_value *pCookie;
sxu32 nOfft;
/* Make sure the $_COOKIE superglobal is available */
pCookie = VmExtractSuper(&(*pVm), "_COOKIE", sizeof("_COOKIE")-1);
if( pCookie == 0 || (pCookie->iFlags & MEMOBJ_HASHMAP) == 0 ){
/* $_COOKIE superglobal not available */
return SXERR_NOTFOUND;
}
for(;;){
/* Jump leading white spaces */
while( zIn < zEnd && SyisSpace(zIn[0]) ){
zIn++;
}
if( zIn >= zEnd ){
break;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
zDelimiter = zIn;
/* Delimit the name[=value]; pair */
while( zDelimiter < zEnd && zDelimiter[0] != ';' ){
zDelimiter++;
}
zPtr = zIn;
while( zPtr < zDelimiter && zPtr[0] != '=' ){
zPtr++;
}
/* Decode the cookie */
SyUriDecode(zIn, (sxu32)(zPtr-zIn), jx9VmBlobConsumer, pWorker, TRUE);
sName.nByte = SyBlobLength(pWorker);
zPtr++;
sValue.zString = 0;
sValue.nByte = 0;
if( zPtr < zDelimiter ){
/* Got a Cookie value */
nOfft = SyBlobLength(pWorker);
SyUriDecode(zPtr, (sxu32)(zDelimiter-zPtr), jx9VmBlobConsumer, pWorker, TRUE);
SyStringInitFromBuf(&sValue, SyBlobDataAt(pWorker, nOfft), SyBlobLength(pWorker)-nOfft);
}
/* Synchronize pointers */
zIn = &zDelimiter[1];
/* Perform the insertion */
sName.zString = (const char *)SyBlobData(pWorker);
VmHashmapInsert((jx9_hashmap *)pCookie->x.pOther,
sName.zString, (int)sName.nByte,
sValue.zString, (int)sValue.nByte
);
}
return SXRET_OK;
}
/*
* Process a full HTTP request and populate the appropriate arrays
* such as $_SERVER, $_GET, $_POST, $_COOKIE, $_REQUEST, ... with the information
* extracted from the raw HTTP request. As an extension Symisc introduced
* the $_HEADER array which hold a copy of the processed HTTP MIME headers
* and their associated values. [i.e: $_HEADER['Server'], $_HEADER['User-Agent'], ...].
* This function return SXRET_OK on success. Any other return value indicates
* a malformed HTTP request.
*/
static sxi32 VmHttpProcessRequest(jx9_vm *pVm, const char *zRequest, int nByte)
{
SyString *pName, *pValue, sRequest; /* Raw HTTP request */
jx9_value *pHeaderArray; /* $_HEADER superglobal (Symisc eXtension to the JX9 specification)*/
SyhttpHeader *pHeader; /* MIME header */
SyhttpUri sUri; /* Parse of the raw URI*/
SyBlob sWorker; /* General purpose working buffer */
SySet sHeader; /* MIME headers set */
sxi32 iMethod; /* HTTP method [i.e: GET, POST, HEAD...]*/
sxi32 iVer; /* HTTP protocol version */
sxi32 rc;
SyStringInitFromBuf(&sRequest, zRequest, nByte);
SySetInit(&sHeader, &pVm->sAllocator, sizeof(SyhttpHeader));
SyBlobInit(&sWorker, &pVm->sAllocator);
/* Ignore leading and trailing white spaces*/
SyStringFullTrim(&sRequest);
/* Process the first line */
rc = VmHttpProcessFirstLine(&sRequest, &iMethod, &sUri, &iVer);
if( rc != SXRET_OK ){
return rc;
}
/* Process MIME headers */
VmHttpExtractHeaders(&sRequest, &sHeader);
/*
* Setup $_SERVER environments
*/
/* 'SERVER_PROTOCOL': Name and revision of the information protocol via which the page was requested */
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"SERVER_PROTOCOL",
iVer == HTTP_PROTO_10 ? "HTTP/1.0" : "HTTP/1.1",
sizeof("HTTP/1.1")-1
);
/* 'REQUEST_METHOD': Which request method was used to access the page */
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"REQUEST_METHOD",
iMethod == HTTP_METHOD_GET ? "GET" :
(iMethod == HTTP_METHOD_POST ? "POST":
(iMethod == HTTP_METHOD_PUT ? "PUT" :
(iMethod == HTTP_METHOD_HEAD ? "HEAD" : "OTHER"))),
-1 /* Compute attribute length automatically */
);
if( SyStringLength(&sUri.sQuery) > 0 && iMethod == HTTP_METHOD_GET ){
pValue = &sUri.sQuery;
/* 'QUERY_STRING': The query string, if any, via which the page was accessed */
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"QUERY_STRING",
pValue->zString,
pValue->nByte
);
/* Decoded the raw query */
VmHttpSplitEncodedQuery(&(*pVm), pValue, &sWorker, FALSE);
}
/* REQUEST_URI: The URI which was given in order to access this page; for instance, '/index.html' */
pValue = &sUri.sRaw;
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"REQUEST_URI",
pValue->zString,
pValue->nByte
);
/*
* 'PATH_INFO'
* 'ORIG_PATH_INFO'
* Contains any client-provided pathname information trailing the actual script filename but preceding
* the query string, if available. For instance, if the current script was accessed via the URL
* http://www.example.com/jx9/path_info.jx9/some/stuff?foo=bar, then $_SERVER['PATH_INFO'] would contain
* /some/stuff.
*/
pValue = &sUri.sPath;
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"PATH_INFO",
pValue->zString,
pValue->nByte
);
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"ORIG_PATH_INFO",
pValue->zString,
pValue->nByte
);
/* 'HTTP_ACCEPT': Contents of the Accept: header from the current request, if there is one */
pValue = VmHttpExtractHeaderValue(&sHeader, "Accept", sizeof("Accept")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_ACCEPT",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_ACCEPT_CHARSET': Contents of the Accept-Charset: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "Accept-Charset", sizeof("Accept-Charset")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_ACCEPT_CHARSET",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_ACCEPT_ENCODING': Contents of the Accept-Encoding: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "Accept-Encoding", sizeof("Accept-Encoding")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_ACCEPT_ENCODING",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_ACCEPT_LANGUAGE': Contents of the Accept-Language: header from the current request, if there is one */
pValue = VmHttpExtractHeaderValue(&sHeader, "Accept-Language", sizeof("Accept-Language")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_ACCEPT_LANGUAGE",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_CONNECTION': Contents of the Connection: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "Connection", sizeof("Connection")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_CONNECTION",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_HOST': Contents of the Host: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "Host", sizeof("Host")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_HOST",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_REFERER': Contents of the Referer: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "Referer", sizeof("Referer")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_REFERER",
pValue->zString,
pValue->nByte
);
}
/* 'HTTP_USER_AGENT': Contents of the Referer: header from the current request, if there is one. */
pValue = VmHttpExtractHeaderValue(&sHeader, "User-Agent", sizeof("User-Agent")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"HTTP_USER_AGENT",
pValue->zString,
pValue->nByte
);
}
/* 'JX9_AUTH_DIGEST': When doing Digest HTTP authentication this variable is set to the 'Authorization'
* header sent by the client (which you should then use to make the appropriate validation).
*/
pValue = VmHttpExtractHeaderValue(&sHeader, "Authorization", sizeof("Authorization")-1);
if( pValue ){
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"JX9_AUTH_DIGEST",
pValue->zString,
pValue->nByte
);
jx9_vm_config(pVm,
JX9_VM_CONFIG_SERVER_ATTR,
"JX9_AUTH",
pValue->zString,
pValue->nByte
);
}
/* Install all clients HTTP headers in the $_HEADER superglobal */
pHeaderArray = VmExtractSuper(&(*pVm), "_HEADER", sizeof("_HEADER")-1);
/* Iterate throw the available MIME headers*/
SySetResetCursor(&sHeader);
pHeader = 0; /* stupid cc warning */
while( SXRET_OK == SySetGetNextEntry(&sHeader, (void **)&pHeader) ){
pName = &pHeader->sName;
pValue = &pHeader->sValue;
if( pHeaderArray && (pHeaderArray->iFlags & MEMOBJ_HASHMAP)){
/* Insert the MIME header and it's associated value */
VmHashmapInsert((jx9_hashmap *)pHeaderArray->x.pOther,
pName->zString, (int)pName->nByte,
pValue->zString, (int)pValue->nByte
);
}
if( pName->nByte == sizeof("Cookie")-1 && SyStrnicmp(pName->zString, "Cookie", sizeof("Cookie")-1) == 0
&& pValue->nByte > 0){
/* Process the name=value pair and insert them in the $_COOKIE superglobal array */
VmHttpPorcessCookie(&(*pVm), &sWorker, pValue->zString, pValue->nByte);
}
}
if( iMethod == HTTP_METHOD_POST ){
/* Extract raw POST data */
pValue = VmHttpExtractHeaderValue(&sHeader, "Content-Type", sizeof("Content-Type") - 1);
if( pValue && pValue->nByte >= sizeof("application/x-www-form-urlencoded") - 1 &&
SyMemcmp("application/x-www-form-urlencoded", pValue->zString, pValue->nByte) == 0 ){
/* Extract POST data length */
pValue = VmHttpExtractHeaderValue(&sHeader, "Content-Length", sizeof("Content-Length") - 1);
if( pValue ){
sxi32 iLen = 0; /* POST data length */
SyStrToInt32(pValue->zString, pValue->nByte, (void *)&iLen, 0);
if( iLen > 0 ){
/* Remove leading and trailing white spaces */
SyStringFullTrim(&sRequest);
if( (int)sRequest.nByte > iLen ){
sRequest.nByte = (sxu32)iLen;
}
/* Decode POST data now */
VmHttpSplitEncodedQuery(&(*pVm), &sRequest, &sWorker, TRUE);
}
}
}
}
/* All done, clean-up the mess left behind */
SySetRelease(&sHeader);
SyBlobRelease(&sWorker);
return SXRET_OK;
}
/*
* ----------------------------------------------------------
* File: lhash_kv.c
* MD5: 581b07ce2984fd95740677285d8a11d3
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: lhash_kv.c v1.7 Solaris 2013-01-14 12:56 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/*
* This file implements disk based hashtable using the linear hashing algorithm.
* This implementation is the one decribed in the paper:
* LINEAR HASHING : A NEW TOOL FOR FILE AND TABLE ADDRESSING. Witold Litwin. I. N. Ft. I. A.. 78 150 Le Chesnay, France.
* Plus a smart extension called Virtual Bucket Table. (contact devel@symisc.net for additional information).
*/
/* Magic number identifying a valid storage image */
#define L_HASH_MAGIC 0xFA782DCB
/*
* Magic word to hash to identify a valid hash function.
*/
#define L_HASH_WORD "chm@symisc"
/*
* Cell size on disk.
*/
#define L_HASH_CELL_SZ (4/*Hash*/+4/*Key*/+8/*Data*/+2/* Offset of the next cell */+8/*Overflow*/)
/*
* Primary page (not overflow pages) header size on disk.
*/
#define L_HASH_PAGE_HDR_SZ (2/* Cell offset*/+2/* Free block offset*/+8/*Slave page number*/)
/*
* The maximum amount of payload (in bytes) that can be stored locally for
* a database entry. If the entry contains more data than this, the
* extra goes onto overflow pages.
*/
#define L_HASH_MX_PAYLOAD(PageSize) (PageSize-(L_HASH_PAGE_HDR_SZ+L_HASH_CELL_SZ))
/*
* Maxium free space on a single page.
*/
#define L_HASH_MX_FREE_SPACE(PageSize) (PageSize - (L_HASH_PAGE_HDR_SZ))
/*
** The maximum number of bytes of payload allowed on a single overflow page.
*/
#define L_HASH_OVERFLOW_SIZE(PageSize) (PageSize-8)
/* Forward declaration */
typedef struct lhash_kv_engine lhash_kv_engine;
typedef struct lhpage lhpage;
/*
* Each record in the database is identified either in-memory or in
* disk by an instance of the following structure.
*/
typedef struct lhcell lhcell;
struct lhcell
{
/* Disk-data (Big-Endian) */
sxu32 nHash; /* Hash of the key: 4 bytes */
sxu32 nKey; /* Key length: 4 bytes */
sxu64 nData; /* Data length: 8 bytes */
sxu16 iNext; /* Offset of the next cell: 2 bytes */
pgno iOvfl; /* Overflow page number if any: 8 bytes */
/* In-memory data only */
lhpage *pPage; /* Page this cell belongs */
sxu16 iStart; /* Offset of this cell */
pgno iDataPage; /* Data page number when overflow */
sxu16 iDataOfft; /* Offset of the data in iDataPage */
SyBlob sKey; /* Record key for fast lookup (Kept in-memory if < 256KB ) */
lhcell *pNext,*pPrev; /* Linked list of the loaded memory cells */
lhcell *pNextCol,*pPrevCol; /* Collison chain */
};
/*
** Each database page has a header that is an instance of this
** structure.
*/
typedef struct lhphdr lhphdr;
struct lhphdr
{
sxu16 iOfft; /* Offset of the first cell */
sxu16 iFree; /* Offset of the first free block*/
pgno iSlave; /* Slave page number */
};
/*
* Each loaded primary disk page is represented in-memory using
* an instance of the following structure.
*/
struct lhpage
{
lhash_kv_engine *pHash; /* KV Storage engine that own this page */
unqlite_page *pRaw; /* Raw page contents */
lhphdr sHdr; /* Processed page header */
lhcell **apCell; /* Cell buckets */
lhcell *pList,*pFirst; /* Linked list of cells */
sxu32 nCell; /* Total number of cells */
sxu32 nCellSize; /* apCell[] size */
lhpage *pMaster; /* Master page in case we are dealing with a slave page */
lhpage *pSlave; /* List of slave pages */
lhpage *pNextSlave; /* Next slave page on the list */
sxi32 iSlave; /* Total number of slave pages */
sxu16 nFree; /* Amount of free space available in the page */
};
/*
* A Bucket map record which is used to map logical bucket number to real
* bucket number is represented by an instance of the following structure.
*/
typedef struct lhash_bmap_rec lhash_bmap_rec;
struct lhash_bmap_rec
{
pgno iLogic; /* Logical bucket number */
pgno iReal; /* Real bucket number */
lhash_bmap_rec *pNext,*pPrev; /* Link to other bucket map */
lhash_bmap_rec *pNextCol,*pPrevCol; /* Collision links */
};
typedef struct lhash_bmap_page lhash_bmap_page;
struct lhash_bmap_page
{
pgno iNum; /* Page number where this entry is stored */
sxu16 iPtr; /* Offset to start reading/writing from */
sxu32 nRec; /* Total number of records in this page */
pgno iNext; /* Next map page */
};
/*
* An in memory linear hash implemenation is represented by in an isntance
* of the following structure.
*/
struct lhash_kv_engine
{
const unqlite_kv_io *pIo; /* IO methods: Must be first */
/* Private fields */
SyMemBackend sAllocator; /* Private memory backend */
ProcHash xHash; /* Default hash function */
ProcCmp xCmp; /* Default comparison function */
unqlite_page *pHeader; /* Page one to identify a valid implementation */
lhash_bmap_rec **apMap; /* Buckets map records */
sxu32 nBuckRec; /* Total number of bucket map records */
sxu32 nBuckSize; /* apMap[] size */
lhash_bmap_rec *pList; /* List of bucket map records */
lhash_bmap_rec *pFirst; /* First record*/
lhash_bmap_page sPageMap; /* Primary bucket map */
int iPageSize; /* Page size */
pgno nFreeList; /* List of free pages */
pgno split_bucket; /* Current split bucket: MUST BE A POWER OF TWO */
pgno max_split_bucket; /* Maximum split bucket: MUST BE A POWER OF TWO */
pgno nmax_split_nucket; /* Next maximum split bucket (1 << nMsb): In-memory only */
sxu32 nMagic; /* Magic number to identify a valid linear hash disk database */
};
/*
* Given a logical bucket number, return the record associated with it.
*/
static lhash_bmap_rec * lhMapFindBucket(lhash_kv_engine *pEngine,pgno iLogic)
{
lhash_bmap_rec *pRec;
if( pEngine->nBuckRec < 1 ){
/* Don't bother */
return 0;
}
pRec = pEngine->apMap[iLogic & (pEngine->nBuckSize - 1)];
for(;;){
if( pRec == 0 ){
break;
}
if( pRec->iLogic == iLogic ){
return pRec;
}
/* Point to the next entry */
pRec = pRec->pNextCol;
}
/* No such record */
return 0;
}
/*
* Install a new bucket map record.
*/
static int lhMapInstallBucket(lhash_kv_engine *pEngine,pgno iLogic,pgno iReal)
{
lhash_bmap_rec *pRec;
sxu32 iBucket;
/* Allocate a new instance */
pRec = (lhash_bmap_rec *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhash_bmap_rec));
if( pRec == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pRec,sizeof(lhash_bmap_rec));
/* Fill in the structure */
pRec->iLogic = iLogic;
pRec->iReal = iReal;
iBucket = iLogic & (pEngine->nBuckSize - 1);
pRec->pNextCol = pEngine->apMap[iBucket];
if( pEngine->apMap[iBucket] ){
pEngine->apMap[iBucket]->pPrevCol = pRec;
}
pEngine->apMap[iBucket] = pRec;
/* Link */
if( pEngine->pFirst == 0 ){
pEngine->pFirst = pEngine->pList = pRec;
}else{
MACRO_LD_PUSH(pEngine->pList,pRec);
}
pEngine->nBuckRec++;
if( (pEngine->nBuckRec >= pEngine->nBuckSize * 3) && pEngine->nBuckRec < 100000 ){
/* Allocate a new larger table */
sxu32 nNewSize = pEngine->nBuckSize << 1;
lhash_bmap_rec *pEntry;
lhash_bmap_rec **apNew;
sxu32 n;
apNew = (lhash_bmap_rec **)SyMemBackendAlloc(&pEngine->sAllocator, nNewSize * sizeof(lhash_bmap_rec *));
if( apNew ){
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(lhash_bmap_rec *));
/* Rehash all entries */
n = 0;
pEntry = pEngine->pList;
for(;;){
/* Loop one */
if( n >= pEngine->nBuckRec ){
break;
}
pEntry->pNextCol = pEntry->pPrevCol = 0;
/* Install in the new bucket */
iBucket = pEntry->iLogic & (nNewSize - 1);
pEntry->pNextCol = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevCol = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(&pEngine->sAllocator,(void *)pEngine->apMap);
pEngine->apMap = apNew;
pEngine->nBuckSize = nNewSize;
}
}
return UNQLITE_OK;
}
/*
* Process a raw bucket map record.
*/
static int lhMapLoadPage(lhash_kv_engine *pEngine,lhash_bmap_page *pMap,const unsigned char *zRaw)
{
const unsigned char *zEnd = &zRaw[pEngine->iPageSize];
const unsigned char *zPtr = zRaw;
pgno iLogic,iReal;
sxu32 n;
int rc;
if( pMap->iPtr == 0 ){
/* Read the map header */
SyBigEndianUnpack64(zRaw,&pMap->iNext);
zRaw += 8;
SyBigEndianUnpack32(zRaw,&pMap->nRec);
zRaw += 4;
}else{
/* Mostly page one of the database */
zRaw += pMap->iPtr;
}
/* Start processing */
for( n = 0; n < pMap->nRec ; ++n ){
if( zRaw >= zEnd ){
break;
}
/* Extract the logical and real bucket number */
SyBigEndianUnpack64(zRaw,&iLogic);
zRaw += 8;
SyBigEndianUnpack64(zRaw,&iReal);
zRaw += 8;
/* Install the record in the map */
rc = lhMapInstallBucket(pEngine,iLogic,iReal);
if( rc != UNQLITE_OK ){
return rc;
}
}
pMap->iPtr = (sxu16)(zRaw-zPtr);
/* All done */
return UNQLITE_OK;
}
/*
* Allocate a new cell instance.
*/
static lhcell * lhNewCell(lhash_kv_engine *pEngine,lhpage *pPage)
{
lhcell *pCell;
pCell = (lhcell *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhcell));
if( pCell == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pCell,sizeof(lhcell));
/* Fill in the structure */
SyBlobInit(&pCell->sKey,&pEngine->sAllocator);
pCell->pPage = pPage;
return pCell;
}
/*
* Discard a cell from the page table.
*/
static void lhCellDiscard(lhcell *pCell)
{
lhpage *pPage = pCell->pPage->pMaster;
if( pCell->pPrevCol ){
pCell->pPrevCol->pNextCol = pCell->pNextCol;
}else{
pPage->apCell[pCell->nHash & (pPage->nCellSize - 1)] = pCell->pNextCol;
}
if( pCell->pNextCol ){
pCell->pNextCol->pPrevCol = pCell->pPrevCol;
}
MACRO_LD_REMOVE(pPage->pList,pCell);
if( pCell == pPage->pFirst ){
pPage->pFirst = pCell->pPrev;
}
pPage->nCell--;
/* Release the cell */
SyBlobRelease(&pCell->sKey);
SyMemBackendPoolFree(&pPage->pHash->sAllocator,pCell);
}
/*
* Install a cell in the page table.
*/
static int lhInstallCell(lhcell *pCell)
{
lhpage *pPage = pCell->pPage->pMaster;
sxu32 iBucket;
if( pPage->nCell < 1 ){
sxu32 nTableSize = 32; /* Must be a power of two */
lhcell **apTable;
/* Allocate a new cell table */
apTable = (lhcell **)SyMemBackendAlloc(&pPage->pHash->sAllocator, nTableSize * sizeof(lhcell *));
if( apTable == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the new table */
SyZero((void *)apTable, nTableSize * sizeof(lhcell *));
/* Install it */
pPage->apCell = apTable;
pPage->nCellSize = nTableSize;
}
iBucket = pCell->nHash & (pPage->nCellSize - 1);
pCell->pNextCol = pPage->apCell[iBucket];
if( pPage->apCell[iBucket] ){
pPage->apCell[iBucket]->pPrevCol = pCell;
}
pPage->apCell[iBucket] = pCell;
if( pPage->pFirst == 0 ){
pPage->pFirst = pPage->pList = pCell;
}else{
MACRO_LD_PUSH(pPage->pList,pCell);
}
pPage->nCell++;
if( (pPage->nCell >= pPage->nCellSize * 3) && pPage->nCell < 100000 ){
/* Allocate a new larger table */
sxu32 nNewSize = pPage->nCellSize << 1;
lhcell *pEntry;
lhcell **apNew;
sxu32 n;
apNew = (lhcell **)SyMemBackendAlloc(&pPage->pHash->sAllocator, nNewSize * sizeof(lhcell *));
if( apNew ){
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(lhcell *));
/* Rehash all entries */
n = 0;
pEntry = pPage->pList;
for(;;){
/* Loop one */
if( n >= pPage->nCell ){
break;
}
pEntry->pNextCol = pEntry->pPrevCol = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextCol = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevCol = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(&pPage->pHash->sAllocator,(void *)pPage->apCell);
pPage->apCell = apNew;
pPage->nCellSize = nNewSize;
}
}
return UNQLITE_OK;
}
/*
* Private data of lhKeyCmp().
*/
struct lhash_key_cmp
{
const char *zIn; /* Start of the stream */
const char *zEnd; /* End of the stream */
ProcCmp xCmp; /* Comparison function */
};
/*
* Comparsion callback for large key > 256 KB
*/
static int lhKeyCmp(const void *pData,sxu32 nLen,void *pUserData)
{
struct lhash_key_cmp *pCmp = (struct lhash_key_cmp *)pUserData;
int rc;
if( pCmp->zIn >= pCmp->zEnd ){
if( nLen > 0 ){
return UNQLITE_ABORT;
}
return UNQLITE_OK;
}
/* Perform the comparison */
rc = pCmp->xCmp((const void *)pCmp->zIn,pData,nLen);
if( rc != 0 ){
/* Abort comparison */
return UNQLITE_ABORT;
}
/* Advance the cursor */
pCmp->zIn += nLen;
return UNQLITE_OK;
}
/* Forward declaration */
static int lhConsumeCellkey(lhcell *pCell,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData,int offt_only);
/*
* given a key, return the cell associated with it on success. NULL otherwise.
*/
static lhcell * lhFindCell(
lhpage *pPage, /* Target page */
const void *pKey, /* Lookup key */
sxu32 nByte, /* Key length */
sxu32 nHash /* Hash of the key */
)
{
lhcell *pEntry;
if( pPage->nCell < 1 ){
/* Don't bother hashing */
return 0;
}
/* Point to the corresponding bucket */
pEntry = pPage->apCell[nHash & (pPage->nCellSize - 1)];
for(;;){
if( pEntry == 0 ){
break;
}
if( pEntry->nHash == nHash && pEntry->nKey == nByte ){
if( SyBlobLength(&pEntry->sKey) < 1 ){
/* Large key (> 256 KB) are not kept in-memory */
struct lhash_key_cmp sCmp;
int rc;
/* Fill-in the structure */
sCmp.zIn = (const char *)pKey;
sCmp.zEnd = &sCmp.zIn[nByte];
sCmp.xCmp = pPage->pHash->xCmp;
/* Fetch the key from disk and perform the comparison */
rc = lhConsumeCellkey(pEntry,lhKeyCmp,&sCmp,0);
if( rc == UNQLITE_OK ){
/* Cell found */
return pEntry;
}
}else if ( pPage->pHash->xCmp(pKey,SyBlobData(&pEntry->sKey),nByte) == 0 ){
/* Cell found */
return pEntry;
}
}
/* Point to the next entry */
pEntry = pEntry->pNextCol;
}
/* No such entry */
return 0;
}
/*
* Parse a raw cell fetched from disk.
*/
static int lhParseOneCell(lhpage *pPage,const unsigned char *zRaw,const unsigned char *zEnd,lhcell **ppOut)
{
sxu16 iNext,iOfft;
sxu32 iHash,nKey;
lhcell *pCell;
sxu64 nData;
int rc;
/* Offset this cell is stored */
iOfft = (sxu16)(zRaw - (const unsigned char *)pPage->pRaw->zData);
/* 4 byte hash number */
SyBigEndianUnpack32(zRaw,&iHash);
zRaw += 4;
/* 4 byte key length */
SyBigEndianUnpack32(zRaw,&nKey);
zRaw += 4;
/* 8 byte data length */
SyBigEndianUnpack64(zRaw,&nData);
zRaw += 8;
/* 2 byte offset of the next cell */
SyBigEndianUnpack16(zRaw,&iNext);
/* Perform a sanity check */
if( iNext > 0 && &pPage->pRaw->zData[iNext] >= zEnd ){
return UNQLITE_CORRUPT;
}
zRaw += 2;
pCell = lhNewCell(pPage->pHash,pPage);
if( pCell == 0 ){
return UNQLITE_NOMEM;
}
/* Fill in the structure */
pCell->iNext = iNext;
pCell->nKey = nKey;
pCell->nData = nData;
pCell->nHash = iHash;
/* Overflow page if any */
SyBigEndianUnpack64(zRaw,&pCell->iOvfl);
zRaw += 8;
/* Cell offset */
pCell->iStart = iOfft;
/* Consume the key */
rc = lhConsumeCellkey(pCell,unqliteDataConsumer,&pCell->sKey,pCell->nKey > 262144 /* 256 KB */? 1 : 0);
if( rc != UNQLITE_OK ){
/* TICKET: 14-32-chm@symisc.net: Key too large for memory */
SyBlobRelease(&pCell->sKey);
}
/* Finally install the cell */
rc = lhInstallCell(pCell);
if( rc != UNQLITE_OK ){
return rc;
}
if( ppOut ){
*ppOut = pCell;
}
return UNQLITE_OK;
}
/*
* Compute the total number of free space on a given page.
*/
static int lhPageFreeSpace(lhpage *pPage)
{
const unsigned char *zEnd,*zRaw = pPage->pRaw->zData;
lhphdr *pHdr = &pPage->sHdr;
sxu16 iNext,iAmount;
sxu16 nFree = 0;
if( pHdr->iFree < 1 ){
/* Don't bother processing, the page is full */
pPage->nFree = 0;
return UNQLITE_OK;
}
/* Point to first free block */
zEnd = &zRaw[pPage->pHash->iPageSize];
zRaw += pHdr->iFree;
for(;;){
/* Offset of the next free block */
SyBigEndianUnpack16(zRaw,&iNext);
zRaw += 2;
/* Available space on this block */
SyBigEndianUnpack16(zRaw,&iAmount);
nFree += iAmount;
if( iNext < 1 ){
/* No more free blocks */
break;
}
/* Point to the next free block*/
zRaw = &pPage->pRaw->zData[iNext];
if( zRaw >= zEnd ){
/* Corrupt page */
return UNQLITE_CORRUPT;
}
}
/* Save the amount of free space */
pPage->nFree = nFree;
return UNQLITE_OK;
}
/*
* Given a primary page, load all its cell.
*/
static int lhLoadCells(lhpage *pPage)
{
const unsigned char *zEnd,*zRaw = pPage->pRaw->zData;
lhphdr *pHdr = &pPage->sHdr;
lhcell *pCell = 0; /* cc warning */
int rc;
/* Calculate the amount of free space available first */
rc = lhPageFreeSpace(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
if( pHdr->iOfft < 1 ){
/* Don't bother processing, the page is empty */
return UNQLITE_OK;
}
/* Point to first cell */
zRaw += pHdr->iOfft;
zEnd = &zRaw[pPage->pHash->iPageSize];
for(;;){
/* Parse a single cell */
rc = lhParseOneCell(pPage,zRaw,zEnd,&pCell);
if( rc != UNQLITE_OK ){
return rc;
}
if( pCell->iNext < 1 ){
/* No more cells */
break;
}
/* Point to the next cell */
zRaw = &pPage->pRaw->zData[pCell->iNext];
if( zRaw >= zEnd ){
/* Corrupt page */
return UNQLITE_CORRUPT;
}
}
/* All done */
return UNQLITE_OK;
}
/*
* Given a page, parse its raw headers.
*/
static int lhParsePageHeader(lhpage *pPage)
{
const unsigned char *zRaw = pPage->pRaw->zData;
lhphdr *pHdr = &pPage->sHdr;
/* Offset of the first cell */
SyBigEndianUnpack16(zRaw,&pHdr->iOfft);
zRaw += 2;
/* Offset of the first free block */
SyBigEndianUnpack16(zRaw,&pHdr->iFree);
zRaw += 2;
/* Slave page number */
SyBigEndianUnpack64(zRaw,&pHdr->iSlave);
/* All done */
return UNQLITE_OK;
}
/*
* Allocate a new page instance.
*/
static lhpage * lhNewPage(
lhash_kv_engine *pEngine, /* KV store which own this instance */
unqlite_page *pRaw, /* Raw page contents */
lhpage *pMaster /* Master page in case we are dealing with a slave page */
)
{
lhpage *pPage;
/* Allocate a new instance */
pPage = (lhpage *)SyMemBackendPoolAlloc(&pEngine->sAllocator,sizeof(lhpage));
if( pPage == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pPage,sizeof(lhpage));
/* Fill-in the structure */
pPage->pHash = pEngine;
pPage->pRaw = pRaw;
pPage->pMaster = pMaster ? pMaster /* Slave page */ : pPage /* Master page */ ;
if( pPage->pMaster != pPage ){
/* Slave page, attach it to its master */
pPage->pNextSlave = pMaster->pSlave;
pMaster->pSlave = pPage;
pMaster->iSlave++;
}
/* Save this instance for future fast lookup */
pRaw->pUserData = pPage;
/* All done */
return pPage;
}
/*
* Load a primary and its associated slave pages from disk.
*/
static int lhLoadPage(lhash_kv_engine *pEngine,pgno pnum,lhpage *pMaster,lhpage **ppOut,int iNest)
{
unqlite_page *pRaw;
lhpage *pPage = 0; /* cc warning */
int rc;
/* Aquire the page from the pager first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pnum,&pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
if( pRaw->pUserData ){
/* The page is already parsed and loaded in memory. Point to it */
pPage = (lhpage *)pRaw->pUserData;
}else{
/* Allocate a new page */
pPage = lhNewPage(pEngine,pRaw,pMaster);
if( pPage == 0 ){
return UNQLITE_NOMEM;
}
/* Process the page */
rc = lhParsePageHeader(pPage);
if( rc == UNQLITE_OK ){
/* Load cells */
rc = lhLoadCells(pPage);
}
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pPage->pRaw); /* pPage will be released inside this call */
return rc;
}
if( pPage->sHdr.iSlave > 0 && iNest < 128 ){
if( pMaster == 0 ){
pMaster = pPage;
}
/* Slave page. Not a fatal error if something goes wrong here */
lhLoadPage(pEngine,pPage->sHdr.iSlave,pMaster,0,iNest++);
}
}
if( ppOut ){
*ppOut = pPage;
}
return UNQLITE_OK;
}
/*
* Given a cell, Consume its key by invoking the given callback for each extracted chunk.
*/
static int lhConsumeCellkey(
lhcell *pCell, /* Target cell */
int (*xConsumer)(const void *,unsigned int,void *), /* Consumer callback */
void *pUserData, /* Last argument to xConsumer() */
int offt_only
)
{
lhpage *pPage = pCell->pPage;
const unsigned char *zRaw = pPage->pRaw->zData;
const unsigned char *zPayload;
int rc;
/* Point to the payload area */
zPayload = &zRaw[pCell->iStart];
if( pCell->iOvfl == 0 ){
/* Best scenario, consume the key directly without any overflow page */
zPayload += L_HASH_CELL_SZ;
rc = xConsumer((const void *)zPayload,pCell->nKey,pUserData);
if( rc != UNQLITE_OK ){
rc = UNQLITE_ABORT;
}
}else{
lhash_kv_engine *pEngine = pPage->pHash;
sxu32 nByte,nData = pCell->nKey;
unqlite_page *pOvfl;
int data_offset = 0;
pgno iOvfl;
/* Overflow page */
iOvfl = pCell->iOvfl;
/* Total usable bytes in an overflow page */
nByte = L_HASH_OVERFLOW_SIZE(pEngine->iPageSize);
for(;;){
if( iOvfl == 0 || nData < 1 ){
/* no more overflow page */
break;
}
/* Point to the overflow page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,iOvfl,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
zPayload = &pOvfl->zData[8];
/* Point to the raw content */
if( !data_offset ){
/* Get the data page and offset */
SyBigEndianUnpack64(zPayload,&pCell->iDataPage);
zPayload += 8;
SyBigEndianUnpack16(zPayload,&pCell->iDataOfft);
zPayload += 2;
if( offt_only ){
/* Key too large, grab the data offset and return */
pEngine->pIo->xPageUnref(pOvfl);
return UNQLITE_OK;
}
data_offset = 1;
}
/* Consume the key */
if( nData <= nByte ){
rc = xConsumer((const void *)zPayload,nData,pUserData);
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pOvfl);
return UNQLITE_ABORT;
}
nData = 0;
}else{
rc = xConsumer((const void *)zPayload,nByte,pUserData);
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pOvfl);
return UNQLITE_ABORT;
}
nData -= nByte;
}
/* Next overflow page in the chain */
SyBigEndianUnpack64(pOvfl->zData,&iOvfl);
/* Unref the page */
pEngine->pIo->xPageUnref(pOvfl);
}
rc = UNQLITE_OK;
}
return rc;
}
/*
* Given a cell, Consume its data by invoking the given callback for each extracted chunk.
*/
static int lhConsumeCellData(
lhcell *pCell, /* Target cell */
int (*xConsumer)(const void *,unsigned int,void *), /* Data consumer callback */
void *pUserData /* Last argument to xConsumer() */
)
{
lhpage *pPage = pCell->pPage;
const unsigned char *zRaw = pPage->pRaw->zData;
const unsigned char *zPayload;
int rc;
/* Point to the payload area */
zPayload = &zRaw[pCell->iStart];
if( pCell->iOvfl == 0 ){
/* Best scenario, consume the data directly without any overflow page */
zPayload += L_HASH_CELL_SZ + pCell->nKey;
rc = xConsumer((const void *)zPayload,(sxu32)pCell->nData,pUserData);
if( rc != UNQLITE_OK ){
rc = UNQLITE_ABORT;
}
}else{
lhash_kv_engine *pEngine = pPage->pHash;
sxu64 nData = pCell->nData;
unqlite_page *pOvfl;
int fix_offset = 0;
sxu32 nByte;
pgno iOvfl;
/* Overflow page where data is stored */
iOvfl = pCell->iDataPage;
for(;;){
if( iOvfl == 0 || nData < 1 ){
/* no more overflow page */
break;
}
/* Point to the overflow page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,iOvfl,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Point to the raw content */
zPayload = pOvfl->zData;
if( !fix_offset ){
/* Point to the data */
zPayload += pCell->iDataOfft;
nByte = pEngine->iPageSize - pCell->iDataOfft;
fix_offset = 1;
}else{
zPayload += 8;
/* Total usable bytes in an overflow page */
nByte = L_HASH_OVERFLOW_SIZE(pEngine->iPageSize);
}
/* Consume the data */
if( nData <= (sxu64)nByte ){
rc = xConsumer((const void *)zPayload,(unsigned int)nData,pUserData);
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pOvfl);
return UNQLITE_ABORT;
}
nData = 0;
}else{
if( nByte > 0 ){
rc = xConsumer((const void *)zPayload,nByte,pUserData);
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pOvfl);
return UNQLITE_ABORT;
}
nData -= nByte;
}
}
/* Next overflow page in the chain */
SyBigEndianUnpack64(pOvfl->zData,&iOvfl);
/* Unref the page */
pEngine->pIo->xPageUnref(pOvfl);
}
rc = UNQLITE_OK;
}
return rc;
}
/*
* Read the linear hash header (Page one of the database).
*/
static int lhash_read_header(lhash_kv_engine *pEngine,unqlite_page *pHeader)
{
const unsigned char *zRaw = pHeader->zData;
lhash_bmap_page *pMap;
sxu32 nHash;
int rc;
pEngine->pHeader = pHeader;
/* 4 byte magic number */
SyBigEndianUnpack32(zRaw,&pEngine->nMagic);
zRaw += 4;
if( pEngine->nMagic != L_HASH_MAGIC ){
/* Corrupt implementation */
return UNQLITE_CORRUPT;
}
/* 4 byte hash value to identify a valid hash function */
SyBigEndianUnpack32(zRaw,&nHash);
zRaw += 4;
/* Sanity check */
if( pEngine->xHash(L_HASH_WORD,sizeof(L_HASH_WORD)-1) != nHash ){
/* Different hash function */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Invalid hash function");
return UNQLITE_INVALID;
}
/* List of free pages */
SyBigEndianUnpack64(zRaw,&pEngine->nFreeList);
zRaw += 8;
/* Current split bucket */
SyBigEndianUnpack64(zRaw,&pEngine->split_bucket);
zRaw += 8;
/* Maximum split bucket */
SyBigEndianUnpack64(zRaw,&pEngine->max_split_bucket);
zRaw += 8;
/* Next generation */
pEngine->nmax_split_nucket = pEngine->max_split_bucket << 1;
/* Initialiaze the bucket map */
pMap = &pEngine->sPageMap;
/* Fill in the structure */
pMap->iNum = pHeader->pgno;
/* Next page in the bucket map */
SyBigEndianUnpack64(zRaw,&pMap->iNext);
zRaw += 8;
/* Total number of records in the bucket map (This page only) */
SyBigEndianUnpack32(zRaw,&pMap->nRec);
zRaw += 4;
pMap->iPtr = (sxu16)(zRaw - pHeader->zData);
/* Load the map in memory */
rc = lhMapLoadPage(pEngine,pMap,pHeader->zData);
if( rc != UNQLITE_OK ){
return rc;
}
/* Load the bucket map chain if any */
for(;;){
pgno iNext = pMap->iNext;
unqlite_page *pPage;
if( iNext == 0 ){
/* No more map pages */
break;
}
/* Point to the target page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,iNext,&pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Fill in the structure */
pMap->iNum = iNext;
pMap->iPtr = 0;
/* Load the map in memory */
rc = lhMapLoadPage(pEngine,pMap,pPage->zData);
if( rc != UNQLITE_OK ){
return rc;
}
}
/* All done */
return UNQLITE_OK;
}
/*
* Perform a record lookup.
*/
static int lhRecordLookup(
lhash_kv_engine *pEngine, /* KV storage engine */
const void *pKey, /* Lookup key */
sxu32 nByte, /* Key length */
lhcell **ppCell /* OUT: Target cell on success */
)
{
lhash_bmap_rec *pRec;
lhpage *pPage;
lhcell *pCell;
pgno iBucket;
sxu32 nHash;
int rc;
/* Acquire the first page (hash Header) so that everything gets loaded autmatically */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Compute the hash of the key first */
nHash = pEngine->xHash(pKey,nByte);
/* Extract the logical (i.e. not real) page number */
iBucket = nHash & (pEngine->nmax_split_nucket - 1);
if( iBucket >= (pEngine->split_bucket + pEngine->max_split_bucket) ){
/* Low mask */
iBucket = nHash & (pEngine->max_split_bucket - 1);
}
/* Map the logical bucket number to real page number */
pRec = lhMapFindBucket(pEngine,iBucket);
if( pRec == 0 ){
/* No such entry */
return UNQLITE_NOTFOUND;
}
/* Load the master page and it's slave page in-memory */
rc = lhLoadPage(pEngine,pRec->iReal,0,&pPage,0);
if( rc != UNQLITE_OK ){
/* IO error, unlikely scenario */
return rc;
}
/* Lookup for the cell */
pCell = lhFindCell(pPage,pKey,nByte,nHash);
if( pCell == 0 ){
/* No such entry */
return UNQLITE_NOTFOUND;
}
if( ppCell ){
*ppCell = pCell;
}
return UNQLITE_OK;
}
/*
* Acquire a new page either from the free list or ask the pager
* for a new one.
*/
static int lhAcquirePage(lhash_kv_engine *pEngine,unqlite_page **ppOut)
{
unqlite_page *pPage;
int rc;
if( pEngine->nFreeList != 0 ){
/* Acquire one from the free list */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pEngine->nFreeList,&pPage);
if( rc == UNQLITE_OK ){
/* Point to the next free page */
SyBigEndianUnpack64(pPage->zData,&pEngine->nFreeList);
/* Update the database header */
rc = pEngine->pIo->xWrite(pEngine->pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/],pEngine->nFreeList);
/* Tell the pager do not journal this page */
pEngine->pIo->xDontJournal(pPage);
/* Return to the caller */
*ppOut = pPage;
/* All done */
return UNQLITE_OK;
}
}
/* Acquire a new page */
rc = pEngine->pIo->xNew(pEngine->pIo->pHandle,&pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Point to the target page */
*ppOut = pPage;
return UNQLITE_OK;
}
/*
* Write a bucket map record to disk.
*/
static int lhMapWriteRecord(lhash_kv_engine *pEngine,pgno iLogic,pgno iReal)
{
lhash_bmap_page *pMap = &pEngine->sPageMap;
unqlite_page *pPage = 0;
int rc;
if( pMap->iPtr > (pEngine->iPageSize - 16) /* 8 byte logical bucket number + 8 byte real bucket number */ ){
unqlite_page *pOld;
/* Point to the old page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pMap->iNum,&pOld);
if( rc != UNQLITE_OK ){
return rc;
}
/* Acquire a new page */
rc = lhAcquirePage(pEngine,&pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Reflect the change */
pMap->iNext = 0;
pMap->iNum = pPage->pgno;
pMap->nRec = 0;
pMap->iPtr = 8/* Next page number */+4/* Total records in the map*/;
/* Link this page */
rc = pEngine->pIo->xWrite(pOld);
if( rc != UNQLITE_OK ){
return rc;
}
if( pOld->pgno == pEngine->pHeader->pgno ){
/* First page (Hash header) */
SyBigEndianPack64(&pOld->zData[4/*magic*/+4/*hash*/+8/* Free page */+8/*current split bucket*/+8/*Maximum split bucket*/],pPage->pgno);
}else{
/* Link the new page */
SyBigEndianPack64(pOld->zData,pPage->pgno);
/* Unref */
pEngine->pIo->xPageUnref(pOld);
}
/* Assume the last bucket map page */
rc = pEngine->pIo->xWrite(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianPack64(pPage->zData,0); /* Next bucket map page on the list */
}
if( pPage == 0){
/* Point to the current map page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pMap->iNum,&pPage);
if( rc != UNQLITE_OK ){
return rc;
}
}
/* Make page writable */
rc = pEngine->pIo->xWrite(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Write the data */
SyBigEndianPack64(&pPage->zData[pMap->iPtr],iLogic);
pMap->iPtr += 8;
SyBigEndianPack64(&pPage->zData[pMap->iPtr],iReal);
pMap->iPtr += 8;
/* Install the bucket map */
rc = lhMapInstallBucket(pEngine,iLogic,iReal);
if( rc == UNQLITE_OK ){
/* Total number of records */
pMap->nRec++;
if( pPage->pgno == pEngine->pHeader->pgno ){
/* Page one: Always writable */
SyBigEndianPack32(
&pPage->zData[4/*magic*/+4/*hash*/+8/* Free page */+8/*current split bucket*/+8/*Maximum split bucket*/+8/*Next map page*/],
pMap->nRec);
}else{
/* Make page writable */
rc = pEngine->pIo->xWrite(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianPack32(&pPage->zData[8],pMap->nRec);
}
}
return rc;
}
/*
* Defragment a page.
*/
static int lhPageDefragment(lhpage *pPage)
{
lhash_kv_engine *pEngine = pPage->pHash;
unsigned char *zTmp,*zPtr,*zEnd,*zPayload;
lhcell *pCell;
/* Get a temporary page from the pager. This opertaion never fail */
zTmp = pEngine->pIo->xTmpPage(pEngine->pIo->pHandle);
/* Move the target cells to the begining */
pCell = pPage->pList;
/* Write the slave page number */
SyBigEndianPack64(&zTmp[2/*Offset of the first cell */+2/*Offset of the first free block */],pPage->sHdr.iSlave);
zPtr = &zTmp[L_HASH_PAGE_HDR_SZ]; /* Offset to start writing from */
zEnd = &zTmp[pEngine->iPageSize];
pPage->sHdr.iOfft = 0; /* Offset of the first cell */
for(;;){
if( pCell == 0 ){
/* No more cells */
break;
}
if( pCell->pPage->pRaw->pgno == pPage->pRaw->pgno ){
/* Cell payload if locally stored */
zPayload = 0;
if( pCell->iOvfl == 0 ){
zPayload = &pCell->pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ];
}
/* Move the cell */
pCell->iNext = pPage->sHdr.iOfft;
pCell->iStart = (sxu16)(zPtr - zTmp); /* Offset where this cell start */
pPage->sHdr.iOfft = pCell->iStart;
/* Write the cell header */
/* 4 byte hash number */
SyBigEndianPack32(zPtr,pCell->nHash);
zPtr += 4;
/* 4 byte ley length */
SyBigEndianPack32(zPtr,pCell->nKey);
zPtr += 4;
/* 8 byte data length */
SyBigEndianPack64(zPtr,pCell->nData);
zPtr += 8;
/* 2 byte offset of the next cell */
SyBigEndianPack16(zPtr,pCell->iNext);
zPtr += 2;
/* 8 byte overflow page number */
SyBigEndianPack64(zPtr,pCell->iOvfl);
zPtr += 8;
if( zPayload ){
/* Local payload */
SyMemcpy((const void *)zPayload,zPtr,(sxu32)(pCell->nKey + pCell->nData));
zPtr += pCell->nKey + pCell->nData;
}
if( zPtr >= zEnd ){
/* Can't happen */
break;
}
}
/* Point to the next page */
pCell = pCell->pNext;
}
/* Mark the free block */
pPage->nFree = (sxu16)(zEnd - zPtr); /* Block length */
if( pPage->nFree > 3 ){
pPage->sHdr.iFree = (sxu16)(zPtr - zTmp); /* Offset of the free block */
/* Mark the block */
SyBigEndianPack16(zPtr,0); /* Offset of the next free block */
SyBigEndianPack16(&zPtr[2],pPage->nFree); /* Block length */
}else{
/* Block of length less than 4 bytes are simply discarded */
pPage->nFree = 0;
pPage->sHdr.iFree = 0;
}
/* Reflect the change */
SyBigEndianPack16(zTmp,pPage->sHdr.iOfft); /* Offset of the first cell */
SyBigEndianPack16(&zTmp[2],pPage->sHdr.iFree); /* Offset of the first free block */
SyMemcpy((const void *)zTmp,pPage->pRaw->zData,pEngine->iPageSize);
/* All done */
return UNQLITE_OK;
}
/*
** Allocate nByte bytes of space on a page.
**
** Return the index into pPage->pRaw->zData[] of the first byte of
** the new allocation. Or return 0 if there is not enough free
** space on the page to satisfy the allocation request.
**
** If the page contains nBytes of free space but does not contain
** nBytes of contiguous free space, then this routine automatically
** calls defragementPage() to consolidate all free space before
** allocating the new chunk.
*/
static int lhAllocateSpace(lhpage *pPage,sxu64 nAmount,sxu16 *pOfft)
{
const unsigned char *zEnd,*zPtr;
sxu16 iNext,iBlksz,nByte;
unsigned char *zPrev;
int rc;
if( (sxu64)pPage->nFree < nAmount ){
/* Don't bother looking for a free chunk */
return UNQLITE_FULL;
}
if( pPage->nCell < 10 && ((int)nAmount >= (pPage->pHash->iPageSize / 2)) ){
/* Big chunk need an overflow page for its data */
return UNQLITE_FULL;
}
zPtr = &pPage->pRaw->zData[pPage->sHdr.iFree];
zEnd = &pPage->pRaw->zData[pPage->pHash->iPageSize];
nByte = (sxu16)nAmount;
zPrev = 0;
iBlksz = 0; /* cc warning */
/* Perform the lookup */
for(;;){
if( zPtr >= zEnd ){
return UNQLITE_FULL;
}
/* Offset of the next free block */
SyBigEndianUnpack16(zPtr,&iNext);
/* Block size */
SyBigEndianUnpack16(&zPtr[2],&iBlksz);
if( iBlksz >= nByte ){
/* Got one */
break;
}
zPrev = (unsigned char *)zPtr;
if( iNext == 0 ){
/* No more free blocks, defragment the page */
rc = lhPageDefragment(pPage);
if( rc == UNQLITE_OK && pPage->nFree >= nByte) {
/* Free blocks are merged together */
iNext = 0;
zPtr = &pPage->pRaw->zData[pPage->sHdr.iFree];
iBlksz = pPage->nFree;
zPrev = 0;
break;
}else{
return UNQLITE_FULL;
}
}
/* Point to the next free block */
zPtr = &pPage->pRaw->zData[iNext];
}
/* Acquire writer lock on this page */
rc = pPage->pHash->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Save block offset */
*pOfft = (sxu16)(zPtr - pPage->pRaw->zData);
/* Fix pointers */
if( iBlksz >= nByte && (iBlksz - nByte) > 3 ){
unsigned char *zBlock = &pPage->pRaw->zData[(*pOfft) + nByte];
/* Create a new block */
zPtr = zBlock;
SyBigEndianPack16(zBlock,iNext); /* Offset of the next block */
SyBigEndianPack16(&zBlock[2],iBlksz-nByte); /* Block size*/
/* Offset of the new block */
iNext = (sxu16)(zPtr - pPage->pRaw->zData);
iBlksz = nByte;
}
/* Fix offsets */
if( zPrev ){
SyBigEndianPack16(zPrev,iNext);
}else{
/* First block */
pPage->sHdr.iFree = iNext;
/* Reflect on the page header */
SyBigEndianPack16(&pPage->pRaw->zData[2/* Offset of the first cell1*/],iNext);
}
/* All done */
pPage->nFree -= iBlksz;
return UNQLITE_OK;
}
/*
* Write the cell header into the corresponding offset.
*/
static int lhCellWriteHeader(lhcell *pCell)
{
lhpage *pPage = pCell->pPage;
unsigned char *zRaw = pPage->pRaw->zData;
/* Seek to the desired location */
zRaw += pCell->iStart;
/* 4 byte hash number */
SyBigEndianPack32(zRaw,pCell->nHash);
zRaw += 4;
/* 4 byte key length */
SyBigEndianPack32(zRaw,pCell->nKey);
zRaw += 4;
/* 8 byte data length */
SyBigEndianPack64(zRaw,pCell->nData);
zRaw += 8;
/* 2 byte offset of the next cell */
pCell->iNext = pPage->sHdr.iOfft;
SyBigEndianPack16(zRaw,pCell->iNext);
zRaw += 2;
/* 8 byte overflow page number */
SyBigEndianPack64(zRaw,pCell->iOvfl);
/* Update the page header */
pPage->sHdr.iOfft = pCell->iStart;
/* pEngine->pIo->xWrite() has been successfully called on this page */
SyBigEndianPack16(pPage->pRaw->zData,pCell->iStart);
/* All done */
return UNQLITE_OK;
}
/*
* Write local payload.
*/
static int lhCellWriteLocalPayload(lhcell *pCell,
const void *pKey,sxu32 nKeylen,
const void *pData,unqlite_int64 nDatalen
)
{
/* A writer lock have been acquired on this page */
lhpage *pPage = pCell->pPage;
unsigned char *zRaw = pPage->pRaw->zData;
/* Seek to the desired location */
zRaw += pCell->iStart + L_HASH_CELL_SZ;
/* Write the key */
SyMemcpy(pKey,(void *)zRaw,nKeylen);
zRaw += nKeylen;
if( nDatalen > 0 ){
/* Write the Data */
SyMemcpy(pData,(void *)zRaw,(sxu32)nDatalen);
}
return UNQLITE_OK;
}
/*
* Allocate as much overflow page we need to store the cell payload.
*/
static int lhCellWriteOvflPayload(lhcell *pCell,const void *pKey,sxu32 nKeylen,...)
{
lhpage *pPage = pCell->pPage;
lhash_kv_engine *pEngine = pPage->pHash;
unqlite_page *pOvfl,*pFirst,*pNew;
const unsigned char *zPtr,*zEnd;
unsigned char *zRaw,*zRawEnd;
sxu32 nAvail;
va_list ap;
int rc;
/* Acquire a new overflow page */
rc = lhAcquirePage(pEngine,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Acquire a writer lock */
rc = pEngine->pIo->xWrite(pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
pFirst = pOvfl;
/* Link */
pCell->iOvfl = pOvfl->pgno;
/* Update the cell header */
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4/*Hash*/ + 4/*Key*/ + 8/*Data*/ + 2 /*Next cell*/],pCell->iOvfl);
/* Start the write process */
zPtr = (const unsigned char *)pKey;
zEnd = &zPtr[nKeylen];
SyBigEndianPack64(pOvfl->zData,0); /* Next overflow page on the chain */
zRaw = &pOvfl->zData[8/* Next ovfl page*/ + 8 /* Data page */ + 2 /* Data offset*/];
zRawEnd = &pOvfl->zData[pEngine->iPageSize];
pNew = pOvfl;
/* Write the key */
for(;;){
if( zPtr >= zEnd ){
break;
}
if( zRaw >= zRawEnd ){
/* Acquire a new page */
rc = lhAcquirePage(pEngine,&pNew);
if( rc != UNQLITE_OK ){
return rc;
}
rc = pEngine->pIo->xWrite(pNew);
if( rc != UNQLITE_OK ){
return rc;
}
/* Link */
SyBigEndianPack64(pOvfl->zData,pNew->pgno);
pEngine->pIo->xPageUnref(pOvfl);
SyBigEndianPack64(pNew->zData,0); /* Next overflow page on the chain */
pOvfl = pNew;
zRaw = &pNew->zData[8];
zRawEnd = &pNew->zData[pEngine->iPageSize];
}
nAvail = (sxu32)(zRawEnd-zRaw);
nKeylen = (sxu32)(zEnd-zPtr);
if( nKeylen > nAvail ){
nKeylen = nAvail;
}
SyMemcpy((const void *)zPtr,(void *)zRaw,nKeylen);
/* Synchronize pointers */
zPtr += nKeylen;
zRaw += nKeylen;
}
rc = UNQLITE_OK;
va_start(ap,nKeylen);
pCell->iDataPage = pNew->pgno;
pCell->iDataOfft = (sxu16)(zRaw-pNew->zData);
/* Write the data page and its offset */
SyBigEndianPack64(&pFirst->zData[8/*Next ovfl*/],pCell->iDataPage);
SyBigEndianPack16(&pFirst->zData[8/*Next ovfl*/+8/*Data page*/],pCell->iDataOfft);
/* Write data */
for(;;){
const void *pData;
sxu32 nDatalen;
sxu64 nData;
pData = va_arg(ap,const void *);
nData = va_arg(ap,sxu64);
if( pData == 0 ){
/* No more chunks */
break;
}
/* Write this chunk */
zPtr = (const unsigned char *)pData;
zEnd = &zPtr[nData];
for(;;){
if( zPtr >= zEnd ){
break;
}
if( zRaw >= zRawEnd ){
/* Acquire a new page */
rc = lhAcquirePage(pEngine,&pNew);
if( rc != UNQLITE_OK ){
va_end(ap);
return rc;
}
rc = pEngine->pIo->xWrite(pNew);
if( rc != UNQLITE_OK ){
va_end(ap);
return rc;
}
/* Link */
SyBigEndianPack64(pOvfl->zData,pNew->pgno);
pEngine->pIo->xPageUnref(pOvfl);
SyBigEndianPack64(pNew->zData,0); /* Next overflow page on the chain */
pOvfl = pNew;
zRaw = &pNew->zData[8];
zRawEnd = &pNew->zData[pEngine->iPageSize];
}
nAvail = (sxu32)(zRawEnd-zRaw);
nDatalen = (sxu32)(zEnd-zPtr);
if( nDatalen > nAvail ){
nDatalen = nAvail;
}
SyMemcpy((const void *)zPtr,(void *)zRaw,nDatalen);
/* Synchronize pointers */
zPtr += nDatalen;
zRaw += nDatalen;
}
}
/* Unref the overflow page */
pEngine->pIo->xPageUnref(pOvfl);
va_end(ap);
return UNQLITE_OK;
}
/*
* Restore a page to the free list.
*/
static int lhRestorePage(lhash_kv_engine *pEngine,unqlite_page *pPage)
{
int rc;
rc = pEngine->pIo->xWrite(pEngine->pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
rc = pEngine->pIo->xWrite(pPage);
if( rc != UNQLITE_OK ){
return rc;
}
/* Link to the list of free page */
SyBigEndianPack64(pPage->zData,pEngine->nFreeList);
pEngine->nFreeList = pPage->pgno;
SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/],pEngine->nFreeList);
/* All done */
return UNQLITE_OK;
}
/*
* Restore cell space and mark it as a free block.
*/
static int lhRestoreSpace(lhpage *pPage,sxu16 iOfft,sxu16 nByte)
{
unsigned char *zRaw;
if( nByte < 4 ){
/* At least 4 bytes of freespace must form a valid block */
return UNQLITE_OK;
}
/* pEngine->pIo->xWrite() has been successfully called on this page */
zRaw = &pPage->pRaw->zData[iOfft];
/* Mark as a free block */
SyBigEndianPack16(zRaw,pPage->sHdr.iFree); /* Offset of the next free block */
zRaw += 2;
SyBigEndianPack16(zRaw,nByte);
/* Link */
SyBigEndianPack16(&pPage->pRaw->zData[2/* offset of the first cell */],iOfft);
pPage->sHdr.iFree = iOfft;
pPage->nFree += nByte;
return UNQLITE_OK;
}
/* Forward declaration */
static lhcell * lhFindSibeling(lhcell *pCell);
/*
* Unlink a cell.
*/
static int lhUnlinkCell(lhcell *pCell)
{
lhash_kv_engine *pEngine = pCell->pPage->pHash;
lhpage *pPage = pCell->pPage;
sxu16 nByte = L_HASH_CELL_SZ;
lhcell *pPrev;
int rc;
rc = pEngine->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Bring the link */
pPrev = lhFindSibeling(pCell);
if( pPrev ){
pPrev->iNext = pCell->iNext;
/* Fix offsets in the page header */
SyBigEndianPack16(&pPage->pRaw->zData[pPrev->iStart + 4/*Hash*/+4/*Key*/+8/*Data*/],pCell->iNext);
}else{
/* First entry on this page (either master or slave) */
pPage->sHdr.iOfft = pCell->iNext;
/* Update the page header */
SyBigEndianPack16(pPage->pRaw->zData,pCell->iNext);
}
/* Restore cell space */
if( pCell->iOvfl == 0 ){
nByte += (sxu16)(pCell->nData + pCell->nKey);
}
lhRestoreSpace(pPage,pCell->iStart,nByte);
/* Discard the cell from the in-memory hashtable */
lhCellDiscard(pCell);
return UNQLITE_OK;
}
/*
* Remove a cell and its paylod (key + data).
*/
static int lhRecordRemove(lhcell *pCell)
{
lhash_kv_engine *pEngine = pCell->pPage->pHash;
int rc;
if( pCell->iOvfl > 0){
/* Discard overflow pages */
unqlite_page *pOvfl;
pgno iNext = pCell->iOvfl;
for(;;){
/* Point to the overflow page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,iNext,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Next page on the chain */
SyBigEndianUnpack64(pOvfl->zData,&iNext);
/* Restore the page to the free list */
rc = lhRestorePage(pEngine,pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Unref */
pEngine->pIo->xPageUnref(pOvfl);
if( iNext == 0 ){
break;
}
}
}
/* Unlink the cell */
rc = lhUnlinkCell(pCell);
return rc;
}
/*
* Find cell sibeling.
*/
static lhcell * lhFindSibeling(lhcell *pCell)
{
lhpage *pPage = pCell->pPage->pMaster;
lhcell *pEntry;
pEntry = pPage->pFirst;
while( pEntry ){
if( pEntry->pPage == pCell->pPage && pEntry->iNext == pCell->iStart ){
/* Sibeling found */
return pEntry;
}
/* Point to the previous entry */
pEntry = pEntry->pPrev;
}
/* Last inserted cell */
return 0;
}
/*
* Move a cell to a new location with its new data.
*/
static int lhMoveLocalCell(
lhcell *pCell,
sxu16 iOfft,
const void *pData,
unqlite_int64 nData
)
{
sxu16 iKeyOfft = pCell->iStart + L_HASH_CELL_SZ;
lhpage *pPage = pCell->pPage;
lhcell *pSibeling;
pSibeling = lhFindSibeling(pCell);
if( pSibeling ){
/* Fix link */
SyBigEndianPack16(&pPage->pRaw->zData[pSibeling->iStart + 4/*Hash*/+4/*Key*/+8/*Data*/],pCell->iNext);
pSibeling->iNext = pCell->iNext;
}else{
/* First cell, update page header only */
SyBigEndianPack16(pPage->pRaw->zData,pCell->iNext);
pPage->sHdr.iOfft = pCell->iNext;
}
/* Set the new offset */
pCell->iStart = iOfft;
pCell->nData = (sxu64)nData;
/* Write the cell payload */
lhCellWriteLocalPayload(pCell,(const void *)&pPage->pRaw->zData[iKeyOfft],pCell->nKey,pData,nData);
/* Finally write the cell header */
lhCellWriteHeader(pCell);
/* All done */
return UNQLITE_OK;
}
/*
* Overwrite an existing record.
*/
static int lhRecordOverwrite(
lhcell *pCell,
const void *pData,unqlite_int64 nByte
)
{
lhash_kv_engine *pEngine = pCell->pPage->pHash;
unsigned char *zRaw,*zRawEnd,*zPayload;
const unsigned char *zPtr,*zEnd;
unqlite_page *pOvfl,*pOld,*pNew;
lhpage *pPage = pCell->pPage;
sxu32 nAvail;
pgno iOvfl;
int rc;
/* Acquire a writer lock on this page */
rc = pEngine->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
if( pCell->iOvfl == 0 ){
/* Local payload, try to deal with the free space issues */
zPayload = &pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ + pCell->nKey];
if( pCell->nData == (sxu64)nByte ){
/* Best scenario, simply a memcpy operation */
SyMemcpy(pData,(void *)zPayload,(sxu32)nByte);
}else if( (sxu64)nByte < pCell->nData ){
/* Shorter data, not so ugly */
SyMemcpy(pData,(void *)zPayload,(sxu32)nByte);
/* Update the cell header */
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4 /* Hash */ + 4 /* Key */],nByte);
/* Restore freespace */
lhRestoreSpace(pPage,(sxu16)(pCell->iStart + L_HASH_CELL_SZ + pCell->nKey + nByte),(sxu16)(pCell->nData - nByte));
/* New data size */
pCell->nData = (sxu64)nByte;
}else{
sxu16 iOfft = 0; /* cc warning */
/* Check if another chunk is available for this cell */
rc = lhAllocateSpace(pPage,L_HASH_CELL_SZ + pCell->nKey + nByte,&iOfft);
if( rc != UNQLITE_OK ){
/* Transfer the payload to an overflow page */
rc = lhCellWriteOvflPayload(pCell,&pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ],pCell->nKey,pData,nByte,(const void *)0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Update the cell header */
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4 /* Hash */ + 4 /* Key */],(sxu64)nByte);
/* Restore freespace */
lhRestoreSpace(pPage,(sxu16)(pCell->iStart + L_HASH_CELL_SZ),(sxu16)(pCell->nKey + pCell->nData));
/* New data size */
pCell->nData = (sxu64)nByte;
}else{
sxu16 iOldOfft = pCell->iStart;
sxu32 iOld = (sxu32)pCell->nData;
/* Space is available, transfer the cell */
lhMoveLocalCell(pCell,iOfft,pData,nByte);
/* Restore cell space */
lhRestoreSpace(pPage,iOldOfft,(sxu16)(L_HASH_CELL_SZ + pCell->nKey + iOld));
}
}
return UNQLITE_OK;
}
/* Point to the overflow page */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pCell->iDataPage,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Relase all old overflow pages first */
SyBigEndianUnpack64(pOvfl->zData,&iOvfl);
pOld = pOvfl;
for(;;){
if( iOvfl == 0 ){
/* No more overflow pages on the chain */
break;
}
/* Point to the target page */
if( UNQLITE_OK != pEngine->pIo->xGet(pEngine->pIo->pHandle,iOvfl,&pOld) ){
/* Not so fatal if something goes wrong here */
break;
}
/* Next overflow page to be released */
SyBigEndianUnpack64(pOld->zData,&iOvfl);
if( pOld != pOvfl ){ /* xx: chm is maniac */
/* Restore the page to the free list */
lhRestorePage(pEngine,pOld);
/* Unref */
pEngine->pIo->xPageUnref(pOld);
}
}
/* Point to the data offset */
zRaw = &pOvfl->zData[pCell->iDataOfft];
zRawEnd = &pOvfl->zData[pEngine->iPageSize];
/* The data to be stored */
zPtr = (const unsigned char *)pData;
zEnd = &zPtr[nByte];
/* Start the overwrite process */
/* Acquire a writer lock */
rc = pEngine->pIo->xWrite(pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianPack64(pOvfl->zData,0);
for(;;){
sxu32 nLen;
if( zPtr >= zEnd ){
break;
}
if( zRaw >= zRawEnd ){
/* Acquire a new page */
rc = lhAcquirePage(pEngine,&pNew);
if( rc != UNQLITE_OK ){
return rc;
}
rc = pEngine->pIo->xWrite(pNew);
if( rc != UNQLITE_OK ){
return rc;
}
/* Link */
SyBigEndianPack64(pOvfl->zData,pNew->pgno);
pEngine->pIo->xPageUnref(pOvfl);
SyBigEndianPack64(pNew->zData,0); /* Next overflow page on the chain */
pOvfl = pNew;
zRaw = &pNew->zData[8];
zRawEnd = &pNew->zData[pEngine->iPageSize];
}
nAvail = (sxu32)(zRawEnd-zRaw);
nLen = (sxu32)(zEnd-zPtr);
if( nLen > nAvail ){
nLen = nAvail;
}
SyMemcpy((const void *)zPtr,(void *)zRaw,nLen);
/* Synchronize pointers */
zPtr += nLen;
zRaw += nLen;
}
/* Unref the last overflow page */
pEngine->pIo->xPageUnref(pOvfl);
/* Finally, update the cell header */
pCell->nData = (sxu64)nByte;
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4 /* Hash */ + 4 /* Key */],pCell->nData);
/* All done */
return UNQLITE_OK;
}
/*
* Append data to an existing record.
*/
static int lhRecordAppend(
lhcell *pCell,
const void *pData,unqlite_int64 nByte
)
{
lhash_kv_engine *pEngine = pCell->pPage->pHash;
const unsigned char *zPtr,*zEnd;
lhpage *pPage = pCell->pPage;
unsigned char *zRaw,*zRawEnd;
unqlite_page *pOvfl,*pNew;
sxu64 nDatalen;
sxu32 nAvail;
pgno iOvfl;
int rc;
if( pCell->nData + nByte < pCell->nData ){
/* Overflow */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Append operation will cause data overflow");
return UNQLITE_LIMIT;
}
/* Acquire a writer lock on this page */
rc = pEngine->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
if( pCell->iOvfl == 0 ){
sxu16 iOfft = 0; /* cc warning */
/* Local payload, check for a bigger place */
rc = lhAllocateSpace(pPage,L_HASH_CELL_SZ + pCell->nKey + pCell->nData + nByte,&iOfft);
if( rc != UNQLITE_OK ){
/* Transfer the payload to an overflow page */
rc = lhCellWriteOvflPayload(pCell,
&pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ],pCell->nKey,
(const void *)&pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ + pCell->nKey],pCell->nData,
pData,nByte,
(const void *)0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Update the cell header */
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4 /* Hash */ + 4 /* Key */],pCell->nData + nByte);
/* Restore freespace */
lhRestoreSpace(pPage,(sxu16)(pCell->iStart + L_HASH_CELL_SZ),(sxu16)(pCell->nKey + pCell->nData));
/* New data size */
pCell->nData += nByte;
}else{
sxu16 iOldOfft = pCell->iStart;
sxu32 iOld = (sxu32)pCell->nData;
SyBlob sWorker;
SyBlobInit(&sWorker,&pEngine->sAllocator);
/* Copy the old data */
rc = SyBlobAppend(&sWorker,(const void *)&pPage->pRaw->zData[pCell->iStart + L_HASH_CELL_SZ + pCell->nKey],(sxu32)pCell->nData);
if( rc == SXRET_OK ){
/* Append the new data */
rc = SyBlobAppend(&sWorker,pData,(sxu32)nByte);
}
if( rc != UNQLITE_OK ){
SyBlobRelease(&sWorker);
return rc;
}
/* Space is available, transfer the cell */
lhMoveLocalCell(pCell,iOfft,SyBlobData(&sWorker),(unqlite_int64)SyBlobLength(&sWorker));
/* Restore cell space */
lhRestoreSpace(pPage,iOldOfft,(sxu16)(L_HASH_CELL_SZ + pCell->nKey + iOld));
/* All done */
SyBlobRelease(&sWorker);
}
return UNQLITE_OK;
}
/* Point to the overflow page which hold the data */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,pCell->iDataPage,&pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
/* Next overflow page in the chain */
SyBigEndianUnpack64(pOvfl->zData,&iOvfl);
/* Point to the end of the chunk */
zRaw = &pOvfl->zData[pCell->iDataOfft];
zRawEnd = &pOvfl->zData[pEngine->iPageSize];
nDatalen = pCell->nData;
nAvail = (sxu32)(zRawEnd - zRaw);
for(;;){
if( zRaw >= zRawEnd ){
if( iOvfl == 0 ){
/* Cant happen */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Corrupt overflow page");
return UNQLITE_CORRUPT;
}
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,iOvfl,&pNew);
if( rc != UNQLITE_OK ){
return rc;
}
/* Next overflow page on the chain */
SyBigEndianUnpack64(pNew->zData,&iOvfl);
/* Unref the previous overflow page */
pEngine->pIo->xPageUnref(pOvfl);
/* Point to the new chunk */
zRaw = &pNew->zData[8];
zRawEnd = &pNew->zData[pCell->pPage->pHash->iPageSize];
nAvail = L_HASH_OVERFLOW_SIZE(pCell->pPage->pHash->iPageSize);
pOvfl = pNew;
}
if( (sxu64)nAvail > nDatalen ){
zRaw += nDatalen;
break;
}else{
nDatalen -= nAvail;
}
zRaw += nAvail;
}
/* Start the append process */
zPtr = (const unsigned char *)pData;
zEnd = &zPtr[nByte];
/* Acquire a writer lock */
rc = pEngine->pIo->xWrite(pOvfl);
if( rc != UNQLITE_OK ){
return rc;
}
for(;;){
sxu32 nLen;
if( zPtr >= zEnd ){
break;
}
if( zRaw >= zRawEnd ){
/* Acquire a new page */
rc = lhAcquirePage(pEngine,&pNew);
if( rc != UNQLITE_OK ){
return rc;
}
rc = pEngine->pIo->xWrite(pNew);
if( rc != UNQLITE_OK ){
return rc;
}
/* Link */
SyBigEndianPack64(pOvfl->zData,pNew->pgno);
pEngine->pIo->xPageUnref(pOvfl);
SyBigEndianPack64(pNew->zData,0); /* Next overflow page on the chain */
pOvfl = pNew;
zRaw = &pNew->zData[8];
zRawEnd = &pNew->zData[pEngine->iPageSize];
}
nAvail = (sxu32)(zRawEnd-zRaw);
nLen = (sxu32)(zEnd-zPtr);
if( nLen > nAvail ){
nLen = nAvail;
}
SyMemcpy((const void *)zPtr,(void *)zRaw,nLen);
/* Synchronize pointers */
zPtr += nLen;
zRaw += nLen;
}
/* Unref the last overflow page */
pEngine->pIo->xPageUnref(pOvfl);
/* Finally, update the cell header */
pCell->nData += nByte;
SyBigEndianPack64(&pPage->pRaw->zData[pCell->iStart + 4 /* Hash */ + 4 /* Key */],pCell->nData);
/* All done */
return UNQLITE_OK;
}
/*
* A write privilege have been acquired on this page.
* Mark it as an empty page (No cells).
*/
static int lhSetEmptyPage(lhpage *pPage)
{
unsigned char *zRaw = pPage->pRaw->zData;
lhphdr *pHeader = &pPage->sHdr;
sxu16 nByte;
int rc;
/* Acquire a writer lock */
rc = pPage->pHash->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Offset of the first cell */
SyBigEndianPack16(zRaw,0);
zRaw += 2;
/* Offset of the first free block */
pHeader->iFree = L_HASH_PAGE_HDR_SZ;
SyBigEndianPack16(zRaw,L_HASH_PAGE_HDR_SZ);
zRaw += 2;
/* Slave page number */
SyBigEndianPack64(zRaw,0);
zRaw += 8;
/* Fill the free block */
SyBigEndianPack16(zRaw,0); /* Offset of the next free block */
zRaw += 2;
nByte = (sxu16)L_HASH_MX_FREE_SPACE(pPage->pHash->iPageSize);
SyBigEndianPack16(zRaw,nByte);
pPage->nFree = nByte;
/* Do not add this page to the hot dirty list */
pPage->pHash->pIo->xDontMkHot(pPage->pRaw);
return UNQLITE_OK;
}
/* Forward declaration */
static int lhSlaveStore(
lhpage *pPage,
const void *pKey,sxu32 nKeyLen,
const void *pData,unqlite_int64 nDataLen,
sxu32 nHash
);
/*
* Store a cell and its payload in a given page.
*/
static int lhStoreCell(
lhpage *pPage, /* Target page */
const void *pKey,sxu32 nKeyLen, /* Payload: Key */
const void *pData,unqlite_int64 nDataLen, /* Payload: Data */
sxu32 nHash, /* Hash of the key */
int auto_append /* Auto append a slave page if full */
)
{
lhash_kv_engine *pEngine = pPage->pHash;
int iNeedOvfl = 0; /* Need overflow page for this cell and its payload*/
lhcell *pCell;
sxu16 nOfft;
int rc;
/* Acquire a writer lock on this page first */
rc = pEngine->pIo->xWrite(pPage->pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Check for a free block */
rc = lhAllocateSpace(pPage,L_HASH_CELL_SZ+nKeyLen+nDataLen,&nOfft);
if( rc != UNQLITE_OK ){
/* Check for a free block to hold a single cell only (without payload) */
rc = lhAllocateSpace(pPage,L_HASH_CELL_SZ,&nOfft);
if( rc != UNQLITE_OK ){
if( !auto_append ){
/* A split must be done */
return UNQLITE_FULL;
}else{
/* Store this record in a slave page */
rc = lhSlaveStore(pPage,pKey,nKeyLen,pData,nDataLen,nHash);
return rc;
}
}
iNeedOvfl = 1;
}
/* Allocate a new cell instance */
pCell = lhNewCell(pEngine,pPage);
if( pCell == 0 ){
pEngine->pIo->xErr(pEngine->pIo->pHandle,"KV store is running out of memory");
return UNQLITE_NOMEM;
}
/* Fill-in the structure */
pCell->iStart = nOfft;
pCell->nKey = nKeyLen;
pCell->nData = (sxu64)nDataLen;
pCell->nHash = nHash;
if( nKeyLen < 262144 /* 256 KB */ ){
/* Keep the key in-memory for fast lookup */
SyBlobAppend(&pCell->sKey,pKey,nKeyLen);
}
/* Link the cell */
rc = lhInstallCell(pCell);
if( rc != UNQLITE_OK ){
return rc;
}
/* Write the payload */
if( iNeedOvfl ){
rc = lhCellWriteOvflPayload(pCell,pKey,nKeyLen,pData,nDataLen,(const void *)0);
if( rc != UNQLITE_OK ){
lhCellDiscard(pCell);
return rc;
}
}else{
lhCellWriteLocalPayload(pCell,pKey,nKeyLen,pData,nDataLen);
}
/* Finally, Write the cell header */
lhCellWriteHeader(pCell);
/* All done */
return UNQLITE_OK;
}
/*
* Find a slave page capable of hosting the given amount.
*/
static int lhFindSlavePage(lhpage *pPage,sxu64 nAmount,sxu16 *pOfft,lhpage **ppSlave)
{
lhash_kv_engine *pEngine = pPage->pHash;
lhpage *pMaster = pPage->pMaster;
lhpage *pSlave = pMaster->pSlave;
unqlite_page *pRaw;
lhpage *pNew;
sxu16 iOfft;
sxi32 i;
int rc;
/* Look for an already attached slave page */
for( i = 0 ; i < pMaster->iSlave ; ++i ){
/* Find a free chunk big enough */
sxu16 size = (sxu16)(L_HASH_CELL_SZ + nAmount);
rc = lhAllocateSpace(pSlave,size,&iOfft);
if( rc != UNQLITE_OK ){
/* A space for cell header only */
size = L_HASH_CELL_SZ;
rc = lhAllocateSpace(pSlave,size,&iOfft);
}
if( rc == UNQLITE_OK ){
/* All done */
if( pOfft ){
*pOfft = iOfft;
}else{
rc = lhRestoreSpace(pSlave, iOfft, size);
}
*ppSlave = pSlave;
return rc;
}
/* Point to the next slave page */
pSlave = pSlave->pNextSlave;
}
/* Acquire a new slave page */
rc = lhAcquirePage(pEngine,&pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Last slave page */
pSlave = pMaster->pSlave;
if( pSlave == 0 ){
/* First slave page */
pSlave = pMaster;
}
/* Initialize the page */
pNew = lhNewPage(pEngine,pRaw,pMaster);
if( pNew == 0 ){
return UNQLITE_NOMEM;
}
/* Mark as an empty page */
rc = lhSetEmptyPage(pNew);
if( rc != UNQLITE_OK ){
goto fail;
}
if( pOfft ){
/* Look for a free block */
if( UNQLITE_OK != lhAllocateSpace(pNew,L_HASH_CELL_SZ+nAmount,&iOfft) ){
/* Cell header only */
lhAllocateSpace(pNew,L_HASH_CELL_SZ,&iOfft); /* Never fail */
}
*pOfft = iOfft;
}
/* Link this page to the previous slave page */
rc = pEngine->pIo->xWrite(pSlave->pRaw);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Reflect in the page header */
SyBigEndianPack64(&pSlave->pRaw->zData[2/*Cell offset*/+2/*Free block offset*/],pRaw->pgno);
pSlave->sHdr.iSlave = pRaw->pgno;
/* All done */
*ppSlave = pNew;
return UNQLITE_OK;
fail:
pEngine->pIo->xPageUnref(pNew->pRaw); /* pNew will be released in this call */
return rc;
}
/*
* Perform a store operation in a slave page.
*/
static int lhSlaveStore(
lhpage *pPage, /* Master page */
const void *pKey,sxu32 nKeyLen, /* Payload: key */
const void *pData,unqlite_int64 nDataLen, /* Payload: data */
sxu32 nHash /* Hash of the key */
)
{
lhpage *pSlave;
int rc;
/* Find a slave page */
rc = lhFindSlavePage(pPage,nKeyLen + nDataLen,0,&pSlave);
if( rc != UNQLITE_OK ){
return rc;
}
/* Perform the insertion in the slave page */
rc = lhStoreCell(pSlave,pKey,nKeyLen,pData,nDataLen,nHash,1);
return rc;
}
/*
* Transfer a cell to a new page (either a master or slave).
*/
static int lhTransferCell(lhcell *pTarget,lhpage *pPage)
{
lhcell *pCell;
sxu16 nOfft;
int rc;
/* Check for a free block to hold a single cell only */
rc = lhAllocateSpace(pPage,L_HASH_CELL_SZ,&nOfft);
if( rc != UNQLITE_OK ){
/* Store in a slave page */
rc = lhFindSlavePage(pPage,L_HASH_CELL_SZ,&nOfft,&pPage);
if( rc != UNQLITE_OK ){
return rc;
}
}
/* Allocate a new cell instance */
pCell = lhNewCell(pPage->pHash,pPage);
if( pCell == 0 ){
return UNQLITE_NOMEM;
}
/* Fill-in the structure */
pCell->iStart = nOfft;
pCell->nData = pTarget->nData;
pCell->nKey = pTarget->nKey;
pCell->iOvfl = pTarget->iOvfl;
pCell->iDataOfft = pTarget->iDataOfft;
pCell->iDataPage = pTarget->iDataPage;
pCell->nHash = pTarget->nHash;
SyBlobDup(&pTarget->sKey,&pCell->sKey);
/* Link the cell */
rc = lhInstallCell(pCell);
if( rc != UNQLITE_OK ){
return rc;
}
/* Finally, Write the cell header */
lhCellWriteHeader(pCell);
/* All done */
return UNQLITE_OK;
}
/*
* Perform a page split.
*/
static int lhPageSplit(
lhpage *pOld, /* Page to be split */
lhpage *pNew, /* New page */
pgno split_bucket, /* Current split bucket */
pgno high_mask /* High mask (Max split bucket - 1) */
)
{
lhcell *pCell,*pNext;
SyBlob sWorker;
pgno iBucket;
int rc;
SyBlobInit(&sWorker,&pOld->pHash->sAllocator);
/* Perform the split */
pCell = pOld->pList;
for( ;; ){
if( pCell == 0 ){
/* No more cells */
break;
}
/* Obtain the new logical bucket */
iBucket = pCell->nHash & high_mask;
pNext = pCell->pNext;
if( iBucket != split_bucket){
rc = UNQLITE_OK;
if( pCell->iOvfl ){
/* Transfer the cell only */
rc = lhTransferCell(pCell,pNew);
}else{
/* Transfer the cell and its payload */
SyBlobReset(&sWorker);
if( SyBlobLength(&pCell->sKey) < 1 ){
/* Consume the key */
rc = lhConsumeCellkey(pCell,unqliteDataConsumer,&pCell->sKey,0);
if( rc != UNQLITE_OK ){
goto fail;
}
}
/* Consume the data (Very small data < 65k) */
rc = lhConsumeCellData(pCell,unqliteDataConsumer,&sWorker);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Perform the transfer */
rc = lhStoreCell(
pNew,
SyBlobData(&pCell->sKey),(int)SyBlobLength(&pCell->sKey),
SyBlobData(&sWorker),SyBlobLength(&sWorker),
pCell->nHash,
1
);
}
if( rc != UNQLITE_OK ){
goto fail;
}
/* Discard the cell from the old page */
lhUnlinkCell(pCell);
}
/* Point to the next cell */
pCell = pNext;
}
/* All done */
rc = UNQLITE_OK;
fail:
SyBlobRelease(&sWorker);
return rc;
}
/*
* Perform the infamous linear hash split operation.
*/
static int lhSplit(lhpage *pTarget,int *pRetry)
{
lhash_kv_engine *pEngine = pTarget->pHash;
lhash_bmap_rec *pRec;
lhpage *pOld,*pNew;
unqlite_page *pRaw;
int rc;
/* Get the real page number of the bucket to split */
pRec = lhMapFindBucket(pEngine,pEngine->split_bucket);
if( pRec == 0 ){
/* Can't happen */
return UNQLITE_CORRUPT;
}
/* Load the page to be split */
rc = lhLoadPage(pEngine,pRec->iReal,0,&pOld,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Request a new page */
rc = lhAcquirePage(pEngine,&pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Initialize the page */
pNew = lhNewPage(pEngine,pRaw,0);
if( pNew == 0 ){
return UNQLITE_NOMEM;
}
/* Mark as an empty page */
rc = lhSetEmptyPage(pNew);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Install and write the logical map record */
rc = lhMapWriteRecord(pEngine,
pEngine->split_bucket + pEngine->max_split_bucket,
pRaw->pgno
);
if( rc != UNQLITE_OK ){
goto fail;
}
if( pTarget->pRaw->pgno == pOld->pRaw->pgno ){
*pRetry = 1;
}
/* Perform the split */
rc = lhPageSplit(pOld,pNew,pEngine->split_bucket,pEngine->nmax_split_nucket - 1);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Update the database header */
pEngine->split_bucket++;
/* Acquire a writer lock on the first page */
rc = pEngine->pIo->xWrite(pEngine->pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
if( pEngine->split_bucket >= pEngine->max_split_bucket ){
/* Increment the generation number */
pEngine->split_bucket = 0;
pEngine->max_split_bucket = pEngine->nmax_split_nucket;
pEngine->nmax_split_nucket <<= 1;
if( !pEngine->nmax_split_nucket ){
/* If this happen to your installation, please tell us <chm@symisc.net> */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Database page (64-bit integer) limit reached");
return UNQLITE_LIMIT;
}
/* Reflect in the page header */
SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/+8/*Free list*/],pEngine->split_bucket);
SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/+8/*Free list*/+8/*Split bucket*/],pEngine->max_split_bucket);
}else{
/* Modify only the split bucket */
SyBigEndianPack64(&pEngine->pHeader->zData[4/*Magic*/+4/*Hash*/+8/*Free list*/],pEngine->split_bucket);
}
/* All done */
return UNQLITE_OK;
fail:
pEngine->pIo->xPageUnref(pNew->pRaw);
return rc;
}
/*
* Store a record in the target page.
*/
static int lhRecordInstall(
lhpage *pPage, /* Target page */
sxu32 nHash, /* Hash of the key */
const void *pKey,sxu32 nKeyLen, /* Payload: Key */
const void *pData,unqlite_int64 nDataLen /* Payload: Data */
)
{
int rc;
rc = lhStoreCell(pPage,pKey,nKeyLen,pData,nDataLen,nHash,0);
if( rc == UNQLITE_FULL ){
int do_retry = 0;
/* Split */
rc = lhSplit(pPage,&do_retry);
if( rc == UNQLITE_OK ){
if( do_retry ){
/* Re-calculate logical bucket number */
return SXERR_RETRY;
}
/* Perform the store */
rc = lhStoreCell(pPage,pKey,nKeyLen,pData,nDataLen,nHash,1);
}
}
return rc;
}
/*
* Insert a record (Either overwrite or append operation) in our database.
*/
static int lh_record_insert(
unqlite_kv_engine *pKv, /* KV store */
const void *pKey,sxu32 nKeyLen, /* Payload: Key */
const void *pData,unqlite_int64 nDataLen, /* Payload: data */
int is_append /* True for an append operation */
)
{
lhash_kv_engine *pEngine = (lhash_kv_engine *)pKv;
lhash_bmap_rec *pRec;
unqlite_page *pRaw;
lhpage *pPage;
lhcell *pCell;
pgno iBucket;
sxu32 nHash;
int iCnt;
int rc;
/* Acquire the first page (DB hash Header) so that everything gets loaded autmatically */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
if( rc != UNQLITE_OK ){
return rc;
}
iCnt = 0;
/* Compute the hash of the key first */
nHash = pEngine->xHash(pKey,(sxu32)nKeyLen);
retry:
/* Extract the logical bucket number */
iBucket = nHash & (pEngine->nmax_split_nucket - 1);
if( iBucket >= pEngine->split_bucket + pEngine->max_split_bucket ){
/* Low mask */
iBucket = nHash & (pEngine->max_split_bucket - 1);
}
/* Map the logical bucket number to real page number */
pRec = lhMapFindBucket(pEngine,iBucket);
if( pRec == 0 ){
/* Request a new page */
rc = lhAcquirePage(pEngine,&pRaw);
if( rc != UNQLITE_OK ){
return rc;
}
/* Initialize the page */
pPage = lhNewPage(pEngine,pRaw,0);
if( pPage == 0 ){
return UNQLITE_NOMEM;
}
/* Mark as an empty page */
rc = lhSetEmptyPage(pPage);
if( rc != UNQLITE_OK ){
pEngine->pIo->xPageUnref(pRaw); /* pPage will be released during this call */
return rc;
}
/* Store the cell */
rc = lhStoreCell(pPage,pKey,nKeyLen,pData,nDataLen,nHash,1);
if( rc == UNQLITE_OK ){
/* Install and write the logical map record */
rc = lhMapWriteRecord(pEngine,iBucket,pRaw->pgno);
}
pEngine->pIo->xPageUnref(pRaw);
return rc;
}else{
/* Load the page */
rc = lhLoadPage(pEngine,pRec->iReal,0,&pPage,0);
if( rc != UNQLITE_OK ){
/* IO error, unlikely scenario */
return rc;
}
/* Do not add this page to the hot dirty list */
pEngine->pIo->xDontMkHot(pPage->pRaw);
/* Lookup for the cell */
pCell = lhFindCell(pPage,pKey,(sxu32)nKeyLen,nHash);
if( pCell == 0 ){
/* Create the record */
rc = lhRecordInstall(pPage,nHash,pKey,nKeyLen,pData,nDataLen);
if( rc == SXERR_RETRY && iCnt++ < 2 ){
rc = UNQLITE_OK;
goto retry;
}
}else{
if( is_append ){
/* Append operation */
rc = lhRecordAppend(pCell,pData,nDataLen);
}else{
/* Overwrite old value */
rc = lhRecordOverwrite(pCell,pData,nDataLen);
}
}
pEngine->pIo->xPageUnref(pPage->pRaw);
}
return rc;
}
/*
* Replace method.
*/
static int lhash_kv_replace(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
int rc;
rc = lh_record_insert(pKv,pKey,(sxu32)nKeyLen,pData,nDataLen,0);
return rc;
}
/*
* Append method.
*/
static int lhash_kv_append(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
int rc;
rc = lh_record_insert(pKv,pKey,(sxu32)nKeyLen,pData,nDataLen,1);
return rc;
}
/*
* Write the hash header (Page one).
*/
static int lhash_write_header(lhash_kv_engine *pEngine,unqlite_page *pHeader)
{
unsigned char *zRaw = pHeader->zData;
lhash_bmap_page *pMap;
pEngine->pHeader = pHeader;
/* 4 byte magic number */
SyBigEndianPack32(zRaw,pEngine->nMagic);
zRaw += 4;
/* 4 byte hash value to identify a valid hash function */
SyBigEndianPack32(zRaw,pEngine->xHash(L_HASH_WORD,sizeof(L_HASH_WORD)-1));
zRaw += 4;
/* List of free pages: Empty */
SyBigEndianPack64(zRaw,0);
zRaw += 8;
/* Current split bucket */
SyBigEndianPack64(zRaw,pEngine->split_bucket);
zRaw += 8;
/* Maximum split bucket */
SyBigEndianPack64(zRaw,pEngine->max_split_bucket);
zRaw += 8;
/* Initialiaze the bucket map */
pMap = &pEngine->sPageMap;
/* Fill in the structure */
pMap->iNum = pHeader->pgno;
/* Next page in the bucket map */
SyBigEndianPack64(zRaw,0);
zRaw += 8;
/* Total number of records in the bucket map */
SyBigEndianPack32(zRaw,0);
zRaw += 4;
pMap->iPtr = (sxu16)(zRaw - pHeader->zData);
/* All done */
return UNQLITE_OK;
}
/*
* Exported: xOpen() method.
*/
static int lhash_kv_open(unqlite_kv_engine *pEngine,pgno dbSize)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
unqlite_page *pHeader;
int rc;
if( dbSize < 1 ){
/* A new database, create the header */
rc = pEngine->pIo->xNew(pEngine->pIo->pHandle,&pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
/* Acquire a writer lock */
rc = pEngine->pIo->xWrite(pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
/* Write the hash header */
rc = lhash_write_header(pHash,pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
}else{
/* Acquire the page one of the database */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,&pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
/* Read the database header */
rc = lhash_read_header(pHash,pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
}
return UNQLITE_OK;
}
/*
* Release a master or slave page. (xUnpin callback).
*/
static void lhash_page_release(void *pUserData)
{
lhpage *pPage = (lhpage *)pUserData;
lhash_kv_engine *pEngine = pPage->pHash;
lhcell *pNext,*pCell = pPage->pList;
unqlite_page *pRaw = pPage->pRaw;
sxu32 n;
/* Drop in-memory cells */
for( n = 0 ; n < pPage->nCell ; ++n ){
pNext = pCell->pNext;
SyBlobRelease(&pCell->sKey);
/* Release the cell instance */
SyMemBackendPoolFree(&pEngine->sAllocator,(void *)pCell);
/* Point to the next entry */
pCell = pNext;
}
if( pPage->apCell ){
/* Release the cell table */
SyMemBackendFree(&pEngine->sAllocator,(void *)pPage->apCell);
}
/* Finally, release the whole page */
SyMemBackendPoolFree(&pEngine->sAllocator,pPage);
pRaw->pUserData = 0;
}
/*
* Default hash function (DJB).
*/
static sxu32 lhash_bin_hash(const void *pSrc,sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
sxu32 nH = 5381;
if( nLen > 2048 /* 2K */ ){
nLen = 2048;
}
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
}
return nH;
}
/*
* Exported: xInit() method.
* Initialize the Key value storage engine.
*/
static int lhash_kv_init(unqlite_kv_engine *pEngine,int iPageSize)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
int rc;
/* This structure is always zeroed, go to the initialization directly */
SyMemBackendInitFromParent(&pHash->sAllocator,unqliteExportMemBackend());
//#if defined(UNQLITE_ENABLE_THREADS)
// /* Already protected by the upper layers */
// SyMemBackendDisbaleMutexing(&pHash->sAllocator);
//#endif
pHash->iPageSize = iPageSize;
/* Default hash function */
pHash->xHash = lhash_bin_hash;
/* Default comparison function */
pHash->xCmp = SyMemcmp;
/* Allocate a new record map */
pHash->nBuckSize = 32;
pHash->apMap = (lhash_bmap_rec **)SyMemBackendAlloc(&pHash->sAllocator,pHash->nBuckSize *sizeof(lhash_bmap_rec *));
if( pHash->apMap == 0 ){
rc = UNQLITE_NOMEM;
goto err;
}
/* Zero the table */
SyZero(pHash->apMap,pHash->nBuckSize * sizeof(lhash_bmap_rec *));
/* Linear hashing components */
pHash->split_bucket = 0; /* Logical not real bucket number */
pHash->max_split_bucket = 1;
pHash->nmax_split_nucket = 2;
pHash->nMagic = L_HASH_MAGIC;
/* Install the cache unpin and reload callbacks */
pHash->pIo->xSetUnpin(pHash->pIo->pHandle,lhash_page_release);
pHash->pIo->xSetReload(pHash->pIo->pHandle,lhash_page_release);
return UNQLITE_OK;
err:
SyMemBackendRelease(&pHash->sAllocator);
return rc;
}
/*
* Exported: xRelease() method.
* Release the Key value storage engine.
*/
static void lhash_kv_release(unqlite_kv_engine *pEngine)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
/* Release the private memory backend */
SyMemBackendRelease(&pHash->sAllocator);
}
/*
* Exported: xConfig() method.
* Configure the linear hash KV store.
*/
static int lhash_kv_config(unqlite_kv_engine *pEngine,int op,va_list ap)
{
lhash_kv_engine *pHash = (lhash_kv_engine *)pEngine;
int rc = UNQLITE_OK;
switch(op){
case UNQLITE_KV_CONFIG_HASH_FUNC: {
/* Default hash function */
if( pHash->nBuckRec > 0 ){
/* Locked operation */
rc = UNQLITE_LOCKED;
}else{
ProcHash xHash = va_arg(ap,ProcHash);
if( xHash ){
pHash->xHash = xHash;
}
}
break;
}
case UNQLITE_KV_CONFIG_CMP_FUNC: {
/* Default comparison function */
ProcCmp xCmp = va_arg(ap,ProcCmp);
if( xCmp ){
pHash->xCmp = xCmp;
}
break;
}
default:
/* Unknown OP */
rc = UNQLITE_UNKNOWN;
break;
}
return rc;
}
/*
* Each public cursor is identified by an instance of this structure.
*/
typedef struct lhash_kv_cursor lhash_kv_cursor;
struct lhash_kv_cursor
{
unqlite_kv_engine *pStore; /* Must be first */
/* Private fields */
int iState; /* Current state of the cursor */
int is_first; /* True to read the database header */
lhcell *pCell; /* Current cell we are processing */
unqlite_page *pRaw; /* Raw disk page */
lhash_bmap_rec *pRec; /* Logical to real bucket map */
};
/*
* Possible state of the cursor
*/
#define L_HASH_CURSOR_STATE_NEXT_PAGE 1 /* Next page in the list */
#define L_HASH_CURSOR_STATE_CELL 2 /* Processing Cell */
#define L_HASH_CURSOR_STATE_DONE 3 /* Cursor does not point to anything */
/*
* Initialize the cursor.
*/
static void lhInitCursor(unqlite_kv_cursor *pPtr)
{
lhash_kv_engine *pEngine = (lhash_kv_engine *)pPtr->pStore;
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
/* Init */
pCur->iState = L_HASH_CURSOR_STATE_NEXT_PAGE;
pCur->pCell = 0;
pCur->pRec = pEngine->pFirst;
pCur->pRaw = 0;
pCur->is_first = 1;
}
/*
* Point to the next page on the database.
*/
static int lhCursorNextPage(lhash_kv_cursor *pPtr)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
lhash_bmap_rec *pRec;
lhpage *pPage;
int rc;
for(;;){
pRec = pCur->pRec;
if( pRec == 0 ){
pCur->iState = L_HASH_CURSOR_STATE_DONE;
return UNQLITE_DONE;
}
if( pPtr->iState == L_HASH_CURSOR_STATE_CELL && pPtr->pRaw ){
/* Unref this page */
pCur->pStore->pIo->xPageUnref(pPtr->pRaw);
pPtr->pRaw = 0;
}
/* Advance the map cursor */
pCur->pRec = pRec->pPrev; /* Not a bug, reverse link */
/* Load the next page on the list */
rc = lhLoadPage((lhash_kv_engine *)pCur->pStore,pRec->iReal,0,&pPage,0);
if( rc != UNQLITE_OK ){
return rc;
}
if( pPage->pList ){
/* Reflect the change */
pCur->pCell = pPage->pList;
pCur->iState = L_HASH_CURSOR_STATE_CELL;
pCur->pRaw = pPage->pRaw;
break;
}
/* Empty page, discard this page and continue */
pPage->pHash->pIo->xPageUnref(pPage->pRaw);
}
return UNQLITE_OK;
}
/*
* Point to the previous page on the database.
*/
static int lhCursorPrevPage(lhash_kv_cursor *pPtr)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
lhash_bmap_rec *pRec;
lhpage *pPage;
int rc;
for(;;){
pRec = pCur->pRec;
if( pRec == 0 ){
pCur->iState = L_HASH_CURSOR_STATE_DONE;
return UNQLITE_DONE;
}
if( pPtr->iState == L_HASH_CURSOR_STATE_CELL && pPtr->pRaw ){
/* Unref this page */
pCur->pStore->pIo->xPageUnref(pPtr->pRaw);
pPtr->pRaw = 0;
}
/* Advance the map cursor */
pCur->pRec = pRec->pNext; /* Not a bug, reverse link */
/* Load the previous page on the list */
rc = lhLoadPage((lhash_kv_engine *)pCur->pStore,pRec->iReal,0,&pPage,0);
if( rc != UNQLITE_OK ){
return rc;
}
if( pPage->pFirst ){
/* Reflect the change */
pCur->pCell = pPage->pFirst;
pCur->iState = L_HASH_CURSOR_STATE_CELL;
pCur->pRaw = pPage->pRaw;
break;
}
/* Discard this page and continue */
pPage->pHash->pIo->xPageUnref(pPage->pRaw);
}
return UNQLITE_OK;
}
/*
* Is a valid cursor.
*/
static int lhCursorValid(unqlite_kv_cursor *pPtr)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pPtr;
return (pCur->iState == L_HASH_CURSOR_STATE_CELL) && pCur->pCell;
}
/*
* Point to the first record.
*/
static int lhCursorFirst(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
int rc;
if( pCur->is_first ){
/* Read the database header first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
if( rc != UNQLITE_OK ){
return rc;
}
pCur->is_first = 0;
}
/* Point to the first map record */
pCur->pRec = pEngine->pFirst;
/* Load the cells */
rc = lhCursorNextPage(pCur);
return rc;
}
/*
* Point to the last record.
*/
static int lhCursorLast(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhash_kv_engine *pEngine = (lhash_kv_engine *)pCursor->pStore;
int rc;
if( pCur->is_first ){
/* Read the database header first */
rc = pEngine->pIo->xGet(pEngine->pIo->pHandle,1,0);
if( rc != UNQLITE_OK ){
return rc;
}
pCur->is_first = 0;
}
/* Point to the last map record */
pCur->pRec = pEngine->pList;
/* Load the cells */
rc = lhCursorPrevPage(pCur);
return rc;
}
/*
* Reset the cursor.
*/
static void lhCursorReset(unqlite_kv_cursor *pCursor)
{
lhCursorFirst(pCursor);
}
/*
* Point to the next record.
*/
static int lhCursorNext(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Load the cells of the next page */
rc = lhCursorNextPage(pCur);
return rc;
}
pCell = pCur->pCell;
pCur->pCell = pCell->pNext;
if( pCur->pCell == 0 ){
/* Load the cells of the next page */
rc = lhCursorNextPage(pCur);
return rc;
}
return UNQLITE_OK;
}
/*
* Point to the previous record.
*/
static int lhCursorPrev(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Load the cells of the previous page */
rc = lhCursorPrevPage(pCur);
return rc;
}
pCell = pCur->pCell;
pCur->pCell = pCell->pPrev;
if( pCur->pCell == 0 ){
/* Load the cells of the previous page */
rc = lhCursorPrevPage(pCur);
return rc;
}
return UNQLITE_OK;
}
/*
* Return key length.
*/
static int lhCursorKeyLength(unqlite_kv_cursor *pCursor,int *pLen)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
/* Return key length */
*pLen = (int)pCell->nKey;
return UNQLITE_OK;
}
/*
* Return data length.
*/
static int lhCursorDataLength(unqlite_kv_cursor *pCursor,unqlite_int64 *pLen)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
/* Return data length */
*pLen = (unqlite_int64)pCell->nData;
return UNQLITE_OK;
}
/*
* Consume the key.
*/
static int lhCursorKey(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
if( SyBlobLength(&pCell->sKey) > 0 ){
/* Consume the key directly */
rc = xConsumer(SyBlobData(&pCell->sKey),SyBlobLength(&pCell->sKey),pUserData);
}else{
/* Very large key */
rc = lhConsumeCellkey(pCell,xConsumer,pUserData,0);
}
return rc;
}
/*
* Consume the data.
*/
static int lhCursorData(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
/* Consume the data */
rc = lhConsumeCellData(pCell,xConsumer,pUserData);
return rc;
}
/*
* Find a partiuclar record.
*/
static int lhCursorSeek(unqlite_kv_cursor *pCursor,const void *pKey,int nByte,int iPos)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
int rc;
/* Perform a lookup */
rc = lhRecordLookup((lhash_kv_engine *)pCur->pStore,pKey,nByte,&pCur->pCell);
if( rc != UNQLITE_OK ){
SXUNUSED(iPos);
pCur->pCell = 0;
pCur->iState = L_HASH_CURSOR_STATE_DONE;
return rc;
}
pCur->iState = L_HASH_CURSOR_STATE_CELL;
return UNQLITE_OK;
}
/*
* Remove a particular record.
*/
static int lhCursorDelete(unqlite_kv_cursor *pCursor)
{
lhash_kv_cursor *pCur = (lhash_kv_cursor *)pCursor;
lhcell *pCell;
int rc;
if( pCur->iState != L_HASH_CURSOR_STATE_CELL || pCur->pCell == 0 ){
/* Invalid state */
return UNQLITE_INVALID;
}
/* Point to the target cell */
pCell = pCur->pCell;
/* Point to the next entry */
pCur->pCell = pCell->pNext;
/* Perform the deletion */
rc = lhRecordRemove(pCell);
return rc;
}
/*
* Export the linear-hash storage engine.
*/
UNQLITE_PRIVATE const unqlite_kv_methods * unqliteExportDiskKvStorage(void)
{
static const unqlite_kv_methods sDiskStore = {
"hash", /* zName */
sizeof(lhash_kv_engine), /* szKv */
sizeof(lhash_kv_cursor), /* szCursor */
1, /* iVersion */
lhash_kv_init, /* xInit */
lhash_kv_release, /* xRelease */
lhash_kv_config, /* xConfig */
lhash_kv_open, /* xOpen */
lhash_kv_replace, /* xReplace */
lhash_kv_append, /* xAppend */
lhInitCursor, /* xCursorInit */
lhCursorSeek, /* xSeek */
lhCursorFirst, /* xFirst */
lhCursorLast, /* xLast */
lhCursorValid, /* xValid */
lhCursorNext, /* xNext */
lhCursorPrev, /* xPrev */
lhCursorDelete, /* xDelete */
lhCursorKeyLength, /* xKeyLength */
lhCursorKey, /* xKey */
lhCursorDataLength, /* xDataLength */
lhCursorData, /* xData */
lhCursorReset, /* xReset */
0 /* xRelease */
};
return &sDiskStore;
}
/*
* ----------------------------------------------------------
* File: mem_kv.c
* MD5: 32e2610c95f53038114d9566f0d0489e
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: mem_kv.c v1.7 Win7 2012-11-28 01:41 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/*
* This file implements an in-memory key value storage engine for unQLite.
* Note that this storage engine does not support transactions.
*
* Normaly, I (chm@symisc.net) planned to implement a red-black tree
* which is suitable for this kind of operation, but due to the lack
* of time, I decided to implement a tunned hashtable which everybody
* know works very well for this kind of operation.
* Again, I insist on a red-black tree implementation for future version
* of Unqlite.
*/
/* Forward declaration */
typedef struct mem_hash_kv_engine mem_hash_kv_engine;
/*
* Each record is storead in an instance of the following structure.
*/
typedef struct mem_hash_record mem_hash_record;
struct mem_hash_record
{
mem_hash_kv_engine *pEngine; /* Storage engine */
sxu32 nHash; /* Hash of the key */
const void *pKey; /* Key */
sxu32 nKeyLen; /* Key size (Max 1GB) */
const void *pData; /* Data */
sxu32 nDataLen; /* Data length (Max 4GB) */
mem_hash_record *pNext,*pPrev; /* Link to other records */
mem_hash_record *pNextHash,*pPrevHash; /* Collision link */
};
/*
* Each in-memory KV engine is represented by an instance
* of the following structure.
*/
struct mem_hash_kv_engine
{
const unqlite_kv_io *pIo; /* IO methods: MUST be first */
/* Private data */
SyMemBackend sAlloc; /* Private memory allocator */
ProcHash xHash; /* Default hash function */
ProcCmp xCmp; /* Default comparison function */
sxu32 nRecord; /* Total number of records */
sxu32 nBucket; /* Bucket size: Must be a power of two */
mem_hash_record **apBucket; /* Hash bucket */
mem_hash_record *pFirst; /* First inserted entry */
mem_hash_record *pLast; /* Last inserted entry */
};
/*
* Allocate a new hash record.
*/
static mem_hash_record * MemHashNewRecord(
mem_hash_kv_engine *pEngine,
const void *pKey,int nKey,
const void *pData,unqlite_int64 nData,
sxu32 nHash
)
{
SyMemBackend *pAlloc = &pEngine->sAlloc;
mem_hash_record *pRecord;
void *pDupData;
sxu32 nByte;
char *zPtr;
/* Total number of bytes to alloc */
nByte = sizeof(mem_hash_record) + nKey;
/* Allocate a new instance */
pRecord = (mem_hash_record *)SyMemBackendAlloc(pAlloc,nByte);
if( pRecord == 0 ){
return 0;
}
pDupData = (void *)SyMemBackendAlloc(pAlloc,(sxu32)nData);
if( pDupData == 0 ){
SyMemBackendFree(pAlloc,pRecord);
return 0;
}
zPtr = (char *)pRecord;
zPtr += sizeof(mem_hash_record);
/* Zero the structure */
SyZero(pRecord,sizeof(mem_hash_record));
/* Fill in the structure */
pRecord->pEngine = pEngine;
pRecord->nDataLen = (sxu32)nData;
pRecord->nKeyLen = (sxu32)nKey;
pRecord->nHash = nHash;
SyMemcpy(pKey,zPtr,pRecord->nKeyLen);
pRecord->pKey = (const void *)zPtr;
SyMemcpy(pData,pDupData,pRecord->nDataLen);
pRecord->pData = pDupData;
/* All done */
return pRecord;
}
/*
* Install a given record in the hashtable.
*/
static void MemHashLinkRecord(mem_hash_kv_engine *pEngine,mem_hash_record *pRecord)
{
sxu32 nBucket = pRecord->nHash & (pEngine->nBucket - 1);
pRecord->pNextHash = pEngine->apBucket[nBucket];
if( pEngine->apBucket[nBucket] ){
pEngine->apBucket[nBucket]->pPrevHash = pRecord;
}
pEngine->apBucket[nBucket] = pRecord;
if( pEngine->pFirst == 0 ){
pEngine->pFirst = pEngine->pLast = pRecord;
}else{
MACRO_LD_PUSH(pEngine->pLast,pRecord);
}
pEngine->nRecord++;
}
/*
* Unlink a given record from the hashtable.
*/
static void MemHashUnlinkRecord(mem_hash_kv_engine *pEngine,mem_hash_record *pEntry)
{
sxu32 nBucket = pEntry->nHash & (pEngine->nBucket - 1);
SyMemBackend *pAlloc = &pEngine->sAlloc;
if( pEntry->pPrevHash == 0 ){
pEngine->apBucket[nBucket] = pEntry->pNextHash;
}else{
pEntry->pPrevHash->pNextHash = pEntry->pNextHash;
}
if( pEntry->pNextHash ){
pEntry->pNextHash->pPrevHash = pEntry->pPrevHash;
}
MACRO_LD_REMOVE(pEngine->pLast,pEntry);
if( pEntry == pEngine->pFirst ){
pEngine->pFirst = pEntry->pPrev;
}
pEngine->nRecord--;
/* Release the entry */
SyMemBackendFree(pAlloc,(void *)pEntry->pData);
SyMemBackendFree(pAlloc,pEntry); /* Key is also stored here */
}
/*
* Perform a lookup for a given entry.
*/
static mem_hash_record * MemHashGetEntry(
mem_hash_kv_engine *pEngine,
const void *pKey,int nKeyLen
)
{
mem_hash_record *pEntry;
sxu32 nHash,nBucket;
/* Hash the entry */
nHash = pEngine->xHash(pKey,(sxu32)nKeyLen);
nBucket = nHash & (pEngine->nBucket - 1);
pEntry = pEngine->apBucket[nBucket];
for(;;){
if( pEntry == 0 ){
break;
}
if( pEntry->nHash == nHash && pEntry->nKeyLen == (sxu32)nKeyLen &&
pEngine->xCmp(pEntry->pKey,pKey,pEntry->nKeyLen) == 0 ){
return pEntry;
}
pEntry = pEntry->pNextHash;
}
/* No such entry */
return 0;
}
/*
* Rehash all the entries in the given table.
*/
static int MemHashGrowTable(mem_hash_kv_engine *pEngine)
{
sxu32 nNewSize = pEngine->nBucket << 1;
mem_hash_record *pEntry;
mem_hash_record **apNew;
sxu32 n,iBucket;
/* Allocate a new larger table */
apNew = (mem_hash_record **)SyMemBackendAlloc(&pEngine->sAlloc, nNewSize * sizeof(mem_hash_record *));
if( apNew == 0 ){
/* Not so fatal, simply a performance hit */
return UNQLITE_OK;
}
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(mem_hash_record *));
/* Rehash all entries */
n = 0;
pEntry = pEngine->pLast;
for(;;){
/* Loop one */
if( n >= pEngine->nRecord ){
break;
}
pEntry->pNextHash = pEntry->pPrevHash = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextHash = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevHash = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
/* Loop two */
if( n >= pEngine->nRecord ){
break;
}
pEntry->pNextHash = pEntry->pPrevHash = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextHash = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevHash = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
/* Loop three */
if( n >= pEngine->nRecord ){
break;
}
pEntry->pNextHash = pEntry->pPrevHash = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextHash = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevHash = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
/* Loop four */
if( n >= pEngine->nRecord ){
break;
}
pEntry->pNextHash = pEntry->pPrevHash = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextHash = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevHash = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(&pEngine->sAlloc,(void *)pEngine->apBucket);
pEngine->apBucket = apNew;
pEngine->nBucket = nNewSize;
return UNQLITE_OK;
}
/*
* Exported Interfaces.
*/
/*
* Each public cursor is identified by an instance of this structure.
*/
typedef struct mem_hash_cursor mem_hash_cursor;
struct mem_hash_cursor
{
unqlite_kv_engine *pStore; /* Must be first */
/* Private fields */
mem_hash_record *pCur; /* Current hash record */
};
/*
* Initialize the cursor.
*/
static void MemHashInitCursor(unqlite_kv_cursor *pCursor)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pCursor->pStore;
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
/* Point to the first inserted entry */
pMem->pCur = pEngine->pFirst;
}
/*
* Point to the first entry.
*/
static int MemHashCursorFirst(unqlite_kv_cursor *pCursor)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pCursor->pStore;
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
pMem->pCur = pEngine->pFirst;
return UNQLITE_OK;
}
/*
* Point to the last entry.
*/
static int MemHashCursorLast(unqlite_kv_cursor *pCursor)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pCursor->pStore;
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
pMem->pCur = pEngine->pLast;
return UNQLITE_OK;
}
/*
* is a Valid Cursor.
*/
static int MemHashCursorValid(unqlite_kv_cursor *pCursor)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
return pMem->pCur != 0 ? 1 : 0;
}
/*
* Point to the next entry.
*/
static int MemHashCursorNext(unqlite_kv_cursor *pCursor)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
pMem->pCur = pMem->pCur->pPrev; /* Reverse link: Not a Bug */
return UNQLITE_OK;
}
/*
* Point to the previous entry.
*/
static int MemHashCursorPrev(unqlite_kv_cursor *pCursor)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
pMem->pCur = pMem->pCur->pNext; /* Reverse link: Not a Bug */
return UNQLITE_OK;
}
/*
* Return key length.
*/
static int MemHashCursorKeyLength(unqlite_kv_cursor *pCursor,int *pLen)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
*pLen = (int)pMem->pCur->nKeyLen;
return UNQLITE_OK;
}
/*
* Return data length.
*/
static int MemHashCursorDataLength(unqlite_kv_cursor *pCursor,unqlite_int64 *pLen)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
if( pMem->pCur == 0 ){
return UNQLITE_EOF;
}
*pLen = pMem->pCur->nDataLen;
return UNQLITE_OK;
}
/*
* Consume the key.
*/
static int MemHashCursorKey(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
int rc;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
/* Invoke the callback */
rc = xConsumer(pMem->pCur->pKey,pMem->pCur->nKeyLen,pUserData);
/* Callback result */
return rc;
}
/*
* Consume the data.
*/
static int MemHashCursorData(unqlite_kv_cursor *pCursor,int (*xConsumer)(const void *,unsigned int,void *),void *pUserData)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
int rc;
if( pMem->pCur == 0){
return UNQLITE_EOF;
}
/* Invoke the callback */
rc = xConsumer(pMem->pCur->pData,pMem->pCur->nDataLen,pUserData);
/* Callback result */
return rc;
}
/*
* Reset the cursor.
*/
static void MemHashCursorReset(unqlite_kv_cursor *pCursor)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
pMem->pCur = ((mem_hash_kv_engine *)pCursor->pStore)->pFirst;
}
/*
* Remove a particular record.
*/
static int MemHashCursorDelete(unqlite_kv_cursor *pCursor)
{
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
mem_hash_record *pNext;
if( pMem->pCur == 0 ){
/* Cursor does not point to anything */
return UNQLITE_NOTFOUND;
}
pNext = pMem->pCur->pPrev;
/* Perform the deletion */
MemHashUnlinkRecord(pMem->pCur->pEngine,pMem->pCur);
/* Point to the next entry */
pMem->pCur = pNext;
return UNQLITE_OK;
}
/*
* Find a particular record.
*/
static int MemHashCursorSeek(unqlite_kv_cursor *pCursor,const void *pKey,int nByte,int iPos)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pCursor->pStore;
mem_hash_cursor *pMem = (mem_hash_cursor *)pCursor;
/* Perform the lookup */
pMem->pCur = MemHashGetEntry(pEngine,pKey,nByte);
if( pMem->pCur == 0 ){
if( iPos != UNQLITE_CURSOR_MATCH_EXACT ){
/* noop; */
}
/* No such record */
return UNQLITE_NOTFOUND;
}
return UNQLITE_OK;
}
/*
* Builtin hash function.
*/
static sxu32 MemHashFunc(const void *pSrc,sxu32 nLen)
{
register unsigned char *zIn = (unsigned char *)pSrc;
unsigned char *zEnd;
sxu32 nH = 5381;
zEnd = &zIn[nLen];
for(;;){
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
if( zIn >= zEnd ){ break; } nH = nH * 33 + zIn[0] ; zIn++;
}
return nH;
}
/* Default bucket size */
#define MEM_HASH_BUCKET_SIZE 64
/* Default fill factor */
#define MEM_HASH_FILL_FACTOR 4 /* or 3 */
/*
* Initialize the in-memory storage engine.
*/
static int MemHashInit(unqlite_kv_engine *pKvEngine,int iPageSize)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
/* Note that this instance is already zeroed */
/* Memory backend */
SyMemBackendInitFromParent(&pEngine->sAlloc,unqliteExportMemBackend());
//#if defined(UNQLITE_ENABLE_THREADS)
// /* Already protected by the upper layers */
// SyMemBackendDisbaleMutexing(&pEngine->sAlloc);
//#endif
/* Default hash & comparison function */
pEngine->xHash = MemHashFunc;
pEngine->xCmp = SyMemcmp;
/* Allocate a new bucket */
pEngine->apBucket = (mem_hash_record **)SyMemBackendAlloc(&pEngine->sAlloc,MEM_HASH_BUCKET_SIZE * sizeof(mem_hash_record *));
if( pEngine->apBucket == 0 ){
SXUNUSED(iPageSize); /* cc warning */
return UNQLITE_NOMEM;
}
/* Zero the bucket */
SyZero(pEngine->apBucket,MEM_HASH_BUCKET_SIZE * sizeof(mem_hash_record *));
pEngine->nRecord = 0;
pEngine->nBucket = MEM_HASH_BUCKET_SIZE;
return UNQLITE_OK;
}
/*
* Release the in-memory storage engine.
*/
static void MemHashRelease(unqlite_kv_engine *pKvEngine)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
/* Release the private memory backend */
SyMemBackendRelease(&pEngine->sAlloc);
}
/*
* Configure the in-memory storage engine.
*/
static int MemHashConfigure(unqlite_kv_engine *pKvEngine,int iOp,va_list ap)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKvEngine;
int rc = UNQLITE_OK;
switch(iOp){
case UNQLITE_KV_CONFIG_HASH_FUNC:{
/* Use a default hash function */
if( pEngine->nRecord > 0 ){
rc = UNQLITE_LOCKED;
}else{
ProcHash xHash = va_arg(ap,ProcHash);
if( xHash ){
pEngine->xHash = xHash;
}
}
break;
}
case UNQLITE_KV_CONFIG_CMP_FUNC: {
/* Default comparison function */
ProcCmp xCmp = va_arg(ap,ProcCmp);
if( xCmp ){
pEngine->xCmp = xCmp;
}
break;
}
default:
/* Unknown configuration option */
rc = UNQLITE_UNKNOWN;
}
return rc;
}
/*
* Replace method.
*/
static int MemHashReplace(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKv;
mem_hash_record *pRecord;
if( nDataLen > SXU32_HIGH ){
/* Database limit */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Record size limit reached");
return UNQLITE_LIMIT;
}
/* Fetch the record first */
pRecord = MemHashGetEntry(pEngine,pKey,nKeyLen);
if( pRecord == 0 ){
/* Allocate a new record */
pRecord = MemHashNewRecord(pEngine,
pKey,nKeyLen,
pData,nDataLen,
pEngine->xHash(pKey,nKeyLen)
);
if( pRecord == 0 ){
return UNQLITE_NOMEM;
}
/* Link the entry */
MemHashLinkRecord(pEngine,pRecord);
if( (pEngine->nRecord >= pEngine->nBucket * MEM_HASH_FILL_FACTOR) && pEngine->nRecord < 100000 ){
/* Rehash the table */
MemHashGrowTable(pEngine);
}
}else{
sxu32 nData = (sxu32)nDataLen;
void *pNew;
/* Replace an existing record */
if( nData == pRecord->nDataLen ){
/* No need to free the old chunk */
pNew = (void *)pRecord->pData;
}else{
pNew = SyMemBackendAlloc(&pEngine->sAlloc,nData);
if( pNew == 0 ){
return UNQLITE_NOMEM;
}
/* Release the old data */
SyMemBackendFree(&pEngine->sAlloc,(void *)pRecord->pData);
}
/* Reflect the change */
pRecord->nDataLen = nData;
SyMemcpy(pData,pNew,nData);
pRecord->pData = pNew;
}
return UNQLITE_OK;
}
/*
* Append method.
*/
static int MemHashAppend(
unqlite_kv_engine *pKv,
const void *pKey,int nKeyLen,
const void *pData,unqlite_int64 nDataLen
)
{
mem_hash_kv_engine *pEngine = (mem_hash_kv_engine *)pKv;
mem_hash_record *pRecord;
if( nDataLen > SXU32_HIGH ){
/* Database limit */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Record size limit reached");
return UNQLITE_LIMIT;
}
/* Fetch the record first */
pRecord = MemHashGetEntry(pEngine,pKey,nKeyLen);
if( pRecord == 0 ){
/* Allocate a new record */
pRecord = MemHashNewRecord(pEngine,
pKey,nKeyLen,
pData,nDataLen,
pEngine->xHash(pKey,nKeyLen)
);
if( pRecord == 0 ){
return UNQLITE_NOMEM;
}
/* Link the entry */
MemHashLinkRecord(pEngine,pRecord);
if( pEngine->nRecord * MEM_HASH_FILL_FACTOR >= pEngine->nBucket && pEngine->nRecord < 100000 ){
/* Rehash the table */
MemHashGrowTable(pEngine);
}
}else{
unqlite_int64 nNew = pRecord->nDataLen + nDataLen;
void *pOld = (void *)pRecord->pData;
sxu32 nData;
char *zNew;
/* Append data to the existing record */
if( nNew > SXU32_HIGH ){
/* Overflow */
pEngine->pIo->xErr(pEngine->pIo->pHandle,"Append operation will cause data overflow");
return UNQLITE_LIMIT;
}
nData = (sxu32)nNew;
/* Allocate bigger chunk */
zNew = (char *)SyMemBackendRealloc(&pEngine->sAlloc,pOld,nData);
if( zNew == 0 ){
return UNQLITE_NOMEM;
}
/* Reflect the change */
SyMemcpy(pData,&zNew[pRecord->nDataLen],(sxu32)nDataLen);
pRecord->pData = (const void *)zNew;
pRecord->nDataLen = nData;
}
return UNQLITE_OK;
}
/*
* Export the in-memory storage engine.
*/
UNQLITE_PRIVATE const unqlite_kv_methods * unqliteExportMemKvStorage(void)
{
static const unqlite_kv_methods sMemStore = {
"mem", /* zName */
sizeof(mem_hash_kv_engine), /* szKv */
sizeof(mem_hash_cursor), /* szCursor */
1, /* iVersion */
MemHashInit, /* xInit */
MemHashRelease, /* xRelease */
MemHashConfigure, /* xConfig */
0, /* xOpen */
MemHashReplace, /* xReplace */
MemHashAppend, /* xAppend */
MemHashInitCursor, /* xCursorInit */
MemHashCursorSeek, /* xSeek */
MemHashCursorFirst, /* xFirst */
MemHashCursorLast, /* xLast */
MemHashCursorValid, /* xValid */
MemHashCursorNext, /* xNext */
MemHashCursorPrev, /* xPrev */
MemHashCursorDelete, /* xDelete */
MemHashCursorKeyLength, /* xKeyLength */
MemHashCursorKey, /* xKey */
MemHashCursorDataLength, /* xDataLength */
MemHashCursorData, /* xData */
MemHashCursorReset, /* xReset */
0 /* xRelease */
};
return &sMemStore;
}
/*
* ----------------------------------------------------------
* File: os.c
* MD5: e7ad243c3cd9e6aac5fba406eedb7766
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: os.c v1.0 FreeBSD 2012-11-12 21:27 devel <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/* OS interfaces abstraction layers: Mostly SQLite3 source tree */
/*
** The following routines are convenience wrappers around methods
** of the unqlite_file object. This is mostly just syntactic sugar. All
** of this would be completely automatic if UnQLite were coded using
** C++ instead of plain old C.
*/
UNQLITE_PRIVATE int unqliteOsRead(unqlite_file *id, void *pBuf, unqlite_int64 amt, unqlite_int64 offset)
{
return id->pMethods->xRead(id, pBuf, amt, offset);
}
UNQLITE_PRIVATE int unqliteOsWrite(unqlite_file *id, const void *pBuf, unqlite_int64 amt, unqlite_int64 offset)
{
return id->pMethods->xWrite(id, pBuf, amt, offset);
}
UNQLITE_PRIVATE int unqliteOsTruncate(unqlite_file *id, unqlite_int64 size)
{
return id->pMethods->xTruncate(id, size);
}
UNQLITE_PRIVATE int unqliteOsSync(unqlite_file *id, int flags)
{
return id->pMethods->xSync(id, flags);
}
UNQLITE_PRIVATE int unqliteOsFileSize(unqlite_file *id, unqlite_int64 *pSize)
{
return id->pMethods->xFileSize(id, pSize);
}
UNQLITE_PRIVATE int unqliteOsLock(unqlite_file *id, int lockType)
{
return id->pMethods->xLock(id, lockType);
}
UNQLITE_PRIVATE int unqliteOsUnlock(unqlite_file *id, int lockType)
{
return id->pMethods->xUnlock(id, lockType);
}
UNQLITE_PRIVATE int unqliteOsCheckReservedLock(unqlite_file *id, int *pResOut)
{
return id->pMethods->xCheckReservedLock(id, pResOut);
}
UNQLITE_PRIVATE int unqliteOsSectorSize(unqlite_file *id)
{
if( id->pMethods->xSectorSize ){
return id->pMethods->xSectorSize(id);
}
return UNQLITE_DEFAULT_SECTOR_SIZE;
}
/*
** The next group of routines are convenience wrappers around the
** VFS methods.
*/
UNQLITE_PRIVATE int unqliteOsOpen(
unqlite_vfs *pVfs,
SyMemBackend *pAlloc,
const char *zPath,
unqlite_file **ppOut,
unsigned int flags
)
{
unqlite_file *pFile;
int rc;
*ppOut = 0;
if( zPath == 0 ){
/* May happen if dealing with an in-memory database */
return SXERR_EMPTY;
}
/* Allocate a new instance */
pFile = (unqlite_file *)SyMemBackendAlloc(pAlloc,sizeof(unqlite_file)+pVfs->szOsFile);
if( pFile == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pFile,sizeof(unqlite_file)+pVfs->szOsFile);
/* Invoke the xOpen method of the underlying VFS */
rc = pVfs->xOpen(pVfs, zPath, pFile, flags);
if( rc != UNQLITE_OK ){
SyMemBackendFree(pAlloc,pFile);
pFile = 0;
}
*ppOut = pFile;
return rc;
}
UNQLITE_PRIVATE int unqliteOsCloseFree(SyMemBackend *pAlloc,unqlite_file *pId)
{
int rc = UNQLITE_OK;
if( pId ){
rc = pId->pMethods->xClose(pId);
SyMemBackendFree(pAlloc,pId);
}
return rc;
}
UNQLITE_PRIVATE int unqliteOsDelete(unqlite_vfs *pVfs, const char *zPath, int dirSync){
return pVfs->xDelete(pVfs, zPath, dirSync);
}
UNQLITE_PRIVATE int unqliteOsAccess(
unqlite_vfs *pVfs,
const char *zPath,
int flags,
int *pResOut
){
return pVfs->xAccess(pVfs, zPath, flags, pResOut);
}
/*
* ----------------------------------------------------------
* File: os_unix.c
* MD5: 5efd57d03f8fb988d081c5bcf5cc2998
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: os_unix.c v1.3 FreeBSD 2013-04-05 01:10 devel <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/*
* Omit the whole layer from the build if compiling for platforms other than Unix (Linux, BSD, Solaris, OS X, etc.).
* Note: Mostly SQLite3 source tree.
*/
#if defined(__UNIXES__)
/** This file contains the VFS implementation for unix-like operating systems
** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
**
** There are actually several different VFS implementations in this file.
** The differences are in the way that file locking is done. The default
** implementation uses Posix Advisory Locks. Alternative implementations
** use flock(), dot-files, various proprietary locking schemas, or simply
** skip locking all together.
**
** This source file is organized into divisions where the logic for various
** subfunctions is contained within the appropriate division. PLEASE
** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
** in the correct division and should be clearly labeled.
**
*/
/*
** standard include files.
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <sys/file.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <errno.h>
#if defined(__APPLE__)
# include <sys/mount.h>
#endif
/*
** Allowed values of unixFile.fsFlags
*/
#define UNQLITE_FSFLAGS_IS_MSDOS 0x1
/*
** Default permissions when creating a new file
*/
#ifndef UNQLITE_DEFAULT_FILE_PERMISSIONS
# define UNQLITE_DEFAULT_FILE_PERMISSIONS 0644
#endif
/*
** Default permissions when creating auto proxy dir
*/
#ifndef UNQLITE_DEFAULT_PROXYDIR_PERMISSIONS
# define UNQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
#endif
/*
** Maximum supported path-length.
*/
#define MAX_PATHNAME 512
/*
** Only set the lastErrno if the error code is a real error and not
** a normal expected return code of UNQLITE_BUSY or UNQLITE_OK
*/
#define IS_LOCK_ERROR(x) ((x != UNQLITE_OK) && (x != UNQLITE_BUSY))
/* Forward references */
typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */
/*
** Sometimes, after a file handle is closed by SQLite, the file descriptor
** cannot be closed immediately. In these cases, instances of the following
** structure are used to store the file descriptor while waiting for an
** opportunity to either close or reuse it.
*/
struct UnixUnusedFd {
int fd; /* File descriptor to close */
int flags; /* Flags this file descriptor was opened with */
UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
};
/*
** The unixFile structure is subclass of unqlite3_file specific to the unix
** VFS implementations.
*/
typedef struct unixFile unixFile;
struct unixFile {
const unqlite_io_methods *pMethod; /* Always the first entry */
unixInodeInfo *pInode; /* Info about locks on this inode */
int h; /* The file descriptor */
int dirfd; /* File descriptor for the directory */
unsigned char eFileLock; /* The type of lock held on this fd */
int lastErrno; /* The unix errno from last I/O error */
void *lockingContext; /* Locking style specific state */
UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */
int fileFlags; /* Miscellanous flags */
const char *zPath; /* Name of the file */
unsigned fsFlags; /* cached details from statfs() */
};
/*
** The following macros define bits in unixFile.fileFlags
*/
#define UNQLITE_WHOLE_FILE_LOCKING 0x0001 /* Use whole-file locking */
/*
** Define various macros that are missing from some systems.
*/
#ifndef O_LARGEFILE
# define O_LARGEFILE 0
#endif
#ifndef O_NOFOLLOW
# define O_NOFOLLOW 0
#endif
#ifndef O_BINARY
# define O_BINARY 0
#endif
/*
** Helper functions to obtain and relinquish the global mutex. The
** global mutex is used to protect the unixInodeInfo and
** vxworksFileId objects used by this file, all of which may be
** shared by multiple threads.
**
** Function unixMutexHeld() is used to assert() that the global mutex
** is held when required. This function is only used as part of assert()
** statements. e.g.
**
** unixEnterMutex()
** assert( unixMutexHeld() );
** unixEnterLeave()
*/
static void unixEnterMutex(void){
#ifdef UNQLITE_ENABLE_THREADS
const SyMutexMethods *pMutexMethods = SyMutexExportMethods();
if( pMutexMethods ){
SyMutex *pMutex = pMutexMethods->xNew(SXMUTEX_TYPE_STATIC_2); /* pre-allocated, never fail */
SyMutexEnter(pMutexMethods,pMutex);
}
#endif /* UNQLITE_ENABLE_THREADS */
}
static void unixLeaveMutex(void){
#ifdef UNQLITE_ENABLE_THREADS
const SyMutexMethods *pMutexMethods = SyMutexExportMethods();
if( pMutexMethods ){
SyMutex *pMutex = pMutexMethods->xNew(SXMUTEX_TYPE_STATIC_2); /* pre-allocated, never fail */
SyMutexLeave(pMutexMethods,pMutex);
}
#endif /* UNQLITE_ENABLE_THREADS */
}
/*
** This routine translates a standard POSIX errno code into something
** useful to the clients of the unqlite3 functions. Specifically, it is
** intended to translate a variety of "try again" errors into UNQLITE_BUSY
** and a variety of "please close the file descriptor NOW" errors into
** UNQLITE_IOERR
**
** Errors during initialization of locks, or file system support for locks,
** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
*/
static int unqliteErrorFromPosixError(int posixError, int unqliteIOErr) {
switch (posixError) {
case 0:
return UNQLITE_OK;
case EAGAIN:
case ETIMEDOUT:
case EBUSY:
case EINTR:
case ENOLCK:
/* random NFS retry error, unless during file system support
* introspection, in which it actually means what it says */
return UNQLITE_BUSY;
case EACCES:
/* EACCES is like EAGAIN during locking operations, but not any other time*/
return UNQLITE_BUSY;
case EPERM:
return UNQLITE_PERM;
case EDEADLK:
return UNQLITE_IOERR;
#if EOPNOTSUPP!=ENOTSUP
case EOPNOTSUPP:
/* something went terribly awry, unless during file system support
* introspection, in which it actually means what it says */
#endif
#ifdef ENOTSUP
case ENOTSUP:
/* invalid fd, unless during file system support introspection, in which
* it actually means what it says */
#endif
case EIO:
case EBADF:
case EINVAL:
case ENOTCONN:
case ENODEV:
case ENXIO:
case ENOENT:
case ESTALE:
case ENOSYS:
/* these should force the client to close the file and reconnect */
default:
return unqliteIOErr;
}
}
/******************************************************************************
*************************** Posix Advisory Locking ****************************
**
** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)
** section 6.5.2.2 lines 483 through 490 specify that when a process
** sets or clears a lock, that operation overrides any prior locks set
** by the same process. It does not explicitly say so, but this implies
** that it overrides locks set by the same process using a different
** file descriptor. Consider this test case:
**
** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
**
** Suppose ./file1 and ./file2 are really the same file (because
** one is a hard or symbolic link to the other) then if you set
** an exclusive lock on fd1, then try to get an exclusive lock
** on fd2, it works. I would have expected the second lock to
** fail since there was already a lock on the file due to fd1.
** But not so. Since both locks came from the same process, the
** second overrides the first, even though they were on different
** file descriptors opened on different file names.
**
** This means that we cannot use POSIX locks to synchronize file access
** among competing threads of the same process. POSIX locks will work fine
** to synchronize access for threads in separate processes, but not
** threads within the same process.
**
** To work around the problem, SQLite has to manage file locks internally
** on its own. Whenever a new database is opened, we have to find the
** specific inode of the database file (the inode is determined by the
** st_dev and st_ino fields of the stat structure that fstat() fills in)
** and check for locks already existing on that inode. When locks are
** created or removed, we have to look at our own internal record of the
** locks to see if another thread has previously set a lock on that same
** inode.
**
** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
** For VxWorks, we have to use the alternative unique ID system based on
** canonical filename and implemented in the previous division.)
**
** There is one locking structure
** per inode, so if the same inode is opened twice, both unixFile structures
** point to the same locking structure. The locking structure keeps
** a reference count (so we will know when to delete it) and a "cnt"
** field that tells us its internal lock status. cnt==0 means the
** file is unlocked. cnt==-1 means the file has an exclusive lock.
** cnt>0 means there are cnt shared locks on the file.
**
** Any attempt to lock or unlock a file first checks the locking
** structure. The fcntl() system call is only invoked to set a
** POSIX lock if the internal lock structure transitions between
** a locked and an unlocked state.
**
** But wait: there are yet more problems with POSIX advisory locks.
**
** If you close a file descriptor that points to a file that has locks,
** all locks on that file that are owned by the current process are
** released. To work around this problem, each unixInodeInfo object
** maintains a count of the number of pending locks on that inode.
** When an attempt is made to close an unixFile, if there are
** other unixFile open on the same inode that are holding locks, the call
** to close() the file descriptor is deferred until all of the locks clear.
** The unixInodeInfo structure keeps a list of file descriptors that need to
** be closed and that list is walked (and cleared) when the last lock
** clears.
**
** Yet another problem: LinuxThreads do not play well with posix locks.
**
** Many older versions of linux use the LinuxThreads library which is
** not posix compliant. Under LinuxThreads, a lock created by thread
** A cannot be modified or overridden by a different thread B.
** Only thread A can modify the lock. Locking behavior is correct
** if the appliation uses the newer Native Posix Thread Library (NPTL)
** on linux - with NPTL a lock created by thread A can override locks
** in thread B. But there is no way to know at compile-time which
** threading library is being used. So there is no way to know at
** compile-time whether or not thread A can override locks on thread B.
** One has to do a run-time check to discover the behavior of the
** current process.
**
*/
/*
** An instance of the following structure serves as the key used
** to locate a particular unixInodeInfo object.
*/
struct unixFileId {
dev_t dev; /* Device number */
ino_t ino; /* Inode number */
};
/*
** An instance of the following structure is allocated for each open
** inode. Or, on LinuxThreads, there is one of these structures for
** each inode opened by each thread.
**
** A single inode can have multiple file descriptors, so each unixFile
** structure contains a pointer to an instance of this object and this
** object keeps a count of the number of unixFile pointing to it.
*/
struct unixInodeInfo {
struct unixFileId fileId; /* The lookup key */
int nShared; /* Number of SHARED locks held */
int eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
int nRef; /* Number of pointers to this structure */
int nLock; /* Number of outstanding file locks */
UnixUnusedFd *pUnused; /* Unused file descriptors to close */
unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
unixInodeInfo *pPrev; /* .... doubly linked */
};
static unixInodeInfo *inodeList = 0;
/*
* Local memory allocation stuff.
*/
void * unqlite_malloc(unsigned int nByte)
{
SyMemBackend *pAlloc;
void *p;
pAlloc = (SyMemBackend *)unqliteExportMemBackend();
p = SyMemBackendAlloc(pAlloc,nByte);
return p;
}
void unqlite_free(void *p)
{
SyMemBackend *pAlloc;
pAlloc = (SyMemBackend *)unqliteExportMemBackend();
SyMemBackendFree(pAlloc,p);
}
/*
** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
** If all such file descriptors are closed without error, the list is
** cleared and UNQLITE_OK returned.
**
** Otherwise, if an error occurs, then successfully closed file descriptor
** entries are removed from the list, and UNQLITE_IOERR_CLOSE returned.
** not deleted and UNQLITE_IOERR_CLOSE returned.
*/
static int closePendingFds(unixFile *pFile){
int rc = UNQLITE_OK;
unixInodeInfo *pInode = pFile->pInode;
UnixUnusedFd *pError = 0;
UnixUnusedFd *p;
UnixUnusedFd *pNext;
for(p=pInode->pUnused; p; p=pNext){
pNext = p->pNext;
if( close(p->fd) ){
pFile->lastErrno = errno;
rc = UNQLITE_IOERR;
p->pNext = pError;
pError = p;
}else{
unqlite_free(p);
}
}
pInode->pUnused = pError;
return rc;
}
/*
** Release a unixInodeInfo structure previously allocated by findInodeInfo().
**
** The mutex entered using the unixEnterMutex() function must be held
** when this function is called.
*/
static void releaseInodeInfo(unixFile *pFile){
unixInodeInfo *pInode = pFile->pInode;
if( pInode ){
pInode->nRef--;
if( pInode->nRef==0 ){
closePendingFds(pFile);
if( pInode->pPrev ){
pInode->pPrev->pNext = pInode->pNext;
}else{
inodeList = pInode->pNext;
}
if( pInode->pNext ){
pInode->pNext->pPrev = pInode->pPrev;
}
unqlite_free(pInode);
}
}
}
/*
** Given a file descriptor, locate the unixInodeInfo object that
** describes that file descriptor. Create a new one if necessary. The
** return value might be uninitialized if an error occurs.
**
** The mutex entered using the unixEnterMutex() function must be held
** when this function is called.
**
** Return an appropriate error code.
*/
static int findInodeInfo(
unixFile *pFile, /* Unix file with file desc used in the key */
unixInodeInfo **ppInode /* Return the unixInodeInfo object here */
){
int rc; /* System call return code */
int fd; /* The file descriptor for pFile */
struct unixFileId fileId; /* Lookup key for the unixInodeInfo */
struct stat statbuf; /* Low-level file information */
unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */
/* Get low-level information about the file that we can used to
** create a unique name for the file.
*/
fd = pFile->h;
rc = fstat(fd, &statbuf);
if( rc!=0 ){
pFile->lastErrno = errno;
#ifdef EOVERFLOW
if( pFile->lastErrno==EOVERFLOW ) return UNQLITE_NOTIMPLEMENTED;
#endif
return UNQLITE_IOERR;
}
#ifdef __APPLE__
/* On OS X on an msdos filesystem, the inode number is reported
** incorrectly for zero-size files. See ticket #3260. To work
** around this problem (we consider it a bug in OS X, not SQLite)
** we always increase the file size to 1 by writing a single byte
** prior to accessing the inode number. The one byte written is
** an ASCII 'S' character which also happens to be the first byte
** in the header of every SQLite database. In this way, if there
** is a race condition such that another thread has already populated
** the first page of the database, no damage is done.
*/
if( statbuf.st_size==0 && (pFile->fsFlags & UNQLITE_FSFLAGS_IS_MSDOS)!=0 ){
rc = write(fd, "S", 1);
if( rc!=1 ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}
rc = fstat(fd, &statbuf);
if( rc!=0 ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}
}
#endif
SyZero(&fileId,sizeof(fileId));
fileId.dev = statbuf.st_dev;
fileId.ino = statbuf.st_ino;
pInode = inodeList;
while( pInode && SyMemcmp((const void *)&fileId,(const void *)&pInode->fileId, sizeof(fileId)) ){
pInode = pInode->pNext;
}
if( pInode==0 ){
pInode = (unixInodeInfo *)unqlite_malloc( sizeof(*pInode) );
if( pInode==0 ){
return UNQLITE_NOMEM;
}
SyZero(pInode,sizeof(*pInode));
SyMemcpy((const void *)&fileId,(void *)&pInode->fileId,sizeof(fileId));
pInode->nRef = 1;
pInode->pNext = inodeList;
pInode->pPrev = 0;
if( inodeList ) inodeList->pPrev = pInode;
inodeList = pInode;
}else{
pInode->nRef++;
}
*ppInode = pInode;
return UNQLITE_OK;
}
/*
** This routine checks if there is a RESERVED lock held on the specified
** file by this or any other process. If such a lock is held, set *pResOut
** to a non-zero value otherwise *pResOut is set to zero. The return value
** is set to UNQLITE_OK unless an I/O error occurs during lock checking.
*/
static int unixCheckReservedLock(unqlite_file *id, int *pResOut){
int rc = UNQLITE_OK;
int reserved = 0;
unixFile *pFile = (unixFile*)id;
unixEnterMutex(); /* Because pFile->pInode is shared across threads */
/* Check if a thread in this process holds such a lock */
if( pFile->pInode->eFileLock>SHARED_LOCK ){
reserved = 1;
}
/* Otherwise see if some other process holds it.
*/
if( !reserved ){
struct flock lock;
lock.l_whence = SEEK_SET;
lock.l_start = RESERVED_BYTE;
lock.l_len = 1;
lock.l_type = F_WRLCK;
if (-1 == fcntl(pFile->h, F_GETLK, &lock)) {
int tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
pFile->lastErrno = tErrno;
} else if( lock.l_type!=F_UNLCK ){
reserved = 1;
}
}
unixLeaveMutex();
*pResOut = reserved;
return rc;
}
/*
** Lock the file with the lock specified by parameter eFileLock - one
** of the following:
**
** (1) SHARED_LOCK
** (2) RESERVED_LOCK
** (3) PENDING_LOCK
** (4) EXCLUSIVE_LOCK
**
** Sometimes when requesting one lock state, additional lock states
** are inserted in between. The locking might fail on one of the later
** transitions leaving the lock state different from what it started but
** still short of its goal. The following chart shows the allowed
** transitions and the inserted intermediate states:
**
** UNLOCKED -> SHARED
** SHARED -> RESERVED
** SHARED -> (PENDING) -> EXCLUSIVE
** RESERVED -> (PENDING) -> EXCLUSIVE
** PENDING -> EXCLUSIVE
**
** This routine will only increase a lock. Use the unqliteOsUnlock()
** routine to lower a locking level.
*/
static int unixLock(unqlite_file *id, int eFileLock){
/* The following describes the implementation of the various locks and
** lock transitions in terms of the POSIX advisory shared and exclusive
** lock primitives (called read-locks and write-locks below, to avoid
** confusion with SQLite lock names). The algorithms are complicated
** slightly in order to be compatible with unixdows systems simultaneously
** accessing the same database file, in case that is ever required.
**
** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
** byte', each single bytes at well known offsets, and the 'shared byte
** range', a range of 510 bytes at a well known offset.
**
** To obtain a SHARED lock, a read-lock is obtained on the 'pending
** byte'. If this is successful, a random byte from the 'shared byte
** range' is read-locked and the lock on the 'pending byte' released.
**
** A process may only obtain a RESERVED lock after it has a SHARED lock.
** A RESERVED lock is implemented by grabbing a write-lock on the
** 'reserved byte'.
**
** A process may only obtain a PENDING lock after it has obtained a
** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
** on the 'pending byte'. This ensures that no new SHARED locks can be
** obtained, but existing SHARED locks are allowed to persist. A process
** does not have to obtain a RESERVED lock on the way to a PENDING lock.
** This property is used by the algorithm for rolling back a journal file
** after a crash.
**
** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
** implemented by obtaining a write-lock on the entire 'shared byte
** range'. Since all other locks require a read-lock on one of the bytes
** within this range, this ensures that no other locks are held on the
** database.
**
** The reason a single byte cannot be used instead of the 'shared byte
** range' is that some versions of unixdows do not support read-locks. By
** locking a random byte from a range, concurrent SHARED locks may exist
** even if the locking primitive used is always a write-lock.
*/
int rc = UNQLITE_OK;
unixFile *pFile = (unixFile*)id;
unixInodeInfo *pInode = pFile->pInode;
struct flock lock;
int s = 0;
int tErrno = 0;
/* If there is already a lock of this type or more restrictive on the
** unixFile, do nothing. Don't use the end_lock: exit path, as
** unixEnterMutex() hasn't been called yet.
*/
if( pFile->eFileLock>=eFileLock ){
return UNQLITE_OK;
}
/* This mutex is needed because pFile->pInode is shared across threads
*/
unixEnterMutex();
pInode = pFile->pInode;
/* If some thread using this PID has a lock via a different unixFile*
** handle that precludes the requested lock, return BUSY.
*/
if( (pFile->eFileLock!=pInode->eFileLock &&
(pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
){
rc = UNQLITE_BUSY;
goto end_lock;
}
/* If a SHARED lock is requested, and some thread using this PID already
** has a SHARED or RESERVED lock, then increment reference counts and
** return UNQLITE_OK.
*/
if( eFileLock==SHARED_LOCK &&
(pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
pFile->eFileLock = SHARED_LOCK;
pInode->nShared++;
pInode->nLock++;
goto end_lock;
}
/* A PENDING lock is needed before acquiring a SHARED lock and before
** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
** be released.
*/
lock.l_len = 1L;
lock.l_whence = SEEK_SET;
if( eFileLock==SHARED_LOCK
|| (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
){
lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
lock.l_start = PENDING_BYTE;
s = fcntl(pFile->h, F_SETLK, &lock);
if( s==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_lock;
}
}
/* If control gets to this point, then actually go ahead and make
** operating system calls for the specified lock.
*/
if( eFileLock==SHARED_LOCK ){
/* Now get the read-lock */
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
if( (s = fcntl(pFile->h, F_SETLK, &lock))==(-1) ){
tErrno = errno;
}
/* Drop the temporary PENDING lock */
lock.l_start = PENDING_BYTE;
lock.l_len = 1L;
lock.l_type = F_UNLCK;
if( fcntl(pFile->h, F_SETLK, &lock)!=0 ){
if( s != -1 ){
/* This could happen with a network mount */
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_lock;
}
}
if( s==(-1) ){
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
}else{
pFile->eFileLock = SHARED_LOCK;
pInode->nLock++;
pInode->nShared = 1;
}
}else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
/* We are trying for an exclusive lock but another thread in this
** same process is still holding a shared lock. */
rc = UNQLITE_BUSY;
}else{
/* The request was for a RESERVED or EXCLUSIVE lock. It is
** assumed that there is a SHARED or greater lock on the file
** already.
*/
lock.l_type = F_WRLCK;
switch( eFileLock ){
case RESERVED_LOCK:
lock.l_start = RESERVED_BYTE;
break;
case EXCLUSIVE_LOCK:
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
break;
default:
/* Can't happen */
break;
}
s = fcntl(pFile->h, F_SETLK, &lock);
if( s==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
}
}
if( rc==UNQLITE_OK ){
pFile->eFileLock = eFileLock;
pInode->eFileLock = eFileLock;
}else if( eFileLock==EXCLUSIVE_LOCK ){
pFile->eFileLock = PENDING_LOCK;
pInode->eFileLock = PENDING_LOCK;
}
end_lock:
unixLeaveMutex();
return rc;
}
/*
** Add the file descriptor used by file handle pFile to the corresponding
** pUnused list.
*/
static void setPendingFd(unixFile *pFile){
unixInodeInfo *pInode = pFile->pInode;
UnixUnusedFd *p = pFile->pUnused;
p->pNext = pInode->pUnused;
pInode->pUnused = p;
pFile->h = -1;
pFile->pUnused = 0;
}
/*
** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
** must be either NO_LOCK or SHARED_LOCK.
**
** If the locking level of the file descriptor is already at or below
** the requested locking level, this routine is a no-op.
**
** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
** the byte range is divided into 2 parts and the first part is unlocked then
** set to a read lock, then the other part is simply unlocked. This works
** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to
** remove the write lock on a region when a read lock is set.
*/
static int _posixUnlock(unqlite_file *id, int eFileLock, int handleNFSUnlock){
unixFile *pFile = (unixFile*)id;
unixInodeInfo *pInode;
struct flock lock;
int rc = UNQLITE_OK;
int h;
int tErrno; /* Error code from system call errors */
if( pFile->eFileLock<=eFileLock ){
return UNQLITE_OK;
}
unixEnterMutex();
h = pFile->h;
pInode = pFile->pInode;
if( pFile->eFileLock>SHARED_LOCK ){
/* downgrading to a shared lock on NFS involves clearing the write lock
** before establishing the readlock - to avoid a race condition we downgrade
** the lock in 2 blocks, so that part of the range will be covered by a
** write lock until the rest is covered by a read lock:
** 1: [WWWWW]
** 2: [....W]
** 3: [RRRRW]
** 4: [RRRR.]
*/
if( eFileLock==SHARED_LOCK ){
if( handleNFSUnlock ){
off_t divSize = SHARED_SIZE - 1;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = divSize;
if( fcntl(h, F_SETLK, &lock)==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
}
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = divSize;
if( fcntl(h, F_SETLK, &lock)==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
}
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST+divSize;
lock.l_len = SHARED_SIZE-divSize;
if( fcntl(h, F_SETLK, &lock)==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
}
}else{
lock.l_type = F_RDLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
if( fcntl(h, F_SETLK, &lock)==(-1) ){
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
}
}
}
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = PENDING_BYTE;
lock.l_len = 2L;
if( fcntl(h, F_SETLK, &lock)!=(-1) ){
pInode->eFileLock = SHARED_LOCK;
}else{
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
goto end_unlock;
}
}
if( eFileLock==NO_LOCK ){
/* Decrement the shared lock counter. Release the lock using an
** OS call only when all threads in this same process have released
** the lock.
*/
pInode->nShared--;
if( pInode->nShared==0 ){
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = lock.l_len = 0L;
if( fcntl(h, F_SETLK, &lock)!=(-1) ){
pInode->eFileLock = NO_LOCK;
}else{
tErrno = errno;
rc = unqliteErrorFromPosixError(tErrno, UNQLITE_LOCKERR);
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
pInode->eFileLock = NO_LOCK;
pFile->eFileLock = NO_LOCK;
}
}
/* Decrement the count of locks against this same file. When the
** count reaches zero, close any other file descriptors whose close
** was deferred because of outstanding locks.
*/
pInode->nLock--;
if( pInode->nLock==0 ){
int rc2 = closePendingFds(pFile);
if( rc==UNQLITE_OK ){
rc = rc2;
}
}
}
end_unlock:
unixLeaveMutex();
if( rc==UNQLITE_OK ) pFile->eFileLock = eFileLock;
return rc;
}
/*
** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
** must be either NO_LOCK or SHARED_LOCK.
**
** If the locking level of the file descriptor is already at or below
** the requested locking level, this routine is a no-op.
*/
static int unixUnlock(unqlite_file *id, int eFileLock){
return _posixUnlock(id, eFileLock, 0);
}
/*
** This function performs the parts of the "close file" operation
** common to all locking schemes. It closes the directory and file
** handles, if they are valid, and sets all fields of the unixFile
** structure to 0.
**
*/
static int closeUnixFile(unqlite_file *id){
unixFile *pFile = (unixFile*)id;
if( pFile ){
if( pFile->dirfd>=0 ){
int err = close(pFile->dirfd);
if( err ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}else{
pFile->dirfd=-1;
}
}
if( pFile->h>=0 ){
int err = close(pFile->h);
if( err ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}
}
unqlite_free(pFile->pUnused);
SyZero(pFile,sizeof(unixFile));
}
return UNQLITE_OK;
}
/*
** Close a file.
*/
static int unixClose(unqlite_file *id){
int rc = UNQLITE_OK;
if( id ){
unixFile *pFile = (unixFile *)id;
unixUnlock(id, NO_LOCK);
unixEnterMutex();
if( pFile->pInode && pFile->pInode->nLock ){
/* If there are outstanding locks, do not actually close the file just
** yet because that would clear those locks. Instead, add the file
** descriptor to pInode->pUnused list. It will be automatically closed
** when the last lock is cleared.
*/
setPendingFd(pFile);
}
releaseInodeInfo(pFile);
rc = closeUnixFile(id);
unixLeaveMutex();
}
return rc;
}
/************** End of the posix advisory lock implementation *****************
******************************************************************************/
/*
**
** The next division contains implementations for all methods of the
** unqlite_file object other than the locking methods. The locking
** methods were defined in divisions above (one locking method per
** division). Those methods that are common to all locking modes
** are gather together into this division.
*/
/*
** Seek to the offset passed as the second argument, then read cnt
** bytes into pBuf. Return the number of bytes actually read.
**
** NB: If you define USE_PREAD or USE_PREAD64, then it might also
** be necessary to define _XOPEN_SOURCE to be 500. This varies from
** one system to another. Since SQLite does not define USE_PREAD
** any form by default, we will not attempt to define _XOPEN_SOURCE.
** See tickets #2741 and #2681.
**
** To avoid stomping the errno value on a failed read the lastErrno value
** is set before returning.
*/
static int seekAndRead(unixFile *id, unqlite_int64 offset, void *pBuf, int cnt){
int got;
#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
unqlite_int64 newOffset;
#endif
#if defined(USE_PREAD)
got = pread(id->h, pBuf, cnt, offset);
#elif defined(USE_PREAD64)
got = pread64(id->h, pBuf, cnt, offset);
#else
newOffset = lseek(id->h, offset, SEEK_SET);
if( newOffset!=offset ){
if( newOffset == -1 ){
((unixFile*)id)->lastErrno = errno;
}else{
((unixFile*)id)->lastErrno = 0;
}
return -1;
}
got = read(id->h, pBuf, cnt);
#endif
if( got<0 ){
((unixFile*)id)->lastErrno = errno;
}
return got;
}
/*
** Read data from a file into a buffer. Return UNQLITE_OK if all
** bytes were read successfully and UNQLITE_IOERR if anything goes
** wrong.
*/
static int unixRead(
unqlite_file *id,
void *pBuf,
unqlite_int64 amt,
unqlite_int64 offset
){
unixFile *pFile = (unixFile *)id;
int got;
got = seekAndRead(pFile, offset, pBuf, (int)amt);
if( got==(int)amt ){
return UNQLITE_OK;
}else if( got<0 ){
/* lastErrno set by seekAndRead */
return UNQLITE_IOERR;
}else{
pFile->lastErrno = 0; /* not a system error */
/* Unread parts of the buffer must be zero-filled */
SyZero(&((char*)pBuf)[got],(sxu32)amt-got);
return UNQLITE_IOERR;
}
}
/*
** Seek to the offset in id->offset then read cnt bytes into pBuf.
** Return the number of bytes actually read. Update the offset.
**
** To avoid stomping the errno value on a failed write the lastErrno value
** is set before returning.
*/
static int seekAndWrite(unixFile *id, unqlite_int64 offset, const void *pBuf, unqlite_int64 cnt){
int got;
#if (!defined(USE_PREAD) && !defined(USE_PREAD64))
unqlite_int64 newOffset;
#endif
#if defined(USE_PREAD)
got = pwrite(id->h, pBuf, cnt, offset);
#elif defined(USE_PREAD64)
got = pwrite64(id->h, pBuf, cnt, offset);
#else
newOffset = lseek(id->h, offset, SEEK_SET);
if( newOffset!=offset ){
if( newOffset == -1 ){
((unixFile*)id)->lastErrno = errno;
}else{
((unixFile*)id)->lastErrno = 0;
}
return -1;
}
got = write(id->h, pBuf, cnt);
#endif
if( got<0 ){
((unixFile*)id)->lastErrno = errno;
}
return got;
}
/*
** Write data from a buffer into a file. Return UNQLITE_OK on success
** or some other error code on failure.
*/
static int unixWrite(
unqlite_file *id,
const void *pBuf,
unqlite_int64 amt,
unqlite_int64 offset
){
unixFile *pFile = (unixFile*)id;
int wrote = 0;
while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
amt -= wrote;
offset += wrote;
pBuf = &((char*)pBuf)[wrote];
}
if( amt>0 ){
if( wrote<0 ){
/* lastErrno set by seekAndWrite */
return UNQLITE_IOERR;
}else{
pFile->lastErrno = 0; /* not a system error */
return UNQLITE_FULL;
}
}
return UNQLITE_OK;
}
/*
** We do not trust systems to provide a working fdatasync(). Some do.
** Others do no. To be safe, we will stick with the (slower) fsync().
** If you know that your system does support fdatasync() correctly,
** then simply compile with -Dfdatasync=fdatasync
*/
#if !defined(fdatasync) && !defined(__linux__)
# define fdatasync fsync
#endif
/*
** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently
** only available on Mac OS X. But that could change.
*/
#ifdef F_FULLFSYNC
# define HAVE_FULLFSYNC 1
#else
# define HAVE_FULLFSYNC 0
#endif
/*
** The fsync() system call does not work as advertised on many
** unix systems. The following procedure is an attempt to make
** it work better.
**
**
** SQLite sets the dataOnly flag if the size of the file is unchanged.
** The idea behind dataOnly is that it should only write the file content
** to disk, not the inode. We only set dataOnly if the file size is
** unchanged since the file size is part of the inode. However,
** Ted Ts'o tells us that fdatasync() will also write the inode if the
** file size has changed. The only real difference between fdatasync()
** and fsync(), Ted tells us, is that fdatasync() will not flush the
** inode if the mtime or owner or other inode attributes have changed.
** We only care about the file size, not the other file attributes, so
** as far as SQLite is concerned, an fdatasync() is always adequate.
** So, we always use fdatasync() if it is available, regardless of
** the value of the dataOnly flag.
*/
static int full_fsync(int fd, int fullSync, int dataOnly){
int rc;
#if HAVE_FULLFSYNC
SXUNUSED(dataOnly);
#else
SXUNUSED(fullSync);
SXUNUSED(dataOnly);
#endif
/* If we compiled with the UNQLITE_NO_SYNC flag, then syncing is a
** no-op
*/
#if HAVE_FULLFSYNC
if( fullSync ){
rc = fcntl(fd, F_FULLFSYNC, 0);
}else{
rc = 1;
}
/* If the FULLFSYNC failed, fall back to attempting an fsync().
** It shouldn't be possible for fullfsync to fail on the local
** file system (on OSX), so failure indicates that FULLFSYNC
** isn't supported for this file system. So, attempt an fsync
** and (for now) ignore the overhead of a superfluous fcntl call.
** It'd be better to detect fullfsync support once and avoid
** the fcntl call every time sync is called.
*/
if( rc ) rc = fsync(fd);
#elif defined(__APPLE__)
/* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
** so currently we default to the macro that redefines fdatasync to fsync
*/
rc = fsync(fd);
#else
rc = fdatasync(fd);
#endif /* ifdef UNQLITE_NO_SYNC elif HAVE_FULLFSYNC */
if( rc!= -1 ){
rc = 0;
}
return rc;
}
/*
** Make sure all writes to a particular file are committed to disk.
**
** If dataOnly==0 then both the file itself and its metadata (file
** size, access time, etc) are synced. If dataOnly!=0 then only the
** file data is synced.
**
** Under Unix, also make sure that the directory entry for the file
** has been created by fsync-ing the directory that contains the file.
** If we do not do this and we encounter a power failure, the directory
** entry for the journal might not exist after we reboot. The next
** SQLite to access the file will not know that the journal exists (because
** the directory entry for the journal was never created) and the transaction
** will not roll back - possibly leading to database corruption.
*/
static int unixSync(unqlite_file *id, int flags){
int rc;
unixFile *pFile = (unixFile*)id;
int isDataOnly = (flags&UNQLITE_SYNC_DATAONLY);
int isFullsync = (flags&0x0F)==UNQLITE_SYNC_FULL;
rc = full_fsync(pFile->h, isFullsync, isDataOnly);
if( rc ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}
if( pFile->dirfd>=0 ){
int err;
#ifndef UNQLITE_DISABLE_DIRSYNC
/* The directory sync is only attempted if full_fsync is
** turned off or unavailable. If a full_fsync occurred above,
** then the directory sync is superfluous.
*/
if( (!HAVE_FULLFSYNC || !isFullsync) && full_fsync(pFile->dirfd,0,0) ){
/*
** We have received multiple reports of fsync() returning
** errors when applied to directories on certain file systems.
** A failed directory sync is not a big deal. So it seems
** better to ignore the error. Ticket #1657
*/
/* pFile->lastErrno = errno; */
/* return UNQLITE_IOERR; */
}
#endif
err = close(pFile->dirfd); /* Only need to sync once, so close the */
if( err==0 ){ /* directory when we are done */
pFile->dirfd = -1;
}else{
pFile->lastErrno = errno;
rc = UNQLITE_IOERR;
}
}
return rc;
}
/*
** Truncate an open file to a specified size
*/
static int unixTruncate(unqlite_file *id, sxi64 nByte){
unixFile *pFile = (unixFile *)id;
int rc;
rc = ftruncate(pFile->h, (off_t)nByte);
if( rc ){
pFile->lastErrno = errno;
return UNQLITE_IOERR;
}else{
return UNQLITE_OK;
}
}
/*
** Determine the current size of a file in bytes
*/
static int unixFileSize(unqlite_file *id,sxi64 *pSize){
int rc;
struct stat buf;
rc = fstat(((unixFile*)id)->h, &buf);
if( rc!=0 ){
((unixFile*)id)->lastErrno = errno;
return UNQLITE_IOERR;
}
*pSize = buf.st_size;
/* When opening a zero-size database, the findInodeInfo() procedure
** writes a single byte into that file in order to work around a bug
** in the OS-X msdos filesystem. In order to avoid problems with upper
** layers, we need to report this file size as zero even though it is
** really 1. Ticket #3260.
*/
if( *pSize==1 ) *pSize = 0;
return UNQLITE_OK;
}
/*
** Return the sector size in bytes of the underlying block device for
** the specified file. This is almost always 512 bytes, but may be
** larger for some devices.
**
** SQLite code assumes this function cannot fail. It also assumes that
** if two files are created in the same file-system directory (i.e.
** a database and its journal file) that the sector size will be the
** same for both.
*/
static int unixSectorSize(unqlite_file *NotUsed){
SXUNUSED(NotUsed);
return UNQLITE_DEFAULT_SECTOR_SIZE;
}
/*
** This vector defines all the methods that can operate on an
** unqlite_file for Windows systems.
*/
static const unqlite_io_methods unixIoMethod = {
1, /* iVersion */
unixClose, /* xClose */
unixRead, /* xRead */
unixWrite, /* xWrite */
unixTruncate, /* xTruncate */
unixSync, /* xSync */
unixFileSize, /* xFileSize */
unixLock, /* xLock */
unixUnlock, /* xUnlock */
unixCheckReservedLock, /* xCheckReservedLock */
unixSectorSize, /* xSectorSize */
};
/****************************************************************************
**************************** unqlite_vfs methods ****************************
**
** This division contains the implementation of methods on the
** unqlite_vfs object.
*/
/*
** Initialize the contents of the unixFile structure pointed to by pId.
*/
static int fillInUnixFile(
unqlite_vfs *pVfs, /* Pointer to vfs object */
int h, /* Open file descriptor of file being opened */
int dirfd, /* Directory file descriptor */
unqlite_file *pId, /* Write to the unixFile structure here */
const char *zFilename, /* Name of the file being opened */
int noLock, /* Omit locking if true */
int isDelete /* Delete on close if true */
){
const unqlite_io_methods *pLockingStyle = &unixIoMethod;
unixFile *pNew = (unixFile *)pId;
int rc = UNQLITE_OK;
/* Parameter isDelete is only used on vxworks. Express this explicitly
** here to prevent compiler warnings about unused parameters.
*/
SXUNUSED(isDelete);
SXUNUSED(noLock);
SXUNUSED(pVfs);
pNew->h = h;
pNew->dirfd = dirfd;
pNew->fileFlags = 0;
pNew->zPath = zFilename;
unixEnterMutex();
rc = findInodeInfo(pNew, &pNew->pInode);
if( rc!=UNQLITE_OK ){
/* If an error occured in findInodeInfo(), close the file descriptor
** immediately, before releasing the mutex. findInodeInfo() may fail
** in two scenarios:
**
** (a) A call to fstat() failed.
** (b) A malloc failed.
**
** Scenario (b) may only occur if the process is holding no other
** file descriptors open on the same file. If there were other file
** descriptors on this file, then no malloc would be required by
** findInodeInfo(). If this is the case, it is quite safe to close
** handle h - as it is guaranteed that no posix locks will be released
** by doing so.
**
** If scenario (a) caused the error then things are not so safe. The
** implicit assumption here is that if fstat() fails, things are in
** such bad shape that dropping a lock or two doesn't matter much.
*/
close(h);
h = -1;
}
unixLeaveMutex();
pNew->lastErrno = 0;
if( rc!=UNQLITE_OK ){
if( dirfd>=0 ) close(dirfd); /* silent leak if fail, already in error */
if( h>=0 ) close(h);
}else{
pNew->pMethod = pLockingStyle;
}
return rc;
}
/*
** Open a file descriptor to the directory containing file zFilename.
** If successful, *pFd is set to the opened file descriptor and
** UNQLITE_OK is returned. If an error occurs, either UNQLITE_NOMEM
** or UNQLITE_CANTOPEN is returned and *pFd is set to an undefined
** value.
**
** If UNQLITE_OK is returned, the caller is responsible for closing
** the file descriptor *pFd using close().
*/
static int openDirectory(const char *zFilename, int *pFd){
sxu32 ii;
int fd = -1;
char zDirname[MAX_PATHNAME+1];
sxu32 n;
n = Systrcpy(zDirname,sizeof(zDirname),zFilename,0);
for(ii=n; ii>1 && zDirname[ii]!='/'; ii--);
if( ii>0 ){
zDirname[ii] = '\0';
fd = open(zDirname, O_RDONLY|O_BINARY, 0);
if( fd>=0 ){
#ifdef FD_CLOEXEC
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
#endif
}
}
*pFd = fd;
return (fd>=0?UNQLITE_OK: UNQLITE_IOERR );
}
/*
** Search for an unused file descriptor that was opened on the database
** file (not a journal or master-journal file) identified by pathname
** zPath with UNQLITE_OPEN_XXX flags matching those passed as the second
** argument to this function.
**
** Such a file descriptor may exist if a database connection was closed
** but the associated file descriptor could not be closed because some
** other file descriptor open on the same file is holding a file-lock.
** Refer to comments in the unixClose() function and the lengthy comment
** describing "Posix Advisory Locking" at the start of this file for
** further details. Also, ticket #4018.
**
** If a suitable file descriptor is found, then it is returned. If no
** such file descriptor is located, -1 is returned.
*/
static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
UnixUnusedFd *pUnused = 0;
struct stat sStat; /* Results of stat() call */
/* A stat() call may fail for various reasons. If this happens, it is
** almost certain that an open() call on the same path will also fail.
** For this reason, if an error occurs in the stat() call here, it is
** ignored and -1 is returned. The caller will try to open a new file
** descriptor on the same path, fail, and return an error to SQLite.
**
** Even if a subsequent open() call does succeed, the consequences of
** not searching for a resusable file descriptor are not dire. */
if( 0==stat(zPath, &sStat) ){
unixInodeInfo *pInode;
unixEnterMutex();
pInode = inodeList;
while( pInode && (pInode->fileId.dev!=sStat.st_dev
|| pInode->fileId.ino!=sStat.st_ino) ){
pInode = pInode->pNext;
}
if( pInode ){
UnixUnusedFd **pp;
for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
pUnused = *pp;
if( pUnused ){
*pp = pUnused->pNext;
}
}
unixLeaveMutex();
}
return pUnused;
}
/*
** This function is called by unixOpen() to determine the unix permissions
** to create new files with. If no error occurs, then UNQLITE_OK is returned
** and a value suitable for passing as the third argument to open(2) is
** written to *pMode. If an IO error occurs, an SQLite error code is
** returned and the value of *pMode is not modified.
**
** If the file being opened is a temporary file, it is always created with
** the octal permissions 0600 (read/writable by owner only). If the file
** is a database or master journal file, it is created with the permissions
** mask UNQLITE_DEFAULT_FILE_PERMISSIONS.
**
** Finally, if the file being opened is a WAL or regular journal file, then
** this function queries the file-system for the permissions on the
** corresponding database file and sets *pMode to this value. Whenever
** possible, WAL and journal files are created using the same permissions
** as the associated database file.
*/
static int findCreateFileMode(
const char *zPath, /* Path of file (possibly) being created */
int flags, /* Flags passed as 4th argument to xOpen() */
mode_t *pMode /* OUT: Permissions to open file with */
){
int rc = UNQLITE_OK; /* Return Code */
if( flags & UNQLITE_OPEN_TEMP_DB ){
*pMode = 0600;
SXUNUSED(zPath);
}else{
*pMode = UNQLITE_DEFAULT_FILE_PERMISSIONS;
}
return rc;
}
/*
** Open the file zPath.
**
** Previously, the SQLite OS layer used three functions in place of this
** one:
**
** unqliteOsOpenReadWrite();
** unqliteOsOpenReadOnly();
** unqliteOsOpenExclusive();
**
** These calls correspond to the following combinations of flags:
**
** ReadWrite() -> (READWRITE | CREATE)
** ReadOnly() -> (READONLY)
** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
**
** The old OpenExclusive() accepted a boolean argument - "delFlag". If
** true, the file was configured to be automatically deleted when the
** file handle closed. To achieve the same effect using this new
** interface, add the DELETEONCLOSE flag to those specified above for
** OpenExclusive().
*/
static int unixOpen(
unqlite_vfs *pVfs, /* The VFS for which this is the xOpen method */
const char *zPath, /* Pathname of file to be opened */
unqlite_file *pFile, /* The file descriptor to be filled in */
unsigned int flags /* Input flags to control the opening */
){
unixFile *p = (unixFile *)pFile;
int fd = -1; /* File descriptor returned by open() */
int dirfd = -1; /* Directory file descriptor */
int openFlags = 0; /* Flags to pass to open() */
int noLock; /* True to omit locking primitives */
int rc = UNQLITE_OK; /* Function Return Code */
UnixUnusedFd *pUnused;
int isExclusive = (flags & UNQLITE_OPEN_EXCLUSIVE);
int isDelete = (flags & UNQLITE_OPEN_TEMP_DB);
int isCreate = (flags & UNQLITE_OPEN_CREATE);
int isReadonly = (flags & UNQLITE_OPEN_READONLY);
int isReadWrite = (flags & UNQLITE_OPEN_READWRITE);
/* If creating a master or main-file journal, this function will open
** a file-descriptor on the directory too. The first time unixSync()
** is called the directory file descriptor will be fsync()ed and close()d.
*/
int isOpenDirectory = isCreate;
const char *zName = zPath;
SyZero(p,sizeof(unixFile));
pUnused = findReusableFd(zName, flags);
if( pUnused ){
fd = pUnused->fd;
}else{
pUnused = unqlite_malloc(sizeof(*pUnused));
if( !pUnused ){
return UNQLITE_NOMEM;
}
}
p->pUnused = pUnused;
/* Determine the value of the flags parameter passed to POSIX function
** open(). These must be calculated even if open() is not called, as
** they may be stored as part of the file handle and used by the
** 'conch file' locking functions later on. */
if( isReadonly ) openFlags |= O_RDONLY;
if( isReadWrite ) openFlags |= O_RDWR;
if( isCreate ) openFlags |= O_CREAT;
if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
openFlags |= (O_LARGEFILE|O_BINARY);
if( fd<0 ){
mode_t openMode; /* Permissions to create file with */
rc = findCreateFileMode(zName, flags, &openMode);
if( rc!=UNQLITE_OK ){
return rc;
}
fd = open(zName, openFlags, openMode);
if( fd<0 ){
rc = UNQLITE_IOERR;
goto open_finished;
}
}
if( p->pUnused ){
p->pUnused->fd = fd;
p->pUnused->flags = flags;
}
if( isDelete ){
unlink(zName);
}
if( isOpenDirectory ){
rc = openDirectory(zPath, &dirfd);
if( rc!=UNQLITE_OK ){
/* It is safe to close fd at this point, because it is guaranteed not
** to be open on a database file. If it were open on a database file,
** it would not be safe to close as this would release any locks held
** on the file by this process. */
close(fd); /* silently leak if fail, already in error */
goto open_finished;
}
}
#ifdef FD_CLOEXEC
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
#endif
noLock = 0;
#if defined(__APPLE__)
struct statfs fsInfo;
if( fstatfs(fd, &fsInfo) == -1 ){
((unixFile*)pFile)->lastErrno = errno;
if( dirfd>=0 ) close(dirfd); /* silently leak if fail, in error */
close(fd); /* silently leak if fail, in error */
return UNQLITE_IOERR;
}
if (0 == SyStrncmp("msdos", fsInfo.f_fstypename, 5)) {
((unixFile*)pFile)->fsFlags |= UNQLITE_FSFLAGS_IS_MSDOS;
}
#endif
rc = fillInUnixFile(pVfs, fd, dirfd, pFile, zPath, noLock, isDelete);
open_finished:
if( rc!=UNQLITE_OK ){
unqlite_free(p->pUnused);
}
return rc;
}
/*
** Delete the file at zPath. If the dirSync argument is true, fsync()
** the directory after deleting the file.
*/
static int unixDelete(
unqlite_vfs *NotUsed, /* VFS containing this as the xDelete method */
const char *zPath, /* Name of file to be deleted */
int dirSync /* If true, fsync() directory after deleting file */
){
int rc = UNQLITE_OK;
SXUNUSED(NotUsed);
if( unlink(zPath)==(-1) && errno!=ENOENT ){
return UNQLITE_IOERR;
}
#ifndef UNQLITE_DISABLE_DIRSYNC
if( dirSync ){
int fd;
rc = openDirectory(zPath, &fd);
if( rc==UNQLITE_OK ){
if( fsync(fd) )
{
rc = UNQLITE_IOERR;
}
if( close(fd) && !rc ){
rc = UNQLITE_IOERR;
}
}
}
#endif
return rc;
}
/*
** Sleep for a little while. Return the amount of time slept.
** The argument is the number of microseconds we want to sleep.
** The return value is the number of microseconds of sleep actually
** requested from the underlying operating system, a number which
** might be greater than or equal to the argument, but not less
** than the argument.
*/
static int unixSleep(unqlite_vfs *NotUsed, int microseconds)
{
#if defined(HAVE_USLEEP) && HAVE_USLEEP
usleep(microseconds);
SXUNUSED(NotUsed);
return microseconds;
#else
int seconds = (microseconds+999999)/1000000;
SXUNUSED(NotUsed);
sleep(seconds);
return seconds*1000000;
#endif
}
/*
* Export the current system time.
*/
static int unixCurrentTime(unqlite_vfs *pVfs,Sytm *pOut)
{
struct tm *pTm;
time_t tt;
SXUNUSED(pVfs);
time(&tt);
pTm = gmtime(&tt);
if( pTm ){ /* Yes, it can fail */
STRUCT_TM_TO_SYTM(pTm,pOut);
}
return UNQLITE_OK;
}
/*
** Test the existance of or access permissions of file zPath. The
** test performed depends on the value of flags:
**
** UNQLITE_ACCESS_EXISTS: Return 1 if the file exists
** UNQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
** UNQLITE_ACCESS_READONLY: Return 1 if the file is readable.
**
** Otherwise return 0.
*/
static int unixAccess(
unqlite_vfs *NotUsed, /* The VFS containing this xAccess method */
const char *zPath, /* Path of the file to examine */
int flags, /* What do we want to learn about the zPath file? */
int *pResOut /* Write result boolean here */
){
int amode = 0;
SXUNUSED(NotUsed);
switch( flags ){
case UNQLITE_ACCESS_EXISTS:
amode = F_OK;
break;
case UNQLITE_ACCESS_READWRITE:
amode = W_OK|R_OK;
break;
case UNQLITE_ACCESS_READ:
amode = R_OK;
break;
default:
/* Can't happen */
break;
}
*pResOut = (access(zPath, amode)==0);
if( flags==UNQLITE_ACCESS_EXISTS && *pResOut ){
struct stat buf;
if( 0==stat(zPath, &buf) && buf.st_size==0 ){
*pResOut = 0;
}
}
return UNQLITE_OK;
}
/*
** Turn a relative pathname into a full pathname. The relative path
** is stored as a nul-terminated string in the buffer pointed to by
** zPath.
**
** zOut points to a buffer of at least unqlite_vfs.mxPathname bytes
** (in this case, MAX_PATHNAME bytes). The full-path is written to
** this buffer before returning.
*/
static int unixFullPathname(
unqlite_vfs *pVfs, /* Pointer to vfs object */
const char *zPath, /* Possibly relative input path */
int nOut, /* Size of output buffer in bytes */
char *zOut /* Output buffer */
){
if( zPath[0]=='/' ){
Systrcpy(zOut,(sxu32)nOut,zPath,0);
SXUNUSED(pVfs);
}else{
sxu32 nCwd;
zOut[nOut-1] = '\0';
if( getcwd(zOut, nOut-1)==0 ){
return UNQLITE_IOERR;
}
nCwd = SyStrlen(zOut);
SyBufferFormat(&zOut[nCwd],(sxu32)nOut-nCwd,"/%s",zPath);
}
return UNQLITE_OK;
}
/*
* Export the Unix Vfs.
*/
UNQLITE_PRIVATE const unqlite_vfs * unqliteExportBuiltinVfs(void)
{
static const unqlite_vfs sUnixvfs = {
"Unix", /* Vfs name */
1, /* Vfs structure version */
sizeof(unixFile), /* szOsFile */
MAX_PATHNAME, /* mxPathName */
unixOpen, /* xOpen */
unixDelete, /* xDelete */
unixAccess, /* xAccess */
unixFullPathname, /* xFullPathname */
0, /* xTmp */
unixSleep, /* xSleep */
unixCurrentTime, /* xCurrentTime */
0, /* xGetLastError */
};
return &sUnixvfs;
}
#endif /* __UNIXES__ */
/*
* ----------------------------------------------------------
* File: os_win.c
* MD5: ab70fb386c21b39a08b0eb776a8391ab
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: os_win.c v1.2 Win7 2012-11-10 12:10 devel <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/* Omit the whole layer from the build if compiling for platforms other than Windows */
#ifdef __WINNT__
/* This file contains code that is specific to windows. (Mostly SQLite3 source tree) */
#include <Windows.h>
/*
** Some microsoft compilers lack this definition.
*/
#ifndef INVALID_FILE_ATTRIBUTES
# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
#endif
/*
** WinCE lacks native support for file locking so we have to fake it
** with some code of our own.
*/
#ifdef __WIN_CE__
typedef struct winceLock {
int nReaders; /* Number of reader locks obtained */
BOOL bPending; /* Indicates a pending lock has been obtained */
BOOL bReserved; /* Indicates a reserved lock has been obtained */
BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
} winceLock;
#define AreFileApisANSI() 1
#define FormatMessageW(a,b,c,d,e,f,g) 0
#endif
/*
** The winFile structure is a subclass of unqlite_file* specific to the win32
** portability layer.
*/
typedef struct winFile winFile;
struct winFile {
const unqlite_io_methods *pMethod; /*** Must be first ***/
unqlite_vfs *pVfs; /* The VFS used to open this file */
HANDLE h; /* Handle for accessing the file */
sxu8 locktype; /* Type of lock currently held on this file */
short sharedLockByte; /* Randomly chosen byte used as a shared lock */
DWORD lastErrno; /* The Windows errno from the last I/O error */
DWORD sectorSize; /* Sector size of the device file is on */
int szChunk; /* Chunk size */
#ifdef __WIN_CE__
WCHAR *zDeleteOnClose; /* Name of file to delete when closing */
HANDLE hMutex; /* Mutex used to control access to shared lock */
HANDLE hShared; /* Shared memory segment used for locking */
winceLock local; /* Locks obtained by this instance of winFile */
winceLock *shared; /* Global shared lock memory for the file */
#endif
};
/*
** Convert a UTF-8 string to microsoft unicode (UTF-16?).
**
** Space to hold the returned string is obtained from HeapAlloc().
*/
static WCHAR *utf8ToUnicode(const char *zFilename){
int nChar;
WCHAR *zWideFilename;
nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, 0, 0);
zWideFilename = (WCHAR *)HeapAlloc(GetProcessHeap(),0,nChar*sizeof(zWideFilename[0]) );
if( zWideFilename==0 ){
return 0;
}
nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
if( nChar==0 ){
HeapFree(GetProcessHeap(),0,zWideFilename);
zWideFilename = 0;
}
return zWideFilename;
}
/*
** Convert microsoft unicode to UTF-8. Space to hold the returned string is
** obtained from malloc().
*/
static char *unicodeToUtf8(const WCHAR *zWideFilename){
int nByte;
char *zFilename;
nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
zFilename = (char *)HeapAlloc(GetProcessHeap(),0,nByte );
if( zFilename==0 ){
return 0;
}
nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
0, 0);
if( nByte == 0 ){
HeapFree(GetProcessHeap(),0,zFilename);
zFilename = 0;
}
return zFilename;
}
/*
** Convert an ansi string to microsoft unicode, based on the
** current codepage settings for file apis.
**
** Space to hold the returned string is obtained
** from malloc.
*/
static WCHAR *mbcsToUnicode(const char *zFilename){
int nByte;
WCHAR *zMbcsFilename;
int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, 0,0)*sizeof(WCHAR);
zMbcsFilename = (WCHAR *)HeapAlloc(GetProcessHeap(),0,nByte*sizeof(zMbcsFilename[0]) );
if( zMbcsFilename==0 ){
return 0;
}
nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
if( nByte==0 ){
HeapFree(GetProcessHeap(),0,zMbcsFilename);
zMbcsFilename = 0;
}
return zMbcsFilename;
}
/*
** Convert multibyte character string to UTF-8. Space to hold the
** returned string is obtained from malloc().
*/
char *unqlite_win32_mbcs_to_utf8(const char *zFilename){
char *zFilenameUtf8;
WCHAR *zTmpWide;
zTmpWide = mbcsToUnicode(zFilename);
if( zTmpWide==0 ){
return 0;
}
zFilenameUtf8 = unicodeToUtf8(zTmpWide);
HeapFree(GetProcessHeap(),0,zTmpWide);
return zFilenameUtf8;
}
/*
** Some microsoft compilers lack this definition.
*/
#ifndef INVALID_SET_FILE_POINTER
# define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif
/*
** Move the current position of the file handle passed as the first
** argument to offset iOffset within the file. If successful, return 0.
** Otherwise, set pFile->lastErrno and return non-zero.
*/
static int seekWinFile(winFile *pFile, unqlite_int64 iOffset){
LONG upperBits; /* Most sig. 32 bits of new offset */
LONG lowerBits; /* Least sig. 32 bits of new offset */
DWORD dwRet; /* Value returned by SetFilePointer() */
upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
lowerBits = (LONG)(iOffset & 0xffffffff);
/* API oddity: If successful, SetFilePointer() returns a dword
** containing the lower 32-bits of the new file-offset. Or, if it fails,
** it returns INVALID_SET_FILE_POINTER. However according to MSDN,
** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
** whether an error has actually occured, it is also necessary to call
** GetLastError().
*/
dwRet = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
if( (dwRet==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR) ){
pFile->lastErrno = GetLastError();
return 1;
}
return 0;
}
/*
** Close a file.
**
** It is reported that an attempt to close a handle might sometimes
** fail. This is a very unreasonable result, but windows is notorious
** for being unreasonable so I do not doubt that it might happen. If
** the close fails, we pause for 100 milliseconds and try again. As
** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
** giving up and returning an error.
*/
#define MX_CLOSE_ATTEMPT 3
static int winClose(unqlite_file *id)
{
int rc, cnt = 0;
winFile *pFile = (winFile*)id;
do{
rc = CloseHandle(pFile->h);
}while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
return rc ? UNQLITE_OK : UNQLITE_IOERR;
}
/*
** Read data from a file into a buffer. Return UNQLITE_OK if all
** bytes were read successfully and UNQLITE_IOERR if anything goes
** wrong.
*/
static int winRead(
unqlite_file *id, /* File to read from */
void *pBuf, /* Write content into this buffer */
unqlite_int64 amt, /* Number of bytes to read */
unqlite_int64 offset /* Begin reading at this offset */
){
winFile *pFile = (winFile*)id; /* file handle */
DWORD nRead; /* Number of bytes actually read from file */
if( seekWinFile(pFile, offset) ){
return UNQLITE_FULL;
}
if( !ReadFile(pFile->h, pBuf, (DWORD)amt, &nRead, 0) ){
pFile->lastErrno = GetLastError();
return UNQLITE_IOERR;
}
if( nRead<(DWORD)amt ){
/* Unread parts of the buffer must be zero-filled */
SyZero(&((char*)pBuf)[nRead],(sxu32)(amt-nRead));
return UNQLITE_IOERR;
}
return UNQLITE_OK;
}
/*
** Write data from a buffer into a file. Return UNQLITE_OK on success
** or some other error code on failure.
*/
static int winWrite(
unqlite_file *id, /* File to write into */
const void *pBuf, /* The bytes to be written */
unqlite_int64 amt, /* Number of bytes to write */
unqlite_int64 offset /* Offset into the file to begin writing at */
){
int rc; /* True if error has occured, else false */
winFile *pFile = (winFile*)id; /* File handle */
rc = seekWinFile(pFile, offset);
if( rc==0 ){
sxu8 *aRem = (sxu8 *)pBuf; /* Data yet to be written */
unqlite_int64 nRem = amt; /* Number of bytes yet to be written */
DWORD nWrite; /* Bytes written by each WriteFile() call */
while( nRem>0 && WriteFile(pFile->h, aRem, (DWORD)nRem, &nWrite, 0) && nWrite>0 ){
aRem += nWrite;
nRem -= nWrite;
}
if( nRem>0 ){
pFile->lastErrno = GetLastError();
rc = 1;
}
}
if( rc ){
if( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ){
return UNQLITE_FULL;
}
return UNQLITE_IOERR;
}
return UNQLITE_OK;
}
/*
** Truncate an open file to a specified size
*/
static int winTruncate(unqlite_file *id, unqlite_int64 nByte){
winFile *pFile = (winFile*)id; /* File handle object */
int rc = UNQLITE_OK; /* Return code for this function */
/* If the user has configured a chunk-size for this file, truncate the
** file so that it consists of an integer number of chunks (i.e. the
** actual file size after the operation may be larger than the requested
** size).
*/
if( pFile->szChunk ){
nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
}
/* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
if( seekWinFile(pFile, nByte) ){
rc = UNQLITE_IOERR;
}else if( 0==SetEndOfFile(pFile->h) ){
pFile->lastErrno = GetLastError();
rc = UNQLITE_IOERR;
}
return rc;
}
/*
** Make sure all writes to a particular file are committed to disk.
*/
static int winSync(unqlite_file *id, int flags){
winFile *pFile = (winFile*)id;
SXUNUSED(flags); /* MSVC warning */
if( FlushFileBuffers(pFile->h) ){
return UNQLITE_OK;
}else{
pFile->lastErrno = GetLastError();
return UNQLITE_IOERR;
}
}
/*
** Determine the current size of a file in bytes
*/
static int winFileSize(unqlite_file *id, unqlite_int64 *pSize){
DWORD upperBits;
DWORD lowerBits;
winFile *pFile = (winFile*)id;
DWORD error;
lowerBits = GetFileSize(pFile->h, &upperBits);
if( (lowerBits == INVALID_FILE_SIZE)
&& ((error = GetLastError()) != NO_ERROR) )
{
pFile->lastErrno = error;
return UNQLITE_IOERR;
}
*pSize = (((unqlite_int64)upperBits)<<32) + lowerBits;
return UNQLITE_OK;
}
/*
** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
*/
#ifndef LOCKFILE_FAIL_IMMEDIATELY
# define LOCKFILE_FAIL_IMMEDIATELY 1
#endif
/*
** Acquire a reader lock.
*/
static int getReadLock(winFile *pFile){
int res;
OVERLAPPED ovlp;
ovlp.Offset = SHARED_FIRST;
ovlp.OffsetHigh = 0;
ovlp.hEvent = 0;
res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,0, SHARED_SIZE, 0, &ovlp);
if( res == 0 ){
pFile->lastErrno = GetLastError();
}
return res;
}
/*
** Undo a readlock
*/
static int unlockReadLock(winFile *pFile){
int res;
res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
if( res == 0 ){
pFile->lastErrno = GetLastError();
}
return res;
}
/*
** Lock the file with the lock specified by parameter locktype - one
** of the following:
**
** (1) SHARED_LOCK
** (2) RESERVED_LOCK
** (3) PENDING_LOCK
** (4) EXCLUSIVE_LOCK
**
** Sometimes when requesting one lock state, additional lock states
** are inserted in between. The locking might fail on one of the later
** transitions leaving the lock state different from what it started but
** still short of its goal. The following chart shows the allowed
** transitions and the inserted intermediate states:
**
** UNLOCKED -> SHARED
** SHARED -> RESERVED
** SHARED -> (PENDING) -> EXCLUSIVE
** RESERVED -> (PENDING) -> EXCLUSIVE
** PENDING -> EXCLUSIVE
**
** This routine will only increase a lock. The winUnlock() routine
** erases all locks at once and returns us immediately to locking level 0.
** It is not possible to lower the locking level one step at a time. You
** must go straight to locking level 0.
*/
static int winLock(unqlite_file *id, int locktype){
int rc = UNQLITE_OK; /* Return code from subroutines */
int res = 1; /* Result of a windows lock call */
int newLocktype; /* Set pFile->locktype to this value before exiting */
int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
winFile *pFile = (winFile*)id;
DWORD error = NO_ERROR;
/* If there is already a lock of this type or more restrictive on the
** OsFile, do nothing.
*/
if( pFile->locktype>=locktype ){
return UNQLITE_OK;
}
/* Make sure the locking sequence is correct
assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
assert( locktype!=PENDING_LOCK );
assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
*/
/* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
** the PENDING_LOCK byte is temporary.
*/
newLocktype = pFile->locktype;
if( (pFile->locktype==NO_LOCK)
|| ( (locktype==EXCLUSIVE_LOCK)
&& (pFile->locktype==RESERVED_LOCK))
){
int cnt = 3;
while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
/* Try 3 times to get the pending lock. The pending lock might be
** held by another reader process who will release it momentarily.
*/
Sleep(1);
}
gotPendingLock = res;
if( !res ){
error = GetLastError();
}
}
/* Acquire a shared lock
*/
if( locktype==SHARED_LOCK && res ){
/* assert( pFile->locktype==NO_LOCK ); */
res = getReadLock(pFile);
if( res ){
newLocktype = SHARED_LOCK;
}else{
error = GetLastError();
}
}
/* Acquire a RESERVED lock
*/
if( locktype==RESERVED_LOCK && res ){
/* assert( pFile->locktype==SHARED_LOCK ); */
res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
if( res ){
newLocktype = RESERVED_LOCK;
}else{
error = GetLastError();
}
}
/* Acquire a PENDING lock
*/
if( locktype==EXCLUSIVE_LOCK && res ){
newLocktype = PENDING_LOCK;
gotPendingLock = 0;
}
/* Acquire an EXCLUSIVE lock
*/
if( locktype==EXCLUSIVE_LOCK && res ){
/* assert( pFile->locktype>=SHARED_LOCK ); */
res = unlockReadLock(pFile);
res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
if( res ){
newLocktype = EXCLUSIVE_LOCK;
}else{
error = GetLastError();
getReadLock(pFile);
}
}
/* If we are holding a PENDING lock that ought to be released, then
** release it now.
*/
if( gotPendingLock && locktype==SHARED_LOCK ){
UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
}
/* Update the state of the lock has held in the file descriptor then
** return the appropriate result code.
*/
if( res ){
rc = UNQLITE_OK;
}else{
pFile->lastErrno = error;
rc = UNQLITE_BUSY;
}
pFile->locktype = (sxu8)newLocktype;
return rc;
}
/*
** This routine checks if there is a RESERVED lock held on the specified
** file by this or any other process. If such a lock is held, return
** non-zero, otherwise zero.
*/
static int winCheckReservedLock(unqlite_file *id, int *pResOut){
int rc;
winFile *pFile = (winFile*)id;
if( pFile->locktype>=RESERVED_LOCK ){
rc = 1;
}else{
rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
if( rc ){
UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
}
rc = !rc;
}
*pResOut = rc;
return UNQLITE_OK;
}
/*
** Lower the locking level on file descriptor id to locktype. locktype
** must be either NO_LOCK or SHARED_LOCK.
**
** If the locking level of the file descriptor is already at or below
** the requested locking level, this routine is a no-op.
**
** It is not possible for this routine to fail if the second argument
** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
** might return UNQLITE_IOERR;
*/
static int winUnlock(unqlite_file *id, int locktype){
int type;
winFile *pFile = (winFile*)id;
int rc = UNQLITE_OK;
type = pFile->locktype;
if( type>=EXCLUSIVE_LOCK ){
UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
/* This should never happen. We should always be able to
** reacquire the read lock */
rc = UNQLITE_IOERR;
}
}
if( type>=RESERVED_LOCK ){
UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
}
if( locktype==NO_LOCK && type>=SHARED_LOCK ){
unlockReadLock(pFile);
}
if( type>=PENDING_LOCK ){
UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
}
pFile->locktype = (sxu8)locktype;
return rc;
}
/*
** Return the sector size in bytes of the underlying block device for
** the specified file. This is almost always 512 bytes, but may be
** larger for some devices.
**
*/
static int winSectorSize(unqlite_file *id){
return (int)(((winFile*)id)->sectorSize);
}
/*
** This vector defines all the methods that can operate on an
** unqlite_file for Windows systems.
*/
static const unqlite_io_methods winIoMethod = {
1, /* iVersion */
winClose, /* xClose */
winRead, /* xRead */
winWrite, /* xWrite */
winTruncate, /* xTruncate */
winSync, /* xSync */
winFileSize, /* xFileSize */
winLock, /* xLock */
winUnlock, /* xUnlock */
winCheckReservedLock, /* xCheckReservedLock */
winSectorSize, /* xSectorSize */
};
/*
* Windows VFS Methods.
*/
/*
** Convert a UTF-8 filename into whatever form the underlying
** operating system wants filenames in. Space to hold the result
** is obtained from malloc and must be freed by the calling
** function.
*/
static void *convertUtf8Filename(const char *zFilename)
{
void *zConverted;
zConverted = utf8ToUnicode(zFilename);
/* caller will handle out of memory */
return zConverted;
}
/*
** Delete the named file.
**
** Note that windows does not allow a file to be deleted if some other
** process has it open. Sometimes a virus scanner or indexing program
** will open a journal file shortly after it is created in order to do
** whatever it does. While this other process is holding the
** file open, we will be unable to delete it. To work around this
** problem, we delay 100 milliseconds and try to delete again. Up
** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
** up and returning an error.
*/
#define MX_DELETION_ATTEMPTS 5
static int winDelete(
unqlite_vfs *pVfs, /* Not used on win32 */
const char *zFilename, /* Name of file to delete */
int syncDir /* Not used on win32 */
){
int cnt = 0;
DWORD rc;
DWORD error = 0;
void *zConverted;
zConverted = convertUtf8Filename(zFilename);
if( zConverted==0 ){
SXUNUSED(pVfs);
SXUNUSED(syncDir);
return UNQLITE_NOMEM;
}
do{
DeleteFileW((LPCWSTR)zConverted);
}while( ( ((rc = GetFileAttributesW((LPCWSTR)zConverted)) != INVALID_FILE_ATTRIBUTES)
|| ((error = GetLastError()) == ERROR_ACCESS_DENIED))
&& (++cnt < MX_DELETION_ATTEMPTS)
&& (Sleep(100), 1)
);
HeapFree(GetProcessHeap(),0,zConverted);
return ( (rc == INVALID_FILE_ATTRIBUTES)
&& (error == ERROR_FILE_NOT_FOUND)) ? UNQLITE_OK : UNQLITE_IOERR;
}
/*
** Check the existance and status of a file.
*/
static int winAccess(
unqlite_vfs *pVfs, /* Not used */
const char *zFilename, /* Name of file to check */
int flags, /* Type of test to make on this file */
int *pResOut /* OUT: Result */
){
WIN32_FILE_ATTRIBUTE_DATA sAttrData;
DWORD attr;
int rc = 0;
void *zConverted;
SXUNUSED(pVfs);
zConverted = convertUtf8Filename(zFilename);
if( zConverted==0 ){
return UNQLITE_NOMEM;
}
SyZero(&sAttrData,sizeof(sAttrData));
if( GetFileAttributesExW((WCHAR*)zConverted,
GetFileExInfoStandard,
&sAttrData) ){
/* For an UNQLITE_ACCESS_EXISTS query, treat a zero-length file
** as if it does not exist.
*/
if( flags==UNQLITE_ACCESS_EXISTS
&& sAttrData.nFileSizeHigh==0
&& sAttrData.nFileSizeLow==0 ){
attr = INVALID_FILE_ATTRIBUTES;
}else{
attr = sAttrData.dwFileAttributes;
}
}else{
if( GetLastError()!=ERROR_FILE_NOT_FOUND ){
HeapFree(GetProcessHeap(),0,zConverted);
return UNQLITE_IOERR;
}else{
attr = INVALID_FILE_ATTRIBUTES;
}
}
HeapFree(GetProcessHeap(),0,zConverted);
switch( flags ){
case UNQLITE_ACCESS_READWRITE:
rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
break;
case UNQLITE_ACCESS_READ:
case UNQLITE_ACCESS_EXISTS:
default:
rc = attr!=INVALID_FILE_ATTRIBUTES;
break;
}
*pResOut = rc;
return UNQLITE_OK;
}
/*
** Turn a relative pathname into a full pathname. Write the full
** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
** bytes in size.
*/
static int winFullPathname(
unqlite_vfs *pVfs, /* Pointer to vfs object */
const char *zRelative, /* Possibly relative input path */
int nFull, /* Size of output buffer in bytes */
char *zFull /* Output buffer */
){
int nByte;
void *zConverted;
WCHAR *zTemp;
char *zOut;
SXUNUSED(nFull);
zConverted = convertUtf8Filename(zRelative);
if( zConverted == 0 ){
return UNQLITE_NOMEM;
}
nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
zTemp = (WCHAR *)HeapAlloc(GetProcessHeap(),0,nByte*sizeof(zTemp[0]) );
if( zTemp==0 ){
HeapFree(GetProcessHeap(),0,zConverted);
return UNQLITE_NOMEM;
}
GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
HeapFree(GetProcessHeap(),0,zConverted);
zOut = unicodeToUtf8(zTemp);
HeapFree(GetProcessHeap(),0,zTemp);
if( zOut == 0 ){
return UNQLITE_NOMEM;
}
Systrcpy(zFull,(sxu32)pVfs->mxPathname,zOut,0);
HeapFree(GetProcessHeap(),0,zOut);
return UNQLITE_OK;
}
/*
** Get the sector size of the device used to store
** file.
*/
static int getSectorSize(
unqlite_vfs *pVfs,
const char *zRelative /* UTF-8 file name */
){
DWORD bytesPerSector = UNQLITE_DEFAULT_SECTOR_SIZE;
char zFullpath[MAX_PATH+1];
int rc;
DWORD dwRet = 0;
DWORD dwDummy;
/*
** We need to get the full path name of the file
** to get the drive letter to look up the sector
** size.
*/
rc = winFullPathname(pVfs, zRelative, MAX_PATH, zFullpath);
if( rc == UNQLITE_OK )
{
void *zConverted = convertUtf8Filename(zFullpath);
if( zConverted ){
/* trim path to just drive reference */
WCHAR *p = (WCHAR *)zConverted;
for(;*p;p++){
if( *p == '\\' ){
*p = '\0';
break;
}
}
dwRet = GetDiskFreeSpaceW((WCHAR*)zConverted,
&dwDummy,
&bytesPerSector,
&dwDummy,
&dwDummy);
HeapFree(GetProcessHeap(),0,zConverted);
}
if( !dwRet ){
bytesPerSector = UNQLITE_DEFAULT_SECTOR_SIZE;
}
}
return (int) bytesPerSector;
}
/*
** Sleep for a little while. Return the amount of time slept.
*/
static int winSleep(unqlite_vfs *pVfs, int microsec){
Sleep((microsec+999)/1000);
SXUNUSED(pVfs);
return ((microsec+999)/1000)*1000;
}
/*
* Export the current system time.
*/
static int winCurrentTime(unqlite_vfs *pVfs,Sytm *pOut)
{
SYSTEMTIME sSys;
SXUNUSED(pVfs);
GetSystemTime(&sSys);
SYSTEMTIME_TO_SYTM(&sSys,pOut);
return UNQLITE_OK;
}
/*
** The idea is that this function works like a combination of
** GetLastError() and FormatMessage() on windows (or errno and
** strerror_r() on unix). After an error is returned by an OS
** function, UnQLite calls this function with zBuf pointing to
** a buffer of nBuf bytes. The OS layer should populate the
** buffer with a nul-terminated UTF-8 encoded error message
** describing the last IO error to have occurred within the calling
** thread.
**
** If the error message is too large for the supplied buffer,
** it should be truncated. The return value of xGetLastError
** is zero if the error message fits in the buffer, or non-zero
** otherwise (if the message was truncated). If non-zero is returned,
** then it is not necessary to include the nul-terminator character
** in the output buffer.
*/
static int winGetLastError(unqlite_vfs *pVfs, int nBuf, char *zBuf)
{
/* FormatMessage returns 0 on failure. Otherwise it
** returns the number of TCHARs written to the output
** buffer, excluding the terminating null char.
*/
DWORD error = GetLastError();
WCHAR *zTempWide = 0;
DWORD dwLen;
char *zOut = 0;
SXUNUSED(pVfs);
dwLen = FormatMessageW(
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
0,
error,
0,
(LPWSTR) &zTempWide,
0,
0
);
if( dwLen > 0 ){
/* allocate a buffer and convert to UTF8 */
zOut = unicodeToUtf8(zTempWide);
/* free the system buffer allocated by FormatMessage */
LocalFree(zTempWide);
}
if( 0 == dwLen ){
Systrcpy(zBuf,(sxu32)nBuf,"OS Error",sizeof("OS Error")-1);
}else{
/* copy a maximum of nBuf chars to output buffer */
Systrcpy(zBuf,(sxu32)nBuf,zOut,0 /* Compute input length automatically */);
/* free the UTF8 buffer */
HeapFree(GetProcessHeap(),0,zOut);
}
return 0;
}
/*
** Open a file.
*/
static int winOpen(
unqlite_vfs *pVfs, /* Not used */
const char *zName, /* Name of the file (UTF-8) */
unqlite_file *id, /* Write the UnQLite file handle here */
unsigned int flags /* Open mode flags */
){
HANDLE h;
DWORD dwDesiredAccess;
DWORD dwShareMode;
DWORD dwCreationDisposition;
DWORD dwFlagsAndAttributes = 0;
winFile *pFile = (winFile*)id;
void *zConverted; /* Filename in OS encoding */
const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
int isExclusive = (flags & UNQLITE_OPEN_EXCLUSIVE);
int isDelete = (flags & UNQLITE_OPEN_TEMP_DB);
int isCreate = (flags & UNQLITE_OPEN_CREATE);
int isReadWrite = (flags & UNQLITE_OPEN_READWRITE);
pFile->h = INVALID_HANDLE_VALUE;
/* Convert the filename to the system encoding. */
zConverted = convertUtf8Filename(zUtf8Name);
if( zConverted==0 ){
return UNQLITE_NOMEM;
}
if( isReadWrite ){
dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
}else{
dwDesiredAccess = GENERIC_READ;
}
/* UNQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
** created.
*/
if( isExclusive ){
/* Creates a new file, only if it does not already exist. */
/* If the file exists, it fails. */
dwCreationDisposition = CREATE_NEW;
}else if( isCreate ){
/* Open existing file, or create if it doesn't exist */
dwCreationDisposition = OPEN_ALWAYS;
}else{
/* Opens a file, only if it exists. */
dwCreationDisposition = OPEN_EXISTING;
}
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
if( isDelete ){
dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
| FILE_ATTRIBUTE_HIDDEN
| FILE_FLAG_DELETE_ON_CLOSE;
}else{
dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
}
h = CreateFileW((WCHAR*)zConverted,
dwDesiredAccess,
dwShareMode,
NULL,
dwCreationDisposition,
dwFlagsAndAttributes,
NULL
);
if( h==INVALID_HANDLE_VALUE ){
pFile->lastErrno = GetLastError();
HeapFree(GetProcessHeap(),0,zConverted);
return UNQLITE_IOERR;
}
SyZero(pFile,sizeof(*pFile));
pFile->pMethod = &winIoMethod;
pFile->h = h;
pFile->lastErrno = NO_ERROR;
pFile->pVfs = pVfs;
pFile->sectorSize = getSectorSize(pVfs, zUtf8Name);
HeapFree(GetProcessHeap(),0,zConverted);
return UNQLITE_OK;
}
/*
* Export the Windows Vfs.
*/
UNQLITE_PRIVATE const unqlite_vfs * unqliteExportBuiltinVfs(void)
{
static const unqlite_vfs sWinvfs = {
"Windows", /* Vfs name */
1, /* Vfs structure version */
sizeof(winFile), /* szOsFile */
MAX_PATH, /* mxPathName */
winOpen, /* xOpen */
winDelete, /* xDelete */
winAccess, /* xAccess */
winFullPathname, /* xFullPathname */
0, /* xTmp */
winSleep, /* xSleep */
winCurrentTime, /* xCurrentTime */
winGetLastError, /* xGetLastError */
};
return &sWinvfs;
}
#endif /* __WINNT__ */
/*
* ----------------------------------------------------------
* File: pager.c
* MD5: 57ff77347402fbf6892af589ff8a5df7
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: pager.c v1.1 Win7 2012-11-29 03:46 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/*
** This file implements the pager and the transaction manager for UnQLite (Mostly inspired from the SQLite3 Source tree).
**
** The Pager.eState variable stores the current 'state' of a pager. A
** pager may be in any one of the seven states shown in the following
** state diagram.
**
** OPEN <------+------+
** | | |
** V | |
** +---------> READER-------+ |
** | | |
** | V |
** |<-------WRITER_LOCKED--------->|
** | | |
** | V |
** |<------WRITER_CACHEMOD-------->|
** | | |
** | V |
** |<-------WRITER_DBMOD---------->|
** | | |
** | V |
** +<------WRITER_FINISHED-------->+
**
** OPEN:
**
** The pager starts up in this state. Nothing is guaranteed in this
** state - the file may or may not be locked and the database size is
** unknown. The database may not be read or written.
**
** * No read or write transaction is active.
** * Any lock, or no lock at all, may be held on the database file.
** * The dbSize and dbOrigSize variables may not be trusted.
**
** READER:
**
** In this state all the requirements for reading the database in
** rollback mode are met. Unless the pager is (or recently
** was) in exclusive-locking mode, a user-level read transaction is
** open. The database size is known in this state.
**
** * A read transaction may be active (but a write-transaction cannot).
** * A SHARED or greater lock is held on the database file.
** * The dbSize variable may be trusted (even if a user-level read
** transaction is not active). The dbOrigSize variables
** may not be trusted at this point.
** * Even if a read-transaction is not open, it is guaranteed that
** there is no hot-journal in the file-system.
**
** WRITER_LOCKED:
**
** The pager moves to this state from READER when a write-transaction
** is first opened on the database. In WRITER_LOCKED state, all locks
** required to start a write-transaction are held, but no actual
** modifications to the cache or database have taken place.
**
** In rollback mode, a RESERVED or (if the transaction was opened with
** EXCLUSIVE flag) EXCLUSIVE lock is obtained on the database file when
** moving to this state, but the journal file is not written to or opened
** to in this state. If the transaction is committed or rolled back while
** in WRITER_LOCKED state, all that is required is to unlock the database
** file.
**
** * A write transaction is active.
** * If the connection is open in rollback-mode, a RESERVED or greater
** lock is held on the database file.
** * The dbSize and dbOrigSize variables are all valid.
** * The contents of the pager cache have not been modified.
** * The journal file may or may not be open.
** * Nothing (not even the first header) has been written to the journal.
**
** WRITER_CACHEMOD:
**
** A pager moves from WRITER_LOCKED state to this state when a page is
** first modified by the upper layer. In rollback mode the journal file
** is opened (if it is not already open) and a header written to the
** start of it. The database file on disk has not been modified.
**
** * A write transaction is active.
** * A RESERVED or greater lock is held on the database file.
** * The journal file is open and the first header has been written
** to it, but the header has not been synced to disk.
** * The contents of the page cache have been modified.
**
** WRITER_DBMOD:
**
** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
** when it modifies the contents of the database file.
**
** * A write transaction is active.
** * An EXCLUSIVE or greater lock is held on the database file.
** * The journal file is open and the first header has been written
** and synced to disk.
** * The contents of the page cache have been modified (and possibly
** written to disk).
**
** WRITER_FINISHED:
**
** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
** state after the entire transaction has been successfully written into the
** database file. In this state the transaction may be committed simply
** by finalizing the journal file. Once in WRITER_FINISHED state, it is
** not possible to modify the database further. At this point, the upper
** layer must either commit or rollback the transaction.
**
** * A write transaction is active.
** * An EXCLUSIVE or greater lock is held on the database file.
** * All writing and syncing of journal and database data has finished.
** If no error occured, all that remains is to finalize the journal to
** commit the transaction. If an error did occur, the caller will need
** to rollback the transaction.
**
**
*/
#define PAGER_OPEN 0
#define PAGER_READER 1
#define PAGER_WRITER_LOCKED 2
#define PAGER_WRITER_CACHEMOD 3
#define PAGER_WRITER_DBMOD 4
#define PAGER_WRITER_FINISHED 5
/*
** Journal files begin with the following magic string. The data
** was obtained from /dev/random. It is used only as a sanity check.
**
** NOTE: These values must be different from the one used by SQLite3
** to avoid journal file collision.
**
*/
static const unsigned char aJournalMagic[] = {
0xa6, 0xe8, 0xcd, 0x2b, 0x1c, 0x92, 0xdb, 0x9f,
};
/*
** The journal header size for this pager. This is usually the same
** size as a single disk sector. See also setSectorSize().
*/
#define JOURNAL_HDR_SZ(pPager) (pPager->iSectorSize)
/*
* Database page handle.
* Each raw disk page is represented in memory by an instance
* of the following structure.
*/
typedef struct Page Page;
struct Page {
/* Must correspond to unqlite_page */
unsigned char *zData; /* Content of this page */
void *pUserData; /* Extra content */
pgno pgno; /* Page number for this page */
/**********************************************************************
** Elements above are public. All that follows is private to pcache.c
** and should not be accessed by other modules.
*/
Pager *pPager; /* The pager this page is part of */
int flags; /* Page flags defined below */
int nRef; /* Number of users of this page */
Page *pNext, *pPrev; /* A list of all pages */
Page *pDirtyNext; /* Next element in list of dirty pages */
Page *pDirtyPrev; /* Previous element in list of dirty pages */
Page *pNextCollide,*pPrevCollide; /* Collission chain */
Page *pNextHot,*pPrevHot; /* Hot dirty pages chain */
};
/* Bit values for Page.flags */
#define PAGE_DIRTY 0x002 /* Page has changed */
#define PAGE_NEED_SYNC 0x004 /* fsync the rollback journal before
** writing this page to the database */
#define PAGE_DONT_WRITE 0x008 /* Dont write page content to disk */
#define PAGE_NEED_READ 0x010 /* Content is unread */
#define PAGE_IN_JOURNAL 0x020 /* Page written to the journal */
#define PAGE_HOT_DIRTY 0x040 /* Hot dirty page */
#define PAGE_DONT_MAKE_HOT 0x080 /* Dont make this page Hot. In other words,
* do not link it to the hot dirty list.
*/
/*
* Each active database pager is represented by an instance of
* the following structure.
*/
struct Pager
{
SyMemBackend *pAllocator; /* Memory backend */
unqlite *pDb; /* DB handle that own this instance */
unqlite_kv_engine *pEngine; /* Underlying KV storage engine */
char *zFilename; /* Name of the database file */
char *zJournal; /* Name of the journal file */
unqlite_vfs *pVfs; /* Underlying virtual file system */
unqlite_file *pfd,*pjfd; /* File descriptors for database and journal */
pgno dbSize; /* Number of pages in the file */
pgno dbOrigSize; /* dbSize before the current change */
sxi64 dbByteSize; /* Database size in bytes */
void *pMmap; /* Read-only Memory view (mmap) of the whole file if requested (UNQLITE_OPEN_MMAP). */
sxu32 nRec; /* Number of pages written to the journal */
SyPRNGCtx sPrng; /* PRNG Context */
sxu32 cksumInit; /* Quasi-random value added to every checksum */
sxu32 iOpenFlags; /* Flag passed to unqlite_open() after processing */
sxi64 iJournalOfft; /* Journal offset we are reading from */
int (*xBusyHandler)(void *); /* Busy handler */
void *pBusyHandlerArg; /* First arg to xBusyHandler() */
void (*xPageUnpin)(void *); /* Page Unpin callback */
void (*xPageReload)(void *); /* Page Reload callback */
Bitvec *pVec; /* Bitmap */
Page *pHeader; /* Page one of the database (Unqlite header) */
Sytm tmCreate; /* Database creation time */
SyString sKv; /* Underlying Key/Value storage engine name */
int iState; /* Pager state */
int iLock; /* Lock state */
sxi32 iFlags; /* Control flags (see below) */
int is_mem; /* True for an in-memory database */
int is_rdonly; /* True for a read-only database */
int no_jrnl; /* TRUE to omit journaling */
int iPageSize; /* Page size in bytes (default 4K) */
int iSectorSize; /* Size of a single sector on disk */
unsigned char *zTmpPage; /* Temporary page */
Page *pFirstDirty; /* First dirty pages */
Page *pDirty; /* Transient list of dirty pages */
Page *pAll; /* List of all pages */
Page *pHotDirty; /* List of hot dirty pages */
Page *pFirstHot; /* First hot dirty page */
sxu32 nHot; /* Total number of hot dirty pages */
Page **apHash; /* Page table */
sxu32 nSize; /* apHash[] size: Must be a power of two */
sxu32 nPage; /* Total number of page loaded in memory */
sxu32 nCacheMax; /* Maximum page to cache*/
};
/* Control flags */
#define PAGER_CTRL_COMMIT_ERR 0x001 /* Commit error */
#define PAGER_CTRL_DIRTY_COMMIT 0x002 /* Dirty commit has been applied */
/*
** Read a 32-bit integer from the given file descriptor.
** All values are stored on disk as big-endian.
*/
static int ReadInt32(unqlite_file *pFd,sxu32 *pOut,sxi64 iOfft)
{
unsigned char zBuf[4];
int rc;
rc = unqliteOsRead(pFd,zBuf,sizeof(zBuf),iOfft);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianUnpack32(zBuf,pOut);
return UNQLITE_OK;
}
/*
** Read a 64-bit integer from the given file descriptor.
** All values are stored on disk as big-endian.
*/
static int ReadInt64(unqlite_file *pFd,sxu64 *pOut,sxi64 iOfft)
{
unsigned char zBuf[8];
int rc;
rc = unqliteOsRead(pFd,zBuf,sizeof(zBuf),iOfft);
if( rc != UNQLITE_OK ){
return rc;
}
SyBigEndianUnpack64(zBuf,pOut);
return UNQLITE_OK;
}
/*
** Write a 32-bit integer into the given file descriptor.
*/
static int WriteInt32(unqlite_file *pFd,sxu32 iNum,sxi64 iOfft)
{
unsigned char zBuf[4];
int rc;
SyBigEndianPack32(zBuf,iNum);
rc = unqliteOsWrite(pFd,zBuf,sizeof(zBuf),iOfft);
return rc;
}
/*
** Write a 64-bit integer into the given file descriptor.
*/
static int WriteInt64(unqlite_file *pFd,sxu64 iNum,sxi64 iOfft)
{
unsigned char zBuf[8];
int rc;
SyBigEndianPack64(zBuf,iNum);
rc = unqliteOsWrite(pFd,zBuf,sizeof(zBuf),iOfft);
return rc;
}
/*
** The maximum allowed sector size. 64KiB. If the xSectorsize() method
** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
** This could conceivably cause corruption following a power failure on
** such a system. This is currently an undocumented limit.
*/
#define MAX_SECTOR_SIZE 0x10000
/*
** Get the size of a single sector on disk.
** The sector size will be used used to determine the size
** and alignment of journal header and within created journal files.
**
** The default sector size is set to 512.
*/
static int GetSectorSize(unqlite_file *pFd)
{
int iSectorSize = UNQLITE_DEFAULT_SECTOR_SIZE;
if( pFd ){
iSectorSize = unqliteOsSectorSize(pFd);
if( iSectorSize < 32 ){
iSectorSize = 512;
}
if( iSectorSize > MAX_SECTOR_SIZE ){
iSectorSize = MAX_SECTOR_SIZE;
}
}
return iSectorSize;
}
/* Hash function for page number */
#define PAGE_HASH(PNUM) (PNUM)
/*
* Fetch a page from the cache.
*/
static Page * pager_fetch_page(Pager *pPager,pgno page_num)
{
Page *pEntry;
if( pPager->nPage < 1 ){
/* Don't bother hashing */
return 0;
}
/* Perform the lookup */
pEntry = pPager->apHash[PAGE_HASH(page_num) & (pPager->nSize - 1)];
for(;;){
if( pEntry == 0 ){
break;
}
if( pEntry->pgno == page_num ){
return pEntry;
}
/* Point to the next entry in the colission chain */
pEntry = pEntry->pNextCollide;
}
/* No such page */
return 0;
}
/*
* Allocate and initialize a new page.
*/
static Page * pager_alloc_page(Pager *pPager,pgno num_page)
{
Page *pNew;
pNew = (Page *)SyMemBackendPoolAlloc(pPager->pAllocator,sizeof(Page)+pPager->iPageSize);
if( pNew == 0 ){
return 0;
}
/* Zero the structure */
SyZero(pNew,sizeof(Page)+pPager->iPageSize);
/* Page data */
pNew->zData = (unsigned char *)&pNew[1];
/* Fill in the structure */
pNew->pPager = pPager;
pNew->nRef = 1;
pNew->pgno = num_page;
return pNew;
}
/*
* Increment the reference count of a given page.
*/
static void page_ref(Page *pPage)
{
if( pPage->pPager->pAllocator->pMutexMethods ){
SyMutexEnter(pPage->pPager->pAllocator->pMutexMethods, pPage->pPager->pAllocator->pMutex);
}
pPage->nRef++;
if( pPage->pPager->pAllocator->pMutexMethods ){
SyMutexLeave(pPage->pPager->pAllocator->pMutexMethods, pPage->pPager->pAllocator->pMutex);
}
}
/*
* Release an in-memory page after its reference count reach zero.
*/
static int pager_release_page(Pager *pPager,Page *pPage)
{
int rc = UNQLITE_OK;
if( !(pPage->flags & PAGE_DIRTY)){
/* Invoke the unpin callback if available */
if( pPager->xPageUnpin && pPage->pUserData ){
pPager->xPageUnpin(pPage->pUserData);
}
pPage->pUserData = 0;
SyMemBackendPoolFree(pPager->pAllocator,pPage);
}else{
/* Dirty page, it will be released later when a dirty commit
* or the final commit have been applied.
*/
rc = UNQLITE_LOCKED;
}
return rc;
}
/* Forward declaration */
static int pager_unlink_page(Pager *pPager,Page *pPage);
/*
* Decrement the reference count of a given page.
*/
static void page_unref(Page *pPage)
{
int nRef;
if( pPage->pPager->pAllocator->pMutexMethods ){
SyMutexEnter(pPage->pPager->pAllocator->pMutexMethods, pPage->pPager->pAllocator->pMutex);
}
nRef = pPage->nRef--;
if( pPage->pPager->pAllocator->pMutexMethods ){
SyMutexLeave(pPage->pPager->pAllocator->pMutexMethods, pPage->pPager->pAllocator->pMutex);
}
if( nRef == 0){
Pager *pPager = pPage->pPager;
if( !(pPage->flags & PAGE_DIRTY) ){
pager_unlink_page(pPager,pPage);
/* Release the page */
pager_release_page(pPager,pPage);
}else{
if( pPage->flags & PAGE_DONT_MAKE_HOT ){
/* Do not add this page to the hot dirty list */
return;
}
if( !(pPage->flags & PAGE_HOT_DIRTY) ){
/* Add to the hot dirty list */
pPage->pPrevHot = 0;
if( pPager->pFirstHot == 0 ){
pPager->pFirstHot = pPager->pHotDirty = pPage;
}else{
pPage->pNextHot = pPager->pHotDirty;
if( pPager->pHotDirty ){
pPager->pHotDirty->pPrevHot = pPage;
}
pPager->pHotDirty = pPage;
}
pPager->nHot++;
pPage->flags |= PAGE_HOT_DIRTY;
}
}
}
}
/*
* Link a freshly created page to the list of active page.
*/
static int pager_link_page(Pager *pPager,Page *pPage)
{
sxu32 nBucket;
/* Install in the corresponding bucket */
nBucket = PAGE_HASH(pPage->pgno) & (pPager->nSize - 1);
pPage->pNextCollide = pPager->apHash[nBucket];
if( pPager->apHash[nBucket] ){
pPager->apHash[nBucket]->pPrevCollide = pPage;
}
pPager->apHash[nBucket] = pPage;
/* Link to the list of active pages */
MACRO_LD_PUSH(pPager->pAll,pPage);
pPager->nPage++;
if( (pPager->nPage >= pPager->nSize * 4) && pPager->nPage < 100000 ){
/* Grow the hashtable */
sxu32 nNewSize = pPager->nSize << 1;
Page *pEntry,**apNew;
sxu32 n;
apNew = (Page **)SyMemBackendAlloc(pPager->pAllocator, nNewSize * sizeof(Page *));
if( apNew ){
sxu32 iBucket;
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(Page *));
/* Rehash all entries */
n = 0;
pEntry = pPager->pAll;
for(;;){
/* Loop one */
if( n >= pPager->nPage ){
break;
}
pEntry->pNextCollide = pEntry->pPrevCollide = 0;
/* Install in the new bucket */
iBucket = PAGE_HASH(pEntry->pgno) & (nNewSize - 1);
pEntry->pNextCollide = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevCollide = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(pPager->pAllocator,(void *)pPager->apHash);
pPager->apHash = apNew;
pPager->nSize = nNewSize;
}
}
return UNQLITE_OK;
}
/*
* Unlink a page from the list of active pages.
*/
static int pager_unlink_page(Pager *pPager,Page *pPage)
{
if( pPage->pNextCollide ){
pPage->pNextCollide->pPrevCollide = pPage->pPrevCollide;
}
if( pPage->pPrevCollide ){
pPage->pPrevCollide->pNextCollide = pPage->pNextCollide;
}else{
sxu32 nBucket = PAGE_HASH(pPage->pgno) & (pPager->nSize - 1);
pPager->apHash[nBucket] = pPage->pNextCollide;
}
MACRO_LD_REMOVE(pPager->pAll,pPage);
pPager->nPage--;
return UNQLITE_OK;
}
/*
* Update the content of a cached page.
*/
static int pager_fill_page(Pager *pPager,pgno iNum,void *pContents)
{
Page *pPage;
/* Fetch the page from the catch */
pPage = pager_fetch_page(pPager,iNum);
if( pPage == 0 ){
return SXERR_NOTFOUND;
}
/* Reflect the change */
SyMemcpy(pContents,pPage->zData,pPager->iPageSize);
return UNQLITE_OK;
}
/*
* Read the content of a page from disk.
*/
static int pager_get_page_contents(Pager *pPager,Page *pPage,int noContent)
{
int rc = UNQLITE_OK;
if( pPager->is_mem || noContent || pPage->pgno >= pPager->dbSize ){
/* Do not bother reading, zero the page contents only */
SyZero(pPage->zData,pPager->iPageSize);
return UNQLITE_OK;
}
if( (pPager->iOpenFlags & UNQLITE_OPEN_MMAP) && (pPager->pMmap /* Paranoid edition */) ){
unsigned char *zMap = (unsigned char *)pPager->pMmap;
pPage->zData = &zMap[pPage->pgno * pPager->iPageSize];
}else{
/* Read content */
rc = unqliteOsRead(pPager->pfd,pPage->zData,pPager->iPageSize,pPage->pgno * pPager->iPageSize);
}
return rc;
}
/*
* Add a page to the dirty list.
*/
static void pager_page_to_dirty_list(Pager *pPager,Page *pPage)
{
if( pPage->flags & PAGE_DIRTY ){
/* Already set */
return;
}
/* Mark the page as dirty */
pPage->flags |= PAGE_DIRTY|PAGE_NEED_SYNC|PAGE_IN_JOURNAL;
/* Link to the list */
pPage->pDirtyPrev = 0;
pPage->pDirtyNext = pPager->pDirty;
if( pPager->pDirty ){
pPager->pDirty->pDirtyPrev = pPage;
}
pPager->pDirty = pPage;
if( pPager->pFirstDirty == 0 ){
pPager->pFirstDirty = pPage;
}
}
/*
* Merge sort.
* The merge sort implementation is based on the one used by
* the PH7 Embeddable PHP Engine (http://ph7.symisc.net/).
*/
/*
** Inputs:
** a: A sorted, null-terminated linked list. (May be null).
** b: A sorted, null-terminated linked list. (May be null).
** cmp: A pointer to the comparison function.
**
** Return Value:
** A pointer to the head of a sorted list containing the elements
** of both a and b.
**
** Side effects:
** The "next", "prev" pointers for elements in the lists a and b are
** changed.
*/
static Page * page_merge_dirty(Page *pA, Page *pB)
{
Page result, *pTail;
/* Prevent compiler warning */
result.pDirtyNext = result.pDirtyPrev = 0;
pTail = &result;
while( pA && pB ){
if( pA->pgno < pB->pgno ){
pTail->pDirtyPrev = pA;
pA->pDirtyNext = pTail;
pTail = pA;
pA = pA->pDirtyPrev;
}else{
pTail->pDirtyPrev = pB;
pB->pDirtyNext = pTail;
pTail = pB;
pB = pB->pDirtyPrev;
}
}
if( pA ){
pTail->pDirtyPrev = pA;
pA->pDirtyNext = pTail;
}else if( pB ){
pTail->pDirtyPrev = pB;
pB->pDirtyNext = pTail;
}else{
pTail->pDirtyPrev = pTail->pDirtyNext = 0;
}
return result.pDirtyPrev;
}
/*
** Inputs:
** Map: Input hashmap
** cmp: A comparison function.
**
** Return Value:
** Sorted hashmap.
**
** Side effects:
** The "next" pointers for elements in list are changed.
*/
#define N_SORT_BUCKET 32
static Page * pager_get_dirty_pages(Pager *pPager)
{
Page *a[N_SORT_BUCKET], *p, *pIn;
sxu32 i;
if( pPager->pFirstDirty == 0 ){
/* Don't bother sorting, the list is already empty */
return 0;
}
SyZero(a, sizeof(a));
/* Point to the first inserted entry */
pIn = pPager->pFirstDirty;
while( pIn ){
p = pIn;
pIn = p->pDirtyPrev;
p->pDirtyPrev = 0;
for(i=0; i<N_SORT_BUCKET-1; i++){
if( a[i]==0 ){
a[i] = p;
break;
}else{
p = page_merge_dirty(a[i], p);
a[i] = 0;
}
}
if( i==N_SORT_BUCKET-1 ){
/* To get here, there need to be 2^(N_SORT_BUCKET) elements in he input list.
* But that is impossible.
*/
a[i] = page_merge_dirty(a[i], p);
}
}
p = a[0];
for(i=1; i<N_SORT_BUCKET; i++){
p = page_merge_dirty(p,a[i]);
}
p->pDirtyNext = 0;
return p;
}
/*
* See block comment above.
*/
static Page * page_merge_hot(Page *pA, Page *pB)
{
Page result, *pTail;
/* Prevent compiler warning */
result.pNextHot = result.pPrevHot = 0;
pTail = &result;
while( pA && pB ){
if( pA->pgno < pB->pgno ){
pTail->pPrevHot = pA;
pA->pNextHot = pTail;
pTail = pA;
pA = pA->pPrevHot;
}else{
pTail->pPrevHot = pB;
pB->pNextHot = pTail;
pTail = pB;
pB = pB->pPrevHot;
}
}
if( pA ){
pTail->pPrevHot = pA;
pA->pNextHot = pTail;
}else if( pB ){
pTail->pPrevHot = pB;
pB->pNextHot = pTail;
}else{
pTail->pPrevHot = pTail->pNextHot = 0;
}
return result.pPrevHot;
}
/*
** Inputs:
** Map: Input hashmap
** cmp: A comparison function.
**
** Return Value:
** Sorted hashmap.
**
** Side effects:
** The "next" pointers for elements in list are changed.
*/
#define N_SORT_BUCKET 32
static Page * pager_get_hot_pages(Pager *pPager)
{
Page *a[N_SORT_BUCKET], *p, *pIn;
sxu32 i;
if( pPager->pFirstHot == 0 ){
/* Don't bother sorting, the list is already empty */
return 0;
}
SyZero(a, sizeof(a));
/* Point to the first inserted entry */
pIn = pPager->pFirstHot;
while( pIn ){
p = pIn;
pIn = p->pPrevHot;
p->pPrevHot = 0;
for(i=0; i<N_SORT_BUCKET-1; i++){
if( a[i]==0 ){
a[i] = p;
break;
}else{
p = page_merge_hot(a[i], p);
a[i] = 0;
}
}
if( i==N_SORT_BUCKET-1 ){
/* To get here, there need to be 2^(N_SORT_BUCKET) elements in he input list.
* But that is impossible.
*/
a[i] = page_merge_hot(a[i], p);
}
}
p = a[0];
for(i=1; i<N_SORT_BUCKET; i++){
p = page_merge_hot(p,a[i]);
}
p->pNextHot = 0;
return p;
}
/*
** The format for the journal header is as follows:
** - 8 bytes: Magic identifying journal format.
** - 4 bytes: Number of records in journal.
** - 4 bytes: Random number used for page hash.
** - 8 bytes: Initial database page count.
** - 4 bytes: Sector size used by the process that wrote this journal.
** - 4 bytes: Database page size.
**
** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
*/
/*
** Open the journal file and extract its header information.
**
** If the header is read successfully, *pNRec is set to the number of
** page records following this header and *pDbSize is set to the size of the
** database before the transaction began, in pages. Also, pPager->cksumInit
** is set to the value read from the journal header. UNQLITE_OK is returned
** in this case.
**
** If the journal header file appears to be corrupted, UNQLITE_DONE is
** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
** cannot be read from the journal file an error code is returned.
*/
static int pager_read_journal_header(
Pager *pPager, /* Pager object */
sxu32 *pNRec, /* OUT: Value read from the nRec field */
pgno *pDbSize /* OUT: Value of original database size field */
)
{
sxu32 iPageSize,iSectorSize;
unsigned char zMagic[8];
sxi64 iHdrOfft;
sxi64 iSize;
int rc;
/* Offset to start reading from */
iHdrOfft = 0;
/* Get the size of the journal */
rc = unqliteOsFileSize(pPager->pjfd,&iSize);
if( rc != UNQLITE_OK ){
return UNQLITE_DONE;
}
/* If the journal file is too small, return UNQLITE_DONE. */
if( 32 /* Minimum sector size */> iSize ){
return UNQLITE_DONE;
}
/* Make sure we are dealing with a valid journal */
rc = unqliteOsRead(pPager->pjfd,zMagic,sizeof(zMagic),iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
if( SyMemcmp(zMagic,aJournalMagic,sizeof(zMagic)) != 0 ){
return UNQLITE_DONE;
}
iHdrOfft += sizeof(zMagic);
/* Read the first three 32-bit fields of the journal header: The nRec
** field, the checksum-initializer and the database size at the start
** of the transaction. Return an error code if anything goes wrong.
*/
rc = ReadInt32(pPager->pjfd,pNRec,iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
iHdrOfft += 4;
rc = ReadInt32(pPager->pjfd,&pPager->cksumInit,iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
iHdrOfft += 4;
rc = ReadInt64(pPager->pjfd,pDbSize,iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
iHdrOfft += 8;
/* Read the page-size and sector-size journal header fields. */
rc = ReadInt32(pPager->pjfd,&iSectorSize,iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
iHdrOfft += 4;
rc = ReadInt32(pPager->pjfd,&iPageSize,iHdrOfft);
if( rc != UNQLITE_OK ){
return rc;
}
/* Check that the values read from the page-size and sector-size fields
** are within range. To be 'in range', both values need to be a power
** of two greater than or equal to 512 or 32, and not greater than their
** respective compile time maximum limits.
*/
if( iPageSize < UNQLITE_MIN_PAGE_SIZE || iSectorSize<32
|| iPageSize > UNQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
|| ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
){
/* If the either the page-size or sector-size in the journal-header is
** invalid, then the process that wrote the journal-header must have
** crashed before the header was synced. In this case stop reading
** the journal file here.
*/
return UNQLITE_DONE;
}
/* Update the assumed sector-size to match the value used by
** the process that created this journal. If this journal was
** created by a process other than this one, then this routine
** is being called from within pager_playback(). The local value
** of Pager.sectorSize is restored at the end of that routine.
*/
pPager->iSectorSize = iSectorSize;
pPager->iPageSize = iPageSize;
/* Ready to rollback */
pPager->iJournalOfft = JOURNAL_HDR_SZ(pPager);
/* All done */
return UNQLITE_OK;
}
/*
* Write the journal header in the given memory buffer.
* The given buffer is big enough to hold the whole header.
*/
static int pager_write_journal_header(Pager *pPager,unsigned char *zBuf)
{
unsigned char *zPtr = zBuf;
/* 8 bytes magic number */
SyMemcpy(aJournalMagic,zPtr,sizeof(aJournalMagic));
zPtr += sizeof(aJournalMagic);
/* 4 bytes: Number of records in journal. */
SyBigEndianPack32(zPtr,0);
zPtr += 4;
/* 4 bytes: Random number used to compute page checksum. */
SyBigEndianPack32(zPtr,pPager->cksumInit);
zPtr += 4;
/* 8 bytes: Initial database page count. */
SyBigEndianPack64(zPtr,pPager->dbOrigSize);
zPtr += 8;
/* 4 bytes: Sector size used by the process that wrote this journal. */
SyBigEndianPack32(zPtr,(sxu32)pPager->iSectorSize);
zPtr += 4;
/* 4 bytes: Database page size. */
SyBigEndianPack32(zPtr,(sxu32)pPager->iPageSize);
return UNQLITE_OK;
}
/*
** Parameter aData must point to a buffer of pPager->pageSize bytes
** of data. Compute and return a checksum based ont the contents of the
** page of data and the current value of pPager->cksumInit.
**
** This is not a real checksum. It is really just the sum of the
** random initial value (pPager->cksumInit) and every 200th byte
** of the page data, starting with byte offset (pPager->pageSize%200).
** Each byte is interpreted as an 8-bit unsigned integer.
**
** Changing the formula used to compute this checksum results in an
** incompatible journal file format.
**
** If journal corruption occurs due to a power failure, the most likely
** scenario is that one end or the other of the record will be changed.
** It is much less likely that the two ends of the journal record will be
** correct and the middle be corrupt. Thus, this "checksum" scheme,
** though fast and simple, catches the mostly likely kind of corruption.
*/
static sxu32 pager_cksum(Pager *pPager,const unsigned char *zData)
{
sxu32 cksum = pPager->cksumInit; /* Checksum value to return */
int i = pPager->iPageSize-200; /* Loop counter */
while( i>0 ){
cksum += zData[i];
i -= 200;
}
return cksum;
}
/*
** Read a single page from the journal file opened on file descriptor
** jfd. Playback this one page. Update the offset to read from.
*/
static int pager_play_back_one_page(Pager *pPager,sxi64 *pOfft,unsigned char *zTmp)
{
unsigned char *zData = zTmp;
sxi64 iOfft; /* Offset to read from */
pgno iNum; /* Pager number */
sxu32 ckSum; /* Sanity check */
int rc;
/* Offset to start reading from */
iOfft = *pOfft;
/* Database page number */
rc = ReadInt64(pPager->pjfd,&iNum,iOfft);
if( rc != UNQLITE_OK ){ return rc; }
iOfft += 8;
/* Page data */
rc = unqliteOsRead(pPager->pjfd,zData,pPager->iPageSize,iOfft);
if( rc != UNQLITE_OK ){ return rc; }
iOfft += pPager->iPageSize;
/* Page cksum */
rc = ReadInt32(pPager->pjfd,&ckSum,iOfft);
if( rc != UNQLITE_OK ){ return rc; }
iOfft += 4;
/* Synchronize pointers */
*pOfft = iOfft;
/* Make sure we are dealing with a valid page */
if( ckSum != pager_cksum(pPager,zData) ){
/* Ignore that page */
return SXERR_IGNORE;
}
if( iNum >= pPager->dbSize ){
/* Ignore that page */
return UNQLITE_OK;
}
/* playback */
rc = unqliteOsWrite(pPager->pfd,zData,pPager->iPageSize,iNum * pPager->iPageSize);
if( rc == UNQLITE_OK ){
/* Flush the cache */
pager_fill_page(pPager,iNum,zData);
}
return rc;
}
/*
** Playback the journal and thus restore the database file to
** the state it was in before we started making changes.
**
** The journal file format is as follows:
**
** (1) 8 byte prefix. A copy of aJournalMagic[].
** (2) 4 byte big-endian integer which is the number of valid page records
** in the journal.
** (3) 4 byte big-endian integer which is the initial value for the
** sanity checksum.
** (4) 8 byte integer which is the number of pages to truncate the
** database to during a rollback.
** (5) 4 byte big-endian integer which is the sector size. The header
** is this many bytes in size.
** (6) 4 byte big-endian integer which is the page size.
** (7) zero padding out to the next sector size.
** (8) Zero or more pages instances, each as follows:
** + 4 byte page number.
** + pPager->pageSize bytes of data.
** + 4 byte checksum
**
** When we speak of the journal header, we mean the first 7 items above.
** Each entry in the journal is an instance of the 8th item.
**
** Call the value from the second bullet "nRec". nRec is the number of
** valid page entries in the journal. In most cases, you can compute the
** value of nRec from the size of the journal file. But if a power
** failure occurred while the journal was being written, it could be the
** case that the size of the journal file had already been increased but
** the extra entries had not yet made it safely to disk. In such a case,
** the value of nRec computed from the file size would be too large. For
** that reason, we always use the nRec value in the header.
**
** If the file opened as the journal file is not a well-formed
** journal file then all pages up to the first corrupted page are rolled
** back (or no pages if the journal header is corrupted). The journal file
** is then deleted and SQLITE_OK returned, just as if no corruption had
** been encountered.
**
** If an I/O or malloc() error occurs, the journal-file is not deleted
** and an error code is returned.
**
*/
static int pager_playback(Pager *pPager)
{
unsigned char *zTmp = 0; /* cc warning */
sxu32 n,nRec;
sxi64 iOfft;
int rc;
/* Read the journal header*/
rc = pager_read_journal_header(pPager,&nRec,&pPager->dbSize);
if( rc != UNQLITE_OK ){
if( rc == UNQLITE_DONE ){
goto end_playback;
}
unqliteGenErrorFormat(pPager->pDb,"IO error while reading journal file '%s' header",pPager->zJournal);
return rc;
}
/* Truncate the database back to its original size */
rc = unqliteOsTruncate(pPager->pfd,pPager->iPageSize * pPager->dbSize);
if( rc != UNQLITE_OK ){
unqliteGenError(pPager->pDb,"IO error while truncating database file");
return rc;
}
/* Allocate a temporary page */
zTmp = (unsigned char *)SyMemBackendAlloc(pPager->pAllocator,(sxu32)pPager->iPageSize);
if( zTmp == 0 ){
unqliteGenOutofMem(pPager->pDb);
return UNQLITE_NOMEM;
}
SyZero((void *)zTmp,(sxu32)pPager->iPageSize);
/* Copy original pages out of the journal and back into the
** database file and/or page cache.
*/
iOfft = pPager->iJournalOfft;
for( n = 0 ; n < nRec ; ++n ){
rc = pager_play_back_one_page(pPager,&iOfft,zTmp);
if( rc != UNQLITE_OK ){
if( rc != SXERR_IGNORE ){
unqliteGenError(pPager->pDb,"Page playback error");
goto end_playback;
}
}
}
end_playback:
/* Release the temp page */
SyMemBackendFree(pPager->pAllocator,(void *)zTmp);
if( rc == UNQLITE_OK ){
/* Sync the database file */
unqliteOsSync(pPager->pfd,UNQLITE_SYNC_FULL);
}
if( rc == UNQLITE_DONE ){
rc = UNQLITE_OK;
}
/* Return to the caller */
return rc;
}
/*
** Unlock the database file to level eLock, which must be either NO_LOCK
** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
** succeeds, set the Pager.iLock variable to match the (attempted) new lock.
**
** Except, if Pager.iLock is set to NO_LOCK when this function is
** called, do not modify it. See the comment above the #define of
** NO_LOCK for an explanation of this.
*/
static int pager_unlock_db(Pager *pPager, int eLock)
{
int rc = UNQLITE_OK;
if( pPager->iLock != NO_LOCK ){
rc = unqliteOsUnlock(pPager->pfd,eLock);
pPager->iLock = eLock;
}
return rc;
}
/*
** Lock the database file to level eLock, which must be either SHARED_LOCK,
** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
** Pager.eLock variable to the new locking state.
**
** Except, if Pager.eLock is set to NO_LOCK when this function is
** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
** See the comment above the #define of NO_LOCK for an explanation
** of this.
*/
static int pager_lock_db(Pager *pPager, int eLock){
int rc = UNQLITE_OK;
if( pPager->iLock < eLock || pPager->iLock == NO_LOCK ){
rc = unqliteOsLock(pPager->pfd, eLock);
if( rc==UNQLITE_OK ){
pPager->iLock = eLock;
}else{
unqliteGenError(pPager->pDb,
rc == UNQLITE_BUSY ? "Another process or thread hold the requested lock" : "Error while requesting database lock"
);
}
}
return rc;
}
/*
** Try to obtain a lock of type locktype on the database file. If
** a similar or greater lock is already held, this function is a no-op
** (returning UNQLITE_OK immediately).
**
** Otherwise, attempt to obtain the lock using unqliteOsLock(). Invoke
** the busy callback if the lock is currently not available. Repeat
** until the busy callback returns false or until the attempt to
** obtain the lock succeeds.
**
** Return UNQLITE_OK on success and an error code if we cannot obtain
** the lock. If the lock is obtained successfully, set the Pager.state
** variable to locktype before returning.
*/
static int pager_wait_on_lock(Pager *pPager, int locktype){
int rc; /* Return code */
do {
rc = pager_lock_db(pPager,locktype);
}while( rc==UNQLITE_BUSY && pPager->xBusyHandler && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
return rc;
}
/*
** This function is called after transitioning from PAGER_OPEN to
** PAGER_SHARED state. It tests if there is a hot journal present in
** the file-system for the given pager. A hot journal is one that
** needs to be played back. According to this function, a hot-journal
** file exists if the following criteria are met:
**
** * The journal file exists in the file system, and
** * No process holds a RESERVED or greater lock on the database file, and
** * The database file itself is greater than 0 bytes in size, and
** * The first byte of the journal file exists and is not 0x00.
**
** If the current size of the database file is 0 but a journal file
** exists, that is probably an old journal left over from a prior
** database with the same name. In this case the journal file is
** just deleted using OsDelete, *pExists is set to 0 and UNQLITE_OK
** is returned.
**
** If a hot-journal file is found to exist, *pExists is set to 1 and
** UNQLITE_OK returned. If no hot-journal file is present, *pExists is
** set to 0 and UNQLITE_OK returned. If an IO error occurs while trying
** to determine whether or not a hot-journal file exists, the IO error
** code is returned and the value of *pExists is undefined.
*/
static int pager_has_hot_journal(Pager *pPager, int *pExists)
{
unqlite_vfs *pVfs = pPager->pVfs;
int rc = UNQLITE_OK; /* Return code */
int exists = 1; /* True if a journal file is present */
*pExists = 0;
rc = unqliteOsAccess(pVfs, pPager->zJournal, UNQLITE_ACCESS_EXISTS, &exists);
if( rc==UNQLITE_OK && exists ){
int locked = 0; /* True if some process holds a RESERVED lock */
/* Race condition here: Another process might have been holding the
** the RESERVED lock and have a journal open at the unqliteOsAccess()
** call above, but then delete the journal and drop the lock before
** we get to the following unqliteOsCheckReservedLock() call. If that
** is the case, this routine might think there is a hot journal when
** in fact there is none. This results in a false-positive which will
** be dealt with by the playback routine.
*/
rc = unqliteOsCheckReservedLock(pPager->pfd, &locked);
if( rc==UNQLITE_OK && !locked ){
sxi64 n = 0; /* Size of db file in bytes */
/* Check the size of the database file. If it consists of 0 pages,
** then delete the journal file. See the header comment above for
** the reasoning here. Delete the obsolete journal file under
** a RESERVED lock to avoid race conditions.
*/
rc = unqliteOsFileSize(pPager->pfd,&n);
if( rc==UNQLITE_OK ){
if( n < 1 ){
if( pager_lock_db(pPager, RESERVED_LOCK)==UNQLITE_OK ){
unqliteOsDelete(pVfs, pPager->zJournal, 0);
pager_unlock_db(pPager, SHARED_LOCK);
}
}else{
/* The journal file exists and no other connection has a reserved
** or greater lock on the database file. */
*pExists = 1;
}
}
}
}
return rc;
}
/*
* Rollback a journal file. (See block-comment above).
*/
static int pager_journal_rollback(Pager *pPager,int check_hot)
{
int rc;
if( check_hot ){
int iExists = 0; /* cc warning */
/* Check if the journal file exists */
rc = pager_has_hot_journal(pPager,&iExists);
if( rc != UNQLITE_OK ){
/* IO error */
return rc;
}
if( !iExists ){
/* Journal file does not exists */
return UNQLITE_OK;
}
}
if( pPager->is_rdonly ){
unqliteGenErrorFormat(pPager->pDb,
"Cannot rollback journal file '%s' due to a read-only database handle",pPager->zJournal);
return UNQLITE_READ_ONLY;
}
/* Get an EXCLUSIVE lock on the database file. At this point it is
** important that a RESERVED lock is not obtained on the way to the
** EXCLUSIVE lock. If it were, another process might open the
** database file, detect the RESERVED lock, and conclude that the
** database is safe to read while this process is still rolling the
** hot-journal back.
**
** Because the intermediate RESERVED lock is not requested, any
** other process attempting to access the database file will get to
** this point in the code and fail to obtain its own EXCLUSIVE lock
** on the database file.
**
** Unless the pager is in locking_mode=exclusive mode, the lock is
** downgraded to SHARED_LOCK before this function returns.
*/
/* Open the journal file */
rc = unqliteOsOpen(pPager->pVfs,pPager->pAllocator,pPager->zJournal,&pPager->pjfd,UNQLITE_OPEN_READWRITE);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pPager->pDb,"IO error while opening journal file: '%s'",pPager->zJournal);
goto fail;
}
rc = pager_lock_db(pPager,EXCLUSIVE_LOCK);
if( rc != UNQLITE_OK ){
unqliteGenError(pPager->pDb,"Cannot acquire an exclusive lock on the database while journal rollback");
goto fail;
}
/* Sync the journal file */
unqliteOsSync(pPager->pjfd,UNQLITE_SYNC_NORMAL);
/* Finally rollback the database */
rc = pager_playback(pPager);
/* Switch back to shared lock */
pager_unlock_db(pPager,SHARED_LOCK);
fail:
/* Close the journal handle */
unqliteOsCloseFree(pPager->pAllocator,pPager->pjfd);
pPager->pjfd = 0;
if( rc == UNQLITE_OK ){
/* Delete the journal file */
unqliteOsDelete(pPager->pVfs,pPager->zJournal,TRUE);
}
return rc;
}
/*
* Write the unqlite header (First page). (Big-Endian)
*/
static int pager_write_db_header(Pager *pPager)
{
unsigned char *zRaw = pPager->pHeader->zData;
unqlite_kv_engine *pEngine = pPager->pEngine;
sxu32 nDos;
sxu16 nLen;
/* Database signature */
SyMemcpy(UNQLITE_DB_SIG,zRaw,sizeof(UNQLITE_DB_SIG)-1);
zRaw += sizeof(UNQLITE_DB_SIG)-1;
/* Database magic number */
SyBigEndianPack32(zRaw,UNQLITE_DB_MAGIC);
zRaw += 4; /* 4 byte magic number */
/* Database creation time */
SyZero(&pPager->tmCreate,sizeof(Sytm));
if( pPager->pVfs->xCurrentTime ){
pPager->pVfs->xCurrentTime(pPager->pVfs,&pPager->tmCreate);
}
/* DOS time format (4 bytes) */
SyTimeFormatToDos(&pPager->tmCreate,&nDos);
SyBigEndianPack32(zRaw,nDos);
zRaw += 4; /* 4 byte DOS time */
/* Sector size */
SyBigEndianPack32(zRaw,(sxu32)pPager->iSectorSize);
zRaw += 4; /* 4 byte sector size */
/* Page size */
SyBigEndianPack32(zRaw,(sxu32)pPager->iPageSize);
zRaw += 4; /* 4 byte page size */
/* Key value storage engine */
nLen = (sxu16)SyStrlen(pEngine->pIo->pMethods->zName);
SyBigEndianPack16(zRaw,nLen); /* 2 byte storage engine name */
zRaw += 2;
SyMemcpy((const void *)pEngine->pIo->pMethods->zName,(void *)zRaw,nLen);
zRaw += nLen;
/* All rest are meta-data available to the host application */
return UNQLITE_OK;
}
/*
* Read the unqlite header (first page). (Big-Endian)
*/
static int pager_extract_header(Pager *pPager,const unsigned char *zRaw,sxu32 nByte)
{
const unsigned char *zEnd = &zRaw[nByte];
sxu32 nDos,iMagic;
sxu16 nLen;
char *zKv;
/* Database signature */
if( SyMemcmp(UNQLITE_DB_SIG,zRaw,sizeof(UNQLITE_DB_SIG)-1) != 0 ){
/* Corrupt database */
return UNQLITE_CORRUPT;
}
zRaw += sizeof(UNQLITE_DB_SIG)-1;
/* Database magic number */
SyBigEndianUnpack32(zRaw,&iMagic);
zRaw += 4; /* 4 byte magic number */
if( iMagic != UNQLITE_DB_MAGIC ){
/* Corrupt database */
return UNQLITE_CORRUPT;
}
/* Database creation time */
SyBigEndianUnpack32(zRaw,&nDos);
zRaw += 4; /* 4 byte DOS time format */
SyDosTimeFormat(nDos,&pPager->tmCreate);
/* Sector size */
SyBigEndianUnpack32(zRaw,(sxu32 *)&pPager->iSectorSize);
zRaw += 4; /* 4 byte sector size */
/* Page size */
SyBigEndianUnpack32(zRaw,(sxu32 *)&pPager->iPageSize);
zRaw += 4; /* 4 byte page size */
/* Check that the values read from the page-size and sector-size fields
** are within range. To be 'in range', both values need to be a power
** of two greater than or equal to 512 or 32, and not greater than their
** respective compile time maximum limits.
*/
if( pPager->iPageSize<UNQLITE_MIN_PAGE_SIZE || pPager->iSectorSize<32
|| pPager->iPageSize>UNQLITE_MAX_PAGE_SIZE || pPager->iSectorSize>MAX_SECTOR_SIZE
|| ((pPager->iPageSize<-1)&pPager->iPageSize)!=0 || ((pPager->iSectorSize-1)&pPager->iSectorSize)!=0
){
return UNQLITE_CORRUPT;
}
/* Key value storage engine */
SyBigEndianUnpack16(zRaw,&nLen); /* 2 byte storage engine length */
zRaw += 2;
if( nLen > (sxu16)(zEnd - zRaw) ){
nLen = (sxu16)(zEnd - zRaw);
}
zKv = (char *)SyMemBackendDup(pPager->pAllocator,(const char *)zRaw,nLen);
if( zKv == 0 ){
return UNQLITE_NOMEM;
}
SyStringInitFromBuf(&pPager->sKv,zKv,nLen);
return UNQLITE_OK;
}
/*
* Read the database header.
*/
static int pager_read_db_header(Pager *pPager)
{
unsigned char zRaw[UNQLITE_MIN_PAGE_SIZE]; /* Minimum page size */
sxi64 n = 0; /* Size of db file in bytes */
int rc;
/* Get the file size first */
rc = unqliteOsFileSize(pPager->pfd,&n);
if( rc != UNQLITE_OK ){
return rc;
}
pPager->dbByteSize = n;
if( n > 0 ){
unqlite_kv_methods *pMethods;
SyString *pKv;
pgno nPage;
if( n < UNQLITE_MIN_PAGE_SIZE ){
/* A valid unqlite database must be at least 512 bytes long */
unqliteGenError(pPager->pDb,"Malformed database image");
return UNQLITE_CORRUPT;
}
/* Read the database header */
rc = unqliteOsRead(pPager->pfd,zRaw,sizeof(zRaw),0);
if( rc != UNQLITE_OK ){
unqliteGenError(pPager->pDb,"IO error while reading database header");
return rc;
}
/* Extract the header */
rc = pager_extract_header(pPager,zRaw,sizeof(zRaw));
if( rc != UNQLITE_OK ){
unqliteGenError(pPager->pDb,rc == UNQLITE_NOMEM ? "Unqlite is running out of memory" : "Malformed database image");
return rc;
}
/* Update pager state */
nPage = (pgno)(n / pPager->iPageSize);
if( nPage==0 && n>0 ){
nPage = 1;
}
pPager->dbSize = nPage;
/* Laod the target Key/Value storage engine */
pKv = &pPager->sKv;
pMethods = unqliteFindKVStore(pKv->zString,pKv->nByte);
if( pMethods == 0 ){
unqliteGenErrorFormat(pPager->pDb,"No such Key/Value storage engine '%z'",pKv);
return UNQLITE_NOTIMPLEMENTED;
}
/* Install the new KV storage engine */
rc = unqlitePagerRegisterKvEngine(pPager,pMethods);
if( rc != UNQLITE_OK ){
return rc;
}
}else{
/* Set a default page and sector size */
pPager->iSectorSize = GetSectorSize(pPager->pfd);
pPager->iPageSize = unqliteGetPageSize();
SyStringInitFromBuf(&pPager->sKv,pPager->pEngine->pIo->pMethods->zName,SyStrlen(pPager->pEngine->pIo->pMethods->zName));
pPager->dbSize = 0;
}
/* Allocate a temporary page size */
pPager->zTmpPage = (unsigned char *)SyMemBackendAlloc(pPager->pAllocator,(sxu32)pPager->iPageSize);
if( pPager->zTmpPage == 0 ){
unqliteGenOutofMem(pPager->pDb);
return UNQLITE_NOMEM;
}
SyZero(pPager->zTmpPage,(sxu32)pPager->iPageSize);
return UNQLITE_OK;
}
/*
* Write the database header.
*/
static int pager_create_header(Pager *pPager)
{
Page *pHeader;
int rc;
/* Allocate a new page */
pHeader = pager_alloc_page(pPager,0);
if( pHeader == 0 ){
return UNQLITE_NOMEM;
}
pPager->pHeader = pHeader;
/* Link the page */
pager_link_page(pPager,pHeader);
/* Add to the dirty list */
pager_page_to_dirty_list(pPager,pHeader);
/* Write the database header */
rc = pager_write_db_header(pPager);
return rc;
}
/*
** This function is called to obtain a shared lock on the database file.
** It is illegal to call unqlitePagerAcquire() until after this function
** has been successfully called. If a shared-lock is already held when
** this function is called, it is a no-op.
**
** The following operations are also performed by this function.
**
** 1) If the pager is currently in PAGER_OPEN state (no lock held
** on the database file), then an attempt is made to obtain a
** SHARED lock on the database file. Immediately after obtaining
** the SHARED lock, the file-system is checked for a hot-journal,
** which is played back if present.
**
** If everything is successful, UNQLITE_OK is returned. If an IO error
** occurs while locking the database, checking for a hot-journal file or
** rolling back a journal file, the IO error code is returned.
*/
static int pager_shared_lock(Pager *pPager)
{
int rc = UNQLITE_OK;
if( pPager->iState == PAGER_OPEN ){
unqlite_kv_methods *pMethods;
/* Open the target database */
rc = unqliteOsOpen(pPager->pVfs,pPager->pAllocator,pPager->zFilename,&pPager->pfd,pPager->iOpenFlags);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pPager->pDb,
"IO error while opening the target database file: %s",pPager->zFilename
);
return rc;
}
/* Try to obtain a shared lock */
rc = pager_wait_on_lock(pPager,SHARED_LOCK);
if( rc == UNQLITE_OK ){
if( pPager->iLock <= SHARED_LOCK ){
/* Rollback any hot journal */
rc = pager_journal_rollback(pPager,1);
if( rc != UNQLITE_OK ){
return rc;
}
}
/* Read the database header */
rc = pager_read_db_header(pPager);
if( rc != UNQLITE_OK ){
return rc;
}
if(pPager->dbSize > 0 ){
if( pPager->iOpenFlags & UNQLITE_OPEN_MMAP ){
const jx9_vfs *pVfs = jx9ExportBuiltinVfs();
/* Obtain a read-only memory view of the whole file */
if( pVfs && pVfs->xMmap ){
int vr;
vr = pVfs->xMmap(pPager->zFilename,&pPager->pMmap,&pPager->dbByteSize);
if( vr != JX9_OK ){
/* Generate a warning */
unqliteGenError(pPager->pDb,"Cannot obtain a read-only memory view of the target database");
pPager->iOpenFlags &= ~UNQLITE_OPEN_MMAP;
}
}else{
/* Generate a warning */
unqliteGenError(pPager->pDb,"Cannot obtain a read-only memory view of the target database");
pPager->iOpenFlags &= ~UNQLITE_OPEN_MMAP;
}
}
}
/* Update the pager state */
pPager->iState = PAGER_READER;
/* Invoke the xOpen methods if available */
pMethods = pPager->pEngine->pIo->pMethods;
if( pMethods->xOpen ){
rc = pMethods->xOpen(pPager->pEngine,pPager->dbSize);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pPager->pDb,
"xOpen() method of the underlying KV engine '%z' failed",
&pPager->sKv
);
pager_unlock_db(pPager,NO_LOCK);
pPager->iState = PAGER_OPEN;
return rc;
}
}
}else if( rc == UNQLITE_BUSY ){
unqliteGenError(pPager->pDb,"Another process or thread have a reserved or exclusive lock on this database");
}
}
return rc;
}
/*
** Begin a write-transaction on the specified pager object. If a
** write-transaction has already been opened, this function is a no-op.
*/
UNQLITE_PRIVATE int unqlitePagerBegin(Pager *pPager)
{
int rc;
/* Obtain a shared lock on the database first */
rc = pager_shared_lock(pPager);
if( rc != UNQLITE_OK ){
return rc;
}
if( pPager->iState >= PAGER_WRITER_LOCKED ){
return UNQLITE_OK;
}
if( pPager->is_rdonly ){
unqliteGenError(pPager->pDb,"Read-only database");
/* Read only database */
return UNQLITE_READ_ONLY;
}
/* Obtain a reserved lock on the database */
rc = pager_wait_on_lock(pPager,RESERVED_LOCK);
if( rc == UNQLITE_OK ){
/* Create the bitvec */
pPager->pVec = unqliteBitvecCreate(pPager->pAllocator,pPager->dbSize);
if( pPager->pVec == 0 ){
unqliteGenOutofMem(pPager->pDb);
rc = UNQLITE_NOMEM;
goto fail;
}
/* Change to the WRITER_LOCK state */
pPager->iState = PAGER_WRITER_LOCKED;
pPager->dbOrigSize = pPager->dbSize;
pPager->iJournalOfft = 0;
pPager->nRec = 0;
if( pPager->dbSize < 1 ){
/* Write the database header */
rc = pager_create_header(pPager);
if( rc != UNQLITE_OK ){
goto fail;
}
pPager->dbSize = 1;
}
}else if( rc == UNQLITE_BUSY ){
unqliteGenError(pPager->pDb,"Another process or thread have a reserved lock on this database");
}
return rc;
fail:
/* Downgrade to shared lock */
pager_unlock_db(pPager,SHARED_LOCK);
return rc;
}
/*
** This function is called at the start of every write transaction.
** There must already be a RESERVED or EXCLUSIVE lock on the database
** file when this routine is called.
**
*/
static int unqliteOpenJournal(Pager *pPager)
{
unsigned char *zHeader;
int rc = UNQLITE_OK;
if( pPager->is_mem || pPager->no_jrnl ){
/* Journaling is omitted for this database */
goto finish;
}
if( pPager->iState >= PAGER_WRITER_CACHEMOD ){
/* Already opened */
return UNQLITE_OK;
}
/* Delete any previously journal with the same name */
unqliteOsDelete(pPager->pVfs,pPager->zJournal,1);
/* Open the journal file */
rc = unqliteOsOpen(pPager->pVfs,pPager->pAllocator,pPager->zJournal,
&pPager->pjfd,UNQLITE_OPEN_CREATE|UNQLITE_OPEN_READWRITE);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pPager->pDb,"IO error while opening journal file: %s",pPager->zJournal);
return rc;
}
/* Write the journal header */
zHeader = (unsigned char *)SyMemBackendAlloc(pPager->pAllocator,(sxu32)pPager->iSectorSize);
if( zHeader == 0 ){
rc = UNQLITE_NOMEM;
goto fail;
}
pager_write_journal_header(pPager,zHeader);
/* Perform the disk write */
rc = unqliteOsWrite(pPager->pjfd,zHeader,pPager->iSectorSize,0);
/* Offset to start writing from */
pPager->iJournalOfft = pPager->iSectorSize;
/* All done, journal will be synced later */
SyMemBackendFree(pPager->pAllocator,zHeader);
finish:
if( rc == UNQLITE_OK ){
pPager->iState = PAGER_WRITER_CACHEMOD;
return UNQLITE_OK;
}
fail:
/* Unlink the journal file if something goes wrong */
unqliteOsCloseFree(pPager->pAllocator,pPager->pjfd);
unqliteOsDelete(pPager->pVfs,pPager->zJournal,0);
pPager->pjfd = 0;
return rc;
}
/*
** Sync the journal. In other words, make sure all the pages that have
** been written to the journal have actually reached the surface of the
** disk and can be restored in the event of a hot-journal rollback.
*
* This routine try also to obtain an exlusive lock on the database.
*/
static int unqliteFinalizeJournal(Pager *pPager,int *pRetry,int close_jrnl)
{
int rc;
*pRetry = 0;
/* Grab the exclusive lock first */
rc = pager_lock_db(pPager,EXCLUSIVE_LOCK);
if( rc != UNQLITE_OK ){
/* Retry the excusive lock process */
*pRetry = 1;
rc = UNQLITE_OK;
}
if( pPager->no_jrnl ){
/* Journaling is omitted, return immediately */
return UNQLITE_OK;
}
/* Write the total number of database records */
rc = WriteInt32(pPager->pjfd,pPager->nRec,8 /* sizeof(aJournalRec) */);
if( rc != UNQLITE_OK ){
if( pPager->nRec > 0 ){
return rc;
}else{
/* Not so fatal */
rc = UNQLITE_OK;
}
}
/* Sync the journal and close it */
rc = unqliteOsSync(pPager->pjfd,UNQLITE_SYNC_NORMAL);
if( close_jrnl ){
/* close the journal file */
if( UNQLITE_OK != unqliteOsCloseFree(pPager->pAllocator,pPager->pjfd) ){
if( rc != UNQLITE_OK /* unqliteOsSync */ ){
return rc;
}
}
pPager->pjfd = 0;
}
if( (*pRetry) == 1 ){
if( pager_lock_db(pPager,EXCLUSIVE_LOCK) == UNQLITE_OK ){
/* Got exclusive lock */
*pRetry = 0;
}
}
return UNQLITE_OK;
}
/*
* Mark a single data page as writeable. The page is written into the
* main journal as required.
*/
static int page_write(Pager *pPager,Page *pPage)
{
int rc;
if( !pPager->is_mem && !pPager->no_jrnl ){
/* Write the page to the transaction journal */
if( pPage->pgno < pPager->dbOrigSize && !unqliteBitvecTest(pPager->pVec,pPage->pgno) ){
sxu32 cksum;
if( pPager->nRec == SXU32_HIGH ){
/* Journal Limit reached */
unqliteGenError(pPager->pDb,"Journal record limit reached, commit your changes");
return UNQLITE_LIMIT;
}
/* Write the page number */
rc = WriteInt64(pPager->pjfd,pPage->pgno,pPager->iJournalOfft);
if( rc != UNQLITE_OK ){ return rc; }
/* Write the raw page */
/** CODEC */
rc = unqliteOsWrite(pPager->pjfd,pPage->zData,pPager->iPageSize,pPager->iJournalOfft + 8);
if( rc != UNQLITE_OK ){ return rc; }
/* Compute the checksum */
cksum = pager_cksum(pPager,pPage->zData);
rc = WriteInt32(pPager->pjfd,cksum,pPager->iJournalOfft + 8 + pPager->iPageSize);
if( rc != UNQLITE_OK ){ return rc; }
/* Update the journal offset */
pPager->iJournalOfft += 8 /* page num */ + pPager->iPageSize + 4 /* cksum */;
pPager->nRec++;
/* Mark as journalled */
unqliteBitvecSet(pPager->pVec,pPage->pgno);
}
}
/* Add the page to the dirty list */
pager_page_to_dirty_list(pPager,pPage);
/* Update the database size and return. */
if( (1 + pPage->pgno) > pPager->dbSize ){
pPager->dbSize = 1 + pPage->pgno;
if( pPager->dbSize == SXU64_HIGH ){
unqliteGenError(pPager->pDb,"Database maximum page limit (64-bit) reached");
return UNQLITE_LIMIT;
}
}
return UNQLITE_OK;
}
/*
** The argument is the first in a linked list of dirty pages connected
** by the PgHdr.pDirty pointer. This function writes each one of the
** in-memory pages in the list to the database file. The argument may
** be NULL, representing an empty list. In this case this function is
** a no-op.
**
** The pager must hold at least a RESERVED lock when this function
** is called. Before writing anything to the database file, this lock
** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
** UNQLITE_BUSY is returned and no data is written to the database file.
*/
static int pager_write_dirty_pages(Pager *pPager,Page *pDirty)
{
int rc = UNQLITE_OK;
Page *pNext;
for(;;){
if( pDirty == 0 ){
break;
}
/* Point to the next dirty page */
pNext = pDirty->pDirtyPrev; /* Not a bug: Reverse link */
if( (pDirty->flags & PAGE_DONT_WRITE) == 0 ){
rc = unqliteOsWrite(pPager->pfd,pDirty->zData,pPager->iPageSize,pDirty->pgno * pPager->iPageSize);
if( rc != UNQLITE_OK ){
/* A rollback should be done */
break;
}
}
/* Remove stale flags */
pDirty->flags &= ~(PAGE_DIRTY|PAGE_DONT_WRITE|PAGE_NEED_SYNC|PAGE_IN_JOURNAL|PAGE_HOT_DIRTY);
if( pDirty->nRef < 1 ){
/* Unlink the page now it is unused */
pager_unlink_page(pPager,pDirty);
/* Release the page */
pager_release_page(pPager,pDirty);
}
/* Point to the next page */
pDirty = pNext;
}
pPager->pDirty = pPager->pFirstDirty = 0;
pPager->pHotDirty = pPager->pFirstHot = 0;
pPager->nHot = 0;
return rc;
}
/*
** The argument is the first in a linked list of hot dirty pages connected
** by the PgHdr.pHotDirty pointer. This function writes each one of the
** in-memory pages in the list to the database file. The argument may
** be NULL, representing an empty list. In this case this function is
** a no-op.
**
** The pager must hold at least a RESERVED lock when this function
** is called. Before writing anything to the database file, this lock
** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
** UNQLITE_BUSY is returned and no data is written to the database file.
*/
static int pager_write_hot_dirty_pages(Pager *pPager,Page *pDirty)
{
int rc = UNQLITE_OK;
Page *pNext;
for(;;){
if( pDirty == 0 ){
break;
}
/* Point to the next page */
pNext = pDirty->pPrevHot; /* Not a bug: Reverse link */
if( (pDirty->flags & PAGE_DONT_WRITE) == 0 ){
rc = unqliteOsWrite(pPager->pfd,pDirty->zData,pPager->iPageSize,pDirty->pgno * pPager->iPageSize);
if( rc != UNQLITE_OK ){
break;
}
}
/* Remove stale flags */
pDirty->flags &= ~(PAGE_DIRTY|PAGE_DONT_WRITE|PAGE_NEED_SYNC|PAGE_IN_JOURNAL|PAGE_HOT_DIRTY);
/* Unlink from the list of dirty pages */
if( pDirty->pDirtyPrev ){
pDirty->pDirtyPrev->pDirtyNext = pDirty->pDirtyNext;
}else{
pPager->pDirty = pDirty->pDirtyNext;
}
if( pDirty->pDirtyNext ){
pDirty->pDirtyNext->pDirtyPrev = pDirty->pDirtyPrev;
}else{
pPager->pFirstDirty = pDirty->pDirtyPrev;
}
/* Discard */
pager_unlink_page(pPager,pDirty);
/* Release the page */
pager_release_page(pPager,pDirty);
/* Next hot page */
pDirty = pNext;
}
return rc;
}
/*
* Commit a transaction: Phase one.
*/
static int pager_commit_phase1(Pager *pPager)
{
int get_excl = 0;
Page *pDirty;
int rc;
/* If no database changes have been made, return early. */
if( pPager->iState < PAGER_WRITER_CACHEMOD ){
return UNQLITE_OK;
}
if( pPager->is_mem ){
/* An in-memory database */
return UNQLITE_OK;
}
if( pPager->is_rdonly ){
/* Read-Only DB */
unqliteGenError(pPager->pDb,"Read-Only database");
return UNQLITE_READ_ONLY;
}
/* Finalize the journal file */
rc = unqliteFinalizeJournal(pPager,&get_excl,1);
if( rc != UNQLITE_OK ){
return rc;
}
/* Get the dirty pages */
pDirty = pager_get_dirty_pages(pPager);
if( get_excl ){
/* Wait one last time for the exclusive lock */
rc = pager_wait_on_lock(pPager,EXCLUSIVE_LOCK);
if( rc != UNQLITE_OK ){
unqliteGenError(pPager->pDb,"Cannot obtain an Exclusive lock on the target database");
return rc;
}
}
if( pPager->iFlags & PAGER_CTRL_DIRTY_COMMIT ){
/* Synce the database first if a dirty commit have been applied */
unqliteOsSync(pPager->pfd,UNQLITE_SYNC_NORMAL);
}
/* Write the dirty pages */
rc = pager_write_dirty_pages(pPager,pDirty);
if( rc != UNQLITE_OK ){
/* Rollback your DB */
pPager->iFlags |= PAGER_CTRL_COMMIT_ERR;
pPager->pFirstDirty = pDirty;
unqliteGenError(pPager->pDb,"IO error while writing dirty pages, rollback your database");
return rc;
}
/* If the file on disk is not the same size as the database image,
* then use unqliteOsTruncate to grow or shrink the file here.
*/
if( pPager->dbSize != pPager->dbOrigSize ){
unqliteOsTruncate(pPager->pfd,pPager->iPageSize * pPager->dbSize);
}
/* Sync the database file */
unqliteOsSync(pPager->pfd,UNQLITE_SYNC_FULL);
/* Remove stale flags */
pPager->iJournalOfft = 0;
pPager->nRec = 0;
return UNQLITE_OK;
}
/*
* Commit a transaction: Phase two.
*/
static int pager_commit_phase2(Pager *pPager)
{
if( !pPager->is_mem ){
if( pPager->iState == PAGER_OPEN ){
return UNQLITE_OK;
}
if( pPager->iState != PAGER_READER ){
if( !pPager->no_jrnl ){
/* Finally, unlink the journal file */
unqliteOsDelete(pPager->pVfs,pPager->zJournal,1);
}
/* Downgrade to shraed lock */
pager_unlock_db(pPager,SHARED_LOCK);
pPager->iState = PAGER_READER;
if( pPager->pVec ){
unqliteBitvecDestroy(pPager->pVec);
pPager->pVec = 0;
}
}
}
return UNQLITE_OK;
}
/*
* Perform a dirty commit.
*/
static int pager_dirty_commit(Pager *pPager)
{
int get_excl = 0;
Page *pHot;
int rc;
/* Finalize the journal file without closing it */
rc = unqliteFinalizeJournal(pPager,&get_excl,0);
if( rc != UNQLITE_OK ){
/* It's not a fatal error if something goes wrong here since
* its not the final commit.
*/
return UNQLITE_OK;
}
/* Point to the list of hot pages */
pHot = pager_get_hot_pages(pPager);
if( pHot == 0 ){
return UNQLITE_OK;
}
if( get_excl ){
/* Wait one last time for the exclusive lock */
rc = pager_wait_on_lock(pPager,EXCLUSIVE_LOCK);
if( rc != UNQLITE_OK ){
/* Not so fatal, will try another time */
return UNQLITE_OK;
}
}
/* Tell that a dirty commit happen */
pPager->iFlags |= PAGER_CTRL_DIRTY_COMMIT;
/* Write the hot pages now */
rc = pager_write_hot_dirty_pages(pPager,pHot);
if( rc != UNQLITE_OK ){
pPager->iFlags |= PAGER_CTRL_COMMIT_ERR;
unqliteGenError(pPager->pDb,"IO error while writing hot dirty pages, rollback your database");
return rc;
}
pPager->pFirstHot = pPager->pHotDirty = 0;
pPager->nHot = 0;
/* No need to sync the database file here, since the journal is already
* open here and this is not the final commit.
*/
return UNQLITE_OK;
}
/*
** Commit a transaction and sync the database file for the pager pPager.
**
** This routine ensures that:
**
** * the journal is synced,
** * all dirty pages are written to the database file,
** * the database file is truncated (if required), and
** * the database file synced.
** * the journal file is deleted.
*/
UNQLITE_PRIVATE int unqlitePagerCommit(Pager *pPager)
{
int rc;
/* Commit: Phase One */
rc = pager_commit_phase1(pPager);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Commit: Phase Two */
rc = pager_commit_phase2(pPager);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Remove stale flags */
pPager->iFlags &= ~PAGER_CTRL_COMMIT_ERR;
/* All done */
return UNQLITE_OK;
fail:
/* Disable the auto-commit flag */
pPager->pDb->iFlags |= UNQLITE_FL_DISABLE_AUTO_COMMIT;
return rc;
}
/*
* Reset the pager to its initial state. This is caused by
* a rollback operation.
*/
static int pager_reset_state(Pager *pPager,int bResetKvEngine)
{
unqlite_kv_engine *pEngine = pPager->pEngine;
Page *pNext,*pPtr = pPager->pAll;
const unqlite_kv_io *pIo;
int rc;
/* Remove stale flags */
pPager->iFlags &= ~(PAGER_CTRL_COMMIT_ERR|PAGER_CTRL_DIRTY_COMMIT);
pPager->iJournalOfft = 0;
pPager->nRec = 0;
/* Database original size */
pPager->dbSize = pPager->dbOrigSize;
/* Discard all in-memory pages */
for(;;){
if( pPtr == 0 ){
break;
}
pNext = pPtr->pNext; /* Reverse link */
/* Remove stale flags */
pPtr->flags &= ~(PAGE_DIRTY|PAGE_DONT_WRITE|PAGE_NEED_SYNC|PAGE_IN_JOURNAL|PAGE_HOT_DIRTY);
/* Release the page */
pager_release_page(pPager,pPtr);
/* Point to the next page */
pPtr = pNext;
}
pPager->pAll = 0;
pPager->nPage = 0;
pPager->pDirty = pPager->pFirstDirty = 0;
pPager->pHotDirty = pPager->pFirstHot = 0;
pPager->nHot = 0;
if( pPager->apHash ){
/* Zero the table */
SyZero((void *)pPager->apHash,sizeof(Page *) * pPager->nSize);
}
if( pPager->pVec ){
unqliteBitvecDestroy(pPager->pVec);
pPager->pVec = 0;
}
/* Switch back to shared lock */
pager_unlock_db(pPager,SHARED_LOCK);
pPager->iState = PAGER_READER;
if( bResetKvEngine ){
/* Reset the underlying KV engine */
pIo = pEngine->pIo;
if( pIo->pMethods->xRelease ){
/* Call the release callback */
pIo->pMethods->xRelease(pEngine);
}
/* Zero the structure */
SyZero(pEngine,(sxu32)pIo->pMethods->szKv);
/* Fill in */
pEngine->pIo = pIo;
if( pIo->pMethods->xInit ){
/* Call the init method */
rc = pIo->pMethods->xInit(pEngine,pPager->iPageSize);
if( rc != UNQLITE_OK ){
return rc;
}
}
if( pIo->pMethods->xOpen ){
/* Call the xOpen method */
rc = pIo->pMethods->xOpen(pEngine,pPager->dbSize);
if( rc != UNQLITE_OK ){
return rc;
}
}
}
/* All done */
return UNQLITE_OK;
}
/*
** If a write transaction is open, then all changes made within the
** transaction are reverted and the current write-transaction is closed.
** The pager falls back to PAGER_READER state if successful.
**
** Otherwise, in rollback mode, this function performs two functions:
**
** 1) It rolls back the journal file, restoring all database file and
** in-memory cache pages to the state they were in when the transaction
** was opened, and
**
** 2) It finalizes the journal file, so that it is not used for hot
** rollback at any point in the future (i.e. deletion).
**
** Finalization of the journal file (task 2) is only performed if the
** rollback is successful.
**
*/
UNQLITE_PRIVATE int unqlitePagerRollback(Pager *pPager,int bResetKvEngine)
{
int rc = UNQLITE_OK;
if( pPager->iState < PAGER_WRITER_LOCKED ){
/* A write transaction must be opened */
return UNQLITE_OK;
}
if( pPager->is_mem ){
/* As of this release 1.1.6: Transactions are not supported for in-memory databases */
return UNQLITE_OK;
}
if( pPager->is_rdonly ){
/* Read-Only DB */
unqliteGenError(pPager->pDb,"Read-Only database");
return UNQLITE_READ_ONLY;
}
if( pPager->iState >= PAGER_WRITER_CACHEMOD ){
if( !pPager->no_jrnl ){
/* Close any outstanding joural file */
if( pPager->pjfd ){
/* Sync the journal file */
unqliteOsSync(pPager->pjfd,UNQLITE_SYNC_NORMAL);
}
unqliteOsCloseFree(pPager->pAllocator,pPager->pjfd);
pPager->pjfd = 0;
if( pPager->iFlags & (PAGER_CTRL_COMMIT_ERR|PAGER_CTRL_DIRTY_COMMIT) ){
/* Perform the rollback */
rc = pager_journal_rollback(pPager,0);
if( rc != UNQLITE_OK ){
/* Set the auto-commit flag */
pPager->pDb->iFlags |= UNQLITE_FL_DISABLE_AUTO_COMMIT;
return rc;
}
}
}
/* Unlink the journal file */
unqliteOsDelete(pPager->pVfs,pPager->zJournal,1);
/* Reset the pager state */
rc = pager_reset_state(pPager,bResetKvEngine);
if( rc != UNQLITE_OK ){
/* Mostly an unlikely scenario */
pPager->pDb->iFlags |= UNQLITE_FL_DISABLE_AUTO_COMMIT; /* Set the auto-commit flag */
unqliteGenError(pPager->pDb,"Error while reseting pager to its initial state");
return rc;
}
}else{
/* Downgrade to shared lock */
pager_unlock_db(pPager,SHARED_LOCK);
pPager->iState = PAGER_READER;
}
return UNQLITE_OK;
}
/*
* Mark a data page as non writeable.
*/
static int unqlitePagerDontWrite(unqlite_page *pMyPage)
{
Page *pPage = (Page *)pMyPage;
if( pPage->pgno > 0 /* Page 0 is always writeable */ ){
pPage->flags |= PAGE_DONT_WRITE;
}
return UNQLITE_OK;
}
/*
** Mark a data page as writeable. This routine must be called before
** making changes to a page. The caller must check the return value
** of this function and be careful not to change any page data unless
** this routine returns UNQLITE_OK.
*/
static int unqlitePageWrite(unqlite_page *pMyPage)
{
Page *pPage = (Page *)pMyPage;
Pager *pPager = pPage->pPager;
int rc;
/* Begin the write transaction */
rc = unqlitePagerBegin(pPager);
if( rc != UNQLITE_OK ){
return rc;
}
if( pPager->iState == PAGER_WRITER_LOCKED ){
/* The journal file needs to be opened. Higher level routines have already
** obtained the necessary locks to begin the write-transaction, but the
** rollback journal might not yet be open. Open it now if this is the case.
*/
rc = unqliteOpenJournal(pPager);
if( rc != UNQLITE_OK ){
return rc;
}
}
if( pPager->nHot > 127 ){
/* Write hot dirty pages */
rc = pager_dirty_commit(pPager);
if( rc != UNQLITE_OK ){
/* A rollback must be done */
unqliteGenError(pPager->pDb,"Please perform a rollback");
return rc;
}
}
/* Write the page to the journal file */
rc = page_write(pPager,pPage);
return rc;
}
/*
** Acquire a reference to page number pgno in pager pPager (a page
** reference has type unqlite_page*). If the requested reference is
** successfully obtained, it is copied to *ppPage and UNQLITE_OK returned.
**
** If the requested page is already in the cache, it is returned.
** Otherwise, a new page object is allocated and populated with data
** read from the database file.
*/
static int unqlitePagerAcquire(
Pager *pPager, /* The pager open on the database file */
pgno pgno, /* Page number to fetch */
unqlite_page **ppPage, /* OUT: Acquired page */
int fetchOnly, /* Cache lookup only */
int noContent /* Do not bother reading content from disk if true */
)
{
Page *pPage;
int rc;
/* Acquire a shared lock (if not yet done) on the database and rollback any hot-journal if present */
rc = pager_shared_lock(pPager);
if( rc != UNQLITE_OK ){
return rc;
}
/* Fetch the page from the cache */
pPage = pager_fetch_page(pPager,pgno);
if( fetchOnly ){
if( ppPage ){
*ppPage = (unqlite_page *)pPage;
}
return pPage ? UNQLITE_OK : UNQLITE_NOTFOUND;
}
if( pPage == 0 ){
/* Allocate a new page */
pPage = pager_alloc_page(pPager,pgno);
if( pPage == 0 ){
unqliteGenOutofMem(pPager->pDb);
return UNQLITE_NOMEM;
}
/* Read page contents */
rc = pager_get_page_contents(pPager,pPage,noContent);
if( rc != UNQLITE_OK ){
SyMemBackendPoolFree(pPager->pAllocator,pPage);
return rc;
}
/* Link the page */
pager_link_page(pPager,pPage);
}else{
if( ppPage ){
page_ref(pPage);
}
}
/* All done, page is loaded in memeory */
if( ppPage ){
*ppPage = (unqlite_page *)pPage;
}
return UNQLITE_OK;
}
/*
* Return true if we are dealing with an in-memory database.
*/
static int unqliteInMemory(const char *zFilename)
{
sxu32 n;
if( SX_EMPTY_STR(zFilename) ){
/* NULL or the empty string means an in-memory database */
return TRUE;
}
n = SyStrlen(zFilename);
if( n == sizeof(":mem:") - 1 &&
SyStrnicmp(zFilename,":mem:",sizeof(":mem:") - 1) == 0 ){
return TRUE;
}
if( n == sizeof(":memory:") - 1 &&
SyStrnicmp(zFilename,":memory:",sizeof(":memory:") - 1) == 0 ){
return TRUE;
}
return FALSE;
}
/*
* Allocate a new KV cursor.
*/
UNQLITE_PRIVATE int unqliteInitCursor(unqlite *pDb,unqlite_kv_cursor **ppOut)
{
unqlite_kv_methods *pMethods;
unqlite_kv_cursor *pCur;
sxu32 nByte;
/* Storage engine methods */
pMethods = pDb->sDB.pPager->pEngine->pIo->pMethods;
if( pMethods->szCursor < 1 ){
/* Implementation does not supprt cursors */
unqliteGenErrorFormat(pDb,"Storage engine '%s' does not support cursors",pMethods->zName);
return UNQLITE_NOTIMPLEMENTED;
}
nByte = pMethods->szCursor;
if( nByte < sizeof(unqlite_kv_cursor) ){
nByte += sizeof(unqlite_kv_cursor);
}
pCur = (unqlite_kv_cursor *)SyMemBackendPoolAlloc(&pDb->sMem,nByte);
if( pCur == 0 ){
unqliteGenOutofMem(pDb);
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pCur,nByte);
/* Save the cursor */
pCur->pStore = pDb->sDB.pPager->pEngine;
/* Invoke the initialization callback if any */
if( pMethods->xCursorInit ){
pMethods->xCursorInit(pCur);
}
/* All done */
*ppOut = pCur;
return UNQLITE_OK;
}
/*
* Release a cursor.
*/
UNQLITE_PRIVATE int unqliteReleaseCursor(unqlite *pDb,unqlite_kv_cursor *pCur)
{
unqlite_kv_methods *pMethods;
/* Storage engine methods */
pMethods = pDb->sDB.pPager->pEngine->pIo->pMethods;
/* Invoke the release callback if available */
if( pMethods->xCursorRelease ){
pMethods->xCursorRelease(pCur);
}
/* Finally, free the whole instance */
SyMemBackendPoolFree(&pDb->sMem,pCur);
return UNQLITE_OK;
}
/*
* Release the underlying KV storage engine and invoke
* its associated callbacks if available.
*/
static void pager_release_kv_engine(Pager *pPager)
{
unqlite_kv_engine *pEngine = pPager->pEngine;
unqlite_db *pStorage = &pPager->pDb->sDB;
if( pStorage->pCursor ){
/* Release the associated cursor */
unqliteReleaseCursor(pPager->pDb,pStorage->pCursor);
pStorage->pCursor = 0;
}
if( pEngine->pIo->pMethods->xRelease ){
pEngine->pIo->pMethods->xRelease(pEngine);
}
/* Release the whole instance */
SyMemBackendFree(&pPager->pDb->sMem,(void *)pEngine->pIo);
SyMemBackendFree(&pPager->pDb->sMem,(void *)pEngine);
pPager->pEngine = 0;
}
/* Forward declaration */
static int pager_kv_io_init(Pager *pPager,unqlite_kv_methods *pMethods,unqlite_kv_io *pIo);
/*
* Allocate, initialize and register a new KV storage engine
* within this database instance.
*/
UNQLITE_PRIVATE int unqlitePagerRegisterKvEngine(Pager *pPager,unqlite_kv_methods *pMethods)
{
unqlite_db *pStorage = &pPager->pDb->sDB;
unqlite *pDb = pPager->pDb;
unqlite_kv_engine *pEngine;
unqlite_kv_io *pIo;
sxu32 nByte;
int rc;
if( pPager->pEngine ){
if( pMethods == pPager->pEngine->pIo->pMethods ){
/* Ticket 1432: Same implementation */
return UNQLITE_OK;
}
/* Release the old KV engine */
pager_release_kv_engine(pPager);
}
/* Allocate a new KV engine instance */
nByte = (sxu32)pMethods->szKv;
pEngine = (unqlite_kv_engine *)SyMemBackendAlloc(&pDb->sMem,nByte);
if( pEngine == 0 ){
unqliteGenOutofMem(pDb);
return UNQLITE_NOMEM;
}
pIo = (unqlite_kv_io *)SyMemBackendAlloc(&pDb->sMem,sizeof(unqlite_kv_io));
if( pIo == 0 ){
SyMemBackendFree(&pDb->sMem,pEngine);
unqliteGenOutofMem(pDb);
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pIo,sizeof(unqlite_io_methods));
SyZero(pEngine,nByte);
/* Populate the IO structure */
pager_kv_io_init(pPager,pMethods,pIo);
pEngine->pIo = pIo;
/* Invoke the init callback if avaialble */
if( pMethods->xInit ){
rc = pMethods->xInit(pEngine,unqliteGetPageSize());
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pDb,
"xInit() method of the underlying KV engine '%z' failed",&pPager->sKv);
goto fail;
}
pEngine->pIo = pIo;
}
pPager->pEngine = pEngine;
/* Allocate a new cursor */
rc = unqliteInitCursor(pDb,&pStorage->pCursor);
if( rc != UNQLITE_OK ){
goto fail;
}
return UNQLITE_OK;
fail:
SyMemBackendFree(&pDb->sMem,pEngine);
SyMemBackendFree(&pDb->sMem,pIo);
return rc;
}
/*
* Return the underlying KV storage engine instance.
*/
UNQLITE_PRIVATE unqlite_kv_engine * unqlitePagerGetKvEngine(unqlite *pDb)
{
return pDb->sDB.pPager->pEngine;
}
/*
* Allocate and initialize a new Pager object. The pager should
* eventually be freed by passing it to unqlitePagerClose().
*
* The zFilename argument is the path to the database file to open.
* If zFilename is NULL or ":memory:" then all information is held
* in cache. It is never written to disk. This can be used to implement
* an in-memory database.
*/
UNQLITE_PRIVATE int unqlitePagerOpen(
unqlite_vfs *pVfs, /* The virtual file system to use */
unqlite *pDb, /* Database handle */
const char *zFilename, /* Name of the database file to open */
unsigned int iFlags /* flags controlling this file */
)
{
unqlite_kv_methods *pMethods = 0;
int is_mem,rd_only,no_jrnl;
Pager *pPager;
sxu32 nByte;
sxu32 nLen;
int rc;
/* Select the appropriate KV storage subsytem */
if( (iFlags & UNQLITE_OPEN_IN_MEMORY) || unqliteInMemory(zFilename) ){
/* An in-memory database, record that */
pMethods = unqliteFindKVStore("mem",sizeof("mem") - 1); /* Always available */
iFlags |= UNQLITE_OPEN_IN_MEMORY;
}else{
/* Install the default key value storage subsystem [i.e. Linear Hash] */
pMethods = unqliteFindKVStore("hash",sizeof("hash")-1);
if( pMethods == 0 ){
/* Use the b+tree storage backend if the linear hash storage is not available */
pMethods = unqliteFindKVStore("btree",sizeof("btree")-1);
}
}
if( pMethods == 0 ){
/* Can't happen */
unqliteGenError(pDb,"Cannot install a default Key/Value storage engine");
return UNQLITE_NOTIMPLEMENTED;
}
is_mem = (iFlags & UNQLITE_OPEN_IN_MEMORY) != 0;
rd_only = (iFlags & UNQLITE_OPEN_READONLY) != 0;
no_jrnl = (iFlags & UNQLITE_OPEN_OMIT_JOURNALING) != 0;
rc = UNQLITE_OK;
if( is_mem ){
/* Omit journaling for in-memory database */
no_jrnl = 1;
}
/* Total number of bytes to allocate */
nByte = sizeof(Pager);
nLen = 0;
if( !is_mem ){
nLen = SyStrlen(zFilename);
nByte += pVfs->mxPathname + nLen + sizeof(char) /* null termniator */;
}
/* Allocate */
pPager = (Pager *)SyMemBackendAlloc(&pDb->sMem,nByte);
if( pPager == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pPager,nByte);
/* Fill-in the structure */
pPager->pAllocator = &pDb->sMem;
pPager->pDb = pDb;
pDb->sDB.pPager = pPager;
/* Allocate page table */
pPager->nSize = 128; /* Must be a power of two */
nByte = pPager->nSize * sizeof(Page *);
pPager->apHash = (Page **)SyMemBackendAlloc(pPager->pAllocator,nByte);
if( pPager->apHash == 0 ){
rc = UNQLITE_NOMEM;
goto fail;
}
SyZero(pPager->apHash,nByte);
pPager->is_mem = is_mem;
pPager->no_jrnl = no_jrnl;
pPager->is_rdonly = rd_only;
pPager->iOpenFlags = iFlags;
pPager->pVfs = pVfs;
SyRandomnessInit(&pPager->sPrng,0,0);
SyRandomness(&pPager->sPrng,(void *)&pPager->cksumInit,sizeof(sxu32));
/* Unlimited cache size */
pPager->nCacheMax = SXU32_HIGH;
/* Copy filename and journal name */
if( !is_mem ){
pPager->zFilename = (char *)&pPager[1];
rc = UNQLITE_OK;
if( pVfs->xFullPathname ){
rc = pVfs->xFullPathname(pVfs,zFilename,pVfs->mxPathname + nLen,pPager->zFilename);
}
if( rc != UNQLITE_OK ){
/* Simple filename copy */
SyMemcpy(zFilename,pPager->zFilename,nLen);
pPager->zFilename[nLen] = 0;
rc = UNQLITE_OK;
}else{
nLen = SyStrlen(pPager->zFilename);
}
pPager->zJournal = (char *) SyMemBackendAlloc(pPager->pAllocator,nLen + sizeof(UNQLITE_JOURNAL_FILE_SUFFIX) + sizeof(char));
if( pPager->zJournal == 0 ){
rc = UNQLITE_NOMEM;
goto fail;
}
/* Copy filename */
SyMemcpy(pPager->zFilename,pPager->zJournal,nLen);
/* Copy journal suffix */
SyMemcpy(UNQLITE_JOURNAL_FILE_SUFFIX,&pPager->zJournal[nLen],sizeof(UNQLITE_JOURNAL_FILE_SUFFIX)-1);
/* Append the nul terminator to the journal path */
pPager->zJournal[nLen + ( sizeof(UNQLITE_JOURNAL_FILE_SUFFIX) - 1)] = 0;
}
/* Finally, register the selected KV engine */
rc = unqlitePagerRegisterKvEngine(pPager,pMethods);
if( rc != UNQLITE_OK ){
goto fail;
}
/* Set the pager state */
if( pPager->is_mem ){
pPager->iState = PAGER_WRITER_FINISHED;
pPager->iLock = EXCLUSIVE_LOCK;
}else{
pPager->iState = PAGER_OPEN;
pPager->iLock = NO_LOCK;
}
/* All done, ready for processing */
return UNQLITE_OK;
fail:
SyMemBackendFree(&pDb->sMem,pPager);
return rc;
}
/*
* Set a cache limit. Note that, this is a simple hint, the pager is not
* forced to honor this limit.
*/
UNQLITE_PRIVATE int unqlitePagerSetCachesize(Pager *pPager,int mxPage)
{
if( mxPage < 256 ){
return UNQLITE_INVALID;
}
pPager->nCacheMax = mxPage;
return UNQLITE_OK;
}
/*
* Shutdown the page cache. Free all memory and close the database file.
*/
UNQLITE_PRIVATE int unqlitePagerClose(Pager *pPager)
{
/* Release the KV engine */
pager_release_kv_engine(pPager);
if( pPager->iOpenFlags & UNQLITE_OPEN_MMAP ){
const jx9_vfs *pVfs = jx9ExportBuiltinVfs();
if( pVfs && pVfs->xUnmap && pPager->pMmap ){
pVfs->xUnmap(pPager->pMmap,pPager->dbByteSize);
}
}
if( !pPager->is_mem && pPager->iState > PAGER_OPEN ){
/* Release all lock on this database handle */
pager_unlock_db(pPager,NO_LOCK);
/* Close the file */
unqliteOsCloseFree(pPager->pAllocator,pPager->pfd);
}
if( pPager->pVec ){
unqliteBitvecDestroy(pPager->pVec);
pPager->pVec = 0;
}
return UNQLITE_OK;
}
/*
* Generate a random string.
*/
UNQLITE_PRIVATE void unqlitePagerRandomString(Pager *pPager,char *zBuf,sxu32 nLen)
{
static const char zBase[] = {"abcdefghijklmnopqrstuvwxyz"}; /* English Alphabet */
sxu32 i;
/* Generate a binary string first */
SyRandomness(&pPager->sPrng,zBuf,nLen);
/* Turn the binary string into english based alphabet */
for( i = 0 ; i < nLen ; ++i ){
zBuf[i] = zBase[zBuf[i] % (sizeof(zBase)-1)];
}
}
/*
* Generate a random number.
*/
UNQLITE_PRIVATE sxu32 unqlitePagerRandomNum(Pager *pPager)
{
sxu32 iNum;
SyRandomness(&pPager->sPrng,(void *)&iNum,sizeof(iNum));
return iNum;
}
/* Exported KV IO Methods */
/*
* Refer to [unqlitePagerAcquire()]
*/
static int unqliteKvIoPageGet(unqlite_kv_handle pHandle,pgno iNum,unqlite_page **ppPage)
{
int rc;
rc = unqlitePagerAcquire((Pager *)pHandle,iNum,ppPage,0,0);
return rc;
}
/*
* Refer to [unqlitePagerAcquire()]
*/
static int unqliteKvIoPageLookup(unqlite_kv_handle pHandle,pgno iNum,unqlite_page **ppPage)
{
int rc;
rc = unqlitePagerAcquire((Pager *)pHandle,iNum,ppPage,1,0);
return rc;
}
/*
* Refer to [unqlitePagerAcquire()]
*/
static int unqliteKvIoNewPage(unqlite_kv_handle pHandle,unqlite_page **ppPage)
{
Pager *pPager = (Pager *)pHandle;
int rc;
/*
* Acquire a reader-lock first so that pPager->dbSize get initialized.
*/
rc = pager_shared_lock(pPager);
if( rc == UNQLITE_OK ){
rc = unqlitePagerAcquire(pPager,pPager->dbSize == 0 ? /* Page 0 is reserved */ 1 : pPager->dbSize ,ppPage,0,0);
}
return rc;
}
/*
* Refer to [unqlitePageWrite()]
*/
static int unqliteKvIopageWrite(unqlite_page *pPage)
{
int rc;
if( pPage == 0 ){
/* TICKET 1433-0348 */
return UNQLITE_OK;
}
rc = unqlitePageWrite(pPage);
return rc;
}
/*
* Refer to [unqlitePagerDontWrite()]
*/
static int unqliteKvIoPageDontWrite(unqlite_page *pPage)
{
int rc;
if( pPage == 0 ){
/* TICKET 1433-0348 */
return UNQLITE_OK;
}
rc = unqlitePagerDontWrite(pPage);
return rc;
}
/*
* Refer to [unqliteBitvecSet()]
*/
static int unqliteKvIoPageDontJournal(unqlite_page *pRaw)
{
Page *pPage = (Page *)pRaw;
Pager *pPager;
if( pPage == 0 ){
/* TICKET 1433-0348 */
return UNQLITE_OK;
}
pPager = pPage->pPager;
if( pPager->iState >= PAGER_WRITER_LOCKED ){
if( !pPager->no_jrnl && pPager->pVec && !unqliteBitvecTest(pPager->pVec,pPage->pgno) ){
unqliteBitvecSet(pPager->pVec,pPage->pgno);
}
}
return UNQLITE_OK;
}
/*
* Do not add a page to the hot dirty list.
*/
static int unqliteKvIoPageDontMakeHot(unqlite_page *pRaw)
{
Page *pPage = (Page *)pRaw;
if( pPage == 0 ){
/* TICKET 1433-0348 */
return UNQLITE_OK;
}
pPage->flags |= PAGE_DONT_MAKE_HOT;
/* Remove from hot dirty list if it is already there */
if( pPage->flags & PAGE_HOT_DIRTY ){
Pager *pPager = pPage->pPager;
if( pPage->pNextHot ){
pPage->pNextHot->pPrevHot = pPage->pPrevHot;
}
if( pPage->pPrevHot ){
pPage->pPrevHot->pNextHot = pPage->pNextHot;
}
if( pPager->pFirstHot == pPage ){
pPager->pFirstHot = pPage->pPrevHot;
}
if( pPager->pHotDirty == pPage ){
pPager->pHotDirty = pPage->pNextHot;
}
pPager->nHot--;
pPage->flags &= ~PAGE_HOT_DIRTY;
}
return UNQLITE_OK;
}
/*
* Refer to [page_ref()]
*/
static int unqliteKvIopage_ref(unqlite_page *pPage)
{
if( pPage ){
page_ref((Page *)pPage);
}
return UNQLITE_OK;
}
/*
* Refer to [page_unref()]
*/
static int unqliteKvIoPageUnRef(unqlite_page *pPage)
{
if( pPage ){
page_unref((Page *)pPage);
}
return UNQLITE_OK;
}
/*
* Refer to the declaration of the [Pager] structure
*/
static int unqliteKvIoReadOnly(unqlite_kv_handle pHandle)
{
return ((Pager *)pHandle)->is_rdonly;
}
/*
* Refer to the declaration of the [Pager] structure
*/
static int unqliteKvIoPageSize(unqlite_kv_handle pHandle)
{
return ((Pager *)pHandle)->iPageSize;
}
/*
* Refer to the declaration of the [Pager] structure
*/
static unsigned char * unqliteKvIoTempPage(unqlite_kv_handle pHandle)
{
return ((Pager *)pHandle)->zTmpPage;
}
/*
* Set a page unpin callback.
* Refer to the declaration of the [Pager] structure
*/
static void unqliteKvIoPageUnpin(unqlite_kv_handle pHandle,void (*xPageUnpin)(void *))
{
Pager *pPager = (Pager *)pHandle;
pPager->xPageUnpin = xPageUnpin;
}
/*
* Set a page reload callback.
* Refer to the declaration of the [Pager] structure
*/
static void unqliteKvIoPageReload(unqlite_kv_handle pHandle,void (*xPageReload)(void *))
{
Pager *pPager = (Pager *)pHandle;
pPager->xPageReload = xPageReload;
}
/*
* Log an error.
* Refer to the declaration of the [Pager] structure
*/
static void unqliteKvIoErr(unqlite_kv_handle pHandle,const char *zErr)
{
Pager *pPager = (Pager *)pHandle;
unqliteGenError(pPager->pDb,zErr);
}
/*
* Init an instance of the [unqlite_kv_io] structure.
*/
static int pager_kv_io_init(Pager *pPager,unqlite_kv_methods *pMethods,unqlite_kv_io *pIo)
{
pIo->pHandle = pPager;
pIo->pMethods = pMethods;
pIo->xGet = unqliteKvIoPageGet;
pIo->xLookup = unqliteKvIoPageLookup;
pIo->xNew = unqliteKvIoNewPage;
pIo->xWrite = unqliteKvIopageWrite;
pIo->xDontWrite = unqliteKvIoPageDontWrite;
pIo->xDontJournal = unqliteKvIoPageDontJournal;
pIo->xDontMkHot = unqliteKvIoPageDontMakeHot;
pIo->xPageRef = unqliteKvIopage_ref;
pIo->xPageUnref = unqliteKvIoPageUnRef;
pIo->xPageSize = unqliteKvIoPageSize;
pIo->xReadOnly = unqliteKvIoReadOnly;
pIo->xTmpPage = unqliteKvIoTempPage;
pIo->xSetUnpin = unqliteKvIoPageUnpin;
pIo->xSetReload = unqliteKvIoPageReload;
pIo->xErr = unqliteKvIoErr;
return UNQLITE_OK;
}
/*
* ----------------------------------------------------------
* File: unqlite_vm.c
* MD5: 2a0c56efb2ab87d3e52d0d7c3147c53b
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: unqlite_vm.c v1.0 Win7 2013-01-29 23:37 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/* This file deals with low level stuff related to the unQLite Virtual Machine */
/* Record ID as a hash value */
#define COL_RECORD_HASH(RID) (RID)
/*
* Fetch a record from a given collection.
*/
static unqlite_col_record * CollectionCacheFetchRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId /* Unique record ID */
)
{
unqlite_col_record *pEntry;
if( pCol->nRec < 1 ){
/* Don't bother hashing */
return 0;
}
pEntry = pCol->apRecord[COL_RECORD_HASH(nId) & (pCol->nRecSize - 1)];
for(;;){
if( pEntry == 0 ){
break;
}
if( pEntry->nId == nId ){
/* Record found */
return pEntry;
}
/* Point to the next entry */
pEntry = pEntry->pNextCol;
}
/* No such record */
return 0;
}
/*
* Install a freshly created record in a given collection.
*/
static int CollectionCacheInstallRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Unique record ID */
jx9_value *pValue /* JSON value */
)
{
unqlite_col_record *pRecord;
sxu32 iBucket;
/* Fetch the record first */
pRecord = CollectionCacheFetchRecord(pCol,nId);
if( pRecord ){
/* Record already installed, overwrite its old value */
jx9MemObjStore(pValue,&pRecord->sValue);
return UNQLITE_OK;
}
/* Allocate a new instance */
pRecord = (unqlite_col_record *)SyMemBackendPoolAlloc(&pCol->pVm->sAlloc,sizeof(unqlite_col_record));
if( pRecord == 0 ){
return UNQLITE_NOMEM;
}
/* Zero the structure */
SyZero(pRecord,sizeof(unqlite_col_record));
/* Fill in the structure */
jx9MemObjInit(pCol->pVm->pJx9Vm,&pRecord->sValue);
jx9MemObjStore(pValue,&pRecord->sValue);
pRecord->nId = nId;
pRecord->pCol = pCol;
/* Install in the corresponding bucket */
iBucket = COL_RECORD_HASH(nId) & (pCol->nRecSize - 1);
pRecord->pNextCol = pCol->apRecord[iBucket];
if( pCol->apRecord[iBucket] ){
pCol->apRecord[iBucket]->pPrevCol = pRecord;
}
pCol->apRecord[iBucket] = pRecord;
/* Link */
MACRO_LD_PUSH(pCol->pList,pRecord);
pCol->nRec++;
if( (pCol->nRec >= pCol->nRecSize * 3) && pCol->nRec < 100000 ){
/* Allocate a new larger table */
sxu32 nNewSize = pCol->nRecSize << 1;
unqlite_col_record *pEntry;
unqlite_col_record **apNew;
sxu32 n;
apNew = (unqlite_col_record **)SyMemBackendAlloc(&pCol->pVm->sAlloc, nNewSize * sizeof(unqlite_col_record *));
if( apNew ){
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(unqlite_col_record *));
/* Rehash all entries */
n = 0;
pEntry = pCol->pList;
for(;;){
/* Loop one */
if( n >= pCol->nRec ){
break;
}
pEntry->pNextCol = pEntry->pPrevCol = 0;
/* Install in the new bucket */
iBucket = COL_RECORD_HASH(pEntry->nId) & (nNewSize - 1);
pEntry->pNextCol = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevCol = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(&pCol->pVm->sAlloc,(void *)pCol->apRecord);
pCol->apRecord = apNew;
pCol->nRecSize = nNewSize;
}
}
/* All done */
return UNQLITE_OK;
}
/*
* Remove a record from the collection table.
*/
UNQLITE_PRIVATE int unqliteCollectionCacheRemoveRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId /* Unique record ID */
)
{
unqlite_col_record *pRecord;
/* Fetch the record first */
pRecord = CollectionCacheFetchRecord(pCol,nId);
if( pRecord == 0 ){
/* No such record */
return UNQLITE_NOTFOUND;
}
if( pRecord->pPrevCol ){
pRecord->pPrevCol->pNextCol = pRecord->pNextCol;
}else{
sxu32 iBucket = COL_RECORD_HASH(nId) & (pCol->nRecSize - 1);
pCol->apRecord[iBucket] = pRecord->pNextCol;
}
if( pRecord->pNextCol ){
pRecord->pNextCol->pPrevCol = pRecord->pPrevCol;
}
/* Unlink */
MACRO_LD_REMOVE(pCol->pList,pRecord);
pCol->nRec--;
return UNQLITE_OK;
}
/*
* Discard a collection and its records.
*/
static int CollectionCacheRelease(unqlite_col *pCol)
{
unqlite_col_record *pNext,*pRec = pCol->pList;
unqlite_vm *pVm = pCol->pVm;
sxu32 n;
/* Discard all records */
for( n = 0 ; n < pCol->nRec ; ++n ){
pNext = pRec->pNext;
jx9MemObjRelease(&pRec->sValue);
SyMemBackendPoolFree(&pVm->sAlloc,(void *)pRec);
/* Point to the next record */
pRec = pNext;
}
SyMemBackendFree(&pVm->sAlloc,(void *)pCol->apRecord);
pCol->nRec = pCol->nRecSize = 0;
pCol->pList = 0;
return UNQLITE_OK;
}
/*
* Install a freshly created collection in the unqlite VM.
*/
static int unqliteVmInstallCollection(
unqlite_vm *pVm, /* Target VM */
unqlite_col *pCol /* Collection to install */
)
{
SyString *pName = &pCol->sName;
sxu32 iBucket;
/* Hash the collection name */
pCol->nHash = SyBinHash((const void *)pName->zString,pName->nByte);
/* Install it in the corresponding bucket */
iBucket = pCol->nHash & (pVm->iColSize - 1);
pCol->pNextCol = pVm->apCol[iBucket];
if( pVm->apCol[iBucket] ){
pVm->apCol[iBucket]->pPrevCol = pCol;
}
pVm->apCol[iBucket] = pCol;
/* Link to the list of active collections */
MACRO_LD_PUSH(pVm->pCol,pCol);
pVm->iCol++;
if( (pVm->iCol >= pVm->iColSize * 4) && pVm->iCol < 10000 ){
/* Grow the hashtable */
sxu32 nNewSize = pVm->iColSize << 1;
unqlite_col *pEntry;
unqlite_col **apNew;
sxu32 n;
apNew = (unqlite_col **)SyMemBackendAlloc(&pVm->sAlloc, nNewSize * sizeof(unqlite_col *));
if( apNew ){
/* Zero the new table */
SyZero((void *)apNew, nNewSize * sizeof(unqlite_col *));
/* Rehash all entries */
n = 0;
pEntry = pVm->pCol;
for(;;){
/* Loop one */
if( n >= pVm->iCol ){
break;
}
pEntry->pNextCol = pEntry->pPrevCol = 0;
/* Install in the new bucket */
iBucket = pEntry->nHash & (nNewSize - 1);
pEntry->pNextCol = apNew[iBucket];
if( apNew[iBucket] ){
apNew[iBucket]->pPrevCol = pEntry;
}
apNew[iBucket] = pEntry;
/* Point to the next entry */
pEntry = pEntry->pNext;
n++;
}
/* Release the old table and reflect the change */
SyMemBackendFree(&pVm->sAlloc,(void *)pVm->apCol);
pVm->apCol = apNew;
pVm->iColSize = nNewSize;
}
}
return UNQLITE_OK;
}
/*
* Fetch a collection from the target VM.
*/
static unqlite_col * unqliteVmFetchCollection(
unqlite_vm *pVm, /* Target VM */
SyString *pName /* Lookup name */
)
{
unqlite_col *pCol;
sxu32 nHash;
if( pVm->iCol < 1 ){
/* Don't bother hashing */
return 0;
}
nHash = SyBinHash((const void *)pName->zString,pName->nByte);
/* Perform the lookup */
pCol = pVm->apCol[nHash & ( pVm->iColSize - 1)];
for(;;){
if( pCol == 0 ){
break;
}
if( nHash == pCol->nHash && SyStringCmp(pName,&pCol->sName,SyMemcmp) == 0 ){
/* Collection found */
return pCol;
}
/* Point to the next entry */
pCol = pCol->pNextCol;
}
/* No such collection */
return 0;
}
/*
* Write and/or alter collection binary header.
*/
static int CollectionSetHeader(
unqlite_kv_engine *pEngine, /* Underlying KV storage engine */
unqlite_col *pCol, /* Target collection */
jx9_int64 iRec, /* Last record ID */
jx9_int64 iTotal, /* Total number of records in this collection */
jx9_value *pSchema /* Collection schema */
)
{
SyBlob *pHeader = &pCol->sHeader;
unqlite_kv_methods *pMethods;
int iWrite = 0;
int rc;
if( pEngine == 0 ){
/* Default storage engine */
pEngine = unqlitePagerGetKvEngine(pCol->pVm->pDb);
}
pMethods = pEngine->pIo->pMethods;
if( SyBlobLength(pHeader) < 1 ){
Sytm *pCreate = &pCol->sCreation; /* Creation time */
unqlite_vfs *pVfs;
sxu32 iDos;
/* Magic number */
rc = SyBlobAppendBig16(pHeader,UNQLITE_COLLECTION_MAGIC);
if( rc != UNQLITE_OK ){
return rc;
}
/* Initial record ID */
rc = SyBlobAppendBig64(pHeader,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Total records in the collection */
rc = SyBlobAppendBig64(pHeader,0);
if( rc != UNQLITE_OK ){
return rc;
}
pVfs = (unqlite_vfs *)unqliteExportBuiltinVfs();
/* Creation time of the collection */
if( pVfs->xCurrentTime ){
/* Get the creation time */
pVfs->xCurrentTime(pVfs,pCreate);
}else{
/* Zero the structure */
SyZero(pCreate,sizeof(Sytm));
}
/* Convert to DOS time */
SyTimeFormatToDos(pCreate,&iDos);
rc = SyBlobAppendBig32(pHeader,iDos);
if( rc != UNQLITE_OK ){
return rc;
}
/* Offset to start writing collection schema */
pCol->nSchemaOfft = SyBlobLength(pHeader);
iWrite = 1;
}else{
unsigned char *zBinary = (unsigned char *)SyBlobData(pHeader);
/* Header update */
if( iRec >= 0 ){
/* Update record ID */
SyBigEndianPack64(&zBinary[2/* Magic number*/],(sxu64)iRec);
iWrite = 1;
}
if( iTotal >= 0 ){
/* Total records */
SyBigEndianPack64(&zBinary[2/* Magic number*/+8/* Record ID*/],(sxu64)iTotal);
iWrite = 1;
}
if( pSchema ){
/* Collection Schema */
SyBlobTruncate(pHeader,pCol->nSchemaOfft);
/* Encode the schema to FastJson */
rc = FastJsonEncode(pSchema,pHeader,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Copy the collection schema */
jx9MemObjStore(pSchema,&pCol->sSchema);
iWrite = 1;
}
}
if( iWrite ){
SyString *pId = &pCol->sName;
/* Reflect the disk and/or in-memory image */
rc = pMethods->xReplace(pEngine,
(const void *)pId->zString,pId->nByte,
SyBlobData(pHeader),SyBlobLength(pHeader)
);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Cannot save collection '%z' header in the underlying storage engine",
pId
);
return rc;
}
}
return UNQLITE_OK;
}
/*
* Load a binary collection from disk.
*/
static int CollectionLoadHeader(unqlite_col *pCol)
{
SyBlob *pHeader = &pCol->sHeader;
unsigned char *zRaw,*zEnd;
sxu16 nMagic;
sxu32 iDos;
int rc;
SyBlobReset(pHeader);
/* Read the binary header */
rc = unqlite_kv_cursor_data_callback(pCol->pCursor,unqliteDataConsumer,pHeader);
if( rc != UNQLITE_OK ){
return rc;
}
/* Perform a sanity check */
if( SyBlobLength(pHeader) < (2 /* magic */ + 8 /* record_id */ + 8 /* total_records */+ 4 /* DOS creation time*/) ){
return UNQLITE_CORRUPT;
}
zRaw = (unsigned char *)SyBlobData(pHeader);
zEnd = &zRaw[SyBlobLength(pHeader)];
/* Extract the magic number */
SyBigEndianUnpack16(zRaw,&nMagic);
if( nMagic != UNQLITE_COLLECTION_MAGIC ){
return UNQLITE_CORRUPT;
}
zRaw += 2; /* sizeof(sxu16) */
/* Extract the record ID */
SyBigEndianUnpack64(zRaw,(sxu64 *)&pCol->nLastid);
zRaw += 8; /* sizeof(sxu64) */
/* Total records in the collection */
SyBigEndianUnpack64(zRaw,(sxu64 *)&pCol->nTotRec);
/* Extract the collection creation date (DOS) */
zRaw += 8; /* sizeof(sxu64) */
SyBigEndianUnpack32(zRaw,&iDos);
SyDosTimeFormat(iDos,&pCol->sCreation);
zRaw += 4;
/* Check for a collection schema */
pCol->nSchemaOfft = (sxu32)(zRaw - (unsigned char *)SyBlobData(pHeader));
if( zRaw < zEnd ){
/* Decode the FastJson value */
FastJsonDecode((const void *)zRaw,(sxu32)(zEnd-zRaw),&pCol->sSchema,0,0);
}
return UNQLITE_OK;
}
/*
* Load or create a binary collection.
*/
static int unqliteVmLoadCollection(
unqlite_vm *pVm, /* Target VM */
const char *zName, /* Collection name */
sxu32 nByte, /* zName length */
int iFlag, /* Control flag */
unqlite_col **ppOut /* OUT: in-memory collection */
)
{
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
unqlite_kv_cursor *pCursor;
unqlite *pDb = pVm->pDb;
unqlite_col *pCol = 0; /* cc warning */
int rc = SXERR_MEM;
char *zDup = 0;
/* Point to the underlying KV store */
pEngine = unqlitePagerGetKvEngine(pVm->pDb);
pMethods = pEngine->pIo->pMethods;
/* Allocate a new cursor */
rc = unqliteInitCursor(pDb,&pCursor);
if( rc != UNQLITE_OK ){
return rc;
}
if( (iFlag & UNQLITE_VM_COLLECTION_CREATE) == 0 ){
/* Seek to the desired location */
rc = pMethods->xSeek(pCursor,(const void *)zName,(int)nByte,UNQLITE_CURSOR_MATCH_EXACT);
if( rc != UNQLITE_OK && (iFlag & UNQLITE_VM_COLLECTION_EXISTS) == 0){
unqliteGenErrorFormat(pDb,"Collection '%.*s' not defined in the underlying database",nByte,zName);
unqliteReleaseCursor(pDb,pCursor);
return rc;
}
else if((iFlag & UNQLITE_VM_COLLECTION_EXISTS)){
unqliteReleaseCursor(pDb,pCursor);
return rc;
}
}
/* Allocate a new instance */
pCol = (unqlite_col *)SyMemBackendPoolAlloc(&pVm->sAlloc,sizeof(unqlite_col));
if( pCol == 0 ){
unqliteGenOutofMem(pDb);
rc = UNQLITE_NOMEM;
goto fail;
}
SyZero(pCol,sizeof(unqlite_col));
/* Fill in the structure */
SyBlobInit(&pCol->sWorker,&pVm->sAlloc);
SyBlobInit(&pCol->sHeader,&pVm->sAlloc);
pCol->pVm = pVm;
pCol->pCursor = pCursor;
/* Duplicate collection name */
zDup = SyMemBackendStrDup(&pVm->sAlloc,zName,nByte);
if( zDup == 0 ){
unqliteGenOutofMem(pDb);
rc = UNQLITE_NOMEM;
goto fail;
}
pCol->nRecSize = 64; /* Must be a power of two */
pCol->apRecord = (unqlite_col_record **)SyMemBackendAlloc(&pVm->sAlloc,pCol->nRecSize * sizeof(unqlite_col_record *));
if( pCol->apRecord == 0 ){
unqliteGenOutofMem(pDb);
rc = UNQLITE_NOMEM;
goto fail;
}
/* Zero the table */
SyZero((void *)pCol->apRecord,pCol->nRecSize * sizeof(unqlite_col_record *));
SyStringInitFromBuf(&pCol->sName,zDup,nByte);
jx9MemObjInit(pVm->pJx9Vm,&pCol->sSchema);
if( iFlag & UNQLITE_VM_COLLECTION_CREATE ){
/* Create a new collection */
if( pMethods->xReplace == 0 ){
/* Read-only KV engine: Generate an error message and return */
unqliteGenErrorFormat(pDb,
"Cannot create new collection '%z' due to a read-only Key/Value storage engine",
&pCol->sName
);
rc = UNQLITE_ABORT; /* Abort VM execution */
goto fail;
}
/* Write the collection header */
rc = CollectionSetHeader(pEngine,pCol,0,0,0);
if( rc != UNQLITE_OK ){
rc = UNQLITE_ABORT; /* Abort VM execution */
goto fail;
}
}else{
/* Read the collection header */
rc = CollectionLoadHeader(pCol);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pDb,"Corrupt collection '%z' header",&pCol->sName);
goto fail;
}
}
/* Finally install the collection */
unqliteVmInstallCollection(pVm,pCol);
/* All done */
if( ppOut ){
*ppOut = pCol;
}
return UNQLITE_OK;
fail:
unqliteReleaseCursor(pDb,pCursor);
if( zDup ){
SyMemBackendFree(&pVm->sAlloc,zDup);
}
if( pCol ){
if( pCol->apRecord ){
SyMemBackendFree(&pVm->sAlloc,(void *)pCol->apRecord);
}
SyBlobRelease(&pCol->sHeader);
SyBlobRelease(&pCol->sWorker);
jx9MemObjRelease(&pCol->sSchema);
SyMemBackendPoolFree(&pVm->sAlloc,pCol);
}
return rc;
}
/*
* Fetch a collection.
*/
UNQLITE_PRIVATE unqlite_col * unqliteCollectionFetch(
unqlite_vm *pVm, /* Target VM */
SyString *pName, /* Lookup key */
int iFlag /* Control flag */
)
{
unqlite_col *pCol = 0; /* cc warning */
int rc;
/* Check if the collection is already loaded in memory */
pCol = unqliteVmFetchCollection(pVm,pName);
if( pCol ){
/* Already loaded in memory*/
return pCol;
}
if( (iFlag & UNQLITE_VM_AUTO_LOAD) == 0 ){
return 0;
}
/* Ask the storage engine for the collection */
rc = unqliteVmLoadCollection(pVm,pName->zString,pName->nByte,0,&pCol);
/* Return to the caller */
return rc == UNQLITE_OK ? pCol : 0;
}
/*
* Return the unique ID of the last inserted record.
*/
UNQLITE_PRIVATE jx9_int64 unqliteCollectionLastRecordId(unqlite_col *pCol)
{
return pCol->nLastid == 0 ? 0 : (pCol->nLastid - 1);
}
/*
* Return the current record ID.
*/
UNQLITE_PRIVATE jx9_int64 unqliteCollectionCurrentRecordId(unqlite_col *pCol)
{
return pCol->nCurid;
}
/*
* Return the total number of records in a given collection.
*/
UNQLITE_PRIVATE jx9_int64 unqliteCollectionTotalRecords(unqlite_col *pCol)
{
return pCol->nTotRec;
}
/*
* Reset the record cursor.
*/
UNQLITE_PRIVATE void unqliteCollectionResetRecordCursor(unqlite_col *pCol)
{
pCol->nCurid = 0;
}
/*
* Fetch a record by its unique ID.
*/
UNQLITE_PRIVATE int unqliteCollectionFetchRecordById(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Unique record ID */
jx9_value *pValue /* OUT: record value */
)
{
SyBlob *pWorker = &pCol->sWorker;
unqlite_col_record *pRec;
int rc;
jx9_value_null(pValue);
/* Perform a cache lookup first */
pRec = CollectionCacheFetchRecord(pCol,nId);
if( pRec ){
/* Copy record value */
jx9MemObjStore(&pRec->sValue,pValue);
return UNQLITE_OK;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Generate the unique ID */
SyBlobFormat(pWorker,"%z_%qd",&pCol->sName,nId);
/* Reset the cursor */
unqlite_kv_cursor_reset(pCol->pCursor);
/* Seek the cursor to the desired location */
rc = unqlite_kv_cursor_seek(pCol->pCursor,
SyBlobData(pWorker),SyBlobLength(pWorker),
UNQLITE_CURSOR_MATCH_EXACT
);
if( rc != UNQLITE_OK ){
return rc;
}
/* Consume the binary JSON */
SyBlobReset(pWorker);
unqlite_kv_cursor_data_callback(pCol->pCursor,unqliteDataConsumer,pWorker);
if( SyBlobLength(pWorker) < 1 ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Empty record '%qd'",nId
);
jx9_value_null(pValue);
}else{
/* Decode the binary JSON */
rc = FastJsonDecode(SyBlobData(pWorker),SyBlobLength(pWorker),pValue,0,0);
if( rc == UNQLITE_OK ){
/* Install the record in the cache */
CollectionCacheInstallRecord(pCol,nId,pValue);
}
}
return rc;
}
/*
* Fetch the next record from a given collection.
*/
UNQLITE_PRIVATE int unqliteCollectionFetchNextRecord(unqlite_col *pCol,jx9_value *pValue)
{
int rc;
for(;;){
if( pCol->nCurid >= pCol->nLastid ){
/* No more records, reset the record cursor ID */
pCol->nCurid = 0;
/* Return to the caller */
return SXERR_EOF;
}
rc = unqliteCollectionFetchRecordById(pCol,pCol->nCurid,pValue);
/* Increment the record ID */
pCol->nCurid++;
/* Lookup result */
if( rc == UNQLITE_OK || rc != UNQLITE_NOTFOUND ){
break;
}
}
return rc;
}
/*
* Judge a collection whether exists
*/
UNQLITE_PRIVATE int unqliteExistsCollection(
unqlite_vm *pVm, /* Target VM */
SyString *pName /* Collection name */
)
{
unqlite_col *pCol;
int rc;
/* Perform a lookup first */
pCol = unqliteVmFetchCollection(pVm,pName);
if( pCol ){
/* Already loaded in memory*/
return UNQLITE_OK;
}
rc = unqliteVmLoadCollection(pVm,pName->zString,pName->nByte,UNQLITE_VM_COLLECTION_EXISTS,0);
return rc;
}
/*
* Create a new collection.
*/
UNQLITE_PRIVATE int unqliteCreateCollection(
unqlite_vm *pVm, /* Target VM */
SyString *pName /* Collection name */
)
{
unqlite_col *pCol;
int rc;
/* Perform a lookup first */
pCol = unqliteCollectionFetch(pVm,pName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
return UNQLITE_EXISTS;
}
/* Now, safely create the collection */
rc = unqliteVmLoadCollection(pVm,pName->zString,pName->nByte,UNQLITE_VM_COLLECTION_CREATE,0);
return rc;
}
/*
* Set a schema (JSON object) for a given collection.
*/
UNQLITE_PRIVATE int unqliteCollectionSetSchema(unqlite_col *pCol,jx9_value *pValue)
{
int rc;
if( !jx9_value_is_json_object(pValue) ){
/* Must be a JSON object */
return SXERR_INVALID;
}
rc = CollectionSetHeader(0,pCol,-1,-1,pValue);
return rc;
}
/*
* Perform a store operation on a given collection.
*/
static int CollectionStore(
unqlite_col *pCol, /* Target collection */
jx9_value *pValue /* JSON value to be stored */
)
{
SyBlob *pWorker = &pCol->sWorker;
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
sxu32 nKeyLen;
int rc;
/* Point to the underlying KV store */
pEngine = unqlitePagerGetKvEngine(pCol->pVm->pDb);
pMethods = pEngine->pIo->pMethods;
if( pCol->nTotRec >= SXI64_HIGH ){
/* Collection limit reached. No more records */
unqliteGenErrorFormat(pCol->pVm->pDb,
"Collection '%z': Records limit reached",
&pCol->sName
);
return UNQLITE_LIMIT;
}
if( pMethods->xReplace == 0 ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Cannot store record into collection '%z' due to a read-only Key/Value storage engine",
&pCol->sName
);
return UNQLITE_READ_ONLY;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
if( jx9_value_is_json_object(pValue) ){
jx9_value sId;
/* If the given type is a JSON object, then add the special __id field */
jx9MemObjInitFromInt(pCol->pVm->pJx9Vm,&sId,pCol->nLastid);
jx9_array_add_strkey_elem(pValue,"__id",&sId);
jx9MemObjRelease(&sId);
}
/* Prepare the unique ID for this record */
SyBlobFormat(pWorker,"%z_%qd",&pCol->sName,pCol->nLastid);
nKeyLen = SyBlobLength(pWorker);
if( nKeyLen < 1 ){
unqliteGenOutofMem(pCol->pVm->pDb);
return UNQLITE_NOMEM;
}
/* Turn to FastJson */
rc = FastJsonEncode(pValue,pWorker,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Finally perform the insertion */
rc = pMethods->xReplace(
pEngine,
SyBlobData(pWorker),nKeyLen,
SyBlobDataAt(pWorker,nKeyLen),SyBlobLength(pWorker)-nKeyLen
);
if( rc == UNQLITE_OK ){
/* Save the value in the cache */
CollectionCacheInstallRecord(pCol,pCol->nLastid,pValue);
/* Increment the unique __id */
pCol->nLastid++;
pCol->nTotRec++;
/* Reflect the change */
rc = CollectionSetHeader(0,pCol,pCol->nLastid,pCol->nTotRec,0);
}
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"IO error while storing record into collection '%z'",
&pCol->sName
);
return rc;
}
return UNQLITE_OK;
}
/*
* Perform a update operation on a given collection.
*/
static int CollectionUpdate(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Record ID */
jx9_value *pValue /* JSON value to be stored */
)
{
SyBlob *pWorker = &pCol->sWorker;
unqlite_kv_methods *pMethods;
unqlite_kv_engine *pEngine;
sxu32 nKeyLen;
int rc;
/* Point to the underlying KV store */
pEngine = unqlitePagerGetKvEngine(pCol->pVm->pDb);
pMethods = pEngine->pIo->pMethods;
if( pCol->nTotRec >= SXI64_HIGH ){
/* Collection limit reached. No more records */
unqliteGenErrorFormat(pCol->pVm->pDb,
"Collection '%z': Records limit reached",
&pCol->sName
);
return UNQLITE_LIMIT;
}
if( pMethods->xReplace == 0 ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Cannot store record into collection '%z' due to a read-only Key/Value storage engine",
&pCol->sName
);
return UNQLITE_READ_ONLY;
}
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Prepare the unique ID for this record */
SyBlobFormat(pWorker,"%z_%qd",&pCol->sName, nId);
/* Reset the cursor */
unqlite_kv_cursor_reset(pCol->pCursor);
/* Seek the cursor to the desired location */
rc = unqlite_kv_cursor_seek(pCol->pCursor,
SyBlobData(pWorker),SyBlobLength(pWorker),
UNQLITE_CURSOR_MATCH_EXACT
);
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"No record to update in collection '%z'",
&pCol->sName
);
return rc;
}
if( jx9_value_is_json_object(pValue) ){
jx9_value sId;
/* If the given type is a JSON object, then add the special __id field */
jx9MemObjInitFromInt(pCol->pVm->pJx9Vm,&sId,nId);
jx9_array_add_strkey_elem(pValue,"__id",&sId);
jx9MemObjRelease(&sId);
}
nKeyLen = SyBlobLength(pWorker);
if( nKeyLen < 1 ){
unqliteGenOutofMem(pCol->pVm->pDb);
return UNQLITE_NOMEM;
}
/* Turn to FastJson */
rc = FastJsonEncode(pValue,pWorker,0);
if( rc != UNQLITE_OK ){
return rc;
}
/* Finally perform the insertion */
rc = pMethods->xReplace(
pEngine,
SyBlobData(pWorker),nKeyLen,
SyBlobDataAt(pWorker,nKeyLen),SyBlobLength(pWorker)-nKeyLen
);
if( rc == UNQLITE_OK ){
/* Save the value in the cache */
CollectionCacheInstallRecord(pCol,nId,pValue);
}
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"IO error while storing record into collection '%z'",
&pCol->sName
);
return rc;
}
return UNQLITE_OK;
}
/*
* Array walker callback (Refer to jx9_array_walk()).
*/
static int CollectionRecordArrayWalker(jx9_value *pKey,jx9_value *pData,void *pUserData)
{
unqlite_col *pCol = (unqlite_col *)pUserData;
int rc;
/* Perform the insertion */
rc = CollectionStore(pCol,pData);
if( rc != UNQLITE_OK ){
SXUNUSED(pKey); /* cc warning */
}
return rc;
}
/*
* Perform a store operation on a given collection.
*/
UNQLITE_PRIVATE int unqliteCollectionPut(unqlite_col *pCol,jx9_value *pValue,int iFlag)
{
int rc;
if( !jx9_value_is_json_object(pValue) && jx9_value_is_json_array(pValue) ){
/* Iterate over the array and store its members in the collection */
rc = jx9_array_walk(pValue,CollectionRecordArrayWalker,pCol);
SXUNUSED(iFlag); /* cc warning */
}else{
rc = CollectionStore(pCol,pValue);
}
return rc;
}
/*
* Drop a record from a given collection.
*/
UNQLITE_PRIVATE int unqliteCollectionDropRecord(
unqlite_col *pCol, /* Target collection */
jx9_int64 nId, /* Unique ID of the record to be droped */
int wr_header, /* True to alter collection header */
int log_err /* True to log error */
)
{
SyBlob *pWorker = &pCol->sWorker;
int rc;
/* Reset the working buffer */
SyBlobReset(pWorker);
/* Prepare the unique ID for this record */
SyBlobFormat(pWorker,"%z_%qd",&pCol->sName,nId);
/* Reset the cursor */
unqlite_kv_cursor_reset(pCol->pCursor);
/* Seek the cursor to the desired location */
rc = unqlite_kv_cursor_seek(pCol->pCursor,
SyBlobData(pWorker),SyBlobLength(pWorker),
UNQLITE_CURSOR_MATCH_EXACT
);
if( rc != UNQLITE_OK ){
return rc;
}
/* Remove the record from the storage engine */
rc = unqlite_kv_cursor_delete_entry(pCol->pCursor);
/* Finally, Remove the record from the cache */
unqliteCollectionCacheRemoveRecord(pCol,nId);
if( rc == UNQLITE_OK ){
pCol->nTotRec--;
if( wr_header ){
/* Relect in the collection header */
rc = CollectionSetHeader(0,pCol,-1,pCol->nTotRec,0);
}
}else if( rc == UNQLITE_NOTIMPLEMENTED ){
if( log_err ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Cannot delete record from collection '%z' due to a read-only Key/Value storage engine",
&pCol->sName
);
}
}
return rc;
}
/*
* Update a given record with new data
*/
UNQLITE_PRIVATE int unqliteCollectionUpdateRecord(unqlite_col *pCol,jx9_int64 nId, jx9_value *pValue,int iFlag)
{
int rc;
if( !jx9_value_is_json_object(pValue) && jx9_value_is_json_array(pValue) ){
/* Iterate over the array and store its members in the collection */
rc = jx9_array_walk(pValue,CollectionRecordArrayWalker,pCol);
SXUNUSED(iFlag); /* cc warning */
}else{
rc = CollectionUpdate(pCol,nId,pValue);
}
return rc;
}
/*
* Drop a collection from the KV storage engine and the underlying
* unqlite VM.
*/
UNQLITE_PRIVATE int unqliteDropCollection(unqlite_col *pCol)
{
unqlite_vm *pVm = pCol->pVm;
jx9_int64 nId;
int rc;
/* Reset the cursor */
unqlite_kv_cursor_reset(pCol->pCursor);
/* Seek the cursor to the desired location */
rc = unqlite_kv_cursor_seek(pCol->pCursor,
SyStringData(&pCol->sName),SyStringLength(&pCol->sName),
UNQLITE_CURSOR_MATCH_EXACT
);
if( rc == UNQLITE_OK ){
/* Remove the record from the storage engine */
rc = unqlite_kv_cursor_delete_entry(pCol->pCursor);
}
if( rc != UNQLITE_OK ){
unqliteGenErrorFormat(pCol->pVm->pDb,
"Cannot remove collection '%z' due to a read-only Key/Value storage engine",
&pCol->sName
);
return rc;
}
/* Drop collection records */
for( nId = 0 ; nId < pCol->nLastid ; ++nId ){
unqliteCollectionDropRecord(pCol,nId,0,0);
}
/* Cleanup */
CollectionCacheRelease(pCol);
SyBlobRelease(&pCol->sHeader);
SyBlobRelease(&pCol->sWorker);
SyMemBackendFree(&pVm->sAlloc,(void *)SyStringData(&pCol->sName));
unqliteReleaseCursor(pVm->pDb,pCol->pCursor);
/* Unlink */
if( pCol->pPrevCol ){
pCol->pPrevCol->pNextCol = pCol->pNextCol;
}else{
sxu32 iBucket = pCol->nHash & (pVm->iColSize - 1);
pVm->apCol[iBucket] = pCol->pNextCol;
}
if( pCol->pNextCol ){
pCol->pNextCol->pPrevCol = pCol->pPrevCol;
}
MACRO_LD_REMOVE(pVm->pCol,pCol);
pVm->iCol--;
SyMemBackendPoolFree(&pVm->sAlloc,pCol);
return UNQLITE_OK;
}
/*
* ----------------------------------------------------------
* File: unqlite_jx9.c
* MD5: 8fddc15b667e85d7b5df5367132518fb
* ----------------------------------------------------------
*/
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/* $SymiscID: unql_jx9.c v1.2 FreeBSD 2013-01-24 22:45 stable <chm@symisc.net> $ */
#ifndef UNQLITE_AMALGAMATION
#include "unqliteInt.h"
#endif
/*
* This file implements UnQLite functions (db_exists(), db_create(), db_put(), db_get(), etc.) for the
* underlying Jx9 Virtual Machine.
*/
/*
* string db_version(void)
* Return the current version of the unQLite database engine.
* Parameter
* None
* Return
* unQLite version number (string).
*/
static int unqliteBuiltin_db_version(jx9_context *pCtx,int argc,jx9_value **argv)
{
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
jx9_result_string(pCtx,UNQLITE_VERSION,(int)sizeof(UNQLITE_VERSION)-1);
return JX9_OK;
}
/*
* string db_errlog(void)
* Return the database error log.
* Parameter
* None
* Return
* Database error log (string).
*/
static int unqliteBuiltin_db_errlog(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
SyBlob *pErr;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the error log */
pErr = &pVm->pDb->sErr;
/* Return the log */
jx9_result_string(pCtx,(const char *)SyBlobData(pErr),(int)SyBlobLength(pErr));
return JX9_OK;
}
/*
* string db_copyright(void)
* string db_credits(void)
* Return the unQLite database engine copyright notice.
* Parameter
* None
* Return
* Copyright notice.
*/
static int unqliteBuiltin_db_credits(jx9_context *pCtx,int argc,jx9_value **argv)
{
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
jx9_result_string(pCtx,UNQLITE_COPYRIGHT,(int)sizeof(UNQLITE_COPYRIGHT)-1);
return JX9_OK;
}
/*
* string db_sig(void)
* Return the unQLite database engine unique signature.
* Parameter
* None
* Return
* unQLite signature.
*/
static int unqliteBuiltin_db_sig(jx9_context *pCtx,int argc,jx9_value **argv)
{
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
jx9_result_string(pCtx,UNQLITE_IDENT,sizeof(UNQLITE_IDENT)-1);
return JX9_OK;
}
/*
* bool collection_exists(string $name)
* bool db_exits(string $name)
* Check if a given collection exists in the underlying database.
* Parameter
* name: Lookup name
* Return
* TRUE if the collection exits. FALSE otherwise.
*/
static int unqliteBuiltin_collection_exists(jx9_context *pCtx,int argc,jx9_value **argv)
{
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Perform the lookup */
rc = unqliteExistsCollection(pVm, &sName);
/* Lookup result */
jx9_result_bool(pCtx, rc == UNQLITE_OK ? 1 : 0);
return JX9_OK;
}
/*
* bool collection_create(string $name)
* bool db_create(string $name)
* Create a new collection.
* Parameter
* name: Collection name
* Return
* TRUE if the collection was successfuly created. FALSE otherwise.
*/
static int unqliteBuiltin_collection_create(jx9_context *pCtx,int argc,jx9_value **argv)
{
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Try to create the collection */
rc = unqliteCreateCollection(pVm,&sName);
/* Return the result to the caller */
jx9_result_bool(pCtx,rc == UNQLITE_OK ? 1 : 0);
return JX9_OK;
}
/*
* value db_fetch(string $col_name)
* value db_get(string $col_name)
* Fetch the current record from a given collection and advance
* the record cursor.
* Parameter
* col_name: Collection name
* Return
* Record content success. NULL on failure (No more records to retrieve).
*/
static int unqliteBuiltin_db_fetch_next(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return null */
jx9_result_null(pCtx);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return null */
jx9_result_null(pCtx);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
/* Fetch the current record */
jx9_value *pValue;
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 ){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Jx9 is running out of memory");
jx9_result_null(pCtx);
return JX9_OK;
}else{
rc = unqliteCollectionFetchNextRecord(pCol,pValue);
if( rc == UNQLITE_OK ){
jx9_result_value(pCtx,pValue);
/* pValue will be automatically released as soon we return from this function */
}else{
/* Return null */
jx9_result_null(pCtx);
}
}
}else{
/* No such collection, return null */
jx9_result_null(pCtx);
}
return JX9_OK;
}
/*
* value db_fetch_by_id(string $col_name,int64 $record_id)
* value db_get_by_id(string $col_name,int64 $record_id)
* Fetch a record using its unique ID from a given collection.
* Parameter
* col_name: Collection name
* record_id: Record number (__id field of a JSON object)
* Return
* Record content success. NULL on failure (No such record).
*/
static int unqliteBuiltin_db_fetch_by_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
jx9_int64 nId;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or record ID");
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
/* Extract the record ID */
nId = jx9_value_to_int(argv[1]);
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
/* Fetch the desired record */
jx9_value *pValue;
pValue = jx9_context_new_scalar(pCtx);
if( pValue == 0 ){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Jx9 is running out of memory");
jx9_result_null(pCtx);
return JX9_OK;
}else{
rc = unqliteCollectionFetchRecordById(pCol,nId,pValue);
if( rc == UNQLITE_OK ){
jx9_result_value(pCtx,pValue);
/* pValue will be automatically released as soon we return from this function */
}else{
/* No such record, return null */
jx9_result_null(pCtx);
}
}
}else{
/* No such collection, return null */
jx9_result_null(pCtx);
}
return JX9_OK;
}
/*
* array db_fetch_all(string $col_name,[callback filter_callback])
* array db_get_all(string $col_name,[callback filter_callback])
* Retrieve all records of a given collection and apply the given
* callback if available to filter records.
* Parameter
* col_name: Collection name
* Return
* Contents of the collection (JSON array) on success. NULL on failure.
*/
static int unqliteBuiltin_db_fetch_all(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return NULL */
jx9_result_null(pCtx);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
jx9_value *pValue,*pArray,*pCallback = 0;
jx9_value sResult; /* Callback result */
/* Allocate an empty scalar value and an empty JSON array */
pArray = jx9_context_new_array(pCtx);
pValue = jx9_context_new_scalar(pCtx);
jx9MemObjInit(pCtx->pVm,&sResult);
if( pValue == 0 || pArray == 0 ){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Jx9 is running out of memory");
jx9_result_null(pCtx);
return JX9_OK;
}
if( argc > 1 && jx9_value_is_callable(argv[1]) ){
pCallback = argv[1];
}
unqliteCollectionResetRecordCursor(pCol);
/* Fetch collection records one after one */
while( UNQLITE_OK == unqliteCollectionFetchNextRecord(pCol,pValue) ){
if( pCallback ){
jx9_value *apArg[2];
/* Invoke the filter callback */
apArg[0] = pValue;
rc = jx9VmCallUserFunction(pCtx->pVm,pCallback,1,apArg,&sResult);
if( rc == JX9_OK ){
int iResult; /* Callback result */
/* Extract callback result */
iResult = jx9_value_to_bool(&sResult);
if( !iResult ){
/* Discard the result */
unqliteCollectionCacheRemoveRecord(pCol,unqliteCollectionCurrentRecordId(pCol) - 1);
continue;
}
}
}
/* Put the value in the JSON array */
jx9_array_add_elem(pArray,0,pValue);
/* Release the value */
jx9_value_null(pValue);
}
jx9MemObjRelease(&sResult);
/* Finally, return our array */
jx9_result_value(pCtx,pArray);
/* pValue will be automatically released as soon we return from
* this foreign function.
*/
}else{
/* No such collection, return null */
jx9_result_null(pCtx);
}
return JX9_OK;
}
/*
* int64 db_last_record_id(string $col_name)
* Return the ID of the last inserted record.
* Parameter
* col_name: Collection name
* Return
* Record ID (64-bit integer) on success. FALSE on failure.
*/
static int unqliteBuiltin_db_last_record_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
jx9_result_int64(pCtx,unqliteCollectionLastRecordId(pCol));
}else{
/* No such collection, return FALSE */
jx9_result_bool(pCtx,0);
}
return JX9_OK;
}
/*
* inr64 db_current_record_id(string $col_name)
* Return the current record ID.
* Parameter
* col_name: Collection name
* Return
* Current record ID (64-bit integer) on success. FALSE on failure.
*/
static int unqliteBuiltin_db_current_record_id(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
jx9_result_int64(pCtx,unqliteCollectionCurrentRecordId(pCol));
}else{
/* No such collection, return FALSE */
jx9_result_bool(pCtx,0);
}
return JX9_OK;
}
/*
* bool db_reset_record_cursor(string $col_name)
* Reset the record ID cursor.
* Parameter
* col_name: Collection name
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_reset_record_cursor(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
unqliteCollectionResetRecordCursor(pCol);
jx9_result_bool(pCtx,1);
}else{
/* No such collection */
jx9_result_bool(pCtx,0);
}
return JX9_OK;
}
/*
* int64 db_total_records(string $col_name)
* Return the total number of inserted records in the given collection.
* Parameter
* col_name: Collection name
* Return
* Total number of records on success. FALSE on failure.
*/
static int unqliteBuiltin_db_total_records(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
unqlite_int64 nRec;
nRec = unqliteCollectionTotalRecords(pCol);
jx9_result_int64(pCtx,nRec);
}else{
/* No such collection */
jx9_result_bool(pCtx,0);
}
return JX9_OK;
}
/*
* string db_creation_date(string $col_name)
* Return the creation date of the given collection.
* Parameter
* col_name: Collection name
* Return
* Creation date on success. FALSE on failure.
*/
static int unqliteBuiltin_db_creation_date(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
Sytm *pTm = &pCol->sCreation;
jx9_result_string_format(pCtx,"%d-%d-%d %02d:%02d:%02d",
pTm->tm_year,pTm->tm_mon,pTm->tm_mday,
pTm->tm_hour,pTm->tm_min,pTm->tm_sec
);
}else{
/* No such collection */
jx9_result_bool(pCtx,0);
}
return JX9_OK;
}
/*
* bool db_store(string $col_name,...)
* bool db_put(string $col_name,...)
* Store one or more JSON values in a given collection.
* Parameter
* col_name: Collection name
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_store(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
int i;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or records");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol == 0 ){
jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
/* Store the given values */
for( i = 1 ; i < argc ; ++i ){
rc = unqliteCollectionPut(pCol,argv[i],0);
if( rc != UNQLITE_OK){
jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,
"Error while storing record %d in collection '%z'",i,&sName
);
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
}
/* All done, return TRUE */
jx9_result_bool(pCtx,1);
return JX9_OK;
}
/*
* bool db_update_record(string $col_name, int_64 record_id, object $json_object)
* Update a given record with new json object
* Parameter
* col_name: Collection name
* record_id: ID of the record
* json_object: New Record data
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_update_record(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
jx9_int64 nId;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or records");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol == 0 ){
jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
/* Update a record with the given value */
nId = jx9_value_to_int64(argv[1]);
rc = unqliteCollectionUpdateRecord(pCol, nId, argv[2], 0);
/* All done, return TRUE */
jx9_result_bool(pCtx,rc == UNQLITE_OK);
return JX9_OK;
}
/*
* bool db_drop_collection(string $col_name)
* bool collection_delete(string $col_name)
* Remove a given collection from the database.
* Parameter
* col_name: Collection name
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_drop_col(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol == 0 ){
jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
/* Drop the collection */
rc = unqliteDropCollection(pCol);
/* Processing result */
jx9_result_bool(pCtx,rc == UNQLITE_OK);
return JX9_OK;
}
/*
* bool db_drop_record(string $col_name,int64 record_id)
* Remove a given record from a collection.
* Parameter
* col_name: Collection name.
* record_id: ID of the record.
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_drop_record(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
jx9_int64 nId;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or records");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol == 0 ){
jx9_context_throw_error_format(pCtx,JX9_CTX_ERR,"No such collection '%z'",&sName);
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
/* Extract the record ID */
nId = jx9_value_to_int64(argv[1]);
/* Drop the record */
rc = unqliteCollectionDropRecord(pCol,nId,1,1);
/* Processing result */
jx9_result_bool(pCtx,rc == UNQLITE_OK);
return JX9_OK;
}
/*
* bool db_set_schema(string $col_name, object $json_object)
* Set a schema for a given collection.
* Parameter
* col_name: Collection name.
* json_object: Collection schema (Must be a JSON object).
* Return
* TRUE on success. FALSE on failure.
*/
static int unqliteBuiltin_db_set_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
int rc;
/* Extract collection name */
if( argc < 2 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or db scheme");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
if( !jx9_value_is_json_object(argv[1]) ){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection scheme");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
rc = UNQLITE_NOOP;
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
/* Set the collection scheme */
rc = unqliteCollectionSetSchema(pCol,argv[1]);
}else{
jx9_context_throw_error_format(pCtx,JX9_CTX_WARNING,
"No such collection '%z'",
&sName
);
}
/* Processing result */
jx9_result_bool(pCtx,rc == UNQLITE_OK);
return JX9_OK;
}
/*
* object db_get_schema(string $col_name)
* Return the schema associated with a given collection.
* Parameter
* col_name: Collection name
* Return
* Collection schema on success. null otherwise.
*/
static int unqliteBuiltin_db_get_schema(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_col *pCol;
const char *zName;
unqlite_vm *pVm;
SyString sName;
int nByte;
/* Extract collection name */
if( argc < 1 ){
/* Missing arguments */
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Missing collection name and/or db scheme");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
zName = jx9_value_to_string(argv[0],&nByte);
if( nByte < 1){
jx9_context_throw_error(pCtx,JX9_CTX_ERR,"Invalid collection name");
/* Return false */
jx9_result_bool(pCtx,0);
return JX9_OK;
}
SyStringInitFromBuf(&sName,zName,nByte);
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Fetch the collection */
pCol = unqliteCollectionFetch(pVm,&sName,UNQLITE_VM_AUTO_LOAD);
if( pCol ){
/* Return the collection schema */
jx9_result_value(pCtx,&pCol->sSchema);
}else{
jx9_context_throw_error_format(pCtx,JX9_CTX_WARNING,
"No such collection '%z'",
&sName
);
jx9_result_null(pCtx);
}
return JX9_OK;
}
/*
* bool db_begin(void)
* Manually begin a write transaction.
* Parameter
* None
* Return
* TRUE on success. FALSE otherwise.
*/
static int unqliteBuiltin_db_begin(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
unqlite *pDb;
int rc;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
/* Point to the unqlite Vm */
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the underlying database handle */
pDb = pVm->pDb;
/* Begin the transaction */
rc = unqlitePagerBegin(pDb->sDB.pPager);
/* result */
jx9_result_bool(pCtx,rc == UNQLITE_OK );
return JX9_OK;
}
/*
* bool db_commit(void)
* Manually commit a transaction.
* Parameter
* None
* Return
* TRUE if the transaction was successfuly commited. FALSE otherwise.
*/
static int unqliteBuiltin_db_commit(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
unqlite *pDb;
int rc;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
/* Point to the unqlite Vm */
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the underlying database handle */
pDb = pVm->pDb;
/* Commit the transaction if any */
rc = unqlitePagerCommit(pDb->sDB.pPager);
/* Commit result */
jx9_result_bool(pCtx,rc == UNQLITE_OK );
return JX9_OK;
}
/*
* bool db_rollback(void)
* Manually rollback a transaction.
* Parameter
* None
* Return
* TRUE if the transaction was successfuly rolled back. FALSE otherwise
*/
static int unqliteBuiltin_db_rollback(jx9_context *pCtx,int argc,jx9_value **argv)
{
unqlite_vm *pVm;
unqlite *pDb;
int rc;
SXUNUSED(argc); /* cc warning */
SXUNUSED(argv);
/* Point to the unqlite Vm */
pVm = (unqlite_vm *)jx9_context_user_data(pCtx);
/* Point to the underlying database handle */
pDb = pVm->pDb;
/* Rollback the transaction if any */
rc = unqlitePagerRollback(pDb->sDB.pPager,TRUE);
/* Rollback result */
jx9_result_bool(pCtx,rc == UNQLITE_OK );
return JX9_OK;
}
/*
* Register all the UnQLite foreign functions defined above.
*/
UNQLITE_PRIVATE int unqliteRegisterJx9Functions(unqlite_vm *pVm)
{
static const jx9_builtin_func aBuiltin[] = {
{ "db_version" , unqliteBuiltin_db_version },
{ "db_copyright", unqliteBuiltin_db_credits },
{ "db_credits" , unqliteBuiltin_db_credits },
{ "db_sig" , unqliteBuiltin_db_sig },
{ "db_errlog", unqliteBuiltin_db_errlog },
{ "collection_exists", unqliteBuiltin_collection_exists },
{ "db_exists", unqliteBuiltin_collection_exists },
{ "collection_create", unqliteBuiltin_collection_create },
{ "db_create", unqliteBuiltin_collection_create },
{ "db_fetch", unqliteBuiltin_db_fetch_next },
{ "db_get", unqliteBuiltin_db_fetch_next },
{ "db_fetch_by_id", unqliteBuiltin_db_fetch_by_id },
{ "db_get_by_id", unqliteBuiltin_db_fetch_by_id },
{ "db_fetch_all", unqliteBuiltin_db_fetch_all },
{ "db_get_all", unqliteBuiltin_db_fetch_all },
{ "db_last_record_id", unqliteBuiltin_db_last_record_id },
{ "db_current_record_id", unqliteBuiltin_db_current_record_id },
{ "db_reset_record_cursor", unqliteBuiltin_db_reset_record_cursor },
{ "db_total_records", unqliteBuiltin_db_total_records },
{ "db_creation_date", unqliteBuiltin_db_creation_date },
{ "db_store", unqliteBuiltin_db_store },
{ "db_update_record", unqliteBuiltin_db_update_record },
{ "db_put", unqliteBuiltin_db_store },
{ "db_drop_collection", unqliteBuiltin_db_drop_col },
{ "collection_delete", unqliteBuiltin_db_drop_col },
{ "db_drop_record", unqliteBuiltin_db_drop_record },
{ "db_set_schema", unqliteBuiltin_db_set_schema },
{ "db_get_schema", unqliteBuiltin_db_get_schema },
{ "db_begin", unqliteBuiltin_db_begin },
{ "db_commit", unqliteBuiltin_db_commit },
{ "db_rollback", unqliteBuiltin_db_rollback },
};
int rc = UNQLITE_OK;
sxu32 n;
/* Register the unQLite functions defined above in the Jx9 call table */
for( n = 0 ; n < SX_ARRAYSIZE(aBuiltin) ; ++n ){
rc = jx9_create_function(pVm->pJx9Vm,aBuiltin[n].zName,aBuiltin[n].xFunc,pVm);
}
return rc;
}
/* END-OF-IMPLEMENTATION: unqlite@embedded@symisc 34-09-46 */
/*
* Symisc unQLite: An Embeddable NoSQL (Post Modern) Database Engine.
* Copyright (C) 2012-2013, Symisc Systems http://unqlite.org/
* Version 1.1.6
* For information on licensing, redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES
* please contact Symisc Systems via:
* legal@symisc.net
* licensing@symisc.net
* contact@symisc.net
* or visit:
* http://unqlite.org/licensing.html
*/
/*
* Copyright (C) 2012, 2013 Symisc Systems, S.U.A.R.L [M.I.A.G Mrad Chems Eddine <chm@symisc.net>].
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SYMISC SYSTEMS ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
* NON-INFRINGEMENT, ARE DISCLAIMED. IN NO EVENT SHALL SYMISC SYSTEMS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _WIN32
#pragma GCC diagnostic pop
#endif
View Git Blame Copy Permalink