QoreLib.h

Go to the documentation of this file.

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    QoreLib.h
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2023 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
 
    Note that the Qore library is released under a choice of three open-source
    licenses: MIT (as above), LGPL 2+, or GPL 2+; see README-LICENSE for more
    information.
*/
 
#ifndef _QORE_QORELIB_H
 
#define _QORE_QORELIB_H
 
#include <qore/common.h>
#include <qore/QoreThreadLock.h>
#include <qore/qore_bitopts.h>
#include <qore/safe_dslist>
 
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <strings.h>
#include <sys/types.h>
#include <vector>
 
typedef std::vector<int> sig_vec_t;
 
#undef _QORE_HAS_QORE_XMLNODE_CLASS
 
#undef _QORE_HAS_QORE_XMLREADER_CLASS
 
#undef _QORE_HAS_QORE_XMLDOC_CLASS
 
#define _QORE_HAS_HARD_TYPING 1
 
#define _QORE_HAS_DBI_EXECRAW 1
 
#define _QORE_HAS_TIME_ZONES 1
 
#define _QORE_HAS_THREAD_RESOURCE_IDS 1
 
#define _QORE_HAS_PREPARED_STATMENT_API 1
 
#define _QORE_HAS_DATASOURCE_ACTIVETRANSACTION 1
 
#define _QORE_HAS_DBI_SELECT_ROW 1
 
#define _QORE_HAS_NUMBER_TYPE 1
 
#define _QORE_HAS_PATH_IS_READABLE 1
 
#define _QORE_HAS_DBI_OPTIONS 1
 
#define _QORE_HAS_FIND_CREATE_TIMEZONE 1
 
#define _QORE_HAS_NUMBER_CONS_WITH_PREC 1
 
#define _QORE_HAS_FILE_OBJECT_HELPER 1
 
#define _QORE_HAS_QUEUE_OBJECT_HELPER 1
 
#define _QORE_HAS_QOREHTTPCLIENTOBJECT 1
 
#define _QORE_HAS_DBI_DESCRIBE 1
 
#define _QORE_HAS_DBI_EVENTS 1
 
#define _QORE_HAS_QUEUE_OBJECT 1
 
#define _QORE_HAS_SOCKET_PERF_API 1
 
#define _QORE_HAS_QL_MIT 1
 
#define _QORE_HAS_DATETIME_ADD_SECONDS_TO 1
 
// qore code flags
#define QCF_NO_FLAGS                     0   
#define QCF_NOOP                   (1 << 0)  
#define QCF_USES_EXTRA_ARGS        (1 << 1)  
#define QCF_CONSTANT_INTERN        (1 << 2)  
#define QCF_DEPRECATED             (1 << 3)  
#define QCF_RET_VALUE_ONLY         (1 << 4)  
#define QCF_RUNTIME_NOOP           (1 << 5)  
#define QCF_ABSTRACT_OVERRIDE_ALL  (1 << 6)  
 
// composite flags
#define QCF_CONSTANT (QCF_CONSTANT_INTERN | QCF_RET_VALUE_ONLY) 
 
class BinaryNode;
class QoreStringNode;
class ExceptionSink;
 
DLLEXPORT char* make_class_name(const char* fn);
 
DLLEXPORT QoreStringNode* q_sprintf(const QoreListNode* params, int field, int offset, ExceptionSink* xsink);
 
DLLEXPORT QoreStringNode* q_vsprintf(const QoreListNode* params, int field, int offset, ExceptionSink* xsink);
 
DLLEXPORT QoreStringNode* q_sprintf(const QoreListNode* params, int field, int offset, ExceptionSink* xsink);
 
DLLEXPORT hashdecl tm* q_localtime(const time_t* clock, struct tm* tms);
 
DLLEXPORT hashdecl tm* q_gmtime(const time_t* clock, struct tm* tms);
 
DLLEXPORT int64 q_epoch();
 
DLLEXPORT int64 q_epoch_us(int &us);
 
DLLEXPORT int64 q_epoch_ns(int &us);
 
DLLEXPORT char* q_basename(const char* path);
 
DLLEXPORT char* q_basenameptr(const char* path);
 
DLLEXPORT char* q_dirname(const char* path);
 
DLLEXPORT void* q_realloc(void* ptr, size_t size);
 
#ifndef _Q_WINDOWS
DLLEXPORT QoreHashNode* q_getpwuid(uid_t uid);
 
