#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
);