// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= //
//  »Project«   Talina Gaming System (TgS) (∂)
//  »File«      TgS Common - Base - API.h
//  »Author«    Andrew Aye (EMail: mailto:andrew.aye@gmail.com, Web: http://www.andrewaye.com)
//  »Version«   4.0
// ------------------------------------------------------------------------------------------------------------------------------ //
//  Copyright: © 2002-2010, Andrew Aye.  All Rights Reserved.
//  This software is free for non-commercial use. Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met: 
//    Redistributions of source code must retain this copyright notice, this list of conditions and the following disclaimers. 
//    Redistributions in binary form must reproduce this copyright notice, this list of conditions and the following
//      disclaimers in the documentation and other materials provided with the distribution. 
//  Neither the names of the copyright owner nor the names of its contributors may be used to endorse or promote products derived
//  from this software without specific prior written permission. 
//  The intellectual property rights of the algorithms used reside with Andrew Aye.  You may not use this software, in whole or
//  in part, in support of any commercial product without the express written consent of the author.
//  There is no warranty or other guarantee of fitness of this software for any purpose. It is provided solely "as is".
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= //
#if !defined(_TGS_COMMON_BASE_API_H_)
#define _TGS_COMMON_BASE_API_H_
#pragma once


// START TGS ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

TgVOID                                      tgCM_Unit_Test_Register_BASE();

TgINLINE TgUINTPTR                          tgCM_FLR_ALGN_PW2_UPTR( C_TgUINTPTR uiA, C_TgUINTPTR uiAlignment );
TgINLINE TgUINTPTR                          tgCM_CEL_ALGN_PW2_UPTR( C_TgUINTPTR uiA, C_TgUINTPTR uiAlignment );

                                            // Init Mersenne Twister Random Generator (Default for TGS)
                                            // 1: Seed
TgVOID                                      tgCM_Init_Random_MT( TgUINT32 );

                                            // Init Mersenne Twister Random Generator (Default for TGS)
                                            // 1: Seed List
                                            // 2: Number of Seeds
TgVOID                                      tgCM_Init_Random_MT__Key_List( PU_TgUINT32, TgUINT32 );

                                            // Request a random number for the Mersenne Twister Random Generator [0,UINTMAX]
TgUINT32                                    tgCM_RND_MT_U32();

                                            // Random Normal Distribution - Return a value on a normal (Gaussian) distribution with
                                            // the give mean and standard deviation.
                                            // 1: Mean
                                            // 2: Standard Deviation
TgFLOAT32                                   tgCM_RND_NRM_F32( C_TgFLOAT32, C_TgFLOAT32 );

//                                          SWP:            Swap the values of the two parameters
//                                          SGN:            Sign of parameter value
//                                          MAX:            Max value of the two parameters
//                                          MIN:            Min value of the two parameters
//                                          CLP:            Clamp value between the min and max
//                                          CLP_MIN:        Limit value to min and above
//                                          CLP_MAX:        Limit value to max and below
//                                          FLR_ALGN_PW2:   Align value down where alignment is a power of two
//                                          CEL_ALGN_PW2:   Align value up where alignment is a power of two
//                                          PRV_PW2:        Find the nearest power of two less or equal to parameter
//                                          NXT_PW2:        Find the nearest power of two greater or equal to parameter
//                                          IS_PW2:         Boolean test to determine if value is a power of two
//                                          RND:            Random number ranging from [MIN,MAX] or [0,1)