DLLEXPORT QoreHashNode* q_getpwnam(const char* name);
 
DLLEXPORT QoreHashNode* q_getgrgid(uid_t uid);
 
DLLEXPORT QoreHashNode* q_getgrnam(const char* name);
 
 
int q_uname2uid(const char* name, uid_t &uid);
 
 
int q_gname2gid(const char* name, gid_t &gid);
#endif // ! windows
 
DLLEXPORT void qore_setup_argv(int pos, int argc, char* argv[]);
 
DLLEXPORT qore_license_t qore_get_license();
 
DLLEXPORT void qore_exit_process(int rc);
 
 
class FeatureList : public safe_dslist<std::string> {
private:
   DLLLOCAL FeatureList(const FeatureList&);
 
   DLLLOCAL FeatureList& operator=(const FeatureList&);
 
public:
   DLLLOCAL FeatureList();
 
   DLLLOCAL ~FeatureList();
};
 
DLLEXPORT extern FeatureList qoreFeatureList;
 
static inline char* strchrs(const char* str, const char* chars) {
   while (*str) {
      if (strchr(chars, *str))
         return (char* )str;
      str++;
   }
   return 0;
}
 
static inline char* strnchr(const char* str, int len, char c) {
   int i = 0;
   while (i++ != len) {
      if (*str == c)
         return (char* )str;
      ++str;
   }
   return 0;
}
 
static inline void strtolower(char* str) {
   while (*(str)) {
      (*str) = tolower(*str);
      str++;
   }
}
 
static inline char* strtoupper(char* str) {
   char* p = str;
   while (*(p)) {
      *p = toupper(*p);
      p++;
   }
   return str;
}
 
DLLEXPORT int getSecZeroInt(QoreValue a);
 
DLLEXPORT int64 getSecZeroBigInt(QoreValue a);
 
DLLEXPORT int getSecMinusOneInt(QoreValue a);
 
DLLEXPORT int64 getSecMinusOneBigInt(QoreValue a);
 
DLLEXPORT int getMsZeroInt(QoreValue a);
 
DLLEXPORT int64 getMsZeroBigInt(QoreValue a);
 
DLLEXPORT int getMsMinusOneInt(QoreValue a);
 
DLLEXPORT int64 getMsMinusOneBigInt(QoreValue a);
 
DLLEXPORT int getMicroSecZeroInt(QoreValue a);
 
DLLEXPORT int64 getMicroSecZeroInt64(QoreValue a);
 
static inline bool is_nothing(const AbstractQoreNode* n) {
   if (!n || n->getType() == NT_NOTHING)
      return true;
 
   return false;
}
 
static inline void discard(AbstractQoreNode* n, ExceptionSink* xsink) {
   if (n)
      n->deref(xsink);
}
 
static inline const char* get_type_name(const AbstractQoreNode* n) {
   return n ? n->getTypeName() : "nothing";
}
 
 
DLLEXPORT const char* get_full_type_name(const AbstractQoreNode* n);
 
 
DLLEXPORT const char* get_full_type_name(const AbstractQoreNode* n, bool with_namespaces);
 
static inline qore_type_t get_node_type(const AbstractQoreNode* n) {
   return n ? n->getType() : NT_NOTHING;
}
 
typedef QoreStringNode* (*qore_uncompress_to_string_t)(const BinaryNode* b, const QoreEncoding* enc,
    ExceptionSink* xsink);
typedef BinaryNode* (*qore_uncompress_to_binary_t)(const BinaryNode* b, ExceptionSink* xsink);
 
DLLEXPORT BinaryNode* qore_deflate(void* ptr, unsigned long len, int level, ExceptionSink* xsink);
DLLEXPORT QoreStringNode* qore_inflate_to_string(const BinaryNode* b, const QoreEncoding* enc, ExceptionSink* xsink);
DLLEXPORT BinaryNode* qore_inflate_to_binary(const BinaryNode* b, ExceptionSink* xsink);
DLLEXPORT BinaryNode* qore_gzip(void* ptr, unsigned long len, int level, ExceptionSink* xsink);
DLLEXPORT QoreStringNode* qore_gunzip_to_string(const BinaryNode* bin, const QoreEncoding* enc, ExceptionSink* xsink);
DLLEXPORT BinaryNode* qore_gunzip_to_binary(const BinaryNode* bin, ExceptionSink* xsink);
DLLEXPORT BinaryNode* qore_bzip2(void* ptr, unsigned long len, int level, ExceptionSink* xsink);
DLLEXPORT QoreStringNode* qore_bunzip2_to_string(const BinaryNode* bin, const QoreEncoding* enc,
    ExceptionSink* xsink);
