Global Namespace

// namespaces

namespace Poco;
    namespace Poco::Dynamic;
        namespace Poco::Dynamic::Impl;
    namespace Poco::Impl;
    namespace Poco::JSON;
    namespace Poco::Net;
        namespace Poco::Net::Impl;
    namespace Poco::Util;
        namespace Poco::Util::Units;
            namespace Poco::Util::Units::Constants;
            namespace Poco::Util::Units::Internal;
            namespace Poco::Util::Units::Units;
            namespace Poco::Util::Units::Values;
    namespace Poco::XML;
namespace std;

// typedefs

typedef struct XML_ParserStruct* XML_Parser;
typedef unsigned char XML_Bool;
typedef struct XML_cp XML_Content;

typedef void(XMLCALL* XML_ElementDeclHandler)(
    void *userData,
    const XML_Char *name,
    XML_Content *model
    );

typedef void(XMLCALL* XML_AttlistDeclHandler)(
    void *userData,
    const XML_Char *elname,
    const XML_Char *attname,
    const XML_Char *att_type,
    const XML_Char *dflt,
    int isrequired
    );

typedef void(XMLCALL* XML_XmlDeclHandler)(
    void *userData,
    const XML_Char *version,
    const XML_Char *encoding,
    int standalone
    );

typedef void(XMLCALL* XML_StartElementHandler)(
    void *userData,
    const XML_Char *name,
    const XML_Char **atts
    );

typedef void(XMLCALL* XML_EndElementHandler)(
    void *userData,
    const XML_Char *name
    );

typedef void(XMLCALL* XML_CharacterDataHandler)(
    void *userData,
    const XML_Char *s,
    int len
    );

typedef void(XMLCALL* XML_ProcessingInstructionHandler)(
    void *userData,
    const XML_Char *target,
    const XML_Char *data
    );

typedef void(XMLCALL* XML_CommentHandler)(
    void *userData,
    const XML_Char *data
    );

typedef void(XMLCALL* XML_StartCdataSectionHandler)(void *userData);
typedef void(XMLCALL* XML_EndCdataSectionHandler)(void *userData);

typedef void(XMLCALL* XML_DefaultHandler)(
    void *userData,
    const XML_Char *s,
    int len
    );

typedef void(XMLCALL* XML_StartDoctypeDeclHandler)(
    void *userData,
    const XML_Char *doctypeName,
    const XML_Char *sysid,
    const XML_Char *pubid,
    int has_internal_subset
    );

typedef void(XMLCALL* XML_EndDoctypeDeclHandler)(void *userData);

typedef void(XMLCALL* XML_EntityDeclHandler)(
    void *userData,
    const XML_Char *entityName,
    int is_parameter_entity,
    const XML_Char *value,
    int value_length,
    const XML_Char *base,
    const XML_Char *systemId,
    const XML_Char *publicId,
    const XML_Char *notationName
    );

typedef void(XMLCALL* XML_UnparsedEntityDeclHandler)(
    void *userData,
    const XML_Char *entityName,
    const XML_Char *base,
    const XML_Char *systemId,
    const XML_Char *publicId,
    const XML_Char *notationName
    );

typedef void(XMLCALL* XML_NotationDeclHandler)(
    void *userData,
    const XML_Char *notationName,
    const XML_Char *base,
    const XML_Char *systemId,
    const XML_Char *publicId
    );

typedef void(XMLCALL* XML_StartNamespaceDeclHandler)(
    void *userData,
    const XML_Char *prefix,
    const XML_Char *uri
    );

typedef void(XMLCALL* XML_EndNamespaceDeclHandler)(
    void *userData,
    const XML_Char *prefix
    );

typedef int(XMLCALL* XML_NotStandaloneHandler)(void *userData);

typedef int(XMLCALL* XML_ExternalEntityRefHandler)(
    XML_Parser parser,
    const XML_Char *context,
    const XML_Char *base,
    const XML_Char *systemId,
    const XML_Char *publicId
    );