TgINLINE TgVOID                             tgCM_SWP_U08( PCU_TgUINT08 puiA, PCU_TgUINT08 puiB );
TgINLINE TgUINT08                           tgCM_SGN_U08( C_TgUINT08 uiA );
TgINLINE TgUINT08                           tgCM_MAX_U08( C_TgUINT08 uiA, C_TgUINT08 uiB );
TgINLINE TgUINT08                           tgCM_MIN_U08( C_TgUINT08 uiA, C_TgUINT08 uiB );
TgINLINE TgUINT08                           tgCM_CLP_U08( C_TgUINT08 uiA, C_TgUINT08 uiLow, C_TgUINT08 uiHigh );
TgINLINE TgUINT08                           tgCM_CLP_MIN_U08( C_TgUINT08 uiA, C_TgUINT08 uiLow );
TgINLINE TgUINT08                           tgCM_CLP_MAX_U08( C_TgUINT08 uiA, C_TgUINT08 uiHigh );
TgINLINE TgUINT08                           tgCM_FLR_ALGN_PW2_U08( C_TgUINT08 uiA, C_TgUINT08 uiAlignment );
TgINLINE TgUINT08                           tgCM_CEL_ALGN_PW2_U08( C_TgUINT08 uiA, C_TgUINT08 uiAlignment );
TgINLINE TgUINT08                           tgCM_PRV_PW2_U08( C_TgUINT08 uiA );
TgINLINE TgUINT08                           tgCM_NXT_PW2_U08( C_TgUINT08 uiA );
TgINLINE TgBOOL                             tgCM_IS_PW2_U08( C_TgUINT08 uiA );
TgINLINE TgUINT08                           tgCM_RND_U08();

TgINLINE TgVOID                             tgCM_SWP_U16( PCU_TgUINT16 puiA, PCU_TgUINT16 puiB );
TgINLINE TgUINT16                           tgCM_SGN_U16( C_TgUINT16 uiA );
TgINLINE TgUINT16                           tgCM_MAX_U16( C_TgUINT16 uiA, C_TgUINT16 uiB );
TgINLINE TgUINT16                           tgCM_MIN_U16( C_TgUINT16 uiA, C_TgUINT16 uiB );
TgINLINE TgUINT16                           tgCM_CLP_U16( C_TgUINT16 uiA, C_TgUINT16 uiLow, C_TgUINT16 uiHigh );
TgINLINE TgUINT16                           tgCM_CLP_MIN_U16( C_TgUINT16 uiA, C_TgUINT16 uiLow );
TgINLINE TgUINT16                           tgCM_CLP_MAX_U16( C_TgUINT16 uiA, C_TgUINT16 uiHigh );
TgINLINE TgUINT16                           tgCM_FLR_ALGN_PW2_U16( C_TgUINT16 uiA, C_TgUINT16 uiAlignment );
TgINLINE TgUINT16                           tgCM_CEL_ALGN_PW2_U16( C_TgUINT16 uiA, C_TgUINT16 uiAlignment );
TgINLINE TgUINT16                           tgCM_PRV_PW2_U16( C_TgUINT16 uiA );
TgINLINE TgUINT16                           tgCM_NXT_PW2_U16( C_TgUINT16 uiA );
TgINLINE TgBOOL                             tgCM_IS_PW2_U16( C_TgUINT16 uiA );
TgINLINE TgUINT16                           tgCM_RND_U16();

TgINLINE TgVOID                             tgCM_SWP_U32( PCU_TgUINT32 puiA, PCU_TgUINT32 puiB );
TgINLINE TgUINT32                           tgCM_SGN_U32( C_TgUINT32 uiA );
TgINLINE TgUINT32                           tgCM_MAX_U32( C_TgUINT32 uiA, C_TgUINT32 uiB );
TgINLINE TgUINT32                           tgCM_MIN_U32( C_TgUINT32 uiA, C_TgUINT32 uiB );
TgINLINE TgUINT32                           tgCM_CLP_U32( C_TgUINT32 uiA, C_TgUINT32 uiLow, C_TgUINT32 uiHigh );
TgINLINE TgUINT32                           tgCM_CLP_MIN_U32( C_TgUINT32 uiA, C_TgUINT32 uiLow );
TgINLINE TgUINT32                           tgCM_CLP_MAX_U32( C_TgUINT32 uiA, C_TgUINT32 uiHigh );
TgINLINE TgUINT32                           tgCM_FLR_ALGN_PW2_U32( C_TgUINT32 uiA, C_TgUINT32 uiAlignment );
TgINLINE TgUINT32                           tgCM_CEL_ALGN_PW2_U32( C_TgUINT32 uiA, C_TgUINT32 uiAlignment );
TgINLINE TgUINT32                           tgCM_PRV_PW2_U32( C_TgUINT32 uiA );
TgINLINE TgUINT32                           tgCM_NXT_PW2_U32( C_TgUINT32 uiA );
TgINLINE TgBOOL                             tgCM_IS_PW2_U32( C_TgUINT32 uiA );
TgINLINE TgUINT32                           tgCM_RND_U32();

