string_t Windows.c

 //#include <stdafx.h>
#include "string_t.h"

int string_file_len(char* s)
{
int i = 0;
while (s[i] != EOF)
{
i++;
}
return i;
}
string_t string_file(char* s, int* file_length)
{
int len = string_file_len(s);

char* content = (char*)malloc(len + 1);
memcpy(content, s, len);
content[len] = EOF;
string_t st = (string_t)malloc(sizeof(struct_var));
st->len = len + 1;
st->str = content;
st->back = content + len - 1;
if (strcmp(s, "\0"))
st->empty = 1;
*file_length = len;
return st;
}

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

char* content = (char*)calloc(len + 1,sizeof(char));
memcpy(content, s, len);
content[len] = '\0';
string_t st = (string_t)malloc(sizeof(struct_var));
st->len = len + 1;
st->str = content;
st->back = content + len - 1;
if (strcmp(s, "\0"))
st->empty = 1;

return st;
}

string_t string_const(const 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(struct_var));
st->len = len + 1;
st->str = content;
st->back = content + len - 1;
if (strcmp(s, "\0"))
st->empty = 1;

return st;
}
#define empty_str(st)   if(st->len == 0)                                                 \
{ printf("Underflow ! func:%s line:%d\n", __FUNCDNAME__, __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_str(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];
}
int find_char(string_t a, char x)
{
int i = 0;
while (a->str[i] != x && a->str[i] != EOF)
{
i++;
}
if (a->str[i] == x)
return i;

return -1;
}

int findCharNext(string_t a,char c, int *pos)
{
for (int i = *pos; i < a->len; i++)
{
if (a->str[i] == c)
{
*pos = i;
return i;
}

}
return -1;

}

string_t copy(string_t a)
{
string_t ret = string(a->str);
return ret;
}

/*void update(string_t st, char* temp)
{
int len = strlen(temp);
st->str = (char*)realloc(st->str, len + 1);
strncpy(temp, st->str, len);
}*/

string_t overwrite(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->str[length_b] = '\0';
a->len = length_b;
}
return a;
}
/*string_t concat_overwrite(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, a->len + length_b);
memcpy(a->str+a->len-1, b->str, length_b);
a->str[a->len+length_b-1] = '\0';
a->len = 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)
{
int ln = find_str->len - 1;
char* arr = (char*)calloc(ln+1, sizeof(char));
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--)
{
if (strncmp(arr, find_str->str, j) == 0)
{
printf("arr is: %s, find_str is: %s  \n", arr, find_str->str);
return i;
}
}
}
return -1;
}

int findString(string_t s, string_t find_str)
{
int ln = find_str->len - 1;
char* arr = (char*)calloc(ln + 1, sizeof(char));
int i, j;
for (i = 0; i < s->len - find_str->len - 1; i++)
{
memcpy(arr, s->str + i, find_str->len - 1);

if (strncmp(arr, find_str->str, find_str->len) == 0)
{
printf("%s: %d, i is:%d, arr is: %s, find_str is: %s  \n", __func__, __LINE__,i, arr, find_str->str);
return i;
}
}
return -1;
}

int findStringPos(string_t s, string_t find_str,int pos)
{
int ln = find_str->len - 1;
char* arr = (char*)calloc(ln + 1, sizeof(char));
int i, j;
for (i = pos; i < s->len - find_str->len - 1; i++)
{
memcpy(arr, s->str + i, find_str->len - 1);

if (strncmp(arr, find_str->str, find_str->len) == 0)
{
//printf("%s: %d, i is:%d, arr is: %s, find_str is: %s  \n", __func__, __LINE__, i, arr, find_str->str);
return i;
}
}
return -1;
}
string_t removeExtraSpacesInFront(string_t s)
{
int start_index = 0;
int len = s->len;
int i;
for (int i = 0; i < len; i++)
{
if (s->str[i] == ' ' || s->str[i] == '\v' || s->str[i] == '\t' || s->str[i] == '\r')
start_index++;
else
break;
}
if (start_index < len - 1)
{
char* new_str = (char*)calloc(len + 1,sizeof(char));
for (i = 0; i < len - start_index; i++)
{
new_str[i] = s->str[i + start_index];
}
new_str[i] = '\0';
string_t ret = string(new_str);
ret->len = strlen(new_str);
return ret;
}

s->len = len - start_index - 1;

return s;
}
string_t truncate(string_t s, int trucationStart)
{
char* new_str = (char*)calloc(s->len-trucationStart+1,sizeof(char));
int i;
int k = 0;
for (i = trucationStart; i < s->len; i++)
{
new_str[k] = s->str[i];
k++;
}
new_str[k] = '\0';
string_t ret = string(new_str);
ret->len = strlen(new_str);
return ret;
}
string_t truncateFromEnd(string_t s, int trucationEnd)
{
char* new_str = (char*)malloc(sizeof(char) * s->len + 1);
int i;
for (i = 0; i < trucationEnd; i++)
{
new_str[i] = s->str[i];
}
new_str[i] = '\0';
string_t ret = string(new_str);
return ret;
}
string_t partOfstring(string_t s, int start, int length)
{
char* new_str = (char*)calloc(length+1, sizeof(char));
int i;
if (length > s->len)
{
printf("[ERROR] $s:%s String length is Out Of Bounds ! \n", __FUNCDNAME__, __LINE__);
return NULL;
}

for (i = 0; i < length; i++)
{
new_str[i] = s->str[i + start];
}
new_str[i] = '\0';
string_t ret = string(new_str);
free(new_str);
return ret;
}
char* c_string(string_t s)
{
char* new_str = (char*)malloc(sizeof(char) * s->len + 1);
int i;
for (i = 0; i < s->len; i++)
{
new_str[i] = s->str[i];
}
new_str[i] = '\0';
return new_str;
}
void insert(string_t src, string_t ins_str, int pos)
{
int diff_len = ins_str->len;
src->str = (char*)realloc(src->str, src->len + diff_len);
char* temp = (char*)malloc(sizeof(src->len - pos));
for (int i = pos, k = 0; i < src->len; i++, k++)
{
temp[k] = src->str[i];
}
for (int i = pos, l = 0; i < pos + diff_len; i++, l++)
{
src->str[i] = ins_str->str[l];
}
for (int m = pos + diff_len, n = 0; m < src->len + diff_len; m++, n++)
{
src->str[m] = temp[n];
}
free(temp);
}

void shift_str(string_t s, int start, int end)
{
int actual_length = 0;
if (end < start)
{
printf("error: end position(%d) is smaller than start position(%d)! ", end, start);
return;
}
if (end >= s->len)
{
printf("error: end character(%d) is greater than length of the string(%d)! ", end, s->len);
return;
}

for (int i = start, j = end + 1; j < end + 1 + (end - start) && j < s->len; j++, i++)
{
s->str[i] = s->str[j];
actual_length++;
}
s->str = (char *)realloc(s->str, s->len - (actual_length));

}

void delete_str(string_t s, int start, int end)
{
int diff = 0;
if (end < start)
{
printf("error: end position(%d) is smaller than start position(%d)! ", end, start);
return;
}
if (end >= s->len)
{
printf("error: end character(%d) is greater than length of the string(%d)! ", end, s->len);
return;
}
if (end - start < s->len - end)
diff = end - start;
else
diff = s->len - end;
char* temp = (char*)calloc(s->len - diff, sizeof(char));
if (end - start > s->len - end)
{
for (int i = start, j = end + 1; j < s->len; i++, j++)
{
s->str[i] = s->str[j];
}
}
else
{
for (int i = start, j = end + 1; i <= end; i++, j++)
{
s->str[i] = s->str[j];
}

}
memcpy(temp, s->str, s->len - (end - start));
free(s->str);
s->str = temp;
}

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", __FUNCDNAME__, __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];
}
free(temp);
return;
}

bool is_first(string_t str_line, int t_pos, char c)
{
while (at(str_line, t_pos) == ' ' || at(str_line, t_pos) == '\v' || at(str_line, t_pos) == '\t')
t_pos++;
if (at(str_line, t_pos) == c)
return true;
else
return false;
}


void 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 c2 - c1;
}
}
}
else
{
return b->len - a->len;
}

return 0;
}

int compare_cstr(string_t a, const char* b)
{
if (a->len-1 != strlen(b))
{
return -1;
}
else
{
for (int i = 0; i < a->len; i++)
{
if (a->str[i] != b[i])
return -1;

}

}
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 + 1);
//ptr = a->str + a->len - 1;
ptr = a->str + a->len - 1;
memcpy(ptr, b->str, b->len);
//a->str[a->len + b->len] = '\0';
a->len = a->len + b->len;

return a;
}

string_t *concat_alloc(string_t *a, string_t b)
{
if (!(*a) || !(*a)->str) {
printf("First string is null\n");
return NULL;
}
if (!b || !b->str) {
return a;
}

size_t new_len = (*a)->len + b->len;
char* new_str = (char*)calloc(new_len + 1, sizeof(char)); // +1 for '\0'
if (!new_str) {
printf("Memory allocation failed\n");
return NULL;
}

memcpy(new_str, (*a)->str, (*a)->len);
memcpy(new_str + (*a)->len, b->str, b->len);
new_str[new_len] = '\0'; // explicit null terminator

free((*a)->str); // Only after copying!
(*a)->str = new_str;
(*a)->len = new_len;

return a;
}
void splitString(string_t wholestr, string_t a, string_t b, int pos)
{
int i,k=0;
char* temp1 = (char*)calloc(pos, sizeof(char));
for (i = 0; i < pos; i++)
{
temp1[k] = wholestr->str[i];
k++;
}
a = string(temp1);
free(temp1);

char* temp2 = (char*)calloc(wholestr->len - pos, sizeof(char));
for (i = pos; i < wholestr->len; i++)
{
temp2[k] = wholestr->str[i];
k++;
}
a = string(temp2);
free(temp2);
}

string_t tokenizeUsingOffset(string_t str, int* offset)
{
//string_t str_withoutSpaces;
int k,j;
if (*offset >= str->len)
{
printf("offset is greater than  string length!");
}
int i = *offset;
while (str->str[i] == ' ' || str->str[i] == '\t' || str->str[i] == '\v' || str->str[i] == '\n')
{
i++;
}
int len = 0;
if (str->str[i] == '(' ||
str->str[i] == ')' ||
str->str[i] == ',' ||
str->str[i] == ';' ||
str->str[i] == '!' ||
str->str[i] == '&' ||
str->str[i] == '^' ||
str->str[i] == '%' ||
str->str[i] == '*' ||
str->str[i] == '{' ||
str->str[i] == '}'
)
{
i++;
len++;
}
else
{
while (str->str[i] == '>' ||
   str->str[i] == '.' ||
   str->str[i] == '<' || 
   str->str[i] == '\"' || 
   str->str[i] == '#' ||
   (str->str[i] >= 'a' && str->str[i] <= 'z') ||
   (str->str[i] >= 'A' && str->str[i] <= 'Z') || 
   (str->str[i] >= '0' && str->str[i] <= '9') ||
   (str->str[i] == '_'))
{
i++;
len++;
}
}
char* s = (char*)calloc(len+1,sizeof(char));
for (k = 0, j = *offset; k < len; k++, j++)
{
s[k] = str->str[j];
}
s[k] = '\0';
*offset = i;
string_t ret = string(s);
free(s);
return ret;
}

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(struct_var));
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_str(a,b) concat(a,b)
#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

Popular posts from this blog

VECPP.c

 /* Written for Embedded C++ */ /* Follow TR.18015 Standard Specs */ /* VECPP version 1.0 */ /* Designed by Daipayan Bhowal */ #include <iostream>  #include "datastructure.h" #include <fstream> #include <string> #include <unistd.h> #include <stdio.h> #include <cstdlib> #include <bits/stdc++.h>  #define UTX 0 #define FWK 0 #define DEBUG 0 #define PARSE 0 #define LEVEL_INC 1 #define NO_OF_MAX_FILES 5 using namespace std; #undef stack bool is_id(string token,string term,const int term_char_option); /**************  Defination ****************/ enum MacroType {     define_t,     include_t,     line_t,     undef_t,     error_tt,     pragma_t,     defined_t,     if_t,     ifdef_t,     ifndef_t,     elif_t,     else_t,     endif_t, UNDEFINED,     MAX_TYPE }; MacroType getIndexFromStr(string_t ...