typedef void(XMLCALL* XML_SkippedEntityHandler)(
    void *userData,
    const XML_Char *entityName,
    int is_parameter_entity
    );

typedef int(XMLCALL* XML_UnknownEncodingHandler)(
    void *encodingHandlerData,
    const XML_Char *name,
    XML_Encoding *info
    );

typedef char XML_Char;
typedef char XML_LChar;
typedef long XML_Index;
typedef unsigned long XML_Size;
typedef unsigned long z_size_t;
typedef unsigned char Byte;
typedef unsigned int uInt;
typedef unsigned long uLong;
typedef Byte FAR Bytef;
typedef char FAR charf;
typedef int FAR intf;
typedef uInt FAR uIntf;
typedef uLong FAR uLongf;
typedef Byte const* voidpc;
typedef Byte FAR* voidpf;
typedef Byte* voidp;
typedef unsigned long z_crc_t;

typedef voidpf alloc_func OF((
        voidpf opaque,
        uInt items,
        uInt size
        ));

typedef struct z_stream_s z_stream;
typedef z_stream FAR* z_streamp;
typedef struct gz_header_s gz_header;
typedef gz_header FAR* gz_headerp;
typedef struct gzFile_s* gzFile;

// enums

enum XML_Content_Quant;
enum XML_Content_Type;
enum XML_Error;
enum XML_FeatureEnum;
enum XML_ParamEntityParsing;
enum XML_Parsing;
enum XML_Status;

// structs

template <>
struct POCO_STATIC_ASSERTION_FAILURE<true>;

template <bool x>
struct POCO_STATIC_ASSERTION_FAILURE;

struct XML_Encoding;
struct XML_Expat_Version;
struct XML_Feature;
struct XML_Memory_Handling_Suite;
struct XML_ParsingStatus;
struct XML_cp;
struct gzFile_s;
struct gz_header_s;

template <int x>
struct poco_static_assert_test;

struct z_stream_s;

// global functions

bool POCO_LIBRARY_API
pocoBuildManifest(Poco::ManifestBase* pManifest);

void POCO_LIBRARY_API
pocoInitializeLibrary();

void POCO_LIBRARY_API
pocoUninitializeLibrary();

XML_SetElementDeclHandler(
    XML_Parser parser,
    XML_ElementDeclHandler eldecl
    );

XML_SetAttlistDeclHandler(
    XML_Parser parser,
    XML_AttlistDeclHandler attdecl
    );

XML_SetXmlDeclHandler(
    XML_Parser parser,
    XML_XmlDeclHandler xmldecl
    );

XML_ParserCreate(const XML_Char* encoding);

XML_ParserCreateNS(
    const XML_Char* encoding,
    XML_Char namespaceSeparator
    );

XML_ParserCreate_MM(
    const XML_Char* encoding,
    const XML_Memory_Handling_Suite* memsuite,
    const XML_Char* namespaceSeparator
    );

XML_ParserReset(
    XML_Parser parser,
    const XML_Char* encoding
    );

XML_SetEntityDeclHandler(
    XML_Parser parser,
    XML_EntityDeclHandler handler
    );

XML_SetElementHandler(
    XML_Parser parser,
    XML_StartElementHandler start,
    XML_EndElementHandler end
    );

XML_SetStartElementHandler(
    XML_Parser parser,
    XML_StartElementHandler handler
    );

XML_SetEndElementHandler(
    XML_Parser parser,
    XML_EndElementHandler handler
    );

XML_SetCharacterDataHandler(
    XML_Parser parser,
    XML_CharacterDataHandler handler
    );

XML_SetProcessingInstructionHandler(
    XML_Parser parser,
    XML_ProcessingInstructionHandler handler
    );

XML_SetCommentHandler(
    XML_Parser parser,
    XML_CommentHandler handler
    );

XML_SetCdataSectionHandler(
    XML_Parser parser,
    XML_StartCdataSectionHandler start,
    XML_EndCdataSectionHandler end
    );

XML_SetStartCdataSectionHandler(
    XML_Parser parser,
    XML_StartCdataSectionHandler start
    );

