Funcs.cpp

Go to the documentation of this file.

#include <ctype.h>
#include <dirent.h>
#include <makro.h>
#include <MemCpy.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

const char *wkdayArray[] = {"Mon", "Tue", "Wed", "Thu", "Fri", "Set", "Sun"};
const char *monthArray[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

int strRcmp(const char *str, const char *str1)
{
 int ret = (str ? strlen(str) : 0) - (str1 ? strlen(str1) : 0);
 if(ret == 0 && str && str1)
 {
  unsigned int i = 0;
  while(str[i] != 0)
  {
   if(static_cast<char>(tolower(str[i])) == static_cast<char>(tolower(str1[i])))
/*    
   if(!(str[i] == str1[i] || 
        str[i] == ((str1[i] >= 'a' && str1[i] <= 'z') ? (str1[i] - 0x20) : (str1[i])) ||
        str[i] == ((str1[i] >= 'A' && str1[i] <= 'Z') ? (str1[i] + 0x20) : (str1[i]))))        
*/
   {
    if(str[i] >= str1[i])
    {
     ret = 1;
    }
    else
    {
     ret = -1;
    }
    break;
   }
   i++;
  }
 }
 return ret;
}

const char *strRstr(const char *str, const char *str1)
{
 const char *ret = NULL;
 int i = 0;
 int y = 0;
 while(str[i] != 0)
 {
  y = 0;
   while(static_cast<char>(tolower(str[i])) == static_cast<char>(tolower(str1[y])))
/*
  while(str[i] == str1[y] || 
       str[i] == ((str1[y] >= 'a' && str1[y] <= 'z') ? (str1[y] - 0x20) : (str1[y])) ||
       str[i] == ((str1[y] >= 'A' && str1[y] <= 'Z') ? (str1[y] + 0x20) : (str1[y])))
*/    
  {
   i++;
   y++;
   if(str1[y] == 0)
   {
    ret = str + i - y;
    break;
   }   
   else if(str[i] == 0)
   {
    break;
   }
  }
  if(str[i] != 0)
  {
   i++;
  }
 }
 return ret;
}

bool beganRstr(const char *str, const char *str1)
{
 bool ret = false;
 if(str && str1)
 {
  int i = 0;
  ret = true;
  while(str[i] != 0 && str1[i] != 0)
  {
   if(static_cast<char>(tolower(str[i])) != static_cast<char>(tolower(str1[i])))  
/*    
   if(!(str[i] == str1[i] || 
        str[i] == ((str1[i] >= 'a' && str1[i] <= 'z') ? (str1[i] - 0x20) : (str1[i])) ||
        str[i] == ((str1[i] >= 'A' && str1[i] <= 'Z') ? (str1[i] + 0x20) : (str1[i]))))
*/     
       {
        ret= false;
        break;
       }
   i++;
  }
  if((str[i] == 0) && (str1[i] != 0))
  {
   ret = false;
  }
 }
 return ret;
}

bool beganStr(const char *str, const char *str1)
{
 bool ret = false;
 if(str && str1)
 {
  int i = 0;
  ret = true;
  while(str[i] != 0 && str1[i] != 0)
  {
   if(str[i] != str1[i])
   {
    ret= false;
    break;
   }
   i++;
  }
  if((str[i] == 0) && (str1[i] != 0))
  {
   ret = false;
  }
 }
 return ret;
}

char **breakBuffByString(const char *buff, char *strSeparate, unsigned int &stringsCount)
{
 char **ret = NULL;
 stringsCount = 0;
 if(buff)
 {
  unsigned int len = strlen(buff); 
  if(strSeparate)
  {
   unsigned int localLen = strlen(strSeparate);  
   unsigned int count = 0;
   char *baseBuff = NULL;
   char *find = const_cast<char *>(buff);
   while((find = strstr(find, strSeparate)) != NULL)
   {
    if(find == buff)
    {
     find += localLen;    
     if(find[0] == 0)
     {
      break;
     }
     continue;
    }
    find += localLen;
    if(find[0] == 0)
    {
     count++;
     break;
    }    
    count++;
   }
//   cout++;
   if(!find)
   {
    count++;
   }
   if(count > 0)
   {
    ret = new char *[count];
    stringsCount = count;
    for(unsigned int i = 0; i < count; i++)
    {
     ret[i] = new char[len + 1];
     ret[i][0] = 0;
    }
    baseBuff = find = const_cast<char *>(buff);
    count = 0;
    while((find = strstr(find, strSeparate)) != NULL)
    {
     if(find == buff)
     {
      find += localLen;    
      baseBuff = find;      
      continue;
     }   
     memcpy_arjanv_interleave(ret[count], baseBuff, find - baseBuff);
     ret[count][find - baseBuff] = 0;
     find += localLen;
     baseBuff = find;
     count++;
    }
    if(baseBuff < buff + len)
    {
     memcpy_arjanv_interleave(ret[count], baseBuff, buff + len + 1 - baseBuff);
    }
   }
  }
  else
  {
   ret = new char *[1];
   ret[0] = new char [len + 1];
   memcpy_arjanv_interleave(ret[0], buff, len + 1);  
  }
 }
 return ret;
}

char **breakBuffBySymbol(const char *buff, char symbol, unsigned int &stringsCount)
{
 stringsCount = 0;
 char **ret = NULL;
 if(buff)
 {
  int y = 0;
  int j = 0;
  int k = 0;
  int size = 0;
  while(buff[y] != 0x00)
  {
   if(buff[y] == symbol)
   {
    if(y > 0 && buff[y - 1] != symbol)
    {
     stringsCount++;
    }
   }
   y++;
  }
  if(y > 0 && buff[y] != symbol)
  {
   stringsCount++;   
  }
  else 
  {
   return ret;
  }
  size = y;
  ret = new char* [stringsCount];
  for(unsigned int i = 0; i < stringsCount; i++)
  {
   ret[i] = new char[size + 1];
  }
  y = 0;
  while(buff[y] != 0x00 )
  {
   if(buff[y] == symbol)
   {
    if(y > 0 && buff[y - 1] != symbol)
    {
     ret[j][k] = 0x00;
     k = 0;
     j++;
    } 
    y++;
    continue;
   }
   ret[j][k] = buff[y];
   k++;
   y++;
  }
  ret[j][k] = 0x00;   
 }
 return ret;
}

void breakBeginSubStr(char **massStrings, unsigned int stringsCount, const char *subStr)
{
 if(massStrings && stringsCount > 0 && subStr)
 {
  for(unsigned int i = 0; i < stringsCount; i++)
  {
   if(massStrings[i] && (strstr(massStrings[i], subStr) == massStrings[i]) && strcmp(massStrings[i], subStr) != 0)
   {
    memmove(massStrings[i], massStrings[i] + strlen(subStr), strlen(massStrings[i]) - strlen(subStr) + 1);
   }
  }
 }
}

const char *strRepl(const char *baseStr, const char **replFrom, const char **replTo, unsigned int replCount, bool chg)
{
 char *ret = NULL;
 if(baseStr && replFrom && replTo && replCount)
 {
  unsigned int size = strlen(baseStr);
  unsigned int len = size;
  unsigned int *replSizeFrom = new unsigned int[replCount];    
  unsigned int *replSizeTo = new unsigned int[replCount];
  char *buff = NULL;
  for(unsigned int i = 0; i < replCount; i++)
  {
   buff = const_cast<char *>(baseStr);
   if(replFrom[i] && replTo[i])
   {
    replSizeFrom[i] = strlen(replFrom[i]);   
    replSizeTo[i] = strlen(replTo[i]);
    while(buff)
    {
     buff = strstr(buff, replFrom[i]);
     if(buff)
     {
      size += replSizeTo[i];     
      buff += replSizeFrom[i];
     }
    }
   }
  }
  if(size > 0U)
  {
   char *buff1 = new char[size + 1];
   char *buff2 = new char[size + 1];
   unsigned int num1 = 0;
   unsigned int num2 = 0;   
   memcpy_arjanv_interleave(buff1, baseStr, len + 1);
   char *tmpBuff = NULL;
   for(unsigned int i = 0; i < replCount; i++)
   {
    num1 = 0;
    num2 = 0;
    tmpBuff = buff1;
    if(replFrom[i] && replTo[i])
    {
     while(tmpBuff)
     {
      tmpBuff = strstr(tmpBuff, replFrom[i]);      
      if(tmpBuff)
      {
       strncpy(buff2 + num2, buff1 + num1, tmpBuff - (buff1 + num1));
       num2 += tmpBuff - (buff1 + num1);
       buff2[num2] = 0;
       if(replTo[i])
       {
        strcat(buff2, replTo[i]);
        num2 += replSizeTo[i];
       }
       tmpBuff += replSizeFrom[i];
       num1 = tmpBuff - buff1;
      }
     }
    }
    if(num1 > 0)
    {
     strncpy(buff2 + num2, buff1 + num1, strlen(buff1) - num1);
     buff2[num2 + strlen(buff1) - num1] = 0;
     tmpBuff = buff1;
     buff1 = buff2;
     buff2 = tmpBuff;
    }
   }
   DELL_BUFF(buff2)
   ret = buff1;
  }
  DELL_BUFF(replSizeFrom)
  DELL_BUFF(replSizeTo)
 }
 if(!ret && chg)
 {
  ret = const_cast<char *>(baseStr);
 }
 return ret;
}

const char *getFileExtension(const char *str)
{
 char *ret = NULL;
 if(str)
 {
  unsigned int i = 0;
  unsigned int y = 0;  
  unsigned int size = strlen(str);
  if(strstr(str, "https://") == str)
  {
   str += 8;
  }
  else if(strstr(str, "http://") == str)
  {
   str += 7;
  }
  while(str[i] != '/' && str[i] != 0)
  {
   i++;
  }
  if(str[i] == '/')
  {
   while(str[i] != '.' && str[i] != 0)
   {
    i++;
   }
   if(str[i] == '.')
   {
    i++;
    ret = new char[size + 1];
    while(str[i] != '?' && str[i] != 0)
    {
     ret[y] = str[i];
     i++;
     y++;
    }
    if(y > 0)
    {
     ret[y] = 0;
    }
    else
    {
     DELL_BUFF(ret)
    }
   }
  }
 }
 return ret;
}

void recurseRemove(const char *fName)
{
 struct stat sStat;
 char localFname[1024];
 unsigned int fNameLen = strlen(fName);
 unsigned int additionChar = 0;
 if(stat(fName, &sStat) == 0)
 {
  if(sStat.st_mode & S_IFDIR)
  {
   DIR *fDir = opendir(fName);
   if (fDir)
   {
    struct dirent *dirEntr = NULL;
    while((dirEntr = readdir(fDir)) != NULL)
    {
     additionChar = 0;
     if(strcmp(dirEntr->d_name, ".") != 0 && strcmp(dirEntr->d_name, "..") != 0)
     {
      if((fNameLen + strlen(dirEntr->d_name)) < 1022)
      {
       memcpy(localFname, fName, fNameLen);
       if(localFname[fNameLen - 1] != '/')
       {
        localFname[fNameLen] = '/';
        additionChar = 1;
       }
       memcpy(localFname + fNameLen + additionChar, dirEntr->d_name, strlen(dirEntr->d_name) + 1);
       recurseRemove(localFname);
      }
     }
    }
    closedir(fDir);
   }
  }
  remove(fName);
 }
}

void createGMTString(char *ret, const char *previousStr, time_t timeVal)
{
 if(timeVal > 0 && ret)
 {
  struct tm *localTime = gmtime(&timeVal);
  if(localTime)
  {
   sprintf(ret, "%s%s, %02d %s %4d %02d:%02d:%02d GMT", (previousStr ? previousStr : ""),
           wkdayArray[localTime->tm_wday ? (localTime->tm_wday - 1) : 6], localTime->tm_mday, monthArray[localTime->tm_mon], 
           localTime->tm_year + 1900, localTime->tm_hour, localTime->tm_min, localTime->tm_sec);
  }
 }
}

const char *createGMTString(const char *previousStr, time_t timeVal)
{
 char *ret = NULL;
 if(timeVal > 0)
 {
  struct tm *localTime = gmtime(&timeVal);
  if(localTime)
  {
   ret = new char[(previousStr ? strlen(previousStr) : 0 ) + 256];
   sprintf(ret, "%s%s, %02d %s %4d %02d:%02d:%02d GMT", (previousStr ? previousStr : ""),
           wkdayArray[localTime->tm_wday ? (localTime->tm_wday - 1) : 6], localTime->tm_mday, monthArray[localTime->tm_mon], 
           localTime->tm_year + 1900, localTime->tm_hour, localTime->tm_min, localTime->tm_sec);
  }
 }
 return ret;
}