---

lStr.cpp

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                    */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

// Standard Header(s)
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

// Common POLiTe Header(s)
#include <lDefs.h>

// Own Header
#include <lStr.h>

int StrLen(const char * const src) {
//counts number of chars in src, returns 0 if src == NULL
        return src == NULL ? 0 : strlen(src);
        };

char *StrCpy(char * (&dst), const char * const src)
//copies the source "src" into destination dst
//frees previously allocated memory for dst
//aloocates memory for dst
{
        if (dst)
                free(dst);
        return (!src /*|| !*src*/)
                ?(dst = NULL)
                :(dst = strcpy((char *)malloc(strlen(src)+1),src));
};

char *StrCpy(const char * const src)
//copies the source "src" and returns the copy
//aloocates memory for it
{
        char *dst = NULL;
        return StrCpy(dst,src);
};


char *StrExp(char * dst, const char * src, int len)
//copies the source "src" into destination dst, maximum of copied character
//is "len". copy is terminated by \0 char, so the buffer must be at least
//"len+1" characters long
//buffer must exists before calling this method!!!
{
        char *aux = dst;
        if (src)
                while (len-- && *src)
                        *dst++ = *src++;
        *dst = '\0';
        return aux;
};

int StrCmp(const char * const dst, const char * const src)
//compares the source "src" with the destination dst
{
        if (dst == src)
                return 0;
        if (!dst)
                return -1;
        if (!src)
                return 1;
        return strcmp(dst,src);
};

int StrCmpUp(const char * const dst, const char * const src)
//compares the source "src" with the destination "dst" in upper case
{
        if (dst == src)
                return 0;
        if (!dst)
                return -1;
        if (!src)
                return 1;
        const char *s = dst;
        const char *t = src;
        while (*s && *t && (toupper(*s) == toupper(*t)))
        {
                ++s; ++t;
        };
        return toupper(*s) - toupper(*t);
};

char *StrFree(char * (&dst)) {
//frees dynamically allocated string
        if (dst)
                free(dst);
        return (dst = NULL);
        };

char *StrCat(char * (&dst), const char * const src) {
//concatenates dst and src in given order
//free previously allocated memory for dst
//allocates memory for the result
  char *_dst = dst;
  if (!src)
         return(dst);
  dst = (char *)malloc(StrLen(src)+StrLen(dst)+1);
  if (_dst) {
         strcpy(dst,_dst);
         strcat(dst,src);
         }
  else
         strcpy(dst,src);
  StrFree(_dst);
  return(dst);
};

char *StrCat(char * (&dst), const int n, const char * const src, ...) {
//concatenates dst_1, ... , dst_n to src in given order
//concatenates src and dst in given order
//free previously allocated memory for dst
//allocates memory for the result
  char *_dst = NULL;
  int i;
  StrCat(_dst, dst);
  for (i = 0; i < n; i++)
         StrCat(_dst,(&src)[i]);
  free(dst);
  dst = _dst;
  return dst;
  };

char *StrAnd(char * (&dst), const char * const src) {
//returns "(dst) AND (src)"
//free previously allocated memory for dst
//allocates memory for the result
  char *_res = NULL;
  if (!dst)
         return StrCpy(dst,src);
  if (!src)
         return dst;
  StrCat(_res,5,"(",dst,") AND (",src,")");
  free(dst);
  return dst = _res;
  };

char *StrOr(char * (&dst), const char * const src) {
//returns "(dst) OR (src)"
//free previously allocated memory for dst
//allocates memory for the result
  char *_res = NULL;
  if (!dst)
         return StrCpy(dst,src);
  if (!src)
         return dst;
  StrCat(_res,5,"(",dst,") OR (",src,")");
  free(dst);
  return dst = _res;
  };

char *StrNot(char * (&dst)) {
//returns "NOT(dst)"
//free previously allocated memory for dst
//allocates memory for the result
  char *_res = NULL;
  if (!dst)
         return dst;
  StrCat(_res,3,"NOT(",dst,")");
  free(dst);
  return dst = _res;
  };

char *StrClause(char * (&dst), const char * const prf) {
//returns "prf dst " if dst is not empty
//if dst is the empty string, returns NULL
//examples:
//              StrClause("ID = 100", "WHERE ") == "WHERE ID = 100 "
//              StrClause(NULL,"WHERE ") == NULL
//free previously allocated memory for dst
//allocates memory for the result
  char *_res = NULL;
  if (!dst || !*dst)
         return dst;
  StrCat(_res,4,prf," ",dst," ");
  free(dst);
  return dst = _res;
  };