XML_SetEndCdataSectionHandler(
    XML_Parser parser,
    XML_EndCdataSectionHandler end
    );

XML_SetDefaultHandler(
    XML_Parser parser,
    XML_DefaultHandler handler
    );

XML_SetDefaultHandlerExpand(
    XML_Parser parser,
    XML_DefaultHandler handler
    );

XML_SetDoctypeDeclHandler(
    XML_Parser parser,
    XML_StartDoctypeDeclHandler start,
    XML_EndDoctypeDeclHandler end
    );

XML_SetStartDoctypeDeclHandler(
    XML_Parser parser,
    XML_StartDoctypeDeclHandler start
    );

XML_SetEndDoctypeDeclHandler(
    XML_Parser parser,
    XML_EndDoctypeDeclHandler end
    );

XML_SetUnparsedEntityDeclHandler(
    XML_Parser parser,
    XML_UnparsedEntityDeclHandler handler
    );

XML_SetNotationDeclHandler(
    XML_Parser parser,
    XML_NotationDeclHandler handler
    );

XML_SetNamespaceDeclHandler(
    XML_Parser parser,
    XML_StartNamespaceDeclHandler start,
    XML_EndNamespaceDeclHandler end
    );

XML_SetStartNamespaceDeclHandler(
    XML_Parser parser,
    XML_StartNamespaceDeclHandler start
    );

XML_SetEndNamespaceDeclHandler(
    XML_Parser parser,
    XML_EndNamespaceDeclHandler end
    );

XML_SetNotStandaloneHandler(
    XML_Parser parser,
    XML_NotStandaloneHandler handler
    );

XML_SetExternalEntityRefHandler(
    XML_Parser parser,
    XML_ExternalEntityRefHandler handler
    );

XML_SetExternalEntityRefHandlerArg(
    XML_Parser parser,
    void* arg
    );

XML_SetSkippedEntityHandler(
    XML_Parser parser,
    XML_SkippedEntityHandler handler
    );

XML_SetUnknownEncodingHandler(
    XML_Parser parser,
    XML_UnknownEncodingHandler handler,
    void* encodingHandlerData
    );

XML_DefaultCurrent(XML_Parser parser);

XML_SetReturnNSTriplet(
    XML_Parser parser,
    int do_nst
    );

XML_SetUserData(
    XML_Parser parser,
    void* userData
    );

XML_SetEncoding(
    XML_Parser parser,
    const XML_Char* encoding
    );

XML_UseParserAsHandlerArg(XML_Parser parser);

XML_UseForeignDTD(
    XML_Parser parser,
    XML_Bool useDTD
    );

XML_SetBase(
    XML_Parser parser,
    const XML_Char* base
    );

XML_GetBase(XML_Parser parser);
XML_GetSpecifiedAttributeCount(XML_Parser parser);
XML_GetIdAttributeIndex(XML_Parser parser);

XML_Parse(
    XML_Parser parser,
    const char* s,
    int len,
    int isFinal
    );

XML_GetBuffer(
    XML_Parser parser,
    int len
    );

XML_ParseBuffer(
    XML_Parser parser,
    int len,
    int isFinal
    );

XML_StopParser(
    XML_Parser parser,
    XML_Bool resumable
    );

XML_ResumeParser(XML_Parser parser);

XML_GetParsingStatus(
    XML_Parser parser,
    XML_ParsingStatus* status
    );

XML_ExternalEntityParserCreate(
    XML_Parser parser,
    const XML_Char* context,
    const XML_Char* encoding
    );

XML_SetParamEntityParsing(
    XML_Parser parser,
    enum XML_ParamEntityParsing parsing
    );

XML_SetHashSalt(
    XML_Parser parser,
    unsigned long hash_salt
    );

XML_GetErrorCode(XML_Parser parser);
XMLPARSEAPI(XML_Size);
XMLPARSEAPI(XML_Index);
XML_GetCurrentByteCount(XML_Parser parser);

XML_GetInputContext(
    XML_Parser parser,
    int* offset,
    int* size
    );

