kApiDef.h

Go to the documentation of this file.

#ifndef K_API_API_DEF_H
#define K_API_API_DEF_H

#include <kApi/kApiCfg.h>

kBeginHeader()

#define kCall           kxCall              
#define kDlCall         kxDlCall            

#if defined(K_EMIT)
#   define kFx(TYPE)    kExportFx(TYPE)     
#   define kDx(TYPE)    kExportDx(TYPE)     
#else
#   define kFx(TYPE)    kImportFx(TYPE)     
#   define kDx(TYPE)    kImportDx(TYPE)     
#endif

typedef void (kCall* kFunction)();          

typedef kx8u k8u;          

#define k8U_MIN    (0)             
#define k8U_MAX    (255U)          
#define k8U_NULL   (k8U_MAX)       

typedef kx16u k16u;           

#define k16U_MIN   (0)             
#define k16U_MAX   (65535U)        
#define k16U_NULL  (k16U_MAX)      

typedef kx32u k32u;   

#define k32U_MIN   (0)             
#define k32U_MAX   (4294967295U)   
#define k32U_NULL  (k32U_MAX)      

typedef kx64u k64u;         

#define k64U(CONST) kx64U(CONST)                    
#define k64U_MIN    k64U(0)                         
#define k64U_MAX    k64U(18446744073709551615)      
#define k64U_NULL  (k64U_MAX)                       

#define kINFINITE   k64U_MAX                        


typedef kx8s k8s;       

#define k8S_MAX    (127)               
#define k8S_MIN    (-k8S_MAX -1)       
#define k8S_NULL   (k8S_MIN)           

typedef kx16s k16s;      

#define k16S_MAX   (32767)             
#define k16S_MIN   (-k16S_MAX -1)      
#define k16S_NULL  (k16S_MIN)          

typedef kx32s k32s;      

#define k32S_MAX   (2147483647)        
#define k32S_MIN   (-k32S_MAX -1)      
#define k32S_NULL  (k32S_MIN)          

typedef kx64s k64s;      

#define k64S(CONST) kx64S(CONST)                
#define k64S_MAX    k64S(9223372036854775807)   
#define k64S_MIN    (-k64S_MAX -1)              
#define k64S_NULL   (k64S_MIN)                  

typedef kx32f k32f;         

#define k32F_MIN   (1.175494351e-38F)      
#define k32F_MAX   (3.402823466e+38F)      
#define k32F_NULL  (-k32F_MAX)             

typedef kx64f k64f;        

#define k64F_MIN   (2.2250738585072014e-308)   
#define k64F_MAX   (1.7976931348623157e+308)   
#define k64F_NULL  (-k64F_MAX)                 

typedef kxByte kByte;                           

typedef kxSize kSize;   

#define kSIZE_MAX           kxSIZE_MAX      
#define kSIZE_NULL          kSIZE_MAX       

typedef kxSSize kSSize;   

#define kSSIZE_MIN       kxSSIZE_MIN        
#define kSSIZE_MAX       kxSSIZE_MAX        
#define kSSIZE_NULL      kSSIZE_MIN         

typedef void* kPointer;   

#define kNULL   (0)     


#define kIsNull(POINTER)    kIsNull_(POINTER)          

typedef k32s kBool;

#define kFALSE     (0)     
#define kTRUE      (1)     

typedef kxChar kChar;                           

typedef kChar kText16[16];    

typedef kChar kText32[32];    

typedef kChar kText64[64];    

typedef kChar kText128[128];  

typedef kChar kText256[256];  

typedef k32s kStatus; 

#define kERROR_STATE               (-1000)     
#define kERROR_NOT_FOUND           (-999)      
#define kERROR_COMMAND             (-998)      
#define kERROR_PARAMETER           (-997)      
#define kERROR_UNIMPLEMENTED       (-996)      
#define kERROR_MEMORY              (-994)      
#define kERROR_TIMEOUT             (-993)      
#define kERROR_INCOMPLETE          (-992)      
#define kERROR_STREAM              (-991)      
#define kERROR_CLOSED              (-990)      
#define kERROR_VERSION             (-989)      
#define kERROR_ABORT               (-988)      
#define kERROR_ALREADY_EXISTS      (-987)      
#define kERROR_NETWORK             (-986)      
#define kERROR_HEAP                (-985)      
#define kERROR_FORMAT              (-984)      
#define kERROR_READ_ONLY           (-983)      
#define kERROR_WRITE_ONLY          (-982)      
#define kERROR_BUSY                (-981)      
#define kERROR_CONFLICT            (-980)      
#define kERROR_OS                  (-979)      
#define kERROR_DEVICE              (-978)      
#define kERROR_FULL                (-977)      
#define kERROR_IN_PROGRESS         (-976)      
#define kERROR                     (0)         
#define kOK                        (1)         