Read more

VECPP Windows.c

#include "tape_t.h" #include "string_t.h" #include "tuple_t.h" #include "bool_t.h" #include <direct.h> #if _MSC_VER #include "io.h" #else #include <cunistd> #endif typedef bool_t _bool; /**** first design #include, #define VAR, #define FUNC() and #ifdef, #elif and #endif *****/ enum MacroType { define_t, include_t, line_t, undef_t, error_tt, pragma_t, defined_t, if_t, ifdef_t, ifndef_t, elif_t, else_t, endif_t, COMPILER_DATA, UNDEFINED, MAX_TYPE }; /*MacroType getIndexFromStr(string_t s) { string_t tmp; char* arr[13] = { "define","include","line","undef","error","pragma","defined","if","ifdef","ifndef","elif","else","endif" }; for (int i = 0; i < 13; i++) { tmp = string(arr[i]); if ((compare(tmp, s)) == 0) return (MacroType)i; } return UNDEF...
Read more

tuple_t Windows.h

#pragma once /******************************************************************************   New Era Datastructure  Designed by Daipayan Bhowal *******************************************************************************/ #include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h> typedef enum Type {     CHAR,     INT,     FLOAT,     DOUBLE,     SHORT,     LONG,     LONG_LONG,     STRING }type_t; typedef struct Tables {     int index;     int type[64];     void* args[64];     char max_index; } tables; typedef tables* table_t; table_t itable(int num, ...) // init_table {     va_list valist;     va_start(valist, num);     static int counter = 0;     table_t t = (table_t)malloc(sizeof(tables));     t->index = ++counter;     for (int j = 0; j < num; j...
Read more