XML_FreeContentModel(
    XML_Parser parser,
    XML_Content* model
    );

XML_ATTR_MALLOC
XML_MemMalloc(
    XML_Parser parser,
    size_t size
    );

XML_MemRealloc(
    XML_Parser parser,
    void* ptr,
    size_t size
    );

XML_MemFree(
    XML_Parser parser,
    void* ptr
    );

XML_ParserFree(XML_Parser parser);
XML_ErrorString(enum XML_Error code);
XML_ExpatVersion(void);
XML_ExpatVersionInfo(void);
XML_GetFeatureList(void);

ZEXTERN const char*ZEXPORT zlibVersion
OF((void));

ZEXTERN int ZEXPORT deflate
OF((z_streamp strm, int flush));

ZEXTERN int ZEXPORT deflateEnd
OF((z_streamp strm));

ZEXTERN int ZEXPORT deflateSetDictionary
OF((z_streamp strm, const Bytef*dictionary, uInt dictLength));

ZEXTERN int ZEXPORT deflateGetDictionary
OF((z_streamp strm, Bytef*dictionary, uInt*dictLength));

ZEXTERN int ZEXPORT deflateCopy
OF((z_streamp dest, z_streamp source));

ZEXTERN int ZEXPORT deflateParams
OF((z_streamp strm, int level, int strategy));

ZEXTERN int ZEXPORT deflateTune
OF((z_streamp strm, int good_length, int max_lazy, int nice_length, int max_chain));

ZEXTERN uLong ZEXPORT deflateBound
OF((z_streamp strm, uLong sourceLen));

ZEXTERN int ZEXPORT deflatePending
OF((z_streamp strm, unsigned*pending, int*bits));

ZEXTERN int ZEXPORT deflatePrime
OF((z_streamp strm, int bits, int value));

ZEXTERN int ZEXPORT deflateSetHeader
OF((z_streamp strm, gz_headerp head));

ZEXTERN int ZEXPORT inflateReset2
OF((z_streamp strm, int windowBits));

ZEXTERN int ZEXPORT inflateBack
OF((z_streamp strm, in_func in, void FAR*in_desc, out_func out, void FAR*out_desc));

ZEXTERN int ZEXPORT compress
OF((Bytef*dest, uLongf*destLen, const Bytef*source, uLong sourceLen));

ZEXTERN int ZEXPORT compress2
OF((Bytef*dest, uLongf*destLen, const Bytef*source, uLong sourceLen, int level));

ZEXTERN uLong ZEXPORT compressBound
OF((uLong sourceLen));

ZEXTERN int ZEXPORT uncompress2
OF((Bytef*dest, uLongf*destLen, const Bytef*source, uLong*sourceLen));

ZEXTERN gzFile ZEXPORT gzdopen
OF((int fd, const char*mode));

ZEXTERN int ZEXPORT gzbuffer
OF((gzFile file, unsigned size));

ZEXTERN int ZEXPORT gzsetparams
OF((gzFile file, int level, int strategy));

ZEXTERN int ZEXPORT gzread
OF((gzFile file, voidp buf, unsigned len));

ZEXTERN z_size_t ZEXPORT gzfread
OF((voidp buf, z_size_t size, z_size_t nitems, gzFile file));

ZEXTERN int ZEXPORT gzwrite
OF((gzFile file, voidpc buf, unsigned len));

ZEXTERN z_size_t ZEXPORT gzfwrite
OF((voidpc buf, z_size_t size, z_size_t nitems, gzFile file));

ZEXTERN int ZEXPORTVA gzprintf
Z_ARG((gzFile file, const char*format,...));

ZEXTERN int ZEXPORT gzputs
OF((gzFile file, const char*s));

ZEXTERN char*ZEXPORT gzgets
OF((gzFile file, char*buf, int len));

ZEXTERN int ZEXPORT gzputc
OF((gzFile file, int c));

ZEXTERN int ZEXPORT gzgetc
OF((gzFile file));