kFx(const kChar*) kStatus_Name(kStatus status); 

#define kIsError(EXPRESSION)        kIsError_(EXPRESSION)

#define kSuccess(EXPRESSION)        kSuccess_(EXPRESSION)

#define kCheck(EXPRESSION)      kCheck_(EXPRESSION)

#define kCheckTrue(EXPRESSION, STATUS)      kCheckTrue_(EXPRESSION, STATUS)

#define kCheckArgs(EXPRESSION)      kCheckArgs_(EXPRESSION)

#define kCheckState(EXPRESSION)     kCheckState_(EXPRESSION)

#define kTry        kTry_

#define kThrow(EXPRESSION)      kThrow_(EXPRESSION)

#define kTest(EXPRESSION)       kTest_(EXPRESSION)

#define kTestTrue(EXPRESSION, STATUS)       kTestTrue_(EXPRESSION, STATUS)

#define kTestArgs(EXPRESSION)       kTestArgs_(EXPRESSION)

#define kTestState(EXPRESSION)      kTestState_(EXPRESSION)

#define kCatch(STATUS_POINTER)      kCatch_(STATUS_POINTER)

#define kEndCatch(STATUS)       kEndCatch_(STATUS)

#define kFinally        kFinally_ 

#define kEndFinally()       kEndFinally_()

#define kCatchEx(STATUS_POINTER)    kCatchEx_(STATUS_POINTER)

#define kEndCatchEx(STATUS)     kEndCatchEx_(STATUS)

#define kFinallyEx      kFinallyEx_ 

#define kEndFinallyEx()             kEndFinallyEx_()

#define kAssert(EXPRESSION)         kAssert_(EXPRESSION)

#define kAssertType(OBJECT, SYMBOL)     kAssertType_(OBJECT, SYMBOL)

#define kTrace(TAG)                 kTrace_(TAG)

typedef k32u kVersion;

kFx(kVersion) kVersion_Create(k32u major, k32u minor, k32u release, k32u build);

kFx(kStatus) kVersion_Parse(kVersion* version, const kChar* buffer);

kFx(kStatus) kVersion_Format(kVersion version, kChar* buffer, kSize capacity);

kFx(k32s) kVersion_Compare(kVersion version1, kVersion version2);

kFx(k8u) kVersion_Major(kVersion version);

kFx(k8u) kVersion_Minor(kVersion version);

kFx(k8u) kVersion_Release(kVersion version);

kFx(k8u) kVersion_Build(kVersion version);

typedef k32s kEndianness; 

#define kENDIANNESS_LITTLE          (1)             
#define kENDIANNESS_BIG             (2)             

#define kEndianness_Host_()             \
    (K_ENDIANNESS)

#define kEndianness_ShouldSwap_(E)    \
    ((E) != kEndianness_Host_())

kFx(kStatus) k8u_Format(k8u value, kChar* buffer, kSize capacity);

kFx(kStatus) k8u_Parse(k8u* value, const kChar* str);

kFx(kStatus) k8s_Format(k8s value, kChar* buffer, kSize capacity);

kFx(kStatus) k8s_Parse(k8s* value, const kChar* str);

kFx(kStatus) k16u_Format(k16u value, kChar* buffer, kSize capacity);

kFx(kStatus) k16u_Parse(k16u* value, const kChar* str);

kFx(kStatus) k16s_Format(k16s value, kChar* buffer, kSize capacity);

kFx(kStatus) k16s_Parse(k16s* value, const kChar* str);

kFx(kStatus) k32u_Format(k32u value, kChar* buffer, kSize capacity);

kFx(kStatus) k32u_Parse(k32u* value, const kChar* str);