DLLEXPORT BinaryNode* qore_bunzip2_to_binary(const BinaryNode* bin, ExceptionSink* xsink);
 
DLLEXPORT BinaryNode* parseBase64(const char* buf, int len, ExceptionSink* xsink);
 
DLLEXPORT BinaryNode* parseHex(const char* buf, int len, ExceptionSink* xsink);
 
class AbstractQoreZoneInfo;
 
DLLEXPORT const AbstractQoreZoneInfo* findCreateOffsetZone(int seconds_east);
 
 
DLLEXPORT const AbstractQoreZoneInfo* find_create_timezone(const char* name, ExceptionSink* xsink);
 
DLLEXPORT int tz_get_utc_offset(const AbstractQoreZoneInfo* tz, int64 epoch_offset, bool &is_dst, const char* &zone_name);
DLLEXPORT bool tz_has_dst(const AbstractQoreZoneInfo* tz);
DLLEXPORT const char* tz_get_region_name(const AbstractQoreZoneInfo* tz);
 
#define QORE_OPT_ATOMIC_OPERATIONS       "atomic operations"
#define QORE_OPT_STACK_GUARD             "stack guard"
#define QORE_OPT_SIGNAL_HANDLING         "signal handling"
#define QORE_OPT_RUNTIME_STACK_TRACE     "runtime stack tracing"
#define QORE_OPT_LIBRARY_DEBUGGING       "library debugging"
#define QORE_OPT_SHA                     "openssl sha"
#define QORE_OPT_SHA224                  "openssl sha224"
#define QORE_OPT_SHA256                  "openssl sha256"
#define QORE_OPT_SHA384                  "openssl sha384"
#define QORE_OPT_SHA512                  "openssl sha512"
#define QORE_OPT_MDC2                    "openssl mdc2"
#define QORE_OPT_RC5                     "openssl rc5"
#define QORE_OPT_MD2                     "openssl md2"
#define QORE_OPT_DSS                     "openssl dss"
#define QORE_OPT_TERMIOS                 "termios"
#define QORE_OPT_FILE_LOCKING            "file locking"
#define QORE_OPT_UNIX_USERMGT            "unix user management"
#define QORE_OPT_UNIX_FILEMGT            "unix file management"
#define QORE_OPT_DETERMINISTIC_GC        "deterministic GC"
#define QORE_OPT_FUNC_ROUND              "round()"
#define QORE_OPT_FUNC_TIMEGM             "timegm()"
#define QORE_OPT_FUNC_SETEUID            "seteuid()"
#define QORE_OPT_FUNC_SETEGID            "setegid()"
#define QORE_OPT_FUNC_SYSTEM             "system()"
#define QORE_OPT_FUNC_KILL               "kill()"
#define QORE_OPT_FUNC_FORK               "fork()"
#define QORE_OPT_FUNC_GETPPID            "getppid()"
#define QORE_OPT_FUNC_STATVFS            "statvfs()"
#define QORE_OPT_FUNC_SETSID             "setsid()"
#define QORE_OPT_FUNC_IS_EXECUTABLE      "is_executable()"
#define QORE_OPT_FUNC_CLOSE_ALL_FD       "close_all_fd()"
#define QORE_OPT_FUNC_GET_NETIF_LIST     "get_netif_list()"
 
#define QO_OPTION     0
#define QO_ALGORITHM  1
#define QO_FUNCTION   2
 
hashdecl qore_option_s {
   const char* option;   
   const char* constant; 
   int type;             
   bool value;           
};
 
DLLEXPORT QoreStringNode* q_strerror(int errnum);
DLLEXPORT void q_strerror(QoreString &str, int errnum);
 
DLLEXPORT extern const qore_option_s* qore_option_list;
DLLEXPORT extern size_t qore_option_list_size;
 
 
DLLEXPORT QoreStringNode* qore_reassign_signal(int sig, const char* name);
 
 
DLLEXPORT QoreStringNode* qore_reassign_signals(const sig_vec_t& sig_vec, const char* name);
 
 
DLLEXPORT int qore_release_signal(int sig, const char* name);
 
 
DLLEXPORT int qore_release_signals(const sig_vec_t& sig_vec, const char* name);
 