ZEXTERN int ZEXPORT gzungetc
OF((int c, gzFile file));

ZEXTERN int ZEXPORT gzflush
OF((gzFile file, int flush));

ZEXTERN const char*ZEXPORT gzerror
OF((gzFile file, int*errnum));

ZEXTERN uLong ZEXPORT adler32
OF((uLong adler, const Bytef*buf, uInt len));

ZEXTERN uLong ZEXPORT adler32_z
OF((uLong adler, const Bytef*buf, z_size_t len));

ZEXTERN uLong ZEXPORT crc32
OF((uLong crc, const Bytef*buf, uInt len));

ZEXTERN int ZEXPORT deflateInit_
OF((z_streamp strm, int level, const char*version, int stream_size));

ZEXTERN int ZEXPORT inflateInit_
OF((z_streamp strm, const char*version, int stream_size));

ZEXTERN int ZEXPORT deflateInit2_
OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char*version, int stream_size));

ZEXTERN int ZEXPORT inflateInit2_
OF((z_streamp strm, int windowBits, const char*version, int stream_size));

ZEXTERN int ZEXPORT inflateBackInit_
OF((z_streamp strm, int windowBits, unsigned char FAR*window, const char*version, int stream_size));

ZEXTERN gzFile ZEXPORT gzopen
OF((const char*, const char*));

ZEXTERN z_off_t ZEXPORT gzseek
OF((gzFile, z_off_t, int));

ZEXTERN z_off_t ZEXPORT gztell
OF((gzFile));

ZEXTERN uLong ZEXPORT adler32_combine
OF((uLong, uLong, z_off_t));

ZEXTERN const char*ZEXPORT zError
OF((int));

ZEXTERN int ZEXPORT inflateSyncPoint
OF((z_streamp));

ZEXTERN int ZEXPORT inflateUndermine
OF((z_streamp, int));

// macros

#define DEFINE_PREFIX_CLASS( \
    name, \
    scale, \
    prefix \
    )

#define FAR
#define Foundation_API
#define INADDR_ALLHOSTS_GROUP
#define INADDR_ALLRTRS_GROUP
#define INADDR_ANY
#define INADDR_BROADCAST
#define INADDR_LOOPBACK
#define INADDR_MAX_LOCAL_GROUP
#define INADDR_NONE
#define INADDR_UNSPEC_GROUP
#define JSON_API
#define MAX_MEM_LEVEL
#define MAX_WBITS
#define NTDDI_VERSION
#define NTDDI_VERSION
#define Net_API
#define OF(args)
#define POCO_APP_MAIN(App)
#define POCO_ARCH_AARCH64
#define POCO_ARCH_ALPHA
#define POCO_ARCH_AMD64
#define POCO_ARCH_ARM
#define POCO_ARCH_HPPA
#define POCO_ARCH_IA32
#define POCO_ARCH_IA64
#define POCO_ARCH_M68K
#define POCO_ARCH_MIPS
#define POCO_ARCH_NIOS2
#define POCO_ARCH_POWER
#define POCO_ARCH_PPC
#define POCO_ARCH_S390
#define POCO_ARCH_SH
#define POCO_ARCH_SPARC
#define POCO_BEGIN_MANIFEST(base)

#define POCO_BEGIN_MANIFEST_IMPL( \
    fnName, \
    base \
    )

#define POCO_BEGIN_NAMED_MANIFEST( \
    name, \
    base \
    )

#define POCO_BROKEN_TIMEOUTS

#define POCO_DECLARE_EXCEPTION( \
    API, \
    CLS, \
    BASE \
    )

#define POCO_DECLARE_EXCEPTION_CODE( \
    API, \
    CLS, \
    BASE, \
    CODE \
    )

#define POCO_DECLARE_NAMED_MANIFEST(name)
#define POCO_DEFAULT_NEWLINE_CHARS

#define POCO_DESCRIPTOR_LITERAL( \
    name, \
    string \
    )

#define POCO_DESCRIPTOR_STRING( \
    name, \
    string \
    )