kFx(kStatus) k32s_Format(k32s value, kChar* buffer, kSize capacity);

kFx(kStatus) k32s_Parse(k32s* value, const kChar* str);

kFx(kStatus) k64u_Format(k64u value, kChar* buffer, kSize capacity);

kFx(kStatus) k64u_Parse(k64u* value, const kChar* str);

kFx(kStatus) k64s_Format(k64s value, kChar* buffer, kSize capacity);

kFx(kStatus) k64s_Parse(k64s* value, const kChar* str);

kFx(kStatus) kBool_Format(kBool value, kChar* buffer, kSize capacity);

kFx(kStatus) kBool_Parse(kBool* value, const kChar* str);

kFx(kStatus) kSize_Format(kSize value, kChar* buffer, kSize capacity);

kFx(kStatus) kSize_Parse(kSize* value, const kChar* str);

kFx(kStatus) kSSize_Format(kSSize value, kChar* buffer, kSize capacity);

kFx(kStatus) kSSize_Parse(kSSize* value, const kChar* str);

kFx(kStatus) k32f_Format(k32f value, kChar* buffer, kSize capacity);

kFx(kStatus) k32f_Parse(k32f* value, const kChar* str);

kFx(kStatus) k64f_Format(k64f value, kChar* buffer, kSize capacity);

kFx(kStatus) k64f_Parse(k64f* value, const kChar* str);

typedef struct kPoint16s
{
    k16s x;     
    k16s y;     
} kPoint16s;

typedef struct kPoint32s
{
    k32s x;     
    k32s y;     
} kPoint32s; 

typedef struct kPoint32f
{
    k32f x;     
    k32f y;     
} kPoint32f;  

typedef struct kPoint64f
{
    k64f x;     
    k64f y;     
} kPoint64f;

#define kPoint_Init_(POINT, X, Y)     kxPoint_Init_(POINT, X, Y)  

typedef struct kPoint3d16s
{
    k16s x;     
    k16s y;     
    k16s z;     
} kPoint3d16s;

typedef struct kPoint3d32s
{
    k32s x;     
    k32s y;     
    k32s z;     
} kPoint3d32s;  

typedef struct kPoint3d32f
{
    k32f x;     
    k32f y;     
    k32f z;     
} kPoint3d32f; 

typedef struct kPoint3d64f
{
    k64f x;     
    k64f y;     
    k64f z;     
} kPoint3d64f;  

#define kPoint3d_Init_(POINT, X, Y, Z)   kxPoint3d_Init_(POINT, X, Y, Z)

typedef struct kRect16s
{
    k16s x;         
    k16s y;         
    k16s width;     
    k16s height;    
} kRect16s;        

typedef struct kRect32s
{
    k32s x;         
    k32s y;         
    k32s width;     
    k32s height;    
} kRect32s;        

typedef struct kRect32f
{
    k32f x;         
    k32f y;         
    k32f width;     
    k32f height;    
} kRect32f;     

typedef struct kRect64f
{
    k64f x;         
    k64f y;         
    k64f width;     
    k64f height;    
} kRect64f;         

#define kRect_Init_(RECT, X, Y, W, H)    kxRect_Init_(RECT, X, Y, W, H) 

typedef struct kRect3d64f
{
    k64f x;         
    k64f y;         
    k64f z;         
    k64f width;     
    k64f height;    
    k64f depth;     
} kRect3d64f;

#define kRect3d_Init_(RECT, X, Y, Z, W, H, D)    kxRect3d_Init_(RECT, X, Y, Z, W, H, D) 

typedef struct kRotatedRect32s
{
    k32s xc;        
    k32s yc;        
    k32s width;     
    k32s height;    
    k32s angle;     
} kRotatedRect32s;

typedef struct kRotatedRect32f
{
    k32f xc;        
    k32f yc;        
    k32f width;     
    k32f height;    
    k32f angle;     
} kRotatedRect32f;  

#define kRotatedRect_Init_(RECT, XC, YC, W, H, A)   kxRotatedRect_Init_(RECT, XC, YC, W, H, A) 

typedef k32s kPixelFormat; 

