LibSq3Lite_sq3.h

Go to the documentation of this file.

 
/* LABEL-NO */
 
#pragma once
 
#ifdef META_STATIC
# include "private_mk.h"
#else
# include "kernel_mk.h"
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  #include <string.h>
  #include "debug_mk.h"
#endif
 
__parser__(library=Sq3Lite@native@Sq3@SqLite3);
 
// MARK_D ################################################################
// -----------------------------------------------------------------------
// documentation order
 
// =========================================================================================
// Makefile:    CPPFLAGS definitions
 
// define:      META_STATIC
// reference:   META_STATIC from kernel_mk.h
 
#ifdef META_STATIC
# undef SQ3_C_BUILD_DLL
# define SQ3_C_BUILD_DLL
#endif
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
/* BEGIN_SQ3_C_DECLS should be used at the beginning of your declarations,
  so that C++ compilers don't mangle their names.  Use END_SQ3_C_DECLS at
  the end of C declarations. */
 
#undef BEGIN_SQ3_C_DECLS
#undef END_SQ3_C_DECLS
#if defined(META_COMPILE_AS_CC)
# define BEGIN_SQ3_C_DECLS namespace libsq3lite { using namespace libmkkernel;
# define END_SQ3_C_DECLS }
#elif defined(__cplusplus)
# define BEGIN_SQ3_C_DECLS extern "C" {
# define END_SQ3_C_DECLS }
#else
# define BEGIN_SQ3_C_DECLS /* empty */
# define END_SQ3_C_DECLS /* empty */
#endif
 
// MARK_O
#ifndef PARSE_C_HEADER_TO_META
# include "gen/sqlite3_overload_sq3.h"
#endif
 
BEGIN_SQ3_C_DECLS
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 
#  define  SQ3_RT_ARGS_ONLY       MK_RT_ARGS_ONLY
#  define  SQ3_RT_ARGS            MK_RT_ARGS
#  define  SQ3_RT_CALL_ONLY       MK_RT_CALL_ONLY
#  define  SQ3_RT_CALL            MK_RT_CALL
#  define  SQ3_RT_CALL_NULL_ONLY  MK_RT_CALL_NULL_ONLY
#  define  SQ3_RT_CALL_NULL       MK_RT_CALL_NULL
#  define  SQ3_RT_REF             MK_RT_REF
#  define  SQ3_RT_PARSER_ONLY     MK_RT_PARSER_ONLY
#  define  SQ3_RT_PARSER          MK_RT_PARSER
#  define  SQ3_RT_PTR             MK_RT_PTR
 
#  define  Sq3RtSetup_O(o)        MkRtSetup_O(o)
#  define  Sq3RtSetup_X(x)        MkRtSetup_X(x)
#  define  Sq3RtSetup_XN(x)       MkRtSetup_XN(x)
#  define  Sq3RtSetup_ON(o)       MkRtSetup_ON(o)
#  define  Sq3RtSetup_NULL        MkRtSetup_NULL
#  define  Sq3RtSetup_NULL_RT     MkRtSetup_NULL_RT
 
#  define  Sq3ERROR_R(r)          MkERROR_R(r)
#  define  Sq3ERROR_RT            MkERROR
#  define  Sq3ERROR_O(o)          MkERROR_O(o)
#  define  Sq3ERROR_X(x)          MkERROR_X(x)
#  define  Sq3ERROR_XN(x)         MkERROR_XN(x)
#  define  Sq3ERROR               MkERROR
 
// Sq3RuntimeC_C_API
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
// ==================================================================================
 
// BEGIN-HEADER - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// If the source of libsq3lite is direct used in an external library
// (without dynamic linking) and this library should *not* export
// the symbol's of libsq3lite then the flag META_IGNORE_EXTERN have
// to be set
#undef SQ3_EXTERN
#if defined(META_IGNORE_EXTERN)
#   define SQ3_EXTERN
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmqmsgque library ?
#      if defined(SQ3_C_BUILD_DLL)
#        define SQ3_EXTERN __declspec(dllexport)
#      else
#        define SQ3_EXTERN __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define SQ3_EXTERN __attribute__ ((visibility("default")))
#  endif
#else
#   define SQ3_EXTERN
#endif
 