#define POCO_DO_JOIN( \
    X, \
    Y \
    )

#define POCO_DO_JOIN2( \
    X, \
    Y \
    )

#define POCO_END_MANIFEST
#define POCO_ENOERR
#define POCO_EXPORT_CLASS(cls)
#define POCO_EXPORT_SINGLETON(cls)
#define POCO_FLT_EXP
#define POCO_FLT_INF
#define POCO_FLT_NAN
#define POCO_HAVE_IPv6
#define POCO_HAVE_SALEN
#define POCO_IMPLEMENT_BYTEORDER_BIG
#define POCO_IMPLEMENT_BYTEORDER_FLIP(op)

#define POCO_IMPLEMENT_BYTEORDER_FLIP_( \
    op, \
    type \
    )

#define POCO_IMPLEMENT_BYTEORDER_LIT
#define POCO_IMPLEMENT_BYTEORDER_NOOP(op)

#define POCO_IMPLEMENT_BYTEORDER_NOOP_( \
    op, \
    type \
    )

#define POCO_IMPLEMENT_EXCEPTION( \
    CLS, \
    BASE, \
    NAME \
    )

#define POCO_JOIN( \
    X, \
    Y \
    )

#define POCO_LIBRARY_API
#define POCO_LPQUERY_SERVICE_CONFIG
#define POCO_MAX_FLT_STRING_LEN
#define POCO_MAX_INT_STRING_LEN
#define POCO_NET_HAS_INTERFACE
#define POCO_NO_FPENVIRONMENT
#define POCO_NO_SHAREDMEMORY
#define POCO_NO_SOO
#define POCO_NO_SYSLOGCHANNEL
#define POCO_NO_SYS_SELECT_H
#define POCO_NO_SYS_SELECT_H
#define POCO_NO_WSTRING
#define POCO_OS_AIX
#define POCO_OS_CYGWIN
#define POCO_OS_FREE_BSD
#define POCO_OS_HPUX
#define POCO_OS_IRIX
#define POCO_OS_LINUX
#define POCO_OS_MAC_OS_X
#define POCO_OS_NACL
#define POCO_OS_NET_BSD
#define POCO_OS_OPEN_BSD
#define POCO_OS_QNX
#define POCO_OS_SOLARIS
#define POCO_OS_TRU64
#define POCO_OS_UNKNOWN_UNIX
#define POCO_OS_VMS
#define POCO_OS_VXWORKS
#define POCO_OS_WINDOWS_CE
#define POCO_OS_WINDOWS_NT
#define POCO_SERVER_MAIN(App)
#define POCO_THREAD_STACK_SIZE
#define POCO_TYPEWRAPPER_DEFAULTVALUE(T)
#define POCO_UNUSED
#define POCO_VERSION
#define POCO_WIN32_UTF8
#define POCO_XML_NAMEPOOL_DEFAULT_SIZE
#define SEEK_CUR
#define SEEK_END
#define SEEK_SET
#define TLS_OUT_OF_INDEXES

#define UNIT_DISPLAY_NAME( \
    Unit, \
    string \
    )

