#include <SFXHelper.h.hpp>

class SFXHelper;

SFMTYPEDEFCLASS(SFXHelper)

[ public, static ]
SInt32 atoi(
    ACharConstPtr string   // pointer to source character string
);

[ public, static ]
ACharPtr basename(
    ACharConstPtr path   
);

[ public, static ]
VoidPtr compressmem(Void);

[ public, static ]
VoidPtr convertbmp(
    VoidPtr address       // pointer to a buffer containing the Windows bitmap
    AEEImageInfo * info   // image's information after conversion
    BoolPtr reallocate    // whether this function separate the allocated memory or not
);

[ public, static ]
Void dbgevent(
    AEEEvent event   // event
    AEECLSID id      // ClassID
);

[ public, static ]
Void dbgevent_ex(
    AEEEvent event   // event
    AEECLSID id      // ClassID
    UInt32 payload   // user defined payload
);

[ public, static ]
VoidPtr dbgheapmarkex(
    VoidPtr address      // address of the heap to be registered
    ACharConstPtr file   // file name
    SInt32 line          // line number
);

[ public, static ]
Void dbgprintf(
    ACharConstPtr format   // format control string
    ...                    // optional argument
);

[ public, static ]
Void dumpheap(Void);

[ public, static ]
SFCError err_malloc(
    UIntN size          // buffer size (in bytes)
    VoidHandle handle   // allocated buffer handle
);

[ public, static ]
SFCError err_realloc(
    UIntN size          // buffer size (in bytes)
    VoidHandle handle   // allocated buffer handle
);

[ public, static ]
SFCError err_strdup(
    ACharConstPtr string   // character string to be duplicated
    ACharHandle result     // handle to the result
);

[ public, static ]
Float64 fabs(
    Float64 value   
);

[ public, static ]
Float64 fadd(
    Float64 left    
    Float64 right   
);

[ public, static ]
Float64 fassign_int(
    SInt32 value   // value to be assigned to the Float64 returned
);

[ public, static ]
Float64 fassign_str(
    ACharConstPtr string   // string containing the value to be assigned
);

[ public, static ]
Float64 fceil(
    Float64 value   
);

[ public, static ]
Bool fcmp_e(
    Float64 left    
    Float64 right   
);

[ public, static ]
Bool fcmp_g(
    Float64 left    
    Float64 right   
);

[ public, static ]
Bool fcmp_ge(
    Float64 left    
    Float64 right   
);

[ public, static ]
Bool fcmp_l(
    Float64 left    
    Float64 right   
);

[ public, static ]
Bool fcmp_le(
    Float64 left    
    Float64 right   
);

[ public, static ]
Float64 fcos(
    Float64 value   
);

[ public, static ]
Float64 fdiv(
    Float64 left    
    Float64 right   
);

[ public, static ]
Float64 ffloor(
    Float64 value   
);

[ public, static ]
Float64 fgetflt_max(Void);

[ public, static ]
Float64 fgetflt_min(Void);

[ public, static ]
Float64 fgethuge_val(Void);

