size_t contains_symbol(char *src, char symbol);

size_t contains_symbol(char *src, char symbol){
  size_t pos = 1;
  if(symbols == NULL)
    return -1;
  while(*symbols != '\0'){
    if(*symbols++ == symbol)
      return pos;
    pos++;
  }
  return 0;
}

void *alloc_mem(size_t nbytes);
void *calloc_mem(size_t nelems, size_t elem_size);
#define alloc_str(x) ((char *) alloc_mem(x + 1))

#include <string.h>
#include <stdlib.h>
void *alloc_mem(size_t nbytes){
  char *buf = (char *)malloc(nbytes);
  if(buf != NULL){
    memset(buf, '\0', nbytes);
    return buf;
  }
  exit(-1);
}
void *calloc_mem(size_t nelems, size_t elem_size){
  void *buf = calloc(nelems, elem_size);
  if(buf != NULL){
    return buf;
  }
  exit(-1);
}

/* trims symbols from separators at src string */
/* returns new trimmed string */
char *trim_separators(char *src, char *separators);

char *trim_separators(char *src, char *separators){
  if(src == NULL || separators == NULL)
    return NULL;
  char *sp = src;
  while(contains_symbol(separators, *sp)) sp++;
  /* if it contains only symbols from separators => NULL */
  if(sp - s == strlen(s)) return NULL;
  char *sp2 = s + strlen(s) - 1; /* last char at src */
  while(contains_symbol(separators, *sp2)) sp2--;
  /* if it contains only symbols from separators => NULL */
  if(sp2 < s) return NULL;
  size_t sz = 0;
  if(sp2 - sp == 0 && *sp == '\0') return NULL; /* zero byte is not a character */
  else if(sp2 - sp == 0){
    sz = 1;
  }
  else{
    sz = (sp2 - sp) + 1;
  }
  char *res = alloc_mem(sz);
  memcpy(res, sp, sz);/* copy all chars except last zero byte */
  return res;
}

char *sp = src;
while(contains_symbol(separators, *sp)) sp++;
/* if it contains only symbols from separators => NULL */
if(sp - s == strlen(s)) return NULL;

char *sp2 = s + strlen(s) - 1; /* last char at src */
while(contains_symbol(separators, *sp2)) sp2--;
/* if it contains only symbols from separators => NULL */
if(sp2 < s) return NULL;