#define Util_API
#define XMLCALL
#define XMLIMPORT
#define XMLPARSEAPI(type)
#define XML_API
#define XML_ATTR_ALLOC_SIZE(x)
#define XML_ATTR_MALLOC
#define XML_FALSE
#define XML_GetErrorByteIndex
#define XML_GetErrorColumnNumber
#define XML_GetErrorLineNumber
#define XML_GetUserData(parser)
#define XML_LIT(lit)
#define XML_MAJOR_VERSION
#define XML_MICRO_VERSION
#define XML_MINOR_VERSION
#define XML_STATUS_ERROR
#define XML_STATUS_OK
#define XML_STATUS_SUSPENDED
#define XML_TRUE
#define ZEXPORT
#define ZEXPORTVA
#define ZEXTERN
#define ZLIB_VERNUM
#define ZLIB_VERSION
#define ZLIB_VER_MAJOR
#define ZLIB_VER_MINOR
#define ZLIB_VER_REVISION
#define ZLIB_VER_SUBREVISION
#define Z_ARG(args)
#define Z_ASCII
#define Z_BEST_COMPRESSION
#define Z_BEST_SPEED
#define Z_BINARY
#define Z_BLOCK
#define Z_BUF_ERROR
#define Z_DATA_ERROR
#define Z_DEFAULT_COMPRESSION
#define Z_DEFAULT_STRATEGY
#define Z_DEFLATED
#define Z_ERRNO
#define Z_FILTERED
#define Z_FINISH
#define Z_FIXED
#define Z_FULL_FLUSH
#define Z_HUFFMAN_ONLY
#define Z_MEM_ERROR
#define Z_NEED_DICT
#define Z_NO_COMPRESSION
#define Z_NO_FLUSH
#define Z_NULL
#define Z_OK
#define Z_PARTIAL_FLUSH
#define Z_RLE
#define Z_STREAM_END
#define Z_STREAM_ERROR
#define Z_SYNC_FLUSH
#define Z_TEXT
#define Z_TREES
#define Z_UNKNOWN
#define Z_VERSION_ERROR
#define _SW_DENORMAL
#define _SW_INEXACT
#define _SW_INVALID
#define _SW_OVERFLOW
#define _SW_UNDERFLOW
#define _SW_ZERODIVIDE
#define _WIN32_WINNT
#define _WIN32_WINNT
#define const

#define deflateInit( \
    strm, \
    level \
    )

#define deflateInit2( \
    strm, \
    level, \
    method, \
    windowBits, \
    memLevel, \
    strategy \
    )

#define gzgetc(g)

#define inflateBackInit( \
    strm, \
    windowBits, \
    window \
    )

#define inflateInit(strm)

#define inflateInit2( \
    strm, \
    windowBits \
    )

#define poco_assert(cond)
#define poco_assert_dbg(cond)

#define poco_assert_msg( \
    cond, \
    text \
    )

#define poco_assert_msg_dbg( \
    cond, \
    text \
    )

#define poco_bugcheck()
#define poco_bugcheck_msg(msg)
#define poco_check_ptr(ptr)

#define poco_critical( \
    logger, \
    msg \
    )

#define poco_critical_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_critical_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_critical_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_critical_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_debug( \
    logger, \
    msg \
    )

#define poco_debug_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_debug_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_debug_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_debug_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_debugger()
#define poco_debugger_msg(msg)

#define poco_error( \
    logger, \
    msg \
    )

#define poco_error_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_error_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_error_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_error_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_fatal( \
    logger, \
    msg \
    )

#define poco_fatal_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_fatal_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_fatal_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_fatal_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_hton_16(x)
#define poco_hton_32(x)

#define poco_information( \
    logger, \
    msg \
    )

#define poco_information_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_information_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_information_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_information_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_ios_init(buf)
#define poco_ndc(func)
#define poco_ndc_dbg(func)

#define poco_notice( \
    logger, \
    msg \
    )

#define poco_notice_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_notice_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_notice_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_notice_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_ntoh_16(x)
#define poco_ntoh_32(x)

#define poco_set_sa_len( \
    pSA, \
    len \
    )

#define poco_set_sin_len(pSA)
#define poco_static_assert(B)
#define poco_stderr_dbg(outstr)
#define poco_stdout_dbg(outstr)

#define poco_trace( \
    logger, \
    msg \
    )

#define poco_trace_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_trace_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_trace_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_trace_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define poco_unexpected()

#define poco_warning( \
    logger, \
    msg \
    )

#define poco_warning_f1( \
    logger, \
    fmt, \
    arg1 \
    )

#define poco_warning_f2( \
    logger, \
    fmt, \
    arg1, \
    arg2 \
    )

#define poco_warning_f3( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3 \
    )

#define poco_warning_f4( \
    logger, \
    fmt, \
    arg1, \
    arg2, \
    arg3, \
    arg4 \
    )

#define s6_addr16
#define z_const
#define z_longlong
#define z_off64_t
#define z_off_t
#define zlib_version