#define kPIXEL_FORMAT_NULL              (0)      
#define kPIXEL_FORMAT_8BPP_GREYSCALE    (1)      
#define kPIXEL_FORMAT_8BPP_CFA          (2)      
#define kPIXEL_FORMAT_8BPC_BGRX         (3)      
#define kPIXEL_FORMAT_1BPP_GREYSCALE    (4)      

typedef k32s kCfa; 

#define kCFA_NONE            (0)      
#define kCFA_BAYER_BGGR      (1)      
#define kCFA_BAYER_GBRG      (2)      
#define kCFA_BAYER_RGGB      (3)      
#define kCFA_BAYER_GRBG      (4)      

typedef struct kRgb
{
    k8u b;      
    k8u g;      
    k8u r;      
    k8u x;      
} kRgb;

#define kRgb_Init_(RGB, R, G, B)  kxRgb_Init_(RGB, R, G, B) 

typedef struct kArgb
{
    k8u b;      
    k8u g;      
    k8u r;      
    k8u a;      
} kArgb;

#define kArgb_Init_(ARGB, A, R, G, B) kxArgb_Init_(ARGB, A, R, G, B)

typedef k32s kComparison; 

#define kCOMPARISON_EQ      (0)        
#define kCOMPARISON_NEQ     (1)        
#define kCOMPARISON_LT      (2)        
#define kCOMPARISON_LTE     (3)        
#define kCOMPARISON_GT      (4)        
#define kCOMPARISON_GTE     (5)        


typedef kBool (kCall* kEqualsFx)(const void* item1, const void* item2); 

typedef kSize (kCall* kHashFx)(const void* item); 

typedef kStatus (kCall* kCallbackFx)(kPointer receiver, kPointer sender, void* args); 

typedef struct kCallback
{
    kCallbackFx function;       
    kPointer receiver;          
} kCallback; 

typedef k32s kFileMode;         

#define kFILE_MODE_READ         (0x1)     
#define kFILE_MODE_WRITE        (0x2)     
#define kFILE_MODE_UPDATE       (0x4)     

typedef k32s kSeekOrigin; 

#define kSEEK_ORIGIN_BEGIN      (0)     
#define kSEEK_ORIGIN_CURRENT    (1)     
#define kSEEK_ORIGIN_END        (2)     


#define kCountOf(CARRAY)    kCountOf_(CARRAY)

#define kCast(TYPE, ITEM)       kCast_(TYPE, ITEM)     

#define kMin_(A, B)         kxMin_(A, B) 

#define kMax_(A, B)         kxMax_(A, B)

#define kClamp_(V, VMIN, VMAX)      kxClamp_((V), (VMIN), (VMAX))

#define kAbs_(A)            kxAbs_(A)

#define kZero_(VALUE)       kxZero_(VALUE)

#define kItemCopy_(DEST, SRC, SIZE)    kxItemCopy_(DEST, SRC, SIZE)       

#define kItemSet_(DEST, FILL, SIZE)    kxItemSet_(DEST, FILL, SIZE)

#define kItemZero_(DEST, SIZE)          kItemSet_(DEST, 0, SIZE)

#define kItemAt_(BASE, INDEX, SIZE)     kAt_((BASE), (INDEX)*(SIZE))


#define kTypeOf(SYMBOL)     kTypeOf_(SYMBOL)

#define kAssemblyOf(SYMBOL)     kAssemblyOf_(SYMBOL)

#define kStaticOf(SYMBOL)   kStaticOf_(SYMBOL)

#define kStaticInitialized(SYMBOL)   kStaticInitialized_(SYMBOL)

#define kDeclareAssembly(PREFIX, SYMBOL)        kDeclareAssembly_(PREFIX, SYMBOL)       

#define kBeginAssembly(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION)       kBeginAssembly_(PREFIX, SYMBOL, VERSION, PLATFORM_VERSION)

#define kEndAssembly()           kEndAssembly_()  

#define kDeclareValue(PREFIX, SYMBOL, BASE)         kDeclareValue_(PREFIX, SYMBOL, BASE) 

#define kBeginValue(PREFIX, SYMBOL, BASE)       kBeginValue_(PREFIX, SYMBOL, BASE)

#define kEndValue()         kEndValue_() 

#define kDeclareEnum(PREFIX, SYMBOL, BASE)      kDeclareEnum_(PREFIX, SYMBOL, BASE) 

