#ifndef INLINE_XADMASTER_H
#define INLINE_XADMASTER_H

/*
    *** Automatically generated from '/home/aros/ABIv0/Build/20120820/AROS/contrib/pack/libxad/portable/xadmaster.conf'. Edits will be lost. ***
    Copyright © 1995-2012, The AROS Development Team. All rights reserved.
*/

/*
    Desc: Inline function for xadmaster
*/

#include <aros/libcall.h>
#include <exec/types.h>
#include <aros/preprocessor/variadic/cast2iptr.hpp>


static inline xadPTR __inline_xadmaster_xadAllocObjectA(xadUINT32 __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadPTR, xadAllocObjectA,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(const struct TagItem *,(__arg2),A0),
        struct xadMasterBase *, (__xadMasterBase), 5, xadmaster    );
}

#define xadAllocObjectA(arg1, arg2) \
    __inline_xadmaster_xadAllocObjectA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadAllocObject(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadAllocObjectA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_xadmaster_xadFreeObjectA(xadPTR __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    AROS_LC2NR(void, xadFreeObjectA,
        AROS_LCA(xadPTR,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 6, xadmaster    );
}

#define xadFreeObjectA(arg1, arg2) \
    __inline_xadmaster_xadFreeObjectA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadFreeObject(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadFreeObjectA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline struct xadClient * __inline_xadmaster_xadRecogFileA(xadSize __arg1, const void * __arg2, const struct TagItem * __arg3, APTR __xadMasterBase)
{
    return AROS_LC3(struct xadClient *, xadRecogFileA,
        AROS_LCA(xadSize,(__arg1),D0),
        AROS_LCA(const void *,(__arg2),A0),
        AROS_LCA(const struct TagItem *,(__arg3),A1),
        struct xadMasterBase *, (__xadMasterBase), 7, xadmaster    );
}

#define xadRecogFileA(arg1, arg2, arg3) \
    __inline_xadmaster_xadRecogFileA((arg1), (arg2), (arg3), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadRecogFile(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadRecogFileA((arg1), (arg2), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadGetInfoA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadERROR, xadGetInfoA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 8, xadmaster    );
}

#define xadGetInfoA(arg1, arg2) \
    __inline_xadmaster_xadGetInfoA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadGetInfo(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadGetInfoA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_xadmaster_xadFreeInfo(struct xadArchiveInfo * __arg1, APTR __xadMasterBase)
{
    AROS_LC1NR(void, xadFreeInfo,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        struct xadMasterBase *, (__xadMasterBase), 9, xadmaster    );
}

#define xadFreeInfo(arg1) \
    __inline_xadmaster_xadFreeInfo((arg1), (APTR)xadMasterBase)

static inline xadERROR __inline_xadmaster_xadFileUnArcA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadERROR, xadFileUnArcA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 10, xadmaster    );
}

#define xadFileUnArcA(arg1, arg2) \
    __inline_xadmaster_xadFileUnArcA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadFileUnArc(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadFileUnArcA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadDiskUnArcA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadERROR, xadDiskUnArcA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 11, xadmaster    );
}

#define xadDiskUnArcA(arg1, arg2) \
    __inline_xadmaster_xadDiskUnArcA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadDiskUnArc(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadDiskUnArcA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadSTRPTR __inline_xadmaster_xadGetErrorText(xadERROR __arg1, APTR __xadMasterBase)
{
    return AROS_LC1(xadSTRPTR, xadGetErrorText,
        AROS_LCA(xadERROR,(__arg1),D0),
        struct xadMasterBase *, (__xadMasterBase), 12, xadmaster    );
}

#define xadGetErrorText(arg1) \
    __inline_xadmaster_xadGetErrorText((arg1), (APTR)xadMasterBase)

static inline struct xadClient * __inline_xadmaster_xadGetClientInfo(APTR __xadMasterBase)
{
    return AROS_LC0(struct xadClient *, xadGetClientInfo,
        struct xadMasterBase *, (__xadMasterBase), 13, xadmaster    );
}

#define xadGetClientInfo() \
    __inline_xadmaster_xadGetClientInfo((APTR)xadMasterBase)

static inline xadERROR __inline_xadmaster_xadHookAccess(xadUINT32 __arg1, xadSignSize __arg2, xadPTR __arg3, struct xadArchiveInfo * __arg4, APTR __xadMasterBase)
{
    return AROS_LC4(xadERROR, xadHookAccess,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(xadSignSize,(__arg2),D1),
        AROS_LCA(xadPTR,(__arg3),A0),
        AROS_LCA(struct xadArchiveInfo *,(__arg4),A1),
        struct xadMasterBase *, (__xadMasterBase), 14, xadmaster    );
}

#define xadHookAccess(arg1, arg2, arg3, arg4) \
    __inline_xadmaster_xadHookAccess((arg1), (arg2), (arg3), (arg4), (APTR)xadMasterBase)

static inline xadERROR __inline_xadmaster_xadConvertDatesA(const struct TagItem * __arg1, APTR __xadMasterBase)
{
    return AROS_LC1(xadERROR, xadConvertDatesA,
        AROS_LCA(const struct TagItem *,(__arg1),A0),
        struct xadMasterBase *, (__xadMasterBase), 15, xadmaster    );
}

#define xadConvertDatesA(arg1) \
    __inline_xadmaster_xadConvertDatesA((arg1), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadConvertDates(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadConvertDatesA((const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadUINT16 __inline_xadmaster_xadCalcCRC16(xadUINT32 __arg1, xadUINT32 __arg2, xadSize __arg3, const xadUINT8 * __arg4, APTR __xadMasterBase)
{
    return AROS_LC4(xadUINT16, xadCalcCRC16,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(xadUINT32,(__arg2),D1),
        AROS_LCA(xadSize,(__arg3),D2),
        AROS_LCA(const xadUINT8 *,(__arg4),A0),
        struct xadMasterBase *, (__xadMasterBase), 16, xadmaster    );
}

#define xadCalcCRC16(arg1, arg2, arg3, arg4) \
    __inline_xadmaster_xadCalcCRC16((arg1), (arg2), (arg3), (arg4), (APTR)xadMasterBase)

static inline xadUINT32 __inline_xadmaster_xadCalcCRC32(xadUINT32 __arg1, xadUINT32 __arg2, xadSize __arg3, const xadUINT8 * __arg4, APTR __xadMasterBase)
{
    return AROS_LC4(xadUINT32, xadCalcCRC32,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(xadUINT32,(__arg2),D1),
        AROS_LCA(xadSize,(__arg3),D2),
        AROS_LCA(const xadUINT8 *,(__arg4),A0),
        struct xadMasterBase *, (__xadMasterBase), 17, xadmaster    );
}

#define xadCalcCRC32(arg1, arg2, arg3, arg4) \
    __inline_xadmaster_xadCalcCRC32((arg1), (arg2), (arg3), (arg4), (APTR)xadMasterBase)

static inline xadPTR __inline_xadmaster_xadAllocVec(xadSize __arg1, xadUINT32 __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadPTR, xadAllocVec,
        AROS_LCA(xadSize,(__arg1),D0),
        AROS_LCA(xadUINT32,(__arg2),D1),
        struct xadMasterBase *, (__xadMasterBase), 18, xadmaster    );
}

#define xadAllocVec(arg1, arg2) \
    __inline_xadmaster_xadAllocVec((arg1), (arg2), (APTR)xadMasterBase)

static inline void __inline_xadmaster_xadCopyMem(const void * __arg1, xadPTR __arg2, xadSize __arg3, APTR __xadMasterBase)
{
    AROS_LC3NR(void, xadCopyMem,
        AROS_LCA(const void *,(__arg1),A0),
        AROS_LCA(xadPTR,(__arg2),A1),
        AROS_LCA(xadSize,(__arg3),D0),
        struct xadMasterBase *, (__xadMasterBase), 19, xadmaster    );
}

#define xadCopyMem(arg1, arg2, arg3) \
    __inline_xadmaster_xadCopyMem((arg1), (arg2), (arg3), (APTR)xadMasterBase)

static inline xadERROR __inline_xadmaster_xadHookTagAccessA(xadUINT32 __arg1, xadSignSize __arg2, xadPTR __arg3, struct xadArchiveInfo * __arg4, const struct TagItem * __arg5, APTR __xadMasterBase)
{
    return AROS_LC5(xadERROR, xadHookTagAccessA,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(xadSignSize,(__arg2),D1),
        AROS_LCA(xadPTR,(__arg3),A0),
        AROS_LCA(struct xadArchiveInfo *,(__arg4),A1),
        AROS_LCA(const struct TagItem *,(__arg5),A2),
        struct xadMasterBase *, (__xadMasterBase), 20, xadmaster    );
}

#define xadHookTagAccessA(arg1, arg2, arg3, arg4, arg5) \
    __inline_xadmaster_xadHookTagAccessA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadHookTagAccess(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadHookTagAccessA((arg1), (arg2), (arg3), (arg4), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadConvertProtectionA(const struct TagItem * __arg1, APTR __xadMasterBase)
{
    return AROS_LC1(xadERROR, xadConvertProtectionA,
        AROS_LCA(const struct TagItem *,(__arg1),A0),
        struct xadMasterBase *, (__xadMasterBase), 21, xadmaster    );
}

#define xadConvertProtectionA(arg1) \
    __inline_xadmaster_xadConvertProtectionA((arg1), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadConvertProtection(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadConvertProtectionA((const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadGetDiskInfoA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadERROR, xadGetDiskInfoA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 22, xadmaster    );
}

#define xadGetDiskInfoA(arg1, arg2) \
    __inline_xadmaster_xadGetDiskInfoA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadGetDiskInfo(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadGetDiskInfoA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadGetHookAccessA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadERROR, xadGetHookAccessA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 23, xadmaster    );
}

#define xadGetHookAccessA(arg1, arg2) \
    __inline_xadmaster_xadGetHookAccessA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadGetHookAccess(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadGetHookAccessA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_xadmaster_xadFreeHookAccessA(struct xadArchiveInfo * __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    AROS_LC2NR(void, xadFreeHookAccessA,
        AROS_LCA(struct xadArchiveInfo *,(__arg1),A0),
        AROS_LCA(const struct TagItem *,(__arg2),A1),
        struct xadMasterBase *, (__xadMasterBase), 24, xadmaster    );
}

#define xadFreeHookAccessA(arg1, arg2) \
    __inline_xadmaster_xadFreeHookAccessA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadFreeHookAccess(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadFreeHookAccessA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadAddFileEntryA(struct xadFileInfo * __arg1, struct xadArchiveInfo * __arg2, const struct TagItem * __arg3, APTR __xadMasterBase)
{
    return AROS_LC3(xadERROR, xadAddFileEntryA,
        AROS_LCA(struct xadFileInfo *,(__arg1),A0),
        AROS_LCA(struct xadArchiveInfo *,(__arg2),A1),
        AROS_LCA(const struct TagItem *,(__arg3),A2),
        struct xadMasterBase *, (__xadMasterBase), 25, xadmaster    );
}

#define xadAddFileEntryA(arg1, arg2, arg3) \
    __inline_xadmaster_xadAddFileEntryA((arg1), (arg2), (arg3), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadAddFileEntry(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadAddFileEntryA((arg1), (arg2), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadAddDiskEntryA(struct xadDiskInfo * __arg1, struct xadArchiveInfo * __arg2, const struct TagItem * __arg3, APTR __xadMasterBase)
{
    return AROS_LC3(xadERROR, xadAddDiskEntryA,
        AROS_LCA(struct xadDiskInfo *,(__arg1),A0),
        AROS_LCA(struct xadArchiveInfo *,(__arg2),A1),
        AROS_LCA(const struct TagItem *,(__arg3),A2),
        struct xadMasterBase *, (__xadMasterBase), 26, xadmaster    );
}

#define xadAddDiskEntryA(arg1, arg2, arg3) \
    __inline_xadmaster_xadAddDiskEntryA((arg1), (arg2), (arg3), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadAddDiskEntry(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadAddDiskEntryA((arg1), (arg2), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadERROR __inline_xadmaster_xadGetFilenameA(xadUINT32 __arg1, xadSTRPTR __arg2, const xadSTRING * __arg3, const xadSTRING * __arg4, const struct TagItem * __arg5, APTR __xadMasterBase)
{
    return AROS_LC5(xadERROR, xadGetFilenameA,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(xadSTRPTR,(__arg2),A0),
        AROS_LCA(const xadSTRING *,(__arg3),A1),
        AROS_LCA(const xadSTRING *,(__arg4),A2),
        AROS_LCA(const struct TagItem *,(__arg5),A3),
        struct xadMasterBase *, (__xadMasterBase), 27, xadmaster    );
}

#define xadGetFilenameA(arg1, arg2, arg3, arg4, arg5) \
    __inline_xadmaster_xadGetFilenameA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadGetFilename(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadGetFilenameA((arg1), (arg2), (arg3), (arg4), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadSTRPTR __inline_xadmaster_xadConvertNameA(xadUINT32 __arg1, const struct TagItem * __arg2, APTR __xadMasterBase)
{
    return AROS_LC2(xadSTRPTR, xadConvertNameA,
        AROS_LCA(xadUINT32,(__arg1),D0),
        AROS_LCA(const struct TagItem *,(__arg2),A0),
        struct xadMasterBase *, (__xadMasterBase), 28, xadmaster    );
}

#define xadConvertNameA(arg1, arg2) \
    __inline_xadmaster_xadConvertNameA((arg1), (arg2), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadConvertName(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadConvertNameA((arg1), (const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline xadSTRPTR __inline_xadmaster_xadGetDefaultNameA(const struct TagItem * __arg1, APTR __xadMasterBase)
{
    return AROS_LC1(xadSTRPTR, xadGetDefaultNameA,
        AROS_LCA(const struct TagItem *,(__arg1),A0),
        struct xadMasterBase *, (__xadMasterBase), 29, xadmaster    );
}

#define xadGetDefaultNameA(arg1) \
    __inline_xadmaster_xadGetDefaultNameA((arg1), (APTR)xadMasterBase)

#if !defined(NO_INLINE_STDARG) && !defined(XADMASTER_NO_INLINE_STDARG)
#define xadGetDefaultName(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    xadGetDefaultNameA((const struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline const struct xadSystemInfo * __inline_xadmaster_xadGetSystemInfo(APTR __xadMasterBase)
{
    return AROS_LC0(const struct xadSystemInfo *, xadGetSystemInfo,
        struct xadMasterBase *, (__xadMasterBase), 30, xadmaster    );
}

#define xadGetSystemInfo() \
    __inline_xadmaster_xadGetSystemInfo((APTR)xadMasterBase)

#endif /* INLINE_XADMASTER_H*/