void StrSwap(const char * (&s1), const char * (&s2)) {
//Swaps two strings
        const char *pom;
        pom = s1;
        s1 = s2;
        s2 = pom;
        };

char *StrSplit(char * (&src), const char delim, char * (&dst)) {
//splits src in form "<dst> <delim> <rest_of_string>"
//returns dst = <dst>, src = <rest_of_string>
//free previously allocated memory for dst and src
//allocates memory for the results
        char *Start = src;                      //start of dst inside src
        char *End;                                              //end of dst inside src
        char *OrgSrc = src;                     //Original src
        char *pom;
        bool InString = false;          //searching delimiter inside a string
        bool WasBackslash = false;      //previous char was backslash
        bool NoDelim;                    //there is no delimiter in the src

        StrFree(dst);
        if (!src)
                return dst;
        while ((*Start == ' ') || (*Start == '\t'))
                Start++;
        pom = Start;
        while (*pom && ((*pom != delim) || InString || WasBackslash)) {
                if (WasBackslash)
                        WasBackslash = false;
                else if (*pom == '\'')
                        InString = !InString;
                else if (*pom == '\\')
                        WasBackslash = !WasBackslash;
                pom++;
                };
        End = pom-1;
        NoDelim = (*pom++ == '\0');
        while ((End >= Start) && ((*End == ' ') || (*End == '\t')))
                End--;
        *++End = '\0';
        if (Start <= End)
                StrCpy(dst,Start);
        if (NoDelim)
                StrFree(src);
        else {
                StrCpy(src = NULL, pom);
                StrFree(OrgSrc);
                }
        return dst;
        };

char *StrPrefix(char * (&src), const char delim, char * (&dst)) {
//like StrSplit() function
//if no delimiter is found in the string, return <dst> == NULL,
//meanwhile StrSplit() returns <src> == NULL
        StrSplit(src,delim,dst);
        if (src == NULL)
                StrSwap((const char *&)src,(const char *&)dst);
        return dst;
        };

char *StrPrefixCut(char * (&src), const char delim) {
//like StrPrefix() function
//Prefix - if exists is cut off
        char *_Prefix = NULL;
        StrPrefix(src,delim,_Prefix);
        StrFree(_Prefix);
        return src;
        };

char *LongToStr(const long n) {
//returns long number n as a char*, allocates space for the result.
        char *_buf = (char *)malloc(33);
        char *_res = NULL;

        sprintf(_buf,"%ld",n);
        StrCpy(_res,_buf);
        StrFree(_buf);
        return _res;
        };

char *ULongToStr(const unsigned long n) {
//returns long number n as a char*, allocates space for the result.
        char *_buf = (char *)malloc(33);
        char *_res = NULL;

        sprintf(_buf,"%lu",n);
        StrCpy(_res,_buf);
        StrFree(_buf);
        return _res;
        };

char *FloatToStr(const double x) {
//returns float number x as a char*, allocates space for the result.
        char *_buf = (char *)malloc(33);
        char *_res = NULL;

        sprintf(_buf,"%lf",x);
        StrCpy(_res,_buf);
        StrFree(_buf);
        return _res;
        };

long StrToLong(const char *s) {
//returns a char* converted to long.
  long result;
  sscanf(s,"%l",&result);
  return result;
  };

static char *_StrMergeLists(
        char * (&dst),
        char * (&list1),
        char * (&list2),
        const char l_delim,
        const char *const sep_begin,
        const char *const sep_values,
        const char *const sep_middle,
        const char *const sep_end,
        const bool cut_off_prefixes,
        const char p_delim
        )
{
        StrFree(dst);
        char * value1 = NULL;
        char * value2 = NULL;
        const char *separator = sep_begin;

        while (StrSplit(list1,l_delim,value1) && StrSplit(list2,l_delim,value2)) {
                if (cut_off_prefixes) {
                        StrPrefixCut(value1,p_delim);
                        };
                StrCat(dst,4,separator,value1,sep_values,value2);
                StrFree(value1);
                StrFree(value2);
                separator = sep_middle;
                };
        separator = sep_end;
        StrCat(dst,separator);
        StrFree(list1);
        StrFree(list2);
        return dst;
        };