// external data lookup
#undef SQ3_EXTERN_DATA
#if defined(META_PRIVATE)
#  define SQ3_EXTERN_DATA extern
#elif defined(META_IGNORE_EXTERN)
#  define SQ3_EXTERN_DATA extern
#elif defined(PIC)
   // does we build a DLL ?
#  if defined(DLL_EXPORT)
       // does we build the libmqmsgque library ?
#      if defined(SQ3_C_BUILD_DLL)
#        define SQ3_EXTERN_DATA __declspec(dllexport)
#      else
#        define SQ3_EXTERN_DATA __declspec(dllimport)
#      endif
#  else
   // no DLL - architecture specific extern specifier
#    define SQ3_EXTERN_DATA __attribute__ ((visibility("default"))) extern
#  endif
#else
#  define SQ3_EXTERN_DATA extern
#endif
 
// END-HEADER - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// SQ3_Compiler_C_API
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                       START api definition                      ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
// #######################################################################
// -----------------------------------------------------------------------
__parser__push__(no-rpc,template-overload,doc-group=libsq3lite,doc-index=Setup);
 
__parser__(no-inline)
SQ3_EXTERN void MK_DECL Sq3Setup (void) __attribute__ ((constructor(1000)));
 
__parser__(no-inline)
SQ3_EXTERN void MK_DECL Sq3Cleanup (void) __attribute__ ((destructor(1000)));
 
__parser__pop__;
 
// Sq3Lite_Setup_C_API
 
// ==================================================================================
 
#define SQ3_SET_T(_cls,_hook,_nat)   ({                     \
  /* _hook isn't used */                                    \
  (_cls##_type) MkObjCreate(_cls##_TT,_nat,NULL);           \
})
 
// Sq3Lite_Type_C_API
 
// BEGIN-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  __parser__(type=ME_CCC_Sq3ValueC:"Sq3ValueC class handle":primary)
  typedef struct Sq3ValueS * SQ3_VAL;
  __parser__(type=ME_CCN_Sq3ValueC:"const - Sq3ValueC class handle":primary)
  typedef const struct Sq3ValueS * SQ3_VALN;
  __parser__(ignore)
  typedef struct Sq3ValueS   SQ3_VALR;
// Sq3ValueC_Class_C_API
 
  __parser__(type=ME_CCC_Sq3StmtC:"Sq3StmtC class handle":primary)
  typedef struct Sq3StmtS * SQ3_STMT;
  __parser__(type=ME_CCN_Sq3StmtC:"const - Sq3StmtC class handle":primary)
  typedef const struct Sq3StmtS * SQ3_STMTN;
  __parser__(ignore)
  typedef struct Sq3StmtS   SQ3_STMTR;
// Sq3StmtC_Class_C_API
 
  __parser__(type=ME_CCC_Sq3BlobC:"Sq3BlobC class handle":primary)
  typedef struct Sq3BlobS * SQ3_BLOB;
  __parser__(type=ME_CCN_Sq3BlobC:"const - Sq3BlobC class handle":primary)
  typedef const struct Sq3BlobS * SQ3_BLOBN;
  __parser__(ignore)
  typedef struct Sq3BlobS   SQ3_BLOBR;
// Sq3BlobC_Class_C_API
 
  __parser__(type=ME_CCC_Sq3FileC:"Sq3FileC class handle":primary)
  typedef struct Sq3FileS * SQ3_FILE;
  __parser__(type=ME_CCN_Sq3FileC:"const - Sq3FileC class handle":primary)
  typedef const struct Sq3FileS * SQ3_FILEN;
  __parser__(ignore)
  typedef struct Sq3FileS   SQ3_FILER;
