Split function in C runtime error

There are many problems. I'm ignoring the code split into two files; I'm treating it as a single file (see comments to question).

1. Do not use gets(). Never use gets(). Do not ever use gets(). I said it three times; it must be true. Note that gets() is no longer a Standard C function (it was removed from the C11 standard — ISO/IEC 9899:2011) because it cannot be used safely. Use fgets() or another safe function instead.

2. You don't need to use dynamic memory allocation for a string of 10 characters; use a local variable (it is simpler).

3. You need a bigger string — think about 4096.

4. You don't check whether you got any data; always check input function calls.

5. You don't free all the substrings at the end of main(), thus leaking memory.

6. One major problem the Split() code slices and dices the input string so that SplitLen() cannot give you the same answer that Split() does for the number of fields. The strtok() function is destructive. It also treats multiple adjacent delimiters as a single delimiter. Your code won't account for the difference.

7. Another major problem is that you analyze the strings based on the delimiter passed into the Split() function, but you use strtok(..., ',') to actually split on commas. This is more consistent with the commentary and names, but totally misleading to you. This is why your assertion fired.

8. You don't need to include <malloc.h> unless you are using the extra facilities it provides. You aren't, so you should not include it; <stdlib.h> declares malloc() and free() perfectly well.

This code works for me; I've annotated most of the places I made changes.

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int altSplitLen(char **array);
static char **Split(char *a_str, const char a_delim);
static int SplitLen(char *src, char sep);

int main(void)
{
    printf("Enter text separated by single spaces:\n");
    char a[4096];       // Simpler
    if (fgets(a, sizeof(a), stdin) != 0)    // Error checked!
    {
        char **aa = Split(a, ' ');
        int k = SplitLen(a, ' ');
        printf("SplitLen() says %d; altSplitLen() says %d\n", k, altSplitLen(aa));

        for (int i = 0; i < k; i++)
        {
            printf("%s\n", aa[i]);
        }

        /* Workaround for broken SplitLen() */
        {
        puts("Loop to null pointer:");
        char **data = aa;
        while (*data != 0)
            printf("[%s]\n", *data++);
        }

        {
        // Fix for major leak!
        char **data = aa;
        while (*data != 0)
            free(*data++);
        }
        free(aa);       // Major leak!
    }
    return 0;
}

char **Split(char *a_str, const char a_delim)
{
    char **result    = 0;
    size_t count     = 0;
    char *tmp        = a_str;
    char *last_comma = 0;

    /* Count how many elements will be extracted. */
    while (*tmp)
    {
        if (a_delim == *tmp)
        {
            count++;
            last_comma = tmp;
        }
        tmp++;
    }
    /* Add space for trailing token. */
    count += last_comma < (a_str + strlen(a_str) - 1);

    /* Add space for terminating null string so caller
       knows where the list of returned strings ends. */
    count++;
    result = malloc(sizeof(char *) * count);

    if (result)
    {
        char delim[2] = { a_delim, '\0' };  // Fix for inconsistent splitting
        size_t idx  = 0;
        char *token = strtok(a_str, delim);

        while (token)
        {
            assert(idx < count);
            *(result + idx++) = strdup(token);
            token = strtok(0, delim);
        }
        assert(idx == count - 1);
        *(result + idx) = 0;
    }
    return result;
}

int SplitLen(char *src, char sep)
{
    int result = 0;
    for (size_t i = 0; i < strlen(src); i++)
    {
        if (src[i] == sep)
        {
            result += 1;
        }
    }
    return result;
}

static int altSplitLen(char **array)
{
    int i = 0;
    while (*array++ != 0)
        i++;
    return i;
}

Sample run:

$ parsing
Enter text separated by single spaces:
a b c d e f gg hhh iii jjjj exculpatory evidence
SplitLen() says 0; altSplitLen() says 12
Loop to null pointer:
[a]
[b]
[c]
[d]
[e]
[f]
[gg]
[hhh]
[iii]
[jjjj]
[exculpatory]
[evidence
]
$

Note that fgets() keeps the newline and gets() does not, so the newline was included in output. Note also how the printf() printing the data showed the limits of the strings; that is enormously helpful on many occasions.