FARStdlib/include/all_far.h

   1 #ifndef __FAR_PLUGINS_STD_HEADERS
   2 #define __FAR_PLUGINS_STD_HEADERS
   3
   4 #define WIN32_LEAN_AND_MEAN
   5
   6 #include <windows.h>
   7 #include <sudo.h>
   8
   9 #include <signal.h>             // SIGxxx
  10 #include <sys/stat.h>   // stat
  11 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__DragonFly__)
  12 #include <malloc.h>             // alloc,NULL
  13 #endif
  14 #include <math.h>               // sqrt
  15 #include <ctype.h>              // isprint
  16 #include <stdio.h>              // sprintf
  17 #include <stdlib.h>             // atexit
  18 #include <string.h>             // strXXX
  19 #include <fcntl.h>              // O_RDWR,xxx
  20 #include <setjmp.h>             // exseptions
  21 #include <assert.h>             // assert
  22 #include <errno.h>              // errors
  23 #include <stdarg.h>             // va_list
  24 #include <time.h>               // timespec
  25 #include <sys/socket.h>
  26 #include <arpa/inet.h>
  27 #include <netinet/in.h>
  28 #include <netinet/tcp.h>
  29 #include <netdb.h>
  30
  31 #ifndef ARRAYSIZE
  32 #define ARRAYSIZE(A) (sizeof(A) / sizeof((A)[0]))
  33 #endif
  34
  35 //- MACROSES
  36 #define MAX_DWORD ((DWORD)0xFFFFFFFFUL)
  37 #define MAX_WORD  ((WORD)0xFFFFU)
  38 #define MAX_BYTE  ((WORD)0xFFU)
  39
  40 template <class T>
  41 inline T Max(T a, T b)
  42 {
  43         return (a > b) ? a : b;
  44 }
  45 template <class T>
  46 inline T Min(T a, T b)
  47 {
  48         return (a < b) ? a : b;
  49 }
  50 template <class T>
  51 inline T Abs(T v)
  52 {
  53         return (v > 0) ? v : (-v);
  54 }
  55 template <class T>
  56 inline BOOL Between(T val, T a, T b)
  57 {
  58         return (val >= a && val <= b) ? TRUE : FALSE;
  59 }
  60 template <class T>
  61 void Swap(T &a, T &b)
  62 {
  63         T tmp = a;
  64         a = b;
  65         b = tmp;
  66 }
  67
  68 /** @def SET_HI_WORD( dw,w ) Sets high subword in DWORD value. */
  69 /** @def SET_LO_WORD( dw,w ) Sets low subword in DWORD value. */
  70 #define SET_HI_WORD(dw, w) ((((DWORD)dw) & 0x0000FFFFUL) | (((DWORD)w) << 16))
  71 #define SET_LO_WORD(dw, w) ((((DWORD)dw) & 0xFFFF0000UL) | (((WORD)w) & 0xFFFFUL))
  72
  73 #ifndef HI_WORD
  74 #define HI_WORD(dw) ((WORD)(((DWORD)(dw)) >> 16))
  75 #define LO_WORD(dw) ((WORD)(((DWORD)(dw)) & 0x0000FFFFUL))
  76 #endif
  77
  78 #define MK_DWORD(hw, lw) (((((DWORD)hw) & 0x0000FFFFUL) << 16) | (((WORD)lw) & 0x0000FFFFUL))
  79
  80 #define SET_HI_BYTE(w, b) ((((WORD)(w)) & 0x00FFU) | (((BYTE)(b)) << 8))
  81 #define SET_LO_BYTE(w, b) ((((WORD)(w)) & 0xFF00U) | ((BYTE)(b)))
  82 #ifndef HI_BYTE
  83 #define HI_BYTE(w) (((WORD)(w)) >> 8)
  84 #define LO_BYTE(w) ((BYTE)((WORD)(w)) & 0x00FFU)
  85 #endif
  86 #define MK_WORD(hb, lb) ((WORD)(((((WORD)(hb)) & 0x00FFU) << 8) | (((BYTE)(lb)) & 0x00FFU)))
  87
  88 #define sSET_HI_WORD(dw, w) ((((int)(dw)) & 0x0000FFFFUL) | (((int)(w)) << 16))
  89 #define sSET_LO_WORD(dw, w) ((((int)(dw)) & 0xFFFF0000UL) | (((short)(w)) & 0xFFFFUL))
  90 #define sHI_WORD(dw)        ((short)((dw) >> 16))
  91 #define sLO_WORD(dw)        ((short)(dw))
  92 #define sMK_DWORD(lw, hw)   ((int)(((((int)(hw)) & 0x0000FFFFUL) << 16) | (((short)(lw)) & 0xFFFFUL)))
  93
  94 #define IS_BIT(val, num)       IS_FLAG(((DWORD)(val)),1UL<<(num)))
  95 #define IS_FLAG(val, flag)  (((val) & (flag)) == (flag))
  96 #define SET_FLAG(val, flag) (val|= (flag))
  97 #define CLR_FLAG(val, flag) (val&= ~(flag))
  98 #define SWITCH_FLAG(f, v)                                                                                      \
  99         do {                                                                                                       \
 100                 if (IS_FLAG(f, v))                                                                                     \
 101                         CLR_FLAG(f, v);                                                                                    \
 102                 else                                                                                                   \
 103                         SET_FLAG(f, v);                                                                                    \
 104         } while (0)
 105
 106 //- MK_ID
 107 #define MK_ID(v, v1, v2, v3) MK_DWORD(MK_WORD(v3, v2), MK_WORD(v1, v))
 108
 109 #define HAbort                   __WinAbort
 110 #define THROW_ERROR(err, fl, nm) HAbort("Assertion...\nConditin: \"%s\"\nAt file: \"%s:%d\"", err, fl, nm)
 111
 112 #if defined(__DEBUG__) || defined(__USEASSERT__)
 113 #define Assert(p)                                                                                              \
 114         do {                                                                                                       \
 115                 if (!(p))                                                                                              \
 116                         THROW_ERROR(#p, __FILE__, __LINE__);                                                               \
 117         } while (0)
 118 #else
 119 #define Assert(p)
 120 #endif
 121
 122 //- ASSERT
 123 #if !defined(__FP_NOT_FUNCTIONS__)
 124 //[fstd_asrt.cpp]
 125 extern void _cdecl __WinAbort(LPCSTR msg, ...);
 126 //[fstd_err.cpp]
 127 extern const char *_cdecl __WINError(void);
 128 //[fstd_exit.cpp]
 129 typedef void(_cdecl *AbortProc)(void);
 130
 131 extern AbortProc WINAPI AtExit(AbortProc p);
 132 extern void WINAPI CallAtExit(void);
 133 #endif
 134
 135 // --------------------------------------------------------------
 136 /** @defgroup TimePeriod Time/Period measurement
 137         @{
 138
 139         [fstd_tm.cpp]
 140         Procedures for get current time, calculate difference and check periods of time.
 141 */
 142 #define CMP_TIME_FORMAT "%3.3lf"
 143 inline void GET_TIME(DWORD &var)
 144 {
 145         var = WINPORT(GetTickCount)();
 146 }
 147 inline double CMP_TIME(DWORD evar, DWORD bvar)
 148 {
 149         return ((double)evar - (double)bvar) / 1000.;
 150 }
 151
 152 extern HANDLE WINAPI FP_PeriodCreate(DWORD ms);
 153 extern BOOL WINAPI FP_PeriodEnd(HANDLE p);
 154 extern DWORD WINAPI FP_PeriodTime(HANDLE p);
 155 extern void WINAPI FP_PeriodDestroy(HANDLE &p);
 156 extern void WINAPI FP_PeriodReset(HANDLE p);
 157
 158 /** @brief Helper class for time period.
 159  */
 160 struct FPPeriod
 161 {
 162         HANDLE Handle;
 163
 164 public:
 165         FPPeriod(void) { Handle = NULL; }
 166         FPPeriod(DWORD ms) { Handle = FP_PeriodCreate(ms); }
 167         ~FPPeriod()
 168         {
 169                 if (Handle)
 170                         FP_PeriodDestroy(Handle);
 171         }
 172
 173         bool End(void) { return FP_PeriodEnd(Handle) != FALSE; }
 174         void Reset(void) { FP_PeriodReset(Handle); }
 175         void Create(DWORD ms) { Handle = FP_PeriodCreate(ms); }
 176 };
 177 /**@} Period*/
 178
 179 // --------------------------------------------------------------
 180 /** @defgroup StdLib RTL extension\replacement
 181         @{
 182
 183         Wrappers for stdlib functions and some useful extended stdlib functions.
 184 */
 185 #if !defined(__FP_NOT_FUNCTIONS__)
 186 // string extension
 187 inline char ToUpperI(char c)
 188 {
 189         return (char)((c) + 'A' - 'a');
 190 }
 191 inline char ToLowerI(char c)
 192 {
 193         return (char)((c) + 'a' - 'A');
 194 }
 195
 196 extern int WINAPI StrCmp(LPCSTR str, LPCSTR str1, int maxlen = -1, BOOL isCaseSens = TRUE);
 197 inline int StrCmpI(LPCSTR str, LPCSTR str1)
 198 {
 199         return StrCmp(str, str1, -1, FALSE);
 200 }
 201 inline int StrNCmp(LPCSTR str, LPCSTR str1, int maxlen)
 202 {
 203         return StrCmp(str, str1, maxlen, TRUE);
 204 }
 205 inline int StrNCmpI(LPCSTR str, LPCSTR str1, int maxlen)
 206 {
 207         return StrCmp(str, str1, maxlen, FALSE);
 208 }
 209
 210 extern char *WINAPI StrCpy(char *dest, LPCSTR src, int dest_sz);
 211 extern char *WINAPI StrCat(char *dest, LPCSTR src, int dest_sz);
 212 extern int WINAPI StrNChr(LPCSTR str, char ch, int maxlen = -1);
 213 extern int WINAPI strchrCount(LPCSTR str, char ch, int maxlen = -1);
 214 extern int WINAPI StrPosChr(LPCSTR str, char ch, int pos = 0);
 215 extern int WINAPI StrPosStr(LPCSTR str, LPCSTR s, int pos = 0);
 216
 217 #endif
 218
 219 // --------------------------------------------------------------
 220 template <class T>
 221 T AtoI(LPCSTR str, T Def)
 222 {
 223         if (!str || !str[0])
 224                 return Def;
 225
 226         T Sign = 1;
 227
 228         if (*str == '-') {
 229                 Sign = -1;
 230                 str++;
 231         } else if (*str == '+')
 232                 str++;
 233
 234         if (!isdigit(*str))
 235                 return Def;
 236
 237         for (Def = 0; *str && isdigit(*str); str++) {
 238                 Def*= 10;
 239                 Def+= (T)(*str - '0');
 240         }
 241
 242         return Def * Sign;
 243 }
 244 /**@} RTL*/
 245
 246 // Args
 247 #if !defined(__FP_NOT_FUNCTIONS__)
 248 extern void WINAPI CTArgInit(int argc, char **argv, BOOL CaseSensitive = FALSE);
 249 extern LPSTR WINAPI CTArgGet(int num);                  // get base argument
 250 extern LPSTR WINAPI CTArgGetArg(int num);               // get`s argument that not switch
 251 extern LPSTR WINAPI CTArgGet(LPCSTR name);              // find "[-/]<name>[=<value>]" key and ret <value> || NULL
 252 extern BOOL WINAPI CTArgCheck(LPCSTR name);             // check for "[-/]<name>" exist
 253
 254 extern char *WINAPI Str2Text(LPCSTR name, char *Buff, DWORD BuffSz);
 255 extern char *WINAPI Text2Str(LPCSTR name, char *Buff, DWORD BuffSz);
 256
 257 // Std columns
 258 extern int WINAPI StrColCount(LPCSTR str, LPCSTR seps);
 259 extern LPCSTR WINAPI StrGetCol(LPCSTR str, int number, LPCSTR seps);
 260
 261 // Generate 32bit CRC for buffer.
 262 extern DWORD WINAPI Crc32(DWORD StartCrc /*=0*/, const BYTE *buf, DWORD len);
 263
 264 //[fstd_Mesg.cpp]
 265 extern LPCSTR _cdecl Message(LPCSTR patt, ...);
 266 extern LPCSTR WINAPI MessageV(LPCSTR patt, va_list a);
 267
 268 // Utils
 269 extern LPCSTR WINAPI FCps(char *buff, double val);      // Create CPS value string (Always 3+1+3+1 length)
 270 extern LPSTR WINAPI AddLastSlash(char *path, char Slash = '/');
 271 extern LPSTR WINAPI DelLastSlash(char *path, char Slash = '/');
 272 extern LPCSTR WINAPI FPath(LPCSTR nm, char Slash = '/');
 273 extern LPCSTR WINAPI FName(LPCSTR nm, char Slash = '/');
 274 extern LPCSTR WINAPI FExtOnly(LPCSTR nm, char Slash = '/');
 275 #endif
 276
 277 // --------------------------------------------------------------
 278 /** @defgroup Log Logging and debug
 279         @{
 280
 281         [fstd_InProc.cpp]
 282         Helpers for logging and debug purposes.
 283 */
 284 class FARINProc
 285 {
 286         static int Counter;
 287         LPCSTR Name;
 288
 289 public:
 290         FARINProc(LPCSTR nm, LPCSTR s, ...);
 291         ~FARINProc();
 292
 293         static void _cdecl Say(LPCSTR s, ...);
 294 };
 295
 296 extern int FP_LogErrorStringLength;
 297
 298 /** @brief Procedure callback for specify name of current log file
 299  */
 300 extern void _cdecl FP_FILELog(LPCSTR msg, ...);         ///< Writes text to current log file.
 301 extern LPCSTR WINAPI FP_GetLogFullFileName(void);       ///< Returns full current file log.
 302 /**@} Log*/
 303
 304 #endif