// Sq3FileC_Class_C_API
 
  __parser__(type=ME_CCC_Sq3LiteC:"Sq3LiteC class handle":primary)
  typedef struct Sq3LiteS * SQ3_LITE;
  __parser__(type=ME_CCN_Sq3LiteC:"const - Sq3LiteC class handle":primary)
  typedef const struct Sq3LiteS * SQ3_LITEN;
  __parser__(ignore)
  typedef struct Sq3LiteS   SQ3_LITER;
// Sq3LiteC_Class_C_API
 
// END-ShortDef - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// =======================================================================
 
END_SQ3_C_DECLS
 
  #include "Sq3Enum_sq3.h"
 
BEGIN_SQ3_C_DECLS
 
// =======================================================================
 
__parser__push__(doc-group=Error);
 
mk_inline bool Sq3ErrorCheckI(enum Sq3ErrorE ret)   { 
  return ((ret) > SQ3_RESULT_OK && (ret) < SQ3_RESULT_ROW) ; 
}
 
#define Sq3ErrorE_Check(sq3_hdl,PROC)                                  \
  if (unlikely(Sq3ErrorCheckI(PROC))) {                                \
    Sq3LiteErrorToMQ(MkOBJ(sq3_hdl), __func__,__FILE__,__LINE__);   \
    goto error;                                                        \
  }                                                                    \
 
#define Sq3ErrorE_Check_Package(PROC)                                   \
  if (unlikely(Sq3ErrorCheckI(PROC))) {                                 \
    Sq3LiteErrorToMQ(MK_ERROR_DEFAULT_NULL, __func__,__FILE__,__LINE__);                  \
    goto error;                                                         \
  }
 
#define Sq3ErrorE_Check_Static(cls_hdl, PROC)                           \
  if (unlikely(Sq3ErrorCheckI(PROC))) {                                 \
    Sq3LiteErrorToMQ(MkOBJ(cls_hdl), __func__,__FILE__,__LINE__);    \
    goto error;                                                         \
  }
 
#define Sq3ErrorE_Check_Ctor(__cls, __hdl, PROC)                                       \
  if (unlikely(Sq3ErrorCheckI(PROC))) {                                                \
    Sq3LiteErrorToMQ(__hdl?MkOBJ(__hdl):MkOBJ(__cls), __func__,__FILE__,__LINE__);  \
    goto error;                                                                        \
  }
 
// fix non common name
// example: (native code) config_error_t → (meta code) Sq3ErrorE
// add new meta-name with: typedef config_error_t Sq3ErrorE;
 
// ------------------------------------------------------------------
// error
 