#define kBeginEnum(PREFIX, SYMBOL, BASE)         kBeginEnum_(PREFIX, SYMBOL, BASE) 

#define kEndEnum()           kEndEnum_()

#define kDeclareBitEnum(PREFIX, SYMBOL, BASE)   kDeclareBitEnum_(PREFIX, SYMBOL, BASE)

#define kBeginBitEnum(PREFIX, SYMBOL, BASE)         kBeginBitEnum_(PREFIX, SYMBOL, BASE)

#define kEndBitEnum()       kEndBitEnum_()  

#define kDeclareArrayValue(PREFIX, SYMBOL, BASE)        kDeclareArrayValue_(PREFIX, SYMBOL, BASE) 

#define kBeginArrayValue(PREFIX, SYMBOL, TYPE, BASE)        kBeginArrayValue_(PREFIX, SYMBOL, TYPE, BASE) 

#define kEndArrayValue()        kEndArrayValue_()

#define kDeclareInterface(PREFIX, SYMBOL, BASE)         kDeclareInterface_(PREFIX, SYMBOL, BASE) 

#define kBeginInterface(PREFIX, SYMBOL, BASE)           kBeginInterface_(PREFIX, SYMBOL, BASE) 

#define kEndInterface()         kEndInterface_()  

#define kDeclareFullClass(PREFIX, SYMBOL, BASE)         kDeclareFullClass_(PREFIX, SYMBOL, BASE)  

#define kBeginFullClass(PREFIX, SYMBOL, BASE)       kBeginFullClass_(PREFIX, SYMBOL, BASE) 

#define kEndFullClass()         kEndFullClass_()

#define kDeclareVirtualClass(PREFIX, SYMBOL, BASE)          kDeclareVirtualClass_(PREFIX, SYMBOL, BASE)

#define kBeginVirtualClass(PREFIX, SYMBOL, BASE)        kBeginVirtualClass_(PREFIX, SYMBOL, BASE) 

#define kEndVirtualClass()          kEndVirtualClass_()   

#define kDeclareStaticClass(PREFIX, SYMBOL)         kDeclareStaticClass_(PREFIX, SYMBOL) 

#define kBeginStaticClass(PREFIX, SYMBOL)       kBeginStaticClass_(PREFIX, SYMBOL)  

#define kEndStaticClass()           kEndStaticClass_()

#define kDeclareClass(PREFIX, SYMBOL, BASE)         kDeclareClass_(PREFIX, SYMBOL, BASE)  

#define kBeginClass(PREFIX, SYMBOL, BASE)       kBeginClass_(PREFIX, SYMBOL, BASE) 

#define kEndClass()         kEndClass_()

#define kAddDependency(SYMBOL)              kAddDependency_(SYMBOL)    

#define kAddType(SYMBOL)        kAddType_(SYMBOL)   

#define kAddPriority(SYMBOL)        kAddPriority_(SYMBOL)

#define kAddInterface(SYMBOL, IFACE)        kAddInterface_(SYMBOL, IFACE) 

#define kAddMethod(SYMBOL, METHOD)           kAddMethod_(SYMBOL, METHOD)  

#define kAddVMethod(IN_TYPE, FROM_TYPE, METHOD)           kAddVMethod_(IN_TYPE, FROM_TYPE, METHOD)   

#define kAddIVMethod(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD)        kAddIVMethod_(IN_TYPE, FROM_IFACE, IMETHOD, CMETHOD)

#define kAddField(VALUE, FIELD_TYPE, FIELD)         kAddField_(VALUE, FIELD_TYPE, FIELD)

#define kAddEnumerator          kAddEnumerator_

#define kAddVersion(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD)          \
    kAddVersion_(TYPE, FORMAT, FORMAT_VER, GUID, WRITE_METHOD, READ_METHOD)   

#define kAddAbstractVersion(TYPE, FORMAT, FORMAT_VER, GUID)          \
    kAddAbstractVersion_(TYPE, FORMAT, FORMAT_VER, GUID)   

#define kAddFlags(TYPE, FLAGS)          kAddFlags_(TYPE, FLAGS)     


#define kDefineDebugHints()          kDefineDebugHints_()

kEndHeader()

#include <kApi/kApiDef.x.h>

#endif