common.h

Go to the documentation of this file.

/* -*- mode: c++; indent-tabs-mode: nil -*- */
/*
    common.h
 
    Qore Programming Language
 
    Copyright (C) 2003 - 2024 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_COMMON_H
 
#define _QORE_COMMON_H
 
#include <algorithm>
#include <cinttypes>
#include <cstdarg>
#include <cstddef>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <list>
#include <set>
#include <set>
#include <string>
#include <strings.h>
#include <vector>
 
#ifdef __GNUC__
#define PACK __attribute__ ((packed))
#else
#define PACK
#endif
 
class QoreTypeInfo;
 
#define Q_AF_UNSPEC -1
 
#define Q_AF_INET -2
 
#define Q_AF_INET6 -3
 
#define Q_SOCK_STREAM -1
 
typedef int16_t qore_type_t;
 
typedef size_t qore_size_t;
 
typedef intptr_t qore_offset_t;
 
typedef unsigned qore_classid_t;
 
typedef std::set<int> int_set_t;
 
enum qore_license_t {
    QL_GPL = 0,         
    QL_LGPL = 1,        
    QL_MIT = 2          
};
 
// class access values
enum ClassAccess : unsigned char {
    Public = 0,        // publicly accessible
    Private = 1,       // accessible only in the class hierarchy (like c++'s 'protected')
    Internal = 2,      // accessible only in the class itself
    Inaccessible = 3,  // not accessible from the class
};
 
#if defined _MSC_VER || ((defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__)
#define _Q_WINDOWS 1
#ifdef _WIN64
#define _Q_WINDOWS64 1
#endif
#endif
 
#ifdef _Q_WINDOWS
  #ifdef BUILDING_DLL
    #define DLLEXPORT __declspec(dllexport)
  #else
    #define DLLEXPORT __declspec(dllimport)
  #endif
  #define DLLLOCAL
 
  #define QLLD "%I64d"
  #define QLLX "%I64x"
  #define QLLDx(a) "%" #a "I64d"
  #define QORE_DIR_SEP '\\'
  #define QORE_DIR_SEP_STR "\\"
  #define QORE_PATH_SEP ';'
  #define QORE_PATH_SEP_STR ";"
  #include <winsock2.h>
#else
  #ifdef HAVE_GCC_VISIBILITY
    #define DLLEXPORT __attribute__ ((visibility("default")))
    #define DLLLOCAL __attribute__ ((visibility("hidden")))
  #else
    #define DLLEXPORT
    #define DLLLOCAL
  #endif
  #define QLLD "%lld"
  #define QLLX "%llx"
  #define QLLDx(a) "%" #a "lld"
  #define QORE_DIR_SEP '/'
  #define QORE_DIR_SEP_STR "/"
  #define QORE_PATH_SEP ':'
  #define QORE_PATH_SEP_STR ":"
#endif
 
#define _Q_MAKE_STRING(x) #x
#define MAKE_STRING_FROM_SYMBOL(x) _Q_MAKE_STRING(x)
 
// forward references
class AbstractQoreNode;
class QoreListNode;
class ExceptionSink;
class QoreObject;
class AbstractPrivateData;
class QoreMethod;
class QoreBuiltinMethod;
class QoreClass;
class TypedHashDecl;
class QoreExternalFunction;
class QoreExternalGlobalVar;
class QoreExternalConstant;
class QoreNamespace;
class QoreHashNode;
 
hashdecl QoreValue;
 
typedef std::vector<const QoreClass*> class_vec_t;
typedef std::vector<std::pair<const TypedHashDecl*, const QoreNamespace*>> hashdecl_vec_t;
typedef std::vector<const QoreExternalFunction*> func_vec_t;
typedef std::vector<const QoreNamespace*> ns_vec_t;
typedef std::vector<std::pair<const QoreExternalGlobalVar*, const QoreNamespace*>> gvar_vec_t;
typedef std::vector<std::pair<const QoreExternalConstant*, const QoreNamespace*>> const_vec_t;
 
template <typename T> hashdecl free_ptr {
    DLLLOCAL void operator()(T* ptr) {
        free(ptr);
    }
};
 
template <typename T> hashdecl simple_delete {
    DLLLOCAL void operator()(T* ptr) {
        delete ptr;
    }
};
 
template <typename T> hashdecl simple_deref {
    DLLLOCAL void operator()(T* ptr) {
        ptr->deref();
    }
    DLLLOCAL void operator()(T* ptr, ExceptionSink* xsink) {
        ptr->deref(xsink);
    }
};
 
class ltstr {
public:
    DLLLOCAL bool operator()(const char* s1, const char* s2) const {
        return strcmp(s1, s2) < 0;
    }
};
 
class ltcstrcase {
public:
    DLLLOCAL bool operator()(const char* s1, const char* s2) const {
        return strcasecmp(s1, s2) < 0;
    }
};
 
class ltstrcase {
public:
    DLLLOCAL bool operator()(std::string s1, std::string s2) const {
        return strcasecmp(s1.c_str(), s2.c_str()) < 0;
    }
};
 
class eqstr {
public:
    DLLLOCAL bool operator()(const char* s1, const char* s2) const {
        return !strcmp(s1, s2);
    }
};
 
class eqstrcase {
public:
    DLLLOCAL bool operator()(const char* s1, const char* s2) const {
        return !strcasecmp(s1, s2);
    }
};
 
class ltchar {
public:
    DLLLOCAL bool operator()(const char s1, const char s2) const {
        return s1 < s2;
    }
};
 
class cstr_vector_t : public std::vector<char*> {
public:
    DLLLOCAL ~cstr_vector_t() {
        clear();
    }
 
    DLLLOCAL void clear() {
        std::for_each(begin(), end(), free_ptr<char>());
        std::vector<char*>::clear();
    }
};
 
typedef std::vector<const QoreTypeInfo*> type_vec_t;
 
typedef std::vector<QoreValue> arg_vec_t;
 
typedef std::vector<std::string> name_vec_t;
 
typedef long long int64;
 
typedef uint64_t q_rt_flags_t;
 
constexpr size_t QSF_INCLUDE_STATIC_CLASS_VARS = (1 << 0);
 
constexpr size_t QDF_STATIC_CLASS_VARS = (1 << 0);
 
constexpr size_t QDF_MERGE_STATIC_CLASS_VARS = (1 << 1) | QDF_STATIC_CLASS_VARS;
 
 
class QoreSerializationContext {
public:
 
    DLLEXPORT int serializeObject(const QoreObject& obj, std::string& index, ExceptionSink* xsink);
 
 
    DLLEXPORT int serializeHash(const QoreHashNode& h, std::string& index, ExceptionSink* xsink);
 
 
    DLLEXPORT int serializeList(const QoreListNode& l, std::string& index, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue serializeValue(const QoreValue val, ExceptionSink* xsink);
 
    DLLEXPORT void addModule(const char* module);
 
    DLLEXPORT int64 getFlags() const;
 
private:
    DLLLOCAL QoreSerializationContext();
};
 
 
class QoreDeserializationContext {
public:
 
    DLLEXPORT QoreValue deserializeContainer(const char* index, ExceptionSink* xsink);
 
 
    DLLEXPORT QoreValue deserializeValue(const QoreValue val, ExceptionSink* xsink);
 
    DLLEXPORT int64 getFlags() const;
 
private:
    DLLLOCAL QoreDeserializationContext();
};
 
 
typedef QoreValue (*q_func_n_t)(const QoreListNode* args, q_rt_flags_t flags, ExceptionSink* xsink);
 
 
typedef QoreValue (*q_external_func_t)(const void* ptr, const QoreListNode* args, q_rt_flags_t flags, ExceptionSink* xsink);
 
 
typedef QoreValue (*q_method_n_t)(QoreObject* self, AbstractPrivateData* private_data, const QoreListNode* args, q_rt_flags_t flags, ExceptionSink* xsink);
 
 
typedef QoreValue (*q_external_method_t)(const QoreMethod& method, const void* ptr, QoreObject* self, AbstractPrivateData* private_data, const QoreListNode* args, q_rt_flags_t flags, ExceptionSink* xsink);
 
 
typedef QoreValue (*q_external_static_method_t)(const QoreMethod& method, const void* ptr, const QoreListNode* args, q_rt_flags_t flags, ExceptionSink* xsink);
 
 
typedef void (*q_constructor_n_t)(QoreObject* self, const QoreListNode* args, q_rt_flags_t rtflags, ExceptionSink* xsink);
 
 
typedef void (*q_external_constructor_t)(const QoreMethod& method, const void* ptr, QoreObject* self, const QoreListNode* args, q_rt_flags_t rtflags, ExceptionSink* xsink);
 
 
typedef void (*q_system_constructor_t)(QoreObject* self, int code, va_list args);
 
 
typedef void (*q_destructor_t)(QoreObject* self, AbstractPrivateData* private_data, ExceptionSink* xsink);
 
 
typedef void (*q_external_destructor_t)(const QoreClass& thisclass, const void* ptr, QoreObject* self, AbstractPrivateData* private_data, ExceptionSink* xsink);
 
 
typedef void (*q_copy_t)(QoreObject* self, QoreObject* old, AbstractPrivateData* private_data, ExceptionSink* xsink);
 
 
typedef void (*q_external_copy_t)(const QoreClass& thisclass, const void* ptr, QoreObject* self, QoreObject* old, AbstractPrivateData* private_data, ExceptionSink* xsink);
 
 
typedef QoreHashNode* (*q_serializer_t)(const QoreObject& self, const AbstractPrivateData& data, QoreSerializationContext& context, ExceptionSink* xsink);
 
 
typedef void (*q_deserializer_t)(QoreObject& self, const QoreHashNode* sdata, QoreDeserializationContext& context, ExceptionSink* xsink);
 
 
typedef unsigned q_trid_t;
 
DLLEXPORT long long q_atoll(const char* str);
 
 
DLLEXPORT const char* type_get_name(const QoreTypeInfo* t);
 
#endif // _QORE_COMMON_H