char *get_token(char *src, char *delims, char **next){
  if(src == NULL || delims == NULL)
    return NULL;
  char *delims_p = delims;
  /* the end of lexem (points to symbol that follows right after lexem */
  char *src_p = trim_separators(src, delims);
  /* the begining of the lexem */
  char *lex_begin = src_p;
  if(src_p == NULL){
    *next = NULL;
    return NULL;
  }
  /* flag that indicates reaching of delimeter */
  int flag = 0;
  while(*src_p != '\0'){
    flag = 0;
    while(*delims_p != '\0'){
      if(*delims_p == *src_p){
        flag = 1;
        break;
      }
      delims_p++;
    }
    if(flag == 1)
      break;
    delims_p = delims;
    src_p++;
  }
  /* now src_p points to the symbol right after lexem */
  /* compute lexem size and reset pointers (from trimmed to the original src) */
  char *offset;
  size_t tok_size;
  offset = (src + strspn(src, delims));
  tok_size = (src_p - lex_begin);
  free(lex_begin);
  lex_begin = offset;
  src_p = offset + tok_size;
  if(*src_p == '\0')
    *next = NULL;
  else
    *next = src_p;
  /* result token */
  char *res = alloc_str(tok_size);
  memcpy(res, lex_begin, tok_size);
  return res;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mem.h"
#include "str_utils.h"
int main(int argc, char **argv){
  char *test = "  They have  a    cat.\n \0";
  char *copytest = test;
  char **next = &copytest; /* has side effect on copytest */
  char *tok = NULL;
  printf("src:%s\n", test);
  printf("copytest:%s\n", copytest);
  while(*next != NULL){
    tok = get_token(*next, " \t\0", next);
    if(tok == NULL)
      break;
    printf("%s\n", tok);
    free(tok);
  }
  printf("src after:%s\n", test);
  printf("copytest after:%s\n", copytest);
  return 0;
}

src:  They have  a    cat.
copytest:  They have  a    cat.
They
have
a
cat.
src after:  They have  a    cat.
copytest:(null)

src:  They have  a    cat.
copytest:  They have  a    cat.
They
have
a
cat.
src after:(null)
copytest:  They have  a    cat.

*next = addr;
*next = NULL;

1233,"John Cenna","Male",4.22,"2004, 2005, 2006",1
1234,"John Doe","Male",4.24,"2001, 2004, 2007",0
1235,"Maria Laws","Female",4.23,"2003, 2006, 2008",1

char *get_token_escaped(char *src, char *delims, char *escaped, char **next){
  if(src == NULL || delims == NULL || escaped == NULL)
    return NULL;
  char *delims_p = delims;
  char *escaped_p = escaped;
  /* the end of lexem (points to symbol that follows right after lexem */
  char *src_p = trim_separators(src, delims);
  /* the begining of the lexem */
  char *lex_begin = src_p;
  if(src_p == NULL){
    *next = NULL;
    return NULL;
  }
  /* check that (delims INTERSECTION escaped) IS NULL. */
  /* IF NOT => return NULL */
  int err = 0;
  while(*delims_p != '\0'){
    while(*escaped_p != '\0' && (err = (*escaped_p == *delims_p) ) != 1) escaped_p++;
    escaped_p = escaped;
    if(err){
      return NULL;
    }
    delims_p++;
  }
  delims_p = delims;
  /* flag that indicates reaching of delimeter */
  int flag = 0;
  /* flag that indicates that we are not in escaped sequence */
  int neflag = 1;
  /* previously saved escape character (i.e. the begining of the escaped seq.) */
  char *esym = (char)0;
  while(*src_p != '\0'){
    flag = 0;
    while(*escaped_p != '\0'){
      if(*src_p == *escaped_p && *src_p == esym){
        neflag = 1;
        esym = (char)0;
        break;
      }
      else if(*src_p == *escaped_p && neflag){
        neflag = 0;
        esym = *escaped_p;
        break;
      }
      escaped_p++;
    }
    while(*delims_p != '\0'){
      if(*delims_p == *src_p){
        flag = 1;
        break;
      }
      delims_p++;
    }
    if(flag && neflag)
      break;
    delims_p = delims;
    escaped_p = escaped;
    src_p++;
  }
  /* now src_p points to the symbol right after lexem */
  /* compute lexem size and reset pointers (from trimmed to the original src) */
  char *offset;
  size_t tok_size;
  offset = (src + strspn(src, delims));
  tok_size = (src_p - lex_begin);
  free(lex_begin);
  lex_begin = offset;
  src_p = offset + tok_size;
  if(*src_p == '\0')
    *next = NULL;
  else
    *next = src_p;
  /* result token */
  char *res = alloc_str(tok_size);
  memcpy(res, lex_begin, tok_size);
  return res;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mem.h"
#include "str_utils.h"
int main(int argc, char **argv){
  char *test = "  They have  "cats dogs mice  "\n \0";
  char *copytest = test;
  char **next = &copytest; /* has side effect on copytest */
  char *tok = NULL;
  printf("src:%s\n", test);
  printf("copytest:%s\n", copytest);
  while(*next != NULL){
    tok = get_token_escaped(*next, " \t\0", ""\0", next);
    if(tok == NULL)
      break;
    printf("%s\n", tok);
    free(tok);
  }
  printf("src after:%s\n", test);
  printf("copytest after:%s\n", copytest);
  return 0;
}

src:  They have  "cats dogs mice  "
copytest:  They have  "cats dogs mice  "
They
have
"cats dogs mice  "
src after:  They have  "cats dogs mice  "
copytest after:(null)