Global Namespace

// namespaces

namespace axl;
    namespace axl::cf;
    namespace axl::cry;
    namespace axl::dox;
    namespace axl::enc;
    namespace axl::err;
    namespace axl::g;
    namespace axl::gui;
    namespace axl::ini;
    namespace axl::io;
        namespace axl::io::psx;
        namespace axl::io::win;
    namespace axl::iok;
    namespace axl::lex;
    namespace axl::lua;
    namespace axl::mem;
    namespace axl::rc;
    namespace axl::re;
    namespace axl::sec;
    namespace axl::sl;
    namespace axl::spy;
    namespace axl::st;
    namespace axl::sys;
        namespace axl::sys::drw;
        namespace axl::sys::lnx;
        namespace axl::sys::psx;
        namespace axl::sys::win;
    namespace axl::xml;
    namespace axl::zip;

// typedefs

typedef int bool_t;
typedef unsigned int uint_t;
typedef unsigned char uchar_t;
typedef unsigned short ushort_t;
typedef unsigned long ulong_t;
typedef uint8_t byte_t;
typedef uint16_t word_t;
typedef uint64_t qword_t;
typedef uint32_t dword_t;
typedef void* handle_t;
typedef char utf8_t;
typedef wchar_t utf16_t;
typedef int32_t utf32_t;

// classes

class axl_va_list;

// global variables

AXL_SELECT_ANY FILE* axl_g_traceFile = stdout;

// global functions

size_t
strlen_s(const char* p);

size_t
wcslen_s(const wchar_t* p);

void
axl_trace_va(
    const char* formatString,
    axl_va_list va
    );

void
axl_trace(
    const char* formatString,
    ...
    );

void
lua_len_impl(
    lua_State* state,
    int index
    );

// macros

#define ASSERT
#define AXL_ASSERT
#define AXL_DEBUG_STRING
#define AXL_DEBUG_SUFFIX
#define AXL_DISABLE_COPY(Class)
#define AXL_GUI_WIDGET_BEGIN_MSG_MAP(BaseClass)
#define AXL_GUI_WIDGET_END_MSG_MAP()

#define AXL_GUI_WIDGET_MSG_HANDLER( \
    msgCode, \
    handler \
    )

#define AXL_ITOA(n)
#define AXL_ITOA_IMPL(n)
#define AXL_LEX_BEGIN_TOKEN_NAME_MAP(Class)
#define AXL_LEX_END_TOKEN_NAME_MAP()
#define AXL_LEX_END_TOKEN_NAME_MAP_EX(unknownName)

#define AXL_LEX_TOKEN_NAME( \
    tokenKind, \
    name \
    )

#define AXL_MAX( \
    a, \
    b \
    )

#define AXL_MEM_ALLOCATE(size)

#define AXL_MEM_ALLOCATE_EX( \
    size, \
    tag \
    )

#define AXL_MEM_DELETE(p)
#define AXL_MEM_FREE(p)
#define AXL_MEM_NEW(T)

#define AXL_MEM_NEW_ARGS( \
    T, \
    args \
    )

#define AXL_MEM_NEW_ARGS_EXTRA( \
    T, \
    args, \
    extra \
    )

#define AXL_MEM_NEW_EXTRA( \
    T, \
    extra \
    )

#define AXL_MEM_ZERO_ALLOCATE(size)

#define AXL_MEM_ZERO_ALLOCATE_EX( \
    size, \
    tag \
    )

#define AXL_MEM_ZERO_NEW(T)

#define AXL_MEM_ZERO_NEW_ARGS( \
    T, \
    args \
    )

#define AXL_MEM_ZERO_NEW_ARGS_EXTRA( \
    T, \
    args, \
    extra \
    )

#define AXL_MEM_ZERO_NEW_EXTRA( \
    T, \
    extra \
    )

#define AXL_MIN( \
    a, \
    b \
    )

#define AXL_PTR_BITS
#define AXL_RC_ALLOCATE(T)

#define AXL_RC_ALLOCATE_EXTRA( \
    T, \
    extra \
    )

