"The code executes for the 1st iteration and names[0] contains the whole file...., How can I separate all the names?"

Regarding the first few statements:

char names[6000][20]; // an array to store 6k names of max length 19
FILE * data = fopen("./022names.txt", "r");

What if there are there are 6001 names. Or one of the names has more than 20 characters? Or what if there are way less than 6000 names?

The point is that with some effort to enumerate the tasks you have listed, and some time mapping out what information is needed to create the code that matches your criteria, you can create a better product: The following is derived from your post:

• Process ascii files in c
• Read file content that is separated by characters
• input is a comma separated file, with other delimiters as well
• Choose a method best suited to parse a file of variable size

As mentioned in the comments under your question there are ways to create your algorithms in such way as to flexibly allow for extra long names, or for a variable number of names. This can be done using a few C standard functions commonly used in parsing files. ( Although fscanf() has it place, it is not the best option for parsing file contents into array elements.)

The following approach performs the following steps to accomplish the user needs enumerated above

• Read file to determine number of, and longest element
• Create array sized to contain exact contents of file using count of elements and longest element using variable length array (VLA)
• Create function to parse file contents into array. (using this technique of passing VLA as function argument.)

Following is a complete example of how to implement each of these, while breaking the tasks into functions when appropriate...

Note, code below was tested using the following input file:

names.txt

"MARY","PATRICIA","LINDA","BARBARA","ELIZABETH","JENNIFER",
"Joseph","Bart","Daniel","Stephan","Karen","Beth","Marcia",
"Calmazzothoulumus"

.

//Prototypes
int    count_names(const char *filename, size_t *count);
size_t filesize(const char *fn);
void   populateNames(const char *fn, int longest, char arr[][longest]);

char *filename = ".\\names.txt";

int main(void) 
{
    size_t count = 0;
    int longest = count_names(filename, &count);
    char names[count][longest+1];//VLA - See linked info
                                 // +1 is room for null termination
    memset(names, 0, sizeof names);
    populateNames(filename, longest+1, names);
            
    return 0;
}

//populate VLA with names in file
void populateNames(const char *fn, int longest, char names[][longest])
{
    char line[80] = {0};
    char *delim = "\",\n ";
    char *tok = NULL;
    FILE * fp = fopen(fn, "r");
    if(fp)
    {
        int i=0;
        while(fgets(line, sizeof line, fp))
        {
            tok = strtok(line, delim);
            while(tok)
            {
                strcpy(names[i], tok);
                tok = strtok(NULL, delim);
                i++;
            }
        }
        fclose(fp);
    }
}
    
//passes back count of tokens in file, and return longest token
int count_names(const char *filename, size_t *count)
{
    int len=0, lenKeep = 0;
    FILE *fp = fopen(filename, "r");
    if(fp)
    {
        char *tok = NULL;
        char *delim = "\",\n ";
        int cnt = 0;
        size_t fSize = filesize(filename);
        char *buf = calloc(fSize, 1);
        while(fgets(buf, fSize, fp)) //goes to newline for each get
        {
            tok = strtok(buf, delim);
            while(tok)
            {
                cnt++;
                len = strlen(tok);
                if(lenKeep < len) lenKeep = len;
                tok = strtok(NULL, delim);
            }
        }
        *count = cnt;
        fclose(fp);
        free(buf);
    }
    
    return lenKeep;
}

//return file size in bytes (binary read)
size_t filesize(const char *fn)
{
    size_t size = 0;
    FILE*fp = fopen(fn, "rb");
    if(fp)
    {
        fseek(fp, 0, SEEK_END); 
        size = ftell(fp); 
        fseek(fp, 0, SEEK_SET); 
        fclose(fp);
    }
    return size;
}

Try this:

char c = 'a'; // or whatever your character is
printf("%c %d", c, c);

The %c is the format string for a single character, and %d for a digit/integer. By casting the char to an integer, you'll get the ascii value.