__parser__(hide,overload-c-no,class=Sq3Lite)
SQ3_EXTERN enum MkErrorE MK_DECL
Sq3LiteErrorToMQ (
  MK_OBJN const obj,
  MK_STRN const func     __parser__(default=F#FUNC)  ,
  MK_STRN const file     __parser__(default=F#FILE)  ,
  MK_I32  const line     __parser__(default=F#LINE)
) MK_ATTR_HDL;
 
__parser__pop__;
// Sq3Lite_Error_C_API
 
__parser__(hide)
typedef void ( MK_DECL *Sq3SetupThreadF ) ( MK_RT_ARGS_ONLY );
 
__parser__(hide,class=Sq3Lite,doc-group=Config)
SQ3_EXTERN void MK_DECL Sq3SetupThreadCallback ( Sq3SetupThreadF call );
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                   D E C L A R A T I O N S                       ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
#ifndef PARSE_C_HEADER_TO_META
// BEGIN-Declaration - created by 'c_MqC.tcl -i NHI1_HOME/theSq3Lite/c/.libsq3lite.meta' - DO NOT change
// -> erased
// END-Declaration - created by 'c_MqC.tcl -i NHI1_HOME/theSq3Lite/c/.libsq3lite.meta' - DO NOT change
#endif
 
END_SQ3_C_DECLS
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                       I N C L U D E                             ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
#ifndef META_DOXYGEN_SHOULD_SKIP_THIS
 
  #ifdef PARSE_C_HEADER_TO_META
    #include "sqlite3_modified.h"
  #else
    #include "sqlite3.h"
  #endif
 
BEGIN_SQ3_C_DECLS
 
__parser__(type=ME_PSN_SQ3_FILENAME:"constant string filename data-type":primary)
typedef   sqlite3_filename  SQ3_FILENAME;
 
END_SQ3_C_DECLS
 
  // BEGIN-Class-Include - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
  #include "Sq3ValueC_sq3.h"
  #include "Sq3StmtC_sq3.h"
  #include "Sq3BlobC_sq3.h"
  #include "Sq3FileC_sq3.h"
  #include "Sq3LiteC_sq3.h"
 
  // END-Class-Include - created by 'c_Class.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
#endif
 
BEGIN_SQ3_C_DECLS
 
/* ####################################################################### */
/* ###                                                                 ### */
/* ###                   P A C K A G E - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
// ===========================================================================
__parser__global__(doc-force=Sq3Lite@Enum@local);
 
// =========================================================================
// BEGIN-Sq3Lite-fupu - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Config,sm_
  
    #define Sq3Fupu_Sq3LiteProgressHandler_X_ret  MK_I32
    #define Sq3Fupu_Sq3LiteProgressHandler_X_args MK_PTR P
    typedef Sq3Fupu_Sq3LiteProgressHandler_X_ret (*Sq3Fupu_Sq3LiteProgressHandler_X) (Sq3Fupu_Sq3LiteProgressHandler_X_args);
  
    #define Sq3Fupu_Sq3LiteSetAuthorizer_xAuth_ret  MK_I32
    #define Sq3Fupu_Sq3LiteSetAuthorizer_xAuth_args MK_PTR pUserData, MK_I32 auth_action_code, MK_STRN arg2, MK_STRN arg3, MK_STRN arg4, MK_STRN arg5
    typedef Sq3Fupu_Sq3LiteSetAuthorizer_xAuth_ret (*Sq3Fupu_Sq3LiteSetAuthorizer_xAuth) (Sq3Fupu_Sq3LiteSetAuthorizer_xAuth_args);
#endif
 
// END-Sq3Lite-fupu - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
// =========================================================================
// BEGIN-Sq3Lite-inline - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Config,sm_
  
  mk_inline MK_STRN Sq3CompileOptionGet (MK_I32 N) {
    MK_STRN __retVal__L = sqlite3_compileoption_get(N);
    return __retVal__L;
  }
  
  mk_inline MK_BOOL Sq3CompileOptionUsed (MK_STRN zOptName) {
    return (MK_BOOL)sqlite3_compileoption_used(zOptName);
  }
  
  mk_inline void Sq3LiteProgressHandler (SQ3_LITE sq3lite, MK_I32 N, Sq3Fupu_Sq3LiteProgressHandler_X X, MK_PTR P) {
    struct sqlite3 * sq3lite_hdl = sq3lite->nat;
    sqlite3_progress_handler(sq3lite_hdl, N, X, (MK_PTR)(P));
  }
  
  mk_inline enum Sq3AuthReturnE Sq3LiteSetAuthorizer (SQ3_LITE sq3lite, Sq3Fupu_Sq3LiteSetAuthorizer_xAuth xAuth, MK_PTR pUserData) {
    struct sqlite3 * sq3lite_hdl = sq3lite->nat;
    return (enum Sq3AuthReturnE)sqlite3_set_authorizer(sq3lite_hdl, xAuth, (MK_PTR)(pUserData));
  }
  
  mk_inline MK_I64 Sq3MemoryHighwater (MK_I32 resetFlag) {
    return sqlite3_memory_highwater(resetFlag);
  }
  
  mk_inline MK_I64 Sq3MemoryUsed (void) {
    return sqlite3_memory_used();
  }
  
  mk_inline void Sq3Randomness (MK_I32 N, MK_PTR P) {
    sqlite3_randomness(N, (MK_PTR)(P));
  }
  
  mk_inline enum MkErrorE Sq3Threadsafe (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_threadsafe();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Info,sm_
  
  mk_inline enum MkErrorE Sq3Complete (MK_STRN sql) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_complete(sql);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3KeywordCheck (MK_STRN arg0, MK_I32 arg1) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_keyword_check(arg0, arg1);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3KeywordCount (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_keyword_count();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  // doc-key: Sq3Lite,Sq3Lite-Info,smo
  
  mk_inline enum MkErrorE Sq3KeywordName (MK_I32 num, MK_STRN *kwd, MK_I32 *kwdsz) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_keyword_name(num, kwd, kwdsz);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3Status (enum Sq3StatusE op, MK_I32 *pCurrent, MK_I32 *pHighwater, MK_BOOL resetFlag) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_status(op, pCurrent, pHighwater, resetFlag);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3Status64 (enum Sq3StatusE op, MK_I64 *pCurrent, MK_I64 *pHighwater, MK_BOOL resetFlag) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_status64(op, pCurrent, pHighwater, resetFlag);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Internal-Alloc,sm_
  
  mk_inline void Sq3Free (MK_PTR N) {
    sqlite3_free((MK_PTR)(N));
  }
  
  mk_inline MK_PTR Sq3Malloc (MK_I32 N) {
    return (MK_PTR)sqlite3_malloc(N);
  }
  
  mk_inline MK_PTR Sq3Malloc64 (MK_I64 N) {
    return (MK_PTR)sqlite3_malloc64((MK_U64)N);
  }
  
  mk_inline MK_I64 Sq3Msize (MK_PTR N) {
    return (MK_I64)sqlite3_msize((MK_PTR)(N));
  }
  
  mk_inline MK_PTR Sq3Realloc (MK_PTR arg0, MK_I32 N) {
    return (MK_PTR)sqlite3_realloc((MK_PTR)(arg0), N);
  }
  
  mk_inline MK_PTR Sq3Realloc64 (MK_PTR arg0, MK_I64 N) {
    return (MK_PTR)sqlite3_realloc64((MK_PTR)(arg0), (MK_U64)N);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Internal-Memory,sm_
  
  mk_inline MK_I64 Sq3HardHeapLimit64 (MK_I64 N) {
    return sqlite3_hard_heap_limit64(N);
  }
  
  mk_inline enum MkErrorE Sq3ReleaseMemory (MK_I32 N) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_release_memory(N);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline MK_I64 Sq3SoftHeapLimit64 (MK_I64 N) {
    return sqlite3_soft_heap_limit64(N);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Internal-String,sm_
  
  mk_inline MK_I32 Sq3StrGlob (MK_STRN zGlob, MK_STRN zStr) {
    return sqlite3_strglob(zGlob, zStr);
  }
  
  mk_inline MK_I32 Sq3StrIcmp (MK_STRN arg0, MK_STRN arg1) {
    return sqlite3_stricmp(arg0, arg1);
  }
  
  mk_inline MK_I32 Sq3StrLike (MK_STRN zGlob, MK_STRN zStr, MK_I32 cEsc) {
    return sqlite3_strlike(zGlob, zStr, (MK_U32)cEsc);
  }
  
  mk_inline MK_I32 Sq3StrNicmp (MK_STRN arg0, MK_STRN arg1, MK_I32 arg2) {
    return sqlite3_strnicmp(arg0, arg1, arg2);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Setup-libsqlite3,sm_
  
  mk_inline enum MkErrorE Sq3Initialize (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_initialize();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3OsEnd (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_os_end();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3OsInit (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_os_init();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline enum MkErrorE Sq3Shutdown (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_shutdown();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Version,sm_
  
  mk_inline MK_STRN Sq3Libversion (void) {
    MK_STRN __retVal__L = sqlite3_libversion();
    return __retVal__L;
  }
  
  mk_inline enum MkErrorE Sq3LibversionNumber (void) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_libversion_number();
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline MK_STRN Sq3Sourceid (void) {
    MK_STRN __retVal__L = sqlite3_sourceid();
    return __retVal__L;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
  
  // doc-key: Sq3Lite,Sq3Lite-Vfs,sm_
  
  mk_inline SQ3_FILENAME Sq3CreateFilename (MK_STRN zDatabase, MK_STRN zJournal, MK_STRN zWal, MK_I32 azParam_num, MK_STRN *azParam) {
    SQ3_FILENAME __retVal__L = sqlite3_create_filename(zDatabase, zJournal, zWal, azParam_num, azParam);
    return __retVal__L;
  }
  
  mk_inline MK_STRN Sq3FilenameDatabase (SQ3_FILENAME F) {
    MK_STRN __retVal__L = sqlite3_filename_database(F);
    return __retVal__L;
  }
  
  mk_inline MK_STRN Sq3FilenameJournal (SQ3_FILENAME F) {
    MK_STRN __retVal__L = sqlite3_filename_journal(F);
    return __retVal__L;
  }
  
  mk_inline MK_STRN Sq3FilenameWal (SQ3_FILENAME F) {
    MK_STRN __retVal__L = sqlite3_filename_wal(F);
    return __retVal__L;
  }
  
  mk_inline void Sq3FreeFilename (SQ3_FILENAME arg0) {
    sqlite3_free_filename(arg0);
  }
  
  mk_inline enum MkErrorE Sq3UriBoolean (SQ3_FILENAME z, MK_STRN zParam, MK_I32 bDefault) {
    enum Sq3ErrorE errVal = (enum Sq3ErrorE)sqlite3_uri_boolean(z, zParam, bDefault);
    Sq3ErrorE_Check_Package(errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
  
  mk_inline MK_I64 Sq3UriInt64 (SQ3_FILENAME arg0, MK_STRN arg1, MK_I64 arg2) {
    return sqlite3_uri_int64(arg0, arg1, arg2);
  }
  
  mk_inline MK_STRN Sq3UriKey (SQ3_FILENAME z, MK_I32 N) {
    MK_STRN __retVal__L = sqlite3_uri_key(z, N);
    return __retVal__L;
  }
  
  mk_inline MK_STRN Sq3UriParameter (SQ3_FILENAME z, MK_STRN zParam) {
    MK_STRN __retVal__L = sqlite3_uri_parameter(z, zParam);
    return __retVal__L;
  }
#endif
 
// END-Sq3Lite-inline - created by 'c_Native.tcl -i NHI1_HOME/theSq3Lite/c/gen/c_sq3lite.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                                  check                                    */
/* (macros used in typeS functions)                                          */
/*****************************************************************************/
 
#define Sq3ErrorC_Check(hdl,PROC)          \
  if (unlikely(Sq3ErrorCheckI(PROC))) {    \
    OT_ERROR_SQ3_2_MQ(hdl);                \
    OT_ERROR_MQ_2_LNG(hdl);                 \
    goto error;                             \
  }
 
#define OT_ERROR_SQ3_2_MQ(hdl)         Sq3LiteErrorToMQ(MkOBJ(hdl), __func__,__FILE__,__LINE__);
 
 
__parser__(class=Package,doc-group=Info)
mk_inline enum MkErrorE Sq3KeywordNameBUF (MK_I32 num, MK_BUF *kwd_out) {
  assert(kwd_out != NULL);
  MkRtSetup_NULL;
  MkBufferCreateTLS_T(MkBuffer64C,buf,0);
  MK_STRN kwd   ;
  MK_I32  kwdsz ;
  Sq3KeywordName_E(num,&kwd,&kwdsz);
  MkBufferSizeNew(buf,kwdsz+1);
  strncpy(bufR.super.buf.storage.first.S,kwd,(size_t)kwdsz);
  bufR.super.buf.storage.first.S[kwdsz] = '\0';
  *kwd_out = buf;
  return MK_OK;
error:
  return MkErrorStack_1X(Sq3LiteC_TT);
}
 
 
END_SQ3_C_DECLS