#define AXL_RC_ALLOC_SIZEOF(T)
#define AXL_RC_NEW(T)

#define AXL_RC_NEW_ARGS( \
    T, \
    args \
    )

#define AXL_RC_NEW_ARGS_EXTRA( \
    T, \
    args, \
    extra \
    )

#define AXL_RC_NEW_ARGS_INPLACE( \
    T, \
    args, \
    p, \
    parent, \
    flags \
    )

#define AXL_RC_NEW_EXTRA( \
    T, \
    extra \
    )

#define AXL_RC_NEW_INPLACE( \
    T, \
    p, \
    parent, \
    flags \
    )

#define AXL_SL_BEGIN_DUCK_TYPE_HASH_TABLE( \
    Class, \
    Key, \
    Value \
    )

#define AXL_SL_BEGIN_HASH_TABLE( \
    Class, \
    Key, \
    Value, \
    Hash \
    )

#define AXL_SL_BEGIN_HASH_TABLE_EX( \
    Class, \
    Key, \
    Value, \
    Hash, \
    Eq, \
    KeyArg, \
    ValueArg \
    )

#define AXL_SL_BEGIN_PROTO_RECV_MAP(processMsg)

#define AXL_SL_BEGIN_SIMPLE_HASH_TABLE( \
    Class, \
    Key, \
    Value \
    )

#define AXL_SL_BEGIN_STRING_HASH_TABLE( \
    Class, \
    Value \
    )

#define AXL_SL_BEGIN_STRING_HASH_TABLE_IGNORE_CASE_PCP( \
    Class, \
    Value \
    )

#define AXL_SL_BEGIN_STRING_HASH_TABLE_IGNORE_CASE_PCU( \
    Class, \
    Value \
    )

#define AXL_SL_CMD_LINE_ADD_SWITCH_INFO( \
    switchKind, \
    name0, \
    name1, \
    name2, \
    name3, \
    value, \
    description \
    )

#define AXL_SL_CMD_LINE_MAP_SWITCH(name)
#define AXL_SL_CMD_LINE_SWITCH

#define AXL_SL_CMD_LINE_SWITCH_1( \
    switchKind, \
    name, \
    value, \
    description \
    )

#define AXL_SL_CMD_LINE_SWITCH_2( \
    switchKind, \
    name0, \
    name1, \
    value, \
    description \
    )

#define AXL_SL_CMD_LINE_SWITCH_3( \
    switchKind, \
    name0, \
    name1, \
    name2, \
    value, \
    description \
    )

#define AXL_SL_CMD_LINE_SWITCH_4( \
    switchKind, \
    name0, \
    name1, \
    name2, \
    name3, \
    value, \
    description \
    )

#define AXL_SL_CMD_LINE_SWITCH_GROUP(description)

#define AXL_SL_DEFINE_GUID( \
    n, \
    l, \
    s1, \
    s2, \
    b1, \
    b2, \
    b3, \
    b4, \
    b5, \
    b6, \
    b7, \
    b8 \
    )

#define AXL_SL_END_CMD_LINE_SWITCH_TABLE()
#define AXL_SL_END_DUCK_TYPE_HASH_TABLE()
#define AXL_SL_END_HASH_TABLE()
#define AXL_SL_END_PROTO_RECV_MAP()
#define AXL_SL_END_SIMPLE_HASH_TABLE()
#define AXL_SL_END_STRING_HASH_TABLE()
#define AXL_SL_END_STRING_HASH_TABLE_IGNORE_CASE_PCP()
#define AXL_SL_END_STRING_HASH_TABLE_IGNORE_CASE_PCU()

#define AXL_SL_GUID_INITIALIZER( \
    l, \
    s1, \
    s2, \
    b1, \
    b2, \
    b3, \
    b4, \
    b5, \
    b6, \
    b7, \
    b8 \
    )

