Line data    Source code

       1              : /*
       2              : ** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $
       3              : ** Interface to Memory Manager
       4              : ** See Copyright Notice in lua.h
       5              : */
       6              : 
       7              : 
       8              : #include <stddef.h>
       9              : 
      10              : #define lmem_c
      11              : #define LUA_CORE
      12              : 
      13              : #include "lua.h"
      14              : 
      15              : #include "ldebug.h"
      16              : #include "ldo.h"
      17              : #include "lgc.h"
      18              : #include "lmem.h"
      19              : #include "lobject.h"
      20              : #include "lstate.h"
      21              : 
      22              : 
      23              : 
      24              : /*
      25              : ** About the realloc function:
      26              : ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
      27              : ** (`osize' is the old size, `nsize' is the new size)
      28              : **
      29              : ** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no
      30              : ** matter 'x').
      31              : **
      32              : ** * frealloc(ud, p, x, 0) frees the block `p'
      33              : ** (in this specific case, frealloc must return NULL);
      34              : ** particularly, frealloc(ud, NULL, 0, 0) does nothing
      35              : ** (which is equivalent to free(NULL) in ANSI C)
      36              : **
      37              : ** frealloc returns NULL if it cannot create or reallocate the area
      38              : ** (any reallocation to an equal or smaller size cannot fail!)
      39              : */
      40              : 
      41              : 
      42              : 
      43              : #define MINSIZEARRAY    4
      44              : 
      45              : 
      46        20863 : void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
      47              :                      int limit, const char *what) {
      48              :   void *newblock;
      49              :   int newsize;
      50        20863 :   if (*size >= limit/2) {  /* cannot double it? */
      51            0 :     if (*size >= limit)  /* cannot grow even a little? */
      52            0 :       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
      53            0 :     newsize = limit;  /* still have at least one free place */
      54              :   }
      55              :   else {
      56        20863 :     newsize = (*size)*2;
      57        20863 :     if (newsize < MINSIZEARRAY)
      58        10534 :       newsize = MINSIZEARRAY;  /* minimum size */
      59              :   }
      60        20863 :   newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
      61        20863 :   *size = newsize;  /* update only when everything else is OK */
      62        20863 :   return newblock;
      63              : }
      64              : 
      65              : 
      66            0 : l_noret luaM_toobig (lua_State *L) {
      67            0 :   luaG_runerror(L, "memory allocation error: block too big");
      68              : }
      69              : 
      70              : 
      71              : 
      72              : /*
      73              : ** generic allocation routine.
      74              : */
      75       249631 : void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
      76              :   void *newblock;
      77       249631 :   global_State *g = G(L);
      78       249631 :   size_t realosize = (block) ? osize : 0;
      79              :   lua_assert((realosize == 0) == (block == NULL));
      80              : #if defined(HARDMEMTESTS)
      81              :   if (nsize > realosize && g->gcrunning)
      82              :     luaC_fullgc(L, 1);  /* force a GC whenever possible */
      83              : #endif
      84       249631 :   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
      85       249631 :   if (newblock == NULL && nsize > 0) {
      86              :     api_check(L, nsize > realosize,
      87              :                  "realloc cannot fail when shrinking a block");
      88            0 :     if (g->gcrunning) {
      89            0 :       luaC_fullgc(L, 1);  /* try to free some memory... */
      90            0 :       newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
      91              :     }
      92            0 :     if (newblock == NULL)
      93            0 :       luaD_throw(L, LUA_ERRMEM);
      94              :   }
      95              :   lua_assert((nsize == 0) == (newblock == NULL));
      96       249631 :   g->GCdebt = (g->GCdebt + nsize) - realosize;
      97       249631 :   return newblock;
      98              : }
      99              :