#define QORE_MAX(a, b) ((a) > (b) ? (a) : (b))
 
#define QORE_MIN(a, b) ((a) < (b) ? (a) : (b))
 
#define QORE_PARAM_NO_ARG QoreSimpleValue().assign(nullptr)
 
// define QORE_PATH_MAX
#ifndef QORE_PATH_MAX
#ifdef _XOPEN_PATH_MAX
#define QORE_PATH_MAX _XOPEN_PATH_MAX
#else
#define QORE_PATH_MAX 1024
#endif
#endif
 
 
DLLEXPORT void parse_set_time_zone(const char* zone);
 
DLLEXPORT int qore_usleep(int64 usecs);
 
DLLEXPORT void qore_disable_gc();
 
DLLEXPORT bool qore_is_gc_enabled();
 
DLLEXPORT bool q_path_is_readable(const char* path);
 
DLLEXPORT bool q_parse_bool(QoreValue n);
 
DLLEXPORT bool q_parse_bool(const char* str);
 
DLLEXPORT bool q_get_option_value(const char* opt);
 
DLLEXPORT bool q_get_option_constant_value(const char* opt);
 
DLLEXPORT const char* q_mode_to_perm(mode_t mode, QoreString& perm);
 
int q_getcwd(QoreString& cwd);
 
DLLEXPORT bool q_absolute_path_unix(const char* path);
 
DLLEXPORT bool q_absolute_path_windows(const char* path);
 
DLLEXPORT bool q_absolute_path(const char* path);
 
DLLEXPORT void q_normalize_path(QoreString& path, const char* cwd = 0);
 
DLLEXPORT int q_realpath(const QoreString& path, QoreString& rv, ExceptionSink* xsink = 0);
 
DLLEXPORT void* q_memmem(const void* big, size_t big_len, const void* little, size_t little_len);
 
 
DLLEXPORT void* q_memrmem(const void* big, size_t big_len, const void* little, size_t little_len);
 
 
DLLEXPORT int q_env_subst(QoreString& str);
 
 
DLLEXPORT double q_strtod(const char* str);
 
 
DLLEXPORT bool q_libqore_initalized();
 
 
DLLEXPORT bool q_libqore_shutdown();
 
 
DLLEXPORT bool q_libqore_exiting();
 
 
DLLEXPORT QoreHashNode* q_get_thread_local_vars(int frame, ExceptionSink* xsink);
 
 
DLLEXPORT int q_set_thread_var_value(int frame, const char* name, const QoreValue& val, ExceptionSink* xsink);
 
DLLEXPORT int q_get_data(const QoreValue& data, const char*& ptr, size_t& len);
 
 
DLLEXPORT QoreListNode* parse_option_bitfield_to_string_list(int64 i, ExceptionSink* xsink);
 
 
DLLEXPORT QoreListNode* domain_bitfield_to_string_list(int64 i, ExceptionSink* xsink);
 
 
DLLEXPORT const QoreTypeInfo* get_or_nothing_type_check(const QoreTypeInfo* typeInfo);
 
 
DLLEXPORT const QoreClass* qore_pseudo_get_class(qore_type_t t);
 
 
DLLEXPORT const QoreClass* qore_pseudo_get_class(const QoreTypeInfo* t);
 
 
DLLEXPORT QoreProgram* qore_get_call_program_context();
 
 
DLLEXPORT void qore_set_module_option(std::string mod, std::string opt, QoreValue val);
 
 
DLLEXPORT QoreValue qore_get_module_option(std::string mod, std::string opt);
 
// try to remove noise in insignificant digits from a number string
DLLEXPORT void qore_apply_rounding_heuristic(QoreString& str, int round_threshold_1, int round_threshold_2);
 
 
DLLEXPORT size_t q_thread_get_stack_size();
 
 
DLLEXPORT size_t q_thread_get_this_stack_size();
 
 
DLLEXPORT size_t q_thread_set_stack_size(size_t size, ExceptionSink* xsink);
 
 
DLLEXPORT size_t q_thread_stack_remaining();
 
 
DLLEXPORT size_t q_thread_stack_used();
 
#endif // _QORE_QORELIB_H