TgINLINE TgVOID                             tgCM_SWP_U64( PCU_TgUINT64 puiA, PCU_TgUINT64 puiB );
TgINLINE TgUINT64                           tgCM_SGN_U64( C_TgUINT64 uiA );
TgINLINE TgUINT64                           tgCM_MAX_U64( C_TgUINT64 uiA, C_TgUINT64 uiB );
TgINLINE TgUINT64                           tgCM_MIN_U64( C_TgUINT64 uiA, C_TgUINT64 uiB );
TgINLINE TgUINT64                           tgCM_CLP_U64( C_TgUINT64 uiA, C_TgUINT64 uiLow, C_TgUINT64 uiHigh );
TgINLINE TgUINT64                           tgCM_CLP_MIN_U64( C_TgUINT64 uiA, C_TgUINT64 uiLow );
TgINLINE TgUINT64                           tgCM_CLP_MAX_U64( C_TgUINT64 uiA, C_TgUINT64 uiHigh );
TgINLINE TgUINT64                           tgCM_FLR_ALGN_PW2_U64( C_TgUINT64 uiA, C_TgUINT64 uiAlignment );
TgINLINE TgUINT64                           tgCM_CEL_ALGN_PW2_U64( C_TgUINT64 uiA, C_TgUINT64 uiAlignment );
TgINLINE TgUINT64                           tgCM_PRV_PW2_U64( C_TgUINT64 uiA );
TgINLINE TgUINT64                           tgCM_NXT_PW2_U64( C_TgUINT64 uiA );
TgINLINE TgBOOL                             tgCM_IS_PW2_U64( C_TgUINT64 uiA );
TgINLINE TgUINT64                           tgCM_RND_U64();

TgINLINE TgVOID                             tgCM_SWP_S08( PCU_TgSINT08 piA, PCU_TgSINT08 piB );
TgINLINE TgSINT08                           tgCM_SGN_S08( C_TgSINT08 iA );
TgINLINE TgSINT08                           tgCM_MAX_S08( C_TgSINT08 iA, C_TgSINT08 iB );
TgINLINE TgSINT08                           tgCM_MIN_S08( C_TgSINT08 iA, C_TgSINT08 iB );
TgINLINE TgSINT08                           tgCM_CLP_S08( C_TgSINT08 iA, C_TgSINT08 iLow, C_TgSINT08 iHigh );
TgINLINE TgSINT08                           tgCM_CLP_MIN_S08( C_TgSINT08 iA, C_TgSINT08 iLow );
TgINLINE TgSINT08                           tgCM_CLP_MAX_S08( C_TgSINT08 iA, C_TgSINT08 iHigh );
TgINLINE TgSINT08                           tgCM_FLR_ALGN_PW2_S08( C_TgSINT08 iA, C_TgSINT08 iAlignment );
TgINLINE TgSINT08                           tgCM_CEL_ALGN_PW2_S08( C_TgSINT08 iA, C_TgSINT08 iAlignment );
TgINLINE TgSINT08                           tgCM_PRV_PW2_S08( C_TgSINT08 iA );
TgINLINE TgSINT08                           tgCM_NXT_PW2_S08( C_TgSINT08 iA );
TgINLINE TgBOOL                             tgCM_IS_PW2_S08( C_TgSINT08 iA );
TgINLINE TgSINT08                           tgCM_RND_S08();

TgINLINE TgVOID                             tgCM_SWP_S16( PCU_TgSINT16 piA, PCU_TgSINT16 piB );
TgINLINE TgSINT16                           tgCM_SGN_S16( C_TgSINT16 iA );
TgINLINE TgSINT16                           tgCM_MAX_S16( C_TgSINT16 iA, C_TgSINT16 iB );
TgINLINE TgSINT16                           tgCM_MIN_S16( C_TgSINT16 iA, C_TgSINT16 iB );
TgINLINE TgSINT16                           tgCM_CLP_S16( C_TgSINT16 iA, C_TgSINT16 iLow, C_TgSINT16 iHigh );
TgINLINE TgSINT16                           tgCM_CLP_MIN_S16( C_TgSINT16 iA, C_TgSINT16 iLow );
TgINLINE TgSINT16                           tgCM_CLP_MAX_S16( C_TgSINT16 iA, C_TgSINT16 iHigh );
TgINLINE TgSINT16                           tgCM_FLR_ALGN_PW2_S16( C_TgSINT16 iA, C_TgSINT16 iAlignment );
TgINLINE TgSINT16                           tgCM_CEL_ALGN_PW2_S16( C_TgSINT16 iA, C_TgSINT16 iAlignment );
TgINLINE TgSINT16                           tgCM_PRV_PW2_S16( C_TgSINT16 iA );
TgINLINE TgSINT16                           tgCM_NXT_PW2_S16( C_TgSINT16 iA );
TgINLINE TgBOOL                             tgCM_IS_PW2_S16( C_TgSINT16 iA );
TgINLINE TgSINT16                           tgCM_RND_S16();