char *StrMergeLists(
        char * (&dst),
        char * (&list1),
        char * (&list2),
        const char l_delim,
        const char *const sep_begin,
        const char *const sep_values,
        const char *const sep_middle,
        const char *const sep_end
        )
{
        return _StrMergeLists(
                dst,
                list1, list2, l_delim,
                sep_begin, sep_values, sep_middle, sep_end,
                false, ' '
                );
        };

char *StrMergeLists(
        char * (&dst),
        char * (&list1),
        char * (&list2),
        const char l_delim,
        const char p_delim,
        const char *const sep_begin,
        const char *const sep_values,
        const char *const sep_middle,
        const char *const sep_end
        )
{
        return _StrMergeLists(
                dst,
                list1, list2, l_delim,
                sep_begin, sep_values, sep_middle, sep_end,
                true, p_delim
                );
        };

char *AliasR(int i)
//Returns alias of i-th relation- "r$_i", allocates space for the result.
{
        char *dst = StrCpy(dst=NULL, R_PREFIX);
        char *stri = LongToStr(i);
        StrCat (dst, stri);
        StrFree (stri);
        return dst;
};

char *AliasT(int i, int j)
//Returns alias of j-th table of i-th DatabaseObject - "t$_i_j",
//allocates space for the result.
{
        char *dst = StrCpy(dst=NULL, T_PREFIX);
        char *stri = LongToStr(i);
        char *strj = LongToStr(j);
                StrCat (dst, 3, stri, "_", strj);
        StrFree (stri);
        StrFree (strj);
        return dst;
};

char *AliasQ(int i)
//Returns alias prefix of table aliases of tables for i-th inner query - "t$_i_",
//allocates space for the result.
{
        char *dst = StrCpy(dst=NULL, T_PREFIX);
        char *stri = LongToStr(i);
                StrCat (dst, 2, stri, "_");
        StrFree (stri);
        return dst;
};

char *StrAddPrefix(char * &dst, const char * const src, const char * const delim)
//Adds prefix src to dst-returns src delim dst
//Example:src="ALIAS_1",delim=".",dst="TABLE_1"-result is "ALIAS1.TABLE"
{
  char * _res=NULL;
  StrCat(_res,3,src,delim,dst);
  StrFree(dst);
  dst=_res;
  return dst;
}

char * RealiasR(char * &fragment, int begin, int end, int incr)
// Increases the numbers of relation aliases beginning i and ending number j
// of incr
{
        if (incr > 0)
                for (int i=end; i>=begin; i--)
                {
                        char * _oldalias=AliasR(i);
                        char * _newalias=AliasR(i+incr);
                        StrReplaceAll(fragment,_oldalias,_newalias,true,true);
                        StrFree(_oldalias);
                        StrFree(_newalias);
                };
        return fragment;
};

char * RealiasQ(char * &fragment, int begin, int end, int incr)
// Increases the numbers of queries aliases beginning i and ending number j
// of incr
{
        if (incr > 0)
                for (int i=end; i>=begin; i--)
                {
                        char * _oldalias=AliasQ(i);
                        char * _newalias=AliasQ(i+incr);
                        StrReplaceAll(fragment,_oldalias,_newalias,true);
                        StrFree(_oldalias);
                        StrFree(_newalias);
                };
        return fragment;
};

bool StrIsIdentChar(const char c)
{
        return ((c>='a')&&(c<='z'))||((c>='A')&&(c<='Z'))||((c>='0')&&(c<='9'))||(c=='_')||(c=='#')||(c=='$');
};

long StrPos(
        const char * const dst,
        const char * const oldstr,
        bool lwb = false, //left-side word boundary required
        bool rwb = false //right-side word boundary required
        )
