typedef struct INFO
{
    int grid_height;            /*Height of the matrix*/
    int grid_width;             /*Width of the matrix*/
} INFO;

static INFO info;

char ***Create_Matrix()     /*This function creates a "Triple matrix"*/
{
    int i, j;
    char ***matrix = NULL;
    
    if(info.file) Check_File();
    
    matrix       = (char ***)calloc(2,                                      sizeof(char **));   /*These three lines should allocate all the necessary space*/
    matrix[0]    = (char  **)calloc(2 * info.grid_width,                    sizeof(char  *));	/*If I multiply the first parameter by 4 it works*/
    matrix[0][0] = (char   *)calloc(2 * info.grid_width * info.grid_height, sizeof(char   ));	/*But I have to do it here to*/
    
    for(i = 0; i < 2; i++)                  /*These two cicles adjust all the pointers in the matrix*/
    {
        /*if(i != 0) matrix[i] = (char **)(matrix[i-1] + (sizeof(char *)*info.grid_width));*/
        matrix[i] = matrix[0] + i*info.grid_width*sizeof(char *);
        
        for(j = 0; j < info.grid_width; j++)
        {
            /*if(!(i == 0 && j == 0))
            {
                matrix[i][j] = (char *)(matrix[i][j-1] + (sizeof(char)*info.grid_height));
            }*/
            matrix[i][j] = matrix[0][0] + i*info.grid_width*info.grid_height*sizeof(char) + j*info.grid_height*sizeof(char);
        }
    }
    
    return matrix;
} 

void Rand_Config(char **matrix)         /*This function creates a random configuration of 1s and 0s*/
{
    int i, j;
    
    srand(My_Time);                             /*reset rand for "more" random numbers*/
    for(i = 0; i < info.grid_width; i++)
        for(j = 0; j < info.grid_height; j++)
            matrix[i][j] = rand()%2;            /*place 1 or 0*/
    
    return;
}

***Create_Matrix()

 for(info.file){} 

 int file; int file(); 

 if(info.file() = 0){} 

typedef struct info
{
   int height;
   int width;
   int grid_height;
   int grid_width;
   int miliseconds;
   int generation;

   char limits;
   char file;
   char automate;
   char draw;
   char rand;
}

char ***Create_Matrix(void)
{
    /*This function creates a "Triple matrix" */
    /* will access matrix elements bi matrix[i][j][k] */
    int i, j;

    char ***matrix;

    /* Allocate storage for two pointers
     * Each pointer will point to a 2-d array
     * Note that for C programs, the cast in front of calloc
     * is neither required or recommended for general use.
     * (For a number of subtle reasons)
     * For C++ programs I think it's better to use new/delete
     * rather than calloc/free, but I'll leave things the
     * way you had them
     */
    matrix = (char ***) calloc(2, sizeof(char **));

    /* Each member of the 3-D matrix is treated as a 2-D matrix
     * (actually a pointer to char*).
     *
     * Allocate storage for a number of pointers equal to
     * the number of 2-D matrices
     *
     * Then for each 2-D matrix, allocate storage for a number
     * of pointers equal to the number of rows.
     *
     * Then for each row, allocate storage for the number of chars
     * in each row.
     */
    for (i = 0; i < 2; i++) { /* two 3-D matrices */
        matrix[i] = calloc(info.grid_height, sizeof(char *));
        for (j = 0; j < info.grid_height; j++) {
            matrix[i][j] = calloc(info.grid_width, sizeof(char));
        }
    }
    /* note that sizeof(char) is always 1, but I left it in place
     * just for the heck of it
     */

    /* note that the total number of chars allocated for matrix
     * elements is equal to
     * two times the grid height times the grid width
     */
    return matrix;
}

char ***Create_Matrix(INFO *inf)
{
.
.
.
    for (i = 0; i < 2; i++) { /* two 3-D matrices */
        matrix[i] = calloc(inf->grid_height, sizeof(char *));
        for (j = 0; j < inf->grid_height; j++) {
            matrix[i][j] = calloc(inf->grid_width, sizeof(char));
        }
    }
.
.
.