[ public, static ]
Bool floattowstr(
    Float64 value          // floating point value to be converted into a WChar string
    WCharPtr destination   // pointer to WChar  buffer to hold the resultant WChar string
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
SInt32 flttoint(
    Float64 value   
);

[ public, static ]
Float64 fmul(
    Float64 left    
    Float64 right   
);

[ public, static ]
Float64 fpow(
    Float64 left    
    Float64 right   
);

[ public, static ]
Void free(
    VoidPtr address   // pointer to the memory to be freed
);

[ public, static ]
Float64 fsin(
    Float64 value   
);

[ public, static ]
Float64 fsqrt(
    Float64 value   
);

[ public, static ]
Float64 fsub(
    Float64 left    
    Float64 right   
);

[ public, static ]
Float64 ftan(
    Float64 value   
);

[ public, static ]
UInt32 getaeeversion(
    ACharPtr destination   // pointer to a buffer where the string containing the version number will be placed
    UIntN size             // size of the destination buffer (in bytes)
    UInt16 flag            // type of information to get
);

[ public, static ]
SFBQueryPtr getalscontext(Void);

[ public, static ]
SFCAppletPtr getappinstance(Void);

[ public, static ]
TChType getchtype(
    WChar character   // character whose type is to be determined
);

[ public, static ]
UInt32 getfsfree(
    UInt32Ptr total   // pointer to the total file system space on the device (in bytes)
);

[ public, static ]
Void getjuliandate(
    UInt32 second      // number of seconds from January 6, 1980
    JulianType* date   // pointer to the structure that needs to be filled on returned
);

[ public, static ]
SFCError getlastfperror(Void);

[ public, static ]
UInt32 getramfree(
    UInt32Ptr total     // pointer to system's total memory value
    UInt32Ptr maximum   // pointer to the size of largest node that can currently be allocated
);

[ public, static ]
Void getrand(
    VoidPtr destination   // pointer to the destination buffer
    UIntN size            // buffer size (in bytes)
);

[ public, static ]
UInt32 gettimems(Void);

[ public, static ]
UInt32 gettimeseconds(Void);

[ public, static ]
VoidPtr gettls(Void);

[ public, static ]
UInt32 getuptimems(Void);

[ public, static ]
UInt32 getutcseconds(Void);

[ public, static ]
Bool inet_aton(
    ACharConstPtr string   // string containing the addr (like "1.2.3.4")
    INAddr* address        // pointer to the inet address to be obtained
);

[ public, static ]
Void inet_ntoa(
    INAddr address         // the inet address to be converted
    ACharPtr destination   // buffer to write into
    UIntN size             // size of the destination
);

[ public, static ]
SIntN inet_ntop(
    SIntN family           // the address family of the address structure that will be converted
    VoidConstPtr address   // pointer to the address structure to be converted
    ACharPtr destination   // buffer to write the string into
    UIntN size             // size of the buffer pointed to by destination
);

[ public, static ]
SIntN inet_pton(
    SIntN family           // the address family of the string that will be converted
    ACharConstPtr source   // string containing the address, it can contain either IPv4 or IPv6 address
    VoidPtr address        // pointer to an address structure that will be filled with the address
);

[ public, static ]
Bool isbadreadptr(
    VoidPtr address   // pointer to the buffer which needs to be verified for read access
    UIntN size        // buffer size
);

[ public, static ]
Bool isbadwriteptr(
    VoidPtr address   // pointer to the buffer which needs to be verified for write access
    UIntN size        // buffer size
);

[ public, static ]
UInt32 juliantoseconds(
    JulianType* date   // pointer to julian date time structure
);

[ public, static ]
SInt32 localtimeoffset(
    BoolPtr daylight   // if not null, this flag specifies whether or not Daylight Savings time is active.
);

[ public, static ]
SIntN lockmem(
    VoidHandle handle   // pointer to the handle of allocated memory
);

[ public, static ]
SFCError makepath(
    ACharConstPtr directory   // directory
    ACharConstPtr file        // file part of the path
    ACharPtr destination      // destination buffer to write the path to
    SInt32Ptr size            // size of the destination
);

[ public, static ]
VoidPtr malloc(
    UIntN size   // buffer size (in bytes)
);

[ public, static ]
ACharPtr memchr(
    VoidConstPtr address   // memory to search
    AChar character        // character to be located
    UIntN size             // size of address
);

[ public, static ]
ACharPtr memchrend(
    VoidConstPtr address   // memory to search
    AChar character        // character to be located
    UIntN size             // size of address
);

[ public, static ]
SInt32 memcmp(
    VoidConstPtr left    // pointer to memory buffer to be compared
    VoidConstPtr right   // pointer to memory buffer to be compared
    UIntN size           // number of bytes that must be compared
);

[ public, static ]
VoidPtr memcpy(
    VoidPtr destination   // pointer to the destination buffer
    VoidConstPtr source   // pointer to source buffer
    UIntN size            // specifies the number of bytes that must be coped from src to dest
);

[ public, static ]
VoidPtr memmove(
    VoidPtr destination   // pointer to the destination buffer
    VoidConstPtr source   // pointer to source buffer
    UIntN size            // specifies the number of bytes that must be coped from src to dest
);

[ public, static ]
ACharPtr memrchr(
    VoidConstPtr address   // memory to search
    AChar character        // character to be located
    UIntN size             // size of address
);

[ public, static ]
ACharPtr memrchrbegin(
    VoidConstPtr address   // memory to search
    AChar character        // character to be located
    UIntN size             // size of address
);

[ public, static ]
VoidPtr memset(
    VoidPtr destination   // pointer to the destination buffer
    UInt08 value          // specify the value that must be copied into the destination buffer
    UIntN size            // specify the number of bytes in dest that must be set to value
);

[ public, static ]
ACharPtr memstr(
    VoidConstPtr address   // memory to search
    ACharConstPtr string   // character string to search for
    UIntN size             // size of address
);

[ public, static ]
Void msleep(
    UInt32 time   // sleep duration (in milleseconds)
);

[ public, static ]
SInt32 oemstrlen(
    ACharConstPtr string   // valid pointer to a null-terminated AChar string
);

[ public, static ]
UIntN oemstrsize(
    ACharConstPtr string   // valid pointer to a null-terminated AChar string
);

[ public, static ]
Void qsort(
    VoidPtr base                 
    UIntN length                 
    UIntN size                   
    PFNQSORTCOMPARE comparator   
);

[ public, static ]
VoidPtr realloc(
    VoidPtr address   // pointer to the previously allocated memory
    UIntN size        // new size (in bytes)
);

[ public, static ]
VoidPtr setstaticbottom(
    VoidPtr address   // new value
);

[ public, static ]
VoidPtr setstaticptr(
    SIntN id          // ID of the static pointer
    VoidPtr address   // new value
);

[ public, static ]
VoidPtr settls(
    VoidPtr address   // new value
);

[ public, static ]
SInt32 snprintf(
    ACharPtr destination   // to store output
    UIntN size             // maximum number of characters
    ACharConstPtr format   // format control string
    ...                    // optional argument
);

[ public, static ]
ACharPtr splitpath(
    ACharConstPtr path        // path
    ACharConstPtr directory   // directory
);

[ public, static ]
SInt32 sprintf(
    ACharPtr destination   // to store output
    ACharConstPtr format   // format control string
    ...                    // optional argument
);

[ public, static ]
Bool strbegins(
    ACharConstPtr prefix   // prefix to test for
    ACharConstPtr string   // string to be checked
);

[ public, static ]
ACharPtr strcat(
    ACharPtr destination   // pointer to the NULL terminated destination string
    ACharConstPtr source   // pointer to the NULL terminated source string
);

[ public, static ]
ACharPtr strchr(
    ACharConstPtr string   // null terminated WChar string to search
    AChar character        // character to be located
);

[ public, static ]
ACharPtr strchrend(
    ACharConstPtr string   // null terminated WChar string to search
    AChar character        // character to be located
);

[ public, static ]
ACharPtr strchrsend(
    ACharConstPtr string   // null terminated WChar string to search
    ACharConstPtr param    // null terminated string of characters to find
);

[ public, static ]
SInt32 strcmp(
    ACharConstPtr left    // pointer to the null terminated string to be compared
    ACharConstPtr right   // pointer to the null terminated string to be compared
);

[ public, static ]
ACharPtr strcpy(
    ACharPtr destination   // pointer to destination string
    ACharConstPtr source   // pointer to source character string
);

[ public, static ]
ACharPtr strdup(
    ACharConstPtr string   // string to be copied
);

[ public, static ]
Bool strends(
    ACharConstPtr suffix   // suffix to test for
    ACharConstPtr string   // string to be checked
);

[ public, static ]
Void strexpand(
    ACharConstPtr source   // source character string ended by null
    SInt32 length          // source string length (number of characters)
    WCharPtr destination   // pointer to the destination buffer
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
Bool stribegins(
    ACharConstPtr prefix   // prefix
    ACharConstPtr string   // string to be checked
);

[ public, static ]
SInt32 stricmp(
    ACharConstPtr left    // pointer to the null terminated string to be compared
    ACharConstPtr right   // pointer to the null terminated string to be compared
);

[ public, static ]
ACharPtr stristr(
    ACharConstPtr string   // character string to be searched
    ACharConstPtr param    // character string to search for
);

[ public, static ]
SInt32 strlcat(
    ACharPtr destination   // destination string. String to concatenate into
    ACharConstPtr source   // source string. string to copy from
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
SInt32 strlcpy(
    ACharPtr destination   // destination string. string to copy into.
    ACharConstPtr source   // source string. string to copy from
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
SInt32 strlen(
    ACharConstPtr string   // null terminated string whose length is to be determined
);

[ public, static ]
ACharPtr strlower(
    ACharPtr string   // string to be converted into small letters
);

[ public, static ]
SInt32 strncmp(
    ACharConstPtr left    // pointer to the null terminated string to be compared
    ACharConstPtr right   // pointer to the null terminated string to be compared
    SInt32 length         // maximum bytes to be compared
);

[ public, static ]
ACharPtr strncpy(
    ACharPtr destination   // destination string
    ACharConstPtr source   // source string
    SInt32 length          // number of characters to be copied
);

[ public, static ]
SInt32 strnicmp(
    ACharConstPtr left    // pointer to the null terminated string to be compared
    ACharConstPtr right   // pointer to the null terminated string to be compared
    SInt32 length         // maximum bytes to be compared
);

[ public, static ]
ACharPtr strrchr(
    ACharConstPtr string   // null terminated WChar string to search
    AChar character        // character to be located
);

[ public, static ]
ACharPtr strstr(
    ACharConstPtr string   // character string to be searched
    ACharConstPtr param    // character string to search for
);

[ public, static ]
Float64 strtod(
    ACharConstPtr string   // null terminated string to be converted
    ACharHandle result     // pointer to character that stops the conversion
);

[ public, static ]
UInt32 strtoul(
    ACharConstPtr string   // null terminated string to be converted
    ACharHandle result     // If not null, it points to character that stops scan on return
    SInt32 base            // number base to use
);

[ public, static ]
WCharPtr strtowstr(
    ACharConstPtr source   // pointer to null terminated string comprised of single-byte characters
    WCharPtr destination   // pointer to destination buffer to store the WChar string
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
ACharPtr strupper(
    ACharPtr string   // string to be converted into capital letter
);

[ public, static ]
UInt32 swapl(
    UInt32 value   // value to be swap
);

[ public, static ]
UInt16 swaps(
    UInt16 value   // value to be swap
);

[ public, static ]
Void sysfree(
    VoidPtr address   // pointer to memory allocated by CONVERTBMP
);

[ public, static ]
SInt32 trunc(
    Float64 value   
);

[ public, static ]
SIntN unlockmem(
    VoidHandle handle   // pointer to the handle of allocated memory
);

[ public, static ]
Bool utf8towstr(
    ACharConstPtr source   // pointer to null terminated input string
    SInt32 length          // length of input string (in bytes)
    WCharPtr destination   // destination string
    UIntN size             // size of destination (in bytes)
);

[ public, static ]
UInt32 utrunc(
    Float64 value   
);

[ public, static ]
SInt32 vsnprintf(
    ACharPtr destination   // to store output
    UIntN size             // buffer size
    ACharConstPtr format   // format control string
    va_list argument       // optional argument list
);

[ public, static ]
SInt32 vsprintf(
    ACharPtr destination   // to store output
    ACharConstPtr format   // format control string
    va_list argument       // optional argument list
);

[ public, static ]
Float64 wgs84_to_degrees(
    SInt32 value   // latitude or longitude in WGS84 format
);

[ public, static ]
Void wsprintf(
    WCharPtr destination   // to store output
    UIntN size             // size of the destination buffer (in bytes)
    WCharConstPtr format   // format control string
    ...                    // optional argument
);

[ public, static ]
WCharPtr wstrcat(
    WCharPtr destination   // pointer to the NULL terminated destination string
    WCharConstPtr source   // pointer to the NULL terminated source string
);

[ public, static ]
WCharPtr wstrchr(
    WCharConstPtr string   // null terminated WChar string to search
    WChar character        // character to be located
);

[ public, static ]
SInt32 wstrcmp(
    WCharConstPtr left    // pointer to first NULL terminated string
    WCharConstPtr right   // pointer to second NULL terminated string
);

[ public, static ]
Void wstrcompress(
    WCharConstPtr source   // source character string ended by null
    SInt32 length          // length of the source string (in AECHARs)
    ACharPtr destination   // pointer to the destination buffer
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
WCharPtr wstrcpy(
    WCharPtr destination   // pointer to destination string
    WCharConstPtr source   // pointer to source character string
);

[ public, static ]
WCharPtr wstrdup(
    WCharConstPtr string   // string to be copied
);

[ public, static ]
SInt32 wstricmp(
    WCharConstPtr left    // pointer to the null terminated string to be compared
    WCharConstPtr right   // pointer to the null terminated string to be compared
);

[ public, static ]
SInt32 wstrlcat(
    WCharPtr destination   // destination string. string to concatenate into
    WCharConstPtr source   // source string. string to copy from
    SInt32 size            // size of destination buffer (in AECHAR)
);

[ public, static ]
SInt32 wstrlcpy(
    WCharPtr destination   // destination string. string to copy into.
    WCharConstPtr source   // source string. string to copy from
    SInt32 size            // size of destination buffer (in AECHAR)
);

[ public, static ]
SInt32 wstrlen(
    WCharConstPtr string   // null terminated string whose length is to be determined
);

[ public, static ]
Void wstrlower(
    WCharPtr string   // string to be converted into small letter
);

[ public, static ]
SInt32 wstrncmp(
    WCharConstPtr left    // pointer to the null terminated string to be compared
    WCharConstPtr right   // pointer to the null terminated string to be compared
    SInt32 length         // maximum number of AECHARS to compare
);

[ public, static ]
SInt32 wstrncopyn(
    WCharPtr destination   // destination string
    SInt32 size            // size of the destination (in AECHAR)
    WCharConstPtr source   // source string
    SInt32 length          // the maximum string length to copy
);

[ public, static ]
SInt32 wstrnicmp(
    WCharConstPtr left    // pointer to the null terminated string to be compared
    WCharConstPtr right   // pointer to the null terminated string to be compared
    SInt32 length         // maximum number (in AECHAR ) can be compared 
);

[ public, static ]
WCharPtr wstrrchr(
    WCharConstPtr string   // null terminated WChar string to search
    WChar character        // character to be located
);

[ public, static ]
UIntN wstrsize(
    WCharConstPtr string   // valid pointer to a null-terminated wide string
);

[ public, static ]
Float64 wstrtofloat(
    WCharConstPtr string   // pointer to null terminated wide string to be converted to float
);

[ public, static ]
ACharPtr wstrtostr(
    WCharConstPtr source   // pointer to null terminated WChar string to be converted to AChar string
    ACharPtr destination   // pointer to destination buffer to store the AChar string
    UIntN size             // size of the destination buffer (in bytes)
);

[ public, static ]
Bool wstrtoutf8(
    WCharConstPtr source   // input string
    SInt32 length          // length of input string (in AECHARs)
    ACharPtr destination   // destination string
    UIntN size             // size of destination (in bytes)
);

[ public, static ]
Void wstrupper(
    WCharPtr string   // string to be converted into capital letter
);

[ public, static ]
WCharPtr wwritelong(
    WCharPtr destination   // valid pointer to a null-terminated WChar string to which the converted long is written
    SInt32 value           // number of long type
);

[ public, static ]
WCharPtr wwritelongex(
    WCharPtr destination   // valid pointer to a null terminated WChar string to which the converted long is written
    SInt32 value           // number of long type
    SInt32 padding         // maximum amount of padding
    SInt32Ptr result       // on input, this pointer points to an integer that specifies the size the destination (in AECHARs)
                           // on output, this points to an integer that denotes the unused space (in terms of number of ARCHARs) left in the destination
       
);