Попытка динамически выделить многомерный массив в C приводит к сбою

По множеству причин я хотел бы размещать многомерные массивы в смежных участках памяти. Я могу сделать это, выделив их вручную, например:

t.versions=(char***)malloc(sizeof(char**)*4);
t.versions[0]=(char**)malloc(sizeof(char*)*t.size*4);
t.versions[0][0]=(char*)calloc(t.size*t.size*4,sizeof(char));
for (i=1; i<t.size*4; ++i) 
    t.versions[0][i]=t.versions[0][i-1]+t.size;
for (i=1; i<4; ++i) 
    t.versions[i]=t.versions[i-1]+t.size;

Помимо других преимуществ, это решение упрощает освобождение выделенной памяти:

void contiguous_array_free(void** ptr, int depth)
{
    int *ptr_d;
    ptr_d=(int*)*ptr;
    if (depth>1)
        contiguous_array_free((void**)ptr_d, depth-1);
    free(ptr);
}
//(elsewhere in the code)
contiguous_array_free((void**)(*tile).versions, 3);

Теперь у меня возникла небольшая проблема с выделением этих массивов. Хотя описанный выше подход действительно работает, в идеале я хотел бы иметь универсальное решение, позволяющее распределять эти массивы с помощью одной функции. вызов.

Однако моя попытка достичь этой цели приводит к сбою программы каждый раз, когда используется содержимое массива.

//dimension points to a 1-dimensional array of integers
//specifying the size in each array dimension
void* contiguous_array_alloc(int* dimension, int depth, int size)
{
    int i;
    char** ptr;
    if (depth==1)
    {
        ptr=(char**)malloc(*dimension*size);
        return ptr;
    }
    ptr=(char**)malloc(*dimension*sizeof(char*));
    *(dimension+1)*=*dimension;
    ptr[0]=(char*)contiguous_array_alloc(dimension+1, depth-1, size);
    *(dimension+1)/=(*dimension);
    for (i=1; i<*dimension; ++i)
        ptr[i]=ptr[i-1]+(*(dimension+1)*size);
    return (void*)ptr;
}

//(later in the code) (
int dimension[3];
dimension[0]=4;
dimension[1]=t.size;
dimension[2]=t.size;
t.versions=(char***)contiguous_array_alloc(&dimension[0], 3, sizeof(char));

Добавление некоторых отладочных сообщений в код, по-видимому, указывает на то, что элементы распределены правильно:

Выделение массива [4][9][9] элементов размера 1; malloc() с 16-байтовым массивом для 4 указателей; Выделенный массив указателей на уровень 2 по адресу 003E29E8;

Выделение массива [36][9] элементов размера 1; malloc() с 144-байтовым массивом для 36 указателей; Выделенный массив указателей на уровень 1 по адресу 003E5728;

Выделение массива [324] элементов размера 1;

324-байтовый массив данных по адресу 003E57C0; Указал данные на 003E57C0; увеличение каждого указателя на 9; Возврат выделенного массива;

Указал данные на 003E5728; увеличение каждого указателя на 9; Возврат выделенного массива;

Выделенный непрерывный массив по адресу 003E29E8;

Что вызывает такое поведение? Я проверил код несколько раз и понятия не имею, что я сделал неправильно.