tesseract/ccutil/memry.h

193 lines
6.7 KiB
C
Raw Normal View History

/**********************************************************************
* File: memry.h (Formerly memory.h)
* Description: Header file for basic memory allocation/deallocation.
* Author: Ray Smith
* Created: Tue May 8 16:03:48 BST 1990
*
* (C) Copyright 1990, Hewlett-Packard Ltd.
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
** http://www.apache.org/licenses/LICENSE-2.0
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*
**********************************************************************/
#ifndef MEMRY_H
#define MEMRY_H
#include <stddef.h>
#include "host.h"
#define JUSTCHECKS 0 /*just check consistency */
#define MEMCHECKS 1 /*report totals */
#define FULLMEMCHECKS 2 /*report on all blocks */
#ifdef __MSW32__
#define NEWDELETE /*replace new & delete*/\
void *operator new( /*fast allocator*/\
size_t size, /*size of object*/\
const char* file=NULL, /*filename*/\
inT32 line=0) /*line number*/\
{\
return alloc_struct(size); /*simple to do*/\
}\
\
void operator delete( /*fast destructor*/\
void *deadstruct, /*thing to free*/\
size_t size) /*sizeof struct*/\
{\
free_struct(deadstruct,size); /*free it*/\
}\
#define NEWDELETE2(name) /*replace new & delete*/\
void *operator new( /*fast allocator*/\
size_t size, /*size of object*/\
const char* file=NULL, /*filename*/\
inT32 line=0) /*line number*/\
{\
return alloc_struct(size,#name); /*simple to do*/\
}\
\
void operator delete( /*fast destructor*/\
void *deadstruct, /*thing to free*/\
size_t size) /*sizeof struct*/\
{\
free_struct(deadstruct,size,#name); /*free it*/\
}\
#undef NEWDELETE
#define NEWDELETE
#undef NEWDELETE2
#define NEWDELETE2(name)
#else
#define NEWDELETE /*replace new & delete*/\
void *operator new( /*fast allocator*/\
size_t size) /*size of object*/\
{\
return alloc_struct(size); /*simple to do*/\
}\
\
void operator delete( /*fast destructor*/\
void *deadstruct, /*thing to free*/\
size_t size) /*sizeof struct*/\
{\
free_struct(deadstruct,size); /*free it*/\
}\
#define NEWDELETE2(name) /*replace new & delete*/\
void *operator new( /*fast allocator*/\
size_t size) /*size of object*/\
{\
return alloc_struct(size,#name); /*simple to do*/\
}\
\
void operator delete( /*fast destructor*/\
void *deadstruct, /*thing to free*/\
size_t size) /*sizeof struct*/\
{\
free_struct(deadstruct,size,#name); /*free it*/\
}\
#endif
/**********************************************************************
* ALLOC_2D_ARRAY
*
* Create a dynamic 2D array.
**********************************************************************/
#define ALLOC_2D_ARRAY(x,y,mem,ptrs,type) /*make 2d array*/\
{ \
inT32 TMP_i; \
mem=(type*)alloc_mem((x)*(y)*sizeof(type)); /*get memory*/\
ptrs=(type**)alloc_mem((x)*sizeof(type*)); /*get ptrs*/\
for (TMP_i=0;TMP_i<(x);TMP_i++)\
ptrs[TMP_i]=mem+(y)*TMP_i; /*set ptrs*/\
} \
/**********************************************************************
* FREE_2D_ARRAY
*
* Destroy a 2D array created by ALLOC_2D_ARRAY
**********************************************************************/
#define FREE_2D_ARRAY(mem,ptrs) /*free a 2D array*/\
{ \
free_mem(mem); /*free the memory*/\
free_mem(ptrs); /*and the ptrs*/\
} \
/**********************************************************************
* ALLOC_BIG_2D_ARRAY
*
* Create a dynamic 2D array. Use a memory allocator that allows
* allocation of bigger chunks.
**********************************************************************/
#define ALLOC_BIG_2D_ARRAY(x,y,mem,ptrs,type) /*make 2d array*/\
{ \
inT32 TMP_i; \
mem=(type*)alloc_big_mem((x)*(y)*sizeof(type)); /*get memory*/\
ptrs=(type**)alloc_big_mem((x)*sizeof(type*)); /*get ptrs*/\
for (TMP_i=0;TMP_i<(x);TMP_i++)\
ptrs[TMP_i]=mem+(y)*TMP_i; /*set ptrs*/\
} \
/**********************************************************************
* FREE_BIG_2D_ARRAY
*
* Destroy a 2D array created by ALLOC_BIG_2D_ARRAY
**********************************************************************/
#define FREE_BIG_2D_ARRAY(mem,ptrs) /*free a 2D array*/\
{ \
free_big_mem(mem); /*free the memory*/\
free_big_mem(ptrs); /*and the ptrs*/\
} \
extern DLLSYM void check_mem( //check consistency
const char *string, //context message
inT8 level //level of check
);
//allocate string
extern DLLSYM char *alloc_string(inT32 count //no of chars required
);
extern DLLSYM void free_string( //free a string
char *string //string to free
);
//allocate memory
extern DLLSYM void *alloc_struct (
inT32 count, //no of chars required
const char *name = NULL //class name
);
extern DLLSYM void free_struct ( //free a structure
void *deadstruct, //structure to free
inT32 count, //no of bytes
const char *name = NULL //class name
);
extern DLLSYM void *alloc_mem_p( //allocate permanent space
inT32 count //block size to allocate
);
extern DLLSYM void *alloc_mem( //get some memory
inT32 count //no of bytes to get
);
//get some memory
extern DLLSYM void *alloc_big_mem(inT32 count //no of bytes to get
);
//get some memory
extern DLLSYM void *alloc_big_zeros(inT32 count //no of bytes to get
);
extern DLLSYM void free_mem( //free mem from alloc_mem
void *oldchunk //chunk to free
);
extern DLLSYM void free_big_mem( //free mem from alloc_mem
void *oldchunk //chunk to free
);
#endif