String library additions
#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;
}
char at(string_t a,int i)
{
if(i >= a->len)
{
printf("length limit crossed\n");
return 0;
}
return a->str[i];
}
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;
string_t temp;
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-1;
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);
}
#define append(a,b) concat(a,b)
#define string_instances(a,b,arr) searchstr(c_string(a), c_string(b), arr)
#define string_instances(a,b,arr) searchstr(c_string(a), c_string(b), arr)
int *searchstr(char *arr, char *find,int *numberOfOccurrance)
{
int k= strlen(arr);
int l= strlen(find);
int i;
int *z = (int*) malloc(k/l, sizeof(int));
int x =0;
for(i=0;i<k;k++)
{
if(strncmp(arr+i,find,l)==0)
{
z[x] = i;
x++;
*numberOfOccurrance = x;
}
}
return z;
}
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,'-')));
concat(a,b);
printf("concat is:%s\n", con(a));
push(a, '/');
printf("%s\n", con(a));
pop(a);
printf("%s\n", con(a));
swap(a,b);
printf("swapped are:%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));
printf("at string is:%c\n",at(b,1));
string_destroy(a);
string_destroy(b);
}
Comments
Post a Comment