//Finds position of oldstr in dst
//Returns -1 if not successful
{
        const char * start;
        const char * occur;
        bool found = false;
        long oldstrlen = StrLen(oldstr);
        if (dst==NULL)
                return -1;
        start = dst;
        // start search from begining of the string
        while ((!found) && ((occur=strstr(start,oldstr))!=NULL))
        {
                // string was found at occur position
                // check, if it is not enclosed in  apostrophes
                bool in_apo=false; // inside apostrophes
                bool in_quo=false; // inside quotas
                const char *s = start;
                for( ; s < occur; s++)
                        if (*s=='"')
                        {
                                if (!in_apo)
                                        in_quo = !in_quo;
                        }
                        else if (*s=='\'')
                        {
                                if (!in_quo)
                                        in_apo = !in_apo;
                        };
                if (in_apo)
                {
                        while (*s && (*s != '\''))
                                s++;
                        start = s;
                }
                else if (in_quo)
                {
                        while (*s && (*s != '"'))
                                s++;
                        start = s;
                }
                else if (lwb && StrIsIdentChar(*s) && (s>start) && StrIsIdentChar(*(s-1)))
                        start = s+1;
                else if (rwb && StrIsIdentChar(*(s+oldstrlen)) && ((s+oldstrlen)>start) && StrIsIdentChar(*(s+oldstrlen-1)))
                        start = s+1;
                else
                        found=true;
        };
        if (found)
                return occur-dst;
        else
                return -1;
};

bool StrReplace(
        char * &dst,
        const char * const oldstr,
        const char * const newstr,
        bool lwb, //left-side word boundary required
        bool rwb //right-side word boundary required
        )
//Replaces first occurence of oldstr in dst with newstr
//Returns true if succees
{
        char * start;
        char * occur;
        start = dst;
        // start search from begining of the string
        long prefixlen = StrPos(dst,oldstr,lwb,rwb);
        if (prefixlen>=0)
        {
                occur=start+prefixlen;
                char *rest=occur+StrLen(oldstr);
                char *result=(char *)malloc(prefixlen+1);
                StrExp(result,dst,prefixlen);
                StrCat(result,2,newstr,rest);
                StrFree(dst);
                dst=result;
                return true;
        }
        else return false;
};

char * StrReplaceAll(
        char * &dst,
        const char * const oldstr,
        const char * const newstr,
        bool lwb, //left-side word boundary required
        bool rwb //right-side word boundary required
        )
//Replaces all occurences of oldstr in dst with newstr
//Returns dst
{
        char * start;
        char * result=NULL;
        long prefixlen;
        start = dst;
        prefixlen = StrPos(start,oldstr,lwb,rwb);
        while(prefixlen>=0)
        {
                char c=start[prefixlen];
                start[prefixlen]='\0';
                StrCat(result,2,start,newstr);
                start[prefixlen]=c;
                start=start+prefixlen+StrLen(oldstr);
                prefixlen = StrPos(start,oldstr,lwb,rwb);
        };
        StrCat(result,start);
        StrFree(dst);
        dst=result;
        return dst;
};

char *StrAndOnly(char * (&dst), const char * const src) {
//returns "dst AND src"
//free previously allocated memory for dst
//allocates memory for the result
  if (!dst)
         return StrCpy(dst,src);
  if (!src)
         return dst;
  return StrCat(dst,2," AND ",src);
  };

char *StrEncode(char * (&dst), const char * const src)
// encodes string by inserting backslash before each
// comma, backslash and apostroph character
// allocates new space for the result
// needed to find it in the comma-separated lists
{
        int newlen = 0; // for enclosing apostrophs
        const char *s;
        char *d;
        if (src)
                for(s=src; *s; s++)
                {
                        newlen++;
                        if ((*s=='\\') || (*s=='\'') || (*s==','))
                                newlen++;
                };
        StrFree(dst);
        if (newlen)
        {
                dst = (char *)malloc(newlen+1);
                d = dst;
                for(s=src; *s; s++)
                {
                        if ((*s=='\\') || (*s=='\'') || (*s==','))
                                *d++ = '\\';
                        *d++ = *s;
                };
                *d = '\0';
        };
        return dst;
};

char *StrEncode(char * (&src))
{
        char *dst = NULL;
        StrEncode(dst,src);
        StrFree(src);
        src=dst;
        return src;
};

char *StrDecode(char * (&dst), const char * const src)
// takes encoded string and return original one
// by eliminating of backslashes
{
        int newlen = 0;
        const char *s;
        char *d;
        if (src && *src)
                for(s=src; *s; s++)
                {
                        if (*s=='\\')
                                *s++;
                        newlen++;
                };
        StrFree(dst);
        if (newlen)
        {
                dst = (char *)malloc(newlen+1);
                d = dst;
                for(s=src; *s; s++)
                {
                        if (*s=='\\')
                                *s++;
                        *d++ = *s;
                };
                *d = '\0';
        };
        return dst;
};

char *StrDecode(char * (&src))
{
        char *dst = NULL;
        StrDecode(dst,src);
        StrFree(src);
        src=dst;
        return src;
};

---