String library

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct string
{
  int len;
  char *str;
  char *back;
  char empty;
} string_type;

typedef string_type* string_t;

typedef struct mem
{
  string_t str;
  int string_size;
  int index;
} memrecord;



string_t string(char *s)
{
  int len=strlen(s);

  char *content=(char *)malloc(len+1);
  memcpy(content,s,len);
  content[len] = '\0';
  string_t st = (string_t) malloc(sizeof(string_type));
  st->len = len+1;
  st->str = content;
  st->back = content + len - 1;
  if(strcmp(s,"\0"))
    st->empty = 1;
      
  return st;
}
#define empty(st)   if(st->len == 0)                \
                     { printf("Underflow ! func:%s line:%d\n",__func__,__LINE__);      \
                       return '\0';       }         
                     
void push(string_t st,char s)
{
   st->str = (char *) realloc(st->str , st->len+1);  
   st->str[st->len-1] = s;
   st->len ++;
   st->str[st->len-1] = '\0';
}
char pop(string_t st)
{
  empty(st);

  char temp = st->str[st->len-1];
  st->str = (char *) realloc(st->str ,st->len-1);
  st->len--;
  st->str[st->len - 1] = '\0';
  return temp;
}
char *con(string_t a) // content of the string
{
  return a->str;
}
int length(string_t a)
{
   return a->len;
}
string_t copy(string_t a,string_t b)
{
   int length_b = b->len;
  if(a->len >= b->len)
  {
     memcpy(a->str ,b->str ,length_b);
  }
  else
  {
     
     a->str = (char *)realloc(a->str, length_b);
     memcpy(a->str ,b->str,length_b);
     a->len = length_b;
  }
  return a;
}

string_t getlines( string_t a )
{
  int prev=0;
  static int k=0;
  prev = k;
  string_t tk = NULL;
  while( a->str[k] != '\n' && a->str[k] != '\0')
  {
    k++;
  }
  if(a->str[k] == '\n' || a->str[k] == '\0')
  {
     tk = (string_t) malloc(sizeof(string_t));
     tk->str = (char*) malloc(a->len);
     memcpy(tk->str, a->str+prev,k-prev+1);
     tk->len = k- prev+1;
     tk->empty = 0;

     k++; // \n character to traverse
  }
  return tk;
}

int locate( string_t s , string_t find_str)
{
   char arr[find_str->len - 1];
   int i,j;
   for(i=0; i< s->len - find_str->len - 1; i++)
   {
      memcpy(arr, s->str + i, find_str->len - 1);
      for(j=find_str->len - 1; j > 0; j--)
      {
        printf("%s\n", arr);
        if ( memcmp(arr,find_str->str, j) == 0)
        {
          return i;
        }
      }
   }
   return -1;
}
string_t partOfstring(string_t s, int start,int length)
{
    char *new = (char*) malloc(sizeof(char)*length+1);
    int i;
    if(length > s->len)
    {
       printf("[ERROR] $s:%s String length is Out Of Bounds ! \n",__func__,__LINE__);
       return NULL;
    }

    for(i=0; i<=length; i++)
    {
        new[i]=s->str[i + start];
    }
    new[i]='\0';

    string_t ret = string(new);
    return ret;
}
char* c_string(string_t s)
{
    char *new = (char*) malloc(sizeof(char)*s->len+1);
    int i;
    for(i=0; i< s->len; i++)
    {
       new[i] = s->str[i];
    }
    new[i] = '\0';
    return new;
}
void manipulate(string_t s,const char *str,int start)
{
   int length = 0,length2=0,i;
   while(str[length] != '\0')
       length++;

   if(s->len < length + start)
   {
     printf("[ERROR] $s:%s String length is Out Of Bounds ! \n",__func__,__LINE__);
     return;
   }
   length2 = s->len;

   char *temp = (char*) malloc(sizeof(s->len));
   memcpy(temp, s->str, s->len);

   if(length > length2)
   {
      s->str = (char *)realloc(s->str, length);
      memcpy(s->str,temp, length);
   }
   else if(length < length2)
   {
      s->str = (char *)realloc(s->str, length2);
      memcpy(s->str,temp, length2);
   }
   for(i=0; i< length; i++)
   {
       s->str[i+start]=str[i];
   }

   return;
}


int swap(string_t a, string_t b)
{
   int length_a = a->len;
   int length_b = b->len;
   char *temp = (char*) malloc(sizeof(a->len));
   memcpy(temp, a->str, a->len);
 
   a->str = (char *)realloc(a->str, length_b);
   memcpy(a->str,b->str, length_b);
   b->str = (char *)realloc(b->str, length_a);
   memcpy(b->str, temp, length_a);

   free(temp);
}
int compare(string_t a,string_t b)
{
   char c1,c2;
   int i;
   if(a->len == b->len)
   {
     for(i=0; i<a->len; i++)
     {
        c1 = b->str[i];
        c2 = a->str[i];
        if(c1 != c2)
        {
           return i;
        }
     }
   }
   else
   {
      return b->len - a->len;
   }

   return 0;
}

string_t concat(string_t a,string_t b)
{
 
  char *ptr;
  if(a == NULL || a->str == NULL)
  {
    printf("Error in concat as first string is empty !\n");
    return NULL;
  }
  else if(b == NULL || b->str == NULL)
  {
    return a;
  }
  a->str = (char *) realloc(a->str,a->len + b->len);
  ptr = a->str + a->len;
  memcpy(ptr,b->str,b->len);

  return a;
}

string_t tokenize(string_t a,char delim)
{
  int len_counter=0;
  static int k=0;
  int prev = k;
  while(a->str[k] != delim && len_counter < a->len)
  {
     k++;
     len_counter++;
  }
  if(len_counter >= a->len)
   return NULL;
  char *content=(char *)malloc(len_counter +1);
  memcpy(content,a->str+prev,len_counter); // prev needs to added for next string totokenize
  content[len_counter] = '\0';
  string_t b = (string_t) malloc(sizeof(string_type));
  b->str = content;
  b->len = len_counter;
  b->back = content + len_counter - 1;
  b->empty = 0;
  k++;
  return b;
}
char pos(string_t a,int p)
{
   return a->str[p];
}
void string_destroy(string_t st)
{
  free(st->str);
  free(st);
}
int main()
{
  string_t c,d;
  string_t a = string ("abc-bcd-");
  string_t b = string ("abc");
  c = string("abc\nhelo\nbye");
  printf("%s\n",  con(tokenize(a,'-')));
  printf("%s\n",  con(tokenize(a,'-')));
  printf("%s\n",  con(concat(a,b)));
  push(a, '/');
  printf("%s\n", con(a));
  pop(a);
  printf("%s\n", con(a));
  swap(a,b);
  printf("%s %s\n", con(a), con(b) );
  printf("parsed lines are:%s %s\n", con(getlines(c)), con(getlines(c)));
  printf("%d\n", locate(a,b));
  string_destroy(a);
  string_destroy(b);
}