#define AXL_SL_HASH_TABLE_ENTRY( \
    key, \
    value \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_0( \
    code, \
    handler \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_0_ERR( \
    code, \
    handler \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_0_PTR( \
    code, \
    handler \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_0_STR( \
    code, \
    handler \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_1( \
    code, \
    handler, \
    T1 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_1_ERR( \
    code, \
    handler, \
    T1 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_1_PTR( \
    code, \
    handler, \
    T1 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_1_STR( \
    code, \
    handler, \
    T1 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_2( \
    code, \
    handler, \
    T1, \
    T2 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_2_ERR( \
    code, \
    handler, \
    T1, \
    T2 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_2_PTR( \
    code, \
    handler, \
    T1, \
    T2 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_2_STR( \
    code, \
    handler, \
    T1, \
    T2 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_3( \
    code, \
    handler, \
    T1, \
    T2, \
    T3 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_3_ERR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_3_PTR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_3_STR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_4( \
    code, \
    handler, \
    T1, \
    T2, \
    T3, \
    T4 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_4_ERR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3, \
    T4 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_4_PTR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3, \
    T4 \
    )

#define AXL_SL_PROTO_RECV_FUNCTION_4_STR( \
    code, \
    handler, \
    T1, \
    T2, \
    T3, \
    T4 \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_0( \
    code, \
    sender \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_0_ERR( \
    code, \
    sender, \
    errArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_0_PTR( \
    code, \
    sender, \
    ptrArg, \
    sizeArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_0_STR( \
    code, \
    sender, \
    strArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_1( \
    code, \
    sender, \
    T1, \
    arg1 \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_1_ERR( \
    code, \
    sender, \
    T1, \
    arg1, \
    errArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_1_PTR( \
    code, \
    sender, \
    T1, \
    arg1, \
    ptrArg, \
    sizeArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_1_STR( \
    code, \
    sender, \
    T1, \
    arg1, \
    strArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_2( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2 \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_2_ERR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    errArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_2_PTR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    ptrArg, \
    sizeArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_2_STR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    strArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_3( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3 \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_3_ERR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    errArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_3_PTR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    ptrArg, \
    sizeArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_3_STR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    strArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_4( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    T4, \
    arg4 \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_4_ERR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    T4, \
    arg4, \
    errArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_4_PTR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    T4, \
    arg4, \
    ptrArg, \
    sizeArg \
    )

#define AXL_SL_PROTO_SEND_FUNCTION_4_STR( \
    code, \
    sender, \
    T1, \
    arg1, \
    T2, \
    arg2, \
    T3, \
    arg3, \
    T4, \
    arg4, \
    strArg \
    )

#define AXL_SYS_BEGIN_SJLJ_TRY()
#define AXL_SYS_END_SJLJ_TRY()
#define AXL_SYS_END_SJLJ_TRY_EX(result)
#define AXL_SYS_END_SJLJ_TRY_IMPL()
#define AXL_SYS_EPOCH_DIFF
#define AXL_SYS_SJLJ_CATCH()
#define AXL_SYS_SJLJ_FINALLY()
#define AXL_SYS_SJLJ_THROW()
#define AXL_TRACE

#define AXL_VA_DECL( \
    va, \
    a \
    )

#define LUA_OK
#define PCAP_NETMASK_UNKNOWN
#define QT_NO_VERSION_TAGGING
#define TRACE
#define _AXL_DEBUG
#define __STDC_CONSTANT_MACROS
#define __STDC_LIMIT_MACROS
#define axl_rc_RT_NEW(Type)

#define axl_rc_RT_NEW_EXTRA( \
    Type, \
    extra \
    )

#define axl_va_arg( \
    va, \
    T \
    )

#define axl_va_end(va)

#define axl_va_start( \
    va, \
    a \
    )

#define containerof( \
    p, \
    T, \
    f \
    )

#define countof(a)
#define getBitmask
#define getHiBit
#define getHiBitIdx
#define getHiBitmask
#define getLoBit
#define getLoBitIdx
#define getLoBitmask
#define getPowerOf2Ge
#define lengthof(s)
#define lua_len
#define lua_rawlen