TgINLINE TgVOID                             tgCM_SWP_S32( PCU_TgSINT32 piA, PCU_TgSINT32 piB );
TgINLINE TgSINT32                           tgCM_SGN_S32( C_TgSINT32 iA );
TgINLINE TgSINT32                           tgCM_MAX_S32( C_TgSINT32 iA, C_TgSINT32 iB );
TgINLINE TgSINT32                           tgCM_MIN_S32( C_TgSINT32 iA, C_TgSINT32 iB );
TgINLINE TgSINT32                           tgCM_CLP_S32( C_TgSINT32 iA, C_TgSINT32 iLow, C_TgSINT32 iHigh );
TgINLINE TgSINT32                           tgCM_CLP_MIN_S32( C_TgSINT32 iA, C_TgSINT32 iLow );
TgINLINE TgSINT32                           tgCM_CLP_MAX_S32( C_TgSINT32 iA, C_TgSINT32 iHigh );
TgINLINE TgSINT32                           tgCM_FLR_ALGN_PW2_S32( C_TgSINT32 iA, C_TgSINT32 iAlignment );
TgINLINE TgSINT32                           tgCM_CEL_ALGN_PW2_S32( C_TgSINT32 iA, C_TgSINT32 iAlignment );
TgINLINE TgSINT32                           tgCM_PRV_PW2_S32( C_TgSINT32 iA );
TgINLINE TgSINT32                           tgCM_NXT_PW2_S32( C_TgSINT32 iA );
TgINLINE TgBOOL                             tgCM_IS_PW2_S32( C_TgSINT32 iA );
TgINLINE TgSINT32                           tgCM_RND_S32();

TgINLINE TgVOID                             tgCM_SWP_S64( PCU_TgSINT64 piA, PCU_TgSINT64 piB );
TgINLINE TgSINT64                           tgCM_SGN_S64( C_TgSINT64 iA );
TgINLINE TgSINT64                           tgCM_MAX_S64( C_TgSINT64 iA, C_TgSINT64 iB );
TgINLINE TgSINT64                           tgCM_MIN_S64( C_TgSINT64 iA, C_TgSINT64 iB );
TgINLINE TgSINT64                           tgCM_CLP_S64( C_TgSINT64 iA, C_TgSINT64 iLow, C_TgSINT64 iHigh );
TgINLINE TgSINT64                           tgCM_CLP_MIN_S64( C_TgSINT64 iA, C_TgSINT64 iLow );
TgINLINE TgSINT64                           tgCM_CLP_MAX_S64( C_TgSINT64 iA, C_TgSINT64 iHigh );
TgINLINE TgSINT64                           tgCM_FLR_ALGN_PW2_S64( C_TgSINT64 iA, C_TgSINT64 iAlignment );
TgINLINE TgSINT64                           tgCM_CEL_ALGN_PW2_S64( C_TgSINT64 iA, C_TgSINT64 iAlignment );
TgINLINE TgSINT64                           tgCM_PRV_PW2_S64( C_TgSINT64 iA );
TgINLINE TgSINT64                           tgCM_NXT_PW2_S64( C_TgSINT64 iA );
TgINLINE TgBOOL                             tgCM_IS_PW2_S64( C_TgSINT64 iA );
TgINLINE TgSINT64                           tgCM_RND_S64();

TgINLINE TgVOID                             tgCM_SWP_F32( PCU_TgFLOAT32 pfA, PCU_TgFLOAT32 pfB );
TgINLINE TgFLOAT32                          tgCM_SGN_F32( C_TgFLOAT32 fA );
TgINLINE TgFLOAT32                          tgCM_MAX_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fB );
TgINLINE TgFLOAT32                          tgCM_MIN_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fB );
TgINLINE TgFLOAT32                          tgCM_CLP_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fLow, C_TgFLOAT32 fHigh );
TgINLINE TgFLOAT32                          tgCM_CLP_MIN_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fLow );
TgINLINE TgFLOAT32                          tgCM_CLP_MAX_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fHigh );
TgINLINE TgBOOL                             tgCM_NaN_F32( C_TgFLOAT32 fA );
TgINLINE TgBOOL                             tgCM_NR0_F32( C_TgFLOAT32 fA );
TgINLINE TgBOOL                             tgCM_NR1_F32( C_TgFLOAT32 fA );
TgINLINE TgFLOAT32                          tgCM_CLP_FRC_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fB );
TgINLINE TgFLOAT32                          tgCM_LRP_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fB, C_TgFLOAT32 fdT );
TgINLINE TgBOOL                             tgCM_EQ_F32( C_TgFLOAT32 fA, C_TgFLOAT32 fB, C_TgFLOAT32 fTol );
TgINLINE TgFLOAT32                          tgCM_RND_F32();

TgINLINE TgVOID                             tgCM_SWP_F64( PCU_TgFLOAT64 pfA, PCU_TgFLOAT64 pfB );
TgINLINE TgFLOAT64                          tgCM_SGN_F64( C_TgFLOAT64 fA );
TgINLINE TgFLOAT64                          tgCM_MAX_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fB );
TgINLINE TgFLOAT64                          tgCM_MIN_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fB );
TgINLINE TgFLOAT64                          tgCM_CLP_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fLow, C_TgFLOAT64 fHigh );
TgINLINE TgFLOAT64                          tgCM_CLP_MIN_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fLow );
TgINLINE TgFLOAT64                          tgCM_CLP_MAX_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fHigh );
TgINLINE TgBOOL                             tgCM_NaN_F64( C_TgFLOAT64 fA );
TgINLINE TgBOOL                             tgCM_NR0_F64( C_TgFLOAT64 fA );
TgINLINE TgBOOL                             tgCM_NR1_F64( C_TgFLOAT64 fA );
TgINLINE TgFLOAT64                          tgCM_CLP_FRC_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fB );
TgINLINE TgFLOAT64                          tgCM_LRP_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fB, C_TgFLOAT64 fdT );
TgINLINE TgBOOL                             tgCM_EQ_F64( C_TgFLOAT64 fA, C_TgFLOAT64 fB, C_TgFLOAT64 fTol );
TgINLINE TgFLOAT64                          tgCM_RND_F64();

// STRING //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                                            // 1: Pointer to the string destination to contain the transcribed number
                                            // 2: Size of the destination buffer
                                            // 3: Number to be converted
P_TgCHAR                                    tgSZ_From_U08( PCU_TgCHAR, C_TgUINT32, C_TgUINT08  );
P_TgCHAR                                    tgSZ_From_U16( PCU_TgCHAR, C_TgUINT32, C_TgUINT16  );
P_TgCHAR                                    tgSZ_From_U32( PCU_TgCHAR, C_TgUINT32, C_TgUINT32  );
P_TgCHAR                                    tgSZ_From_U64( PCU_TgCHAR, C_TgUINT32, C_TgUINT64  );
P_TgCHAR                                    tgSZ_From_S08( PCU_TgCHAR, C_TgUINT32, C_TgSINT08  );
P_TgCHAR                                    tgSZ_From_S16( PCU_TgCHAR, C_TgUINT32, C_TgSINT16  );
P_TgCHAR                                    tgSZ_From_S32( PCU_TgCHAR, C_TgUINT32, C_TgSINT32  );
P_TgCHAR                                    tgSZ_From_S64( PCU_TgCHAR, C_TgUINT32, C_TgSINT64  );
P_TgCHAR                                    tgSZ_From_F32( PCU_TgCHAR, C_TgUINT32, C_TgFLOAT32 );
P_TgCHAR                                    tgSZ_From_F64( PCU_TgCHAR, C_TgUINT32, C_TgFLOAT64 );

                                            // 1: Pointer to the string containing the number to be converted
TgUINT08                                    tgSZ_To_U08( CPCU_TgCHAR );
TgUINT16                                    tgSZ_To_U16( CPCU_TgCHAR );
TgUINT32                                    tgSZ_To_U32( CPCU_TgCHAR );
TgUINT64                                    tgSZ_To_U64( CPCU_TgCHAR );
TgSINT08                                    tgSZ_To_S08( CPCU_TgCHAR );
TgSINT16                                    tgSZ_To_S16( CPCU_TgCHAR );
TgSINT32                                    tgSZ_To_S32( CPCU_TgCHAR );
TgSINT64                                    tgSZ_To_S64( CPCU_TgCHAR );
TgFLOAT32                                   tgSZ_To_F32( CPCU_TgCHAR );
TgFLOAT64                                   tgSZ_To_F64( CPCU_TgCHAR );

                                            // 1: Pointer to the string to be processed
TgUINT32                                    tgSZ_Length( CPCU_TgCHAR );
TgUINT32                                    tgSZ_Hash( CPCU_TgCHAR );

                                            // 1: First comparison argument
                                            // 2: Second comparison argument
TgSINT                                      tgSZ_Compare( CPC_TgCHAR, CPC_TgCHAR );
TgSINT                                      tgSZ_CompareNoCase( CPC_TgCHAR, CPC_TgCHAR );

                                            // 1: First comparison argument
                                            // 2: Second comparison argument
                                            // 3: Maximum number of characters to be compared
TgSINT                                      tgSZ_CompareN( CPC_TgCHAR, CPC_TgCHAR, C_TgUINT32 );
TgSINT                                      tgSZ_CompareNoCaseN( CPC_TgCHAR, CPC_TgCHAR, C_TgUINT32 );

                                            // 1: String optionally containing printf markers
                                            // 2: Variable argument list
TgUINT32                                    tgSZ_LengthVF( CPC_TgCHAR, va_list );

                                            // 1: Character to be processed
TgBOOL                                      tgSZ_Is_Space( C_TgCHAR );

                                            // Convert string to upper case, return string length.
                                            // 1: Pointer to the string to be processed
P_TgCHAR                                    tgSZ_To_Upper( PCU_TgCHAR );

                                            // Convert string to lower case, return string length.
                                            // 1: Pointer to the string to be processed
P_TgCHAR                                    tgSZ_To_Lower( PCU_TgCHAR );

                                            // 1: Pointer to the string destination
                                            // 2: Size of the destination buffer (including NULL)
                                            // 3: Source string for processing
P_TgCHAR                                    tgSZ_Copy( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR );
P_TgCHAR                                    tgSZ_Append( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR );

                                            // 1: Pointer to the string destination
                                            // 2: Size of the destination buffer (including NULL)
                                            // 3: Source string for processing
                                            // 4: Number of characters to be copied (not including NULL)
P_TgCHAR                                    tgSZ_CopyN( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, C_TgUINT32 );
P_TgCHAR                                    tgSZ_AppendN( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, C_TgUINT32 );

                                            // 1: Pointer to the string destination
                                            // 2: Size of the destination buffer (including NULL)
                                            // 3: Source string for processing
                                            // 4: Variable argument list
P_TgCHAR                                    tgSZ_PrintVF( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, va_list );
P_TgCHAR                                    tgSZ_AppendVF( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, va_list );

                                            // 1: Pointer to the string destination
                                            // 2: Size of the destination buffer (including NULL)
                                            // 3: Source string for processing
                                            // 4: Optional list of arguments
P_TgCHAR                                    tgSZ_PrintF( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, ... );
P_TgCHAR                                    tgSZ_AppendF( PC_TgCHAR, C_TgUINT32, CPC_TgCHAR, ... );

                                            // 1: Pointer to the string destination
                                            // 2: List of deliminators
                                            // 3: Token context
P_TgCHAR                                    tgSZ_Token( PC_TgCHAR, CPC_TgCHAR, PP_TgCHAR );

                                            // 1: String to be searched
                                            // 2: Sub-string to search
CP_TgCHAR                                   tgSZ_StrStr( CPC_TgCHAR, CPC_TgCHAR );

#endif //  END  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////