Allocation of a simple matrix


#ifndef __ESTDLIB_H__
#define __ESTDLIB_H__
#include <stdlib.h>

void **mcalloc(size_t nmemb, size_t mmemb, size_t size);
void mmalloc(void ***matrix,size_t n, size_t m);
void mfree(void **matrix, size_t n);
void **mrealloc(void **matrix, size_t n, size_t m, size_t nsize, size_t msize);

void **mcalloc(size_t nmemb, size_t mmemb, size_t size)
{
    return NULL;
}

void mmalloc(void ***matrix, size_t n, size_t m)
{
    register unsigned long int i, j;
    if (matrix == NULL)
        return;
    *matrix = malloc(n);
    if (*matrix == NULL)
        return;
    for (i = 0; i < n; ++i) {
        *((*matrix)+i) = malloc(m);
        if (*((*matrix)+i) == NULL)
            break;
    }
   
    if (i < n+1) {
        for (j = 0; j <= i; ++j) {
            if (*((*matrix)+j) != NULL)
                free(*((*matrix)+j));
        }
        free(*matrix);
    }

    return;
}

void mfree(void **matrix, size_t n)
{
    register size_t i;
    for (i = 0; i < n; ++i)
        free(*(matrix+i));
    free(matrix);
}

void **mrealloc(void **matrix, size_t n, size_t m, size_t nsize, size_t msize)
{
    return NULL;
}

#endif

When I'm back from 2 weeks vacation, I'll bet that /prog/ (even the wizards) haven't solved this mystery. The amount segfault and other corruptions I got from my own code was amazing. Enjoy.

dalloc.h
#ifndef __DALLOC_H
#define __DALLOC_H

/*
 * Allocates 2D memory of m_memb x n_memb elements
 * size bytes large.
 */
extern void **dalloc(size_t m_memb, size_t n_memb, size_t size);

/*
 * Frees the memory previously allocated by dalloc.
 */
extern void dalloc_free(void **ptr);

#endif

dalloc.c
#include <stdlib.h>
#include "dalloc.h"

void **
dalloc(size_t m_memb, size_t n_memb, size_t size)
{
  size_t i;
  void **ptr;

  ptr = (void **) malloc(m_memb * sizeof(void *));

  if (ptr == NULL)
    return NULL;

  *ptr = malloc(m_memb * n_memb * size);

  if (*ptr == NULL) {
    free(ptr);
    return NULL;
  }

  for (i = 0; i < m_memb; i++)
    ptr[i] = *ptr + i * n_memb * size;

  return ptr;
}

void
dalloc_free(void **ptr)
{
  free(*ptr);
  free( ptr);
}

Reallocation is probably marginally more difficult, but at least this ensures contiguous memory.