mirror of https://github.com/rusefi/lua.git
better use of extra include files (both for tests and for old_ansi)
This commit is contained in:
Roberto Ierusalimschy
parent
d444153dbe
commit
1f917e709c
34
liolib.c
34
liolib.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: liolib.c,v 1.102 2001/01/26 12:12:16 roberto Exp roberto $
|
||||
** $Id: liolib.c,v 1.103 2001/02/02 19:02:40 roberto Exp roberto $
|
||||
** Standard I/O (and system) library
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -21,19 +21,13 @@
|
|||
#ifndef OLD_ANSI
|
||||
#include <errno.h>
|
||||
#include <locale.h>
|
||||
#define realloc(b,s) ((b) == NULL ? malloc(s) : (realloc)(b, s))
|
||||
#define free(b) if (b) (free)(b)
|
||||
#else
|
||||
/* no support for locale and for strerror: fake them */
|
||||
#define setlocale(a,b) ((void)a, strcmp((b),"C")==0?"C":NULL)
|
||||
#define LC_ALL 0
|
||||
#define LC_COLLATE 0
|
||||
#define LC_CTYPE 0
|
||||
#define LC_MONETARY 0
|
||||
#define LC_NUMERIC 0
|
||||
#define LC_TIME 0
|
||||
#define strerror(e) "I/O error"
|
||||
#define errno (-1)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef l_realloc
|
||||
#define l_malloc(s) malloc(s)
|
||||
#define l_realloc(b,os,s) realloc(b, s)
|
||||
#define l_free(b, os) free(b)
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -258,20 +252,22 @@ static int read_line (lua_State *L, FILE *f) {
|
|||
static void read_file (lua_State *L, FILE *f) {
|
||||
size_t len = 0;
|
||||
size_t size = LUAL_BUFFERSIZE;
|
||||
size_t oldsize = 0;
|
||||
char *buffer = NULL;
|
||||
for (;;) {
|
||||
char *newbuffer = (char *)realloc(buffer, size);
|
||||
char *newbuffer = (char *)l_realloc(buffer, oldsize, size);
|
||||
if (newbuffer == NULL) {
|
||||
free(buffer);
|
||||
l_free(buffer, oldsize);
|
||||
lua_error(L, "not enough memory to read a file");
|
||||
}
|
||||
buffer = newbuffer;
|
||||
len += fread(buffer+len, sizeof(char), size-len, f);
|
||||
if (len < size) break; /* did not read all it could */
|
||||
oldsize = size;
|
||||
size *= 2;
|
||||
}
|
||||
lua_pushlstring(L, buffer, len);
|
||||
free(buffer);
|
||||
l_free(buffer, size);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -282,13 +278,13 @@ static int read_chars (lua_State *L, FILE *f, size_t n) {
|
|||
if (n <= LUAL_BUFFERSIZE)
|
||||
buffer = statbuff;
|
||||
else {
|
||||
buffer = (char *)malloc(n);
|
||||
buffer = (char *)l_malloc(n);
|
||||
if (buffer == NULL)
|
||||
lua_error(L, "not enough memory to read a file");
|
||||
}
|
||||
n1 = fread(buffer, sizeof(char), n, f);
|
||||
lua_pushlstring(L, buffer, n1);
|
||||
if (buffer != statbuff) free(buffer);
|
||||
if (buffer != statbuff) l_free(buffer, n);
|
||||
return (n1 > 0 || n == 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
115
lmem.c
115
lmem.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lmem.c,v 1.44 2001/01/24 15:45:33 roberto Exp roberto $
|
||||
** $Id: lmem.c,v 1.45 2001/02/05 19:08:01 roberto Exp roberto $
|
||||
** Interface to Memory Manager
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -16,115 +16,12 @@
|
|||
|
||||
|
||||
|
||||
|
||||
#ifdef LUA_DEBUG
|
||||
/*
|
||||
** {======================================================================
|
||||
** Controlled version for realloc.
|
||||
** =======================================================================
|
||||
*/
|
||||
|
||||
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
|
||||
#define basicrealloc(b, os, s) debug_realloc(b, os, s)
|
||||
#define basicfree(b, s) debug_realloc(b, s, 0)
|
||||
|
||||
|
||||
/* ensures maximum alignment for HEADER */
|
||||
#define HEADER (sizeof(union L_Umaxalign))
|
||||
|
||||
#define MARKSIZE 32
|
||||
#define MARK 0x55 /* 01010101 (a nice pattern) */
|
||||
|
||||
|
||||
#define blocksize(b) ((size_t *)((char *)(b) - HEADER))
|
||||
|
||||
unsigned long memdebug_numblocks = 0;
|
||||
unsigned long memdebug_total = 0;
|
||||
unsigned long memdebug_maxmem = 0;
|
||||
unsigned long memdebug_memlimit = ULONG_MAX;
|
||||
|
||||
|
||||
static void *checkblock (void *block) {
|
||||
size_t *b = blocksize(block);
|
||||
size_t size = *b;
|
||||
int i;
|
||||
for (i=0;i<MARKSIZE;i++)
|
||||
assert(*(((char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
static void freeblock (void *block) {
|
||||
if (block) {
|
||||
size_t size = *blocksize(block);
|
||||
block = checkblock(block);
|
||||
memset(block, -1, size+HEADER+MARKSIZE); /* erase block */
|
||||
free(block); /* free original block */
|
||||
memdebug_numblocks--;
|
||||
memdebug_total -= size;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void *debug_realloc (void *block, size_t oldsize, size_t size) {
|
||||
assert((oldsize == 0) ? block == NULL : oldsize == *blocksize(block));
|
||||
if (size == 0) {
|
||||
freeblock(block);
|
||||
return NULL;
|
||||
}
|
||||
else if (memdebug_total+size > memdebug_memlimit)
|
||||
return NULL; /* to test memory allocation errors */
|
||||
else {
|
||||
char *newblock;
|
||||
int i;
|
||||
size_t realsize = HEADER+size+MARKSIZE;
|
||||
if (realsize < size) return NULL; /* overflow! */
|
||||
newblock = (char *)malloc(realsize); /* alloc a new block */
|
||||
if (newblock == NULL) return NULL;
|
||||
if (oldsize > size) oldsize = size;
|
||||
if (block) {
|
||||
memcpy(newblock+HEADER, block, oldsize);
|
||||
freeblock(block); /* erase (and check) old copy */
|
||||
}
|
||||
/* initialize new part of the block with something `weird' */
|
||||
memset(newblock+HEADER+oldsize, -MARK, size-oldsize);
|
||||
memdebug_total += size;
|
||||
if (memdebug_total > memdebug_maxmem)
|
||||
memdebug_maxmem = memdebug_total;
|
||||
memdebug_numblocks++;
|
||||
*(size_t *)newblock = size;
|
||||
for (i=0;i<MARKSIZE;i++)
|
||||
*(newblock+HEADER+size+i) = (char)(MARK+i);
|
||||
return newblock+HEADER;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* }====================================================================== */
|
||||
|
||||
#else
|
||||
/* no debug */
|
||||
|
||||
/*
|
||||
** Real ISO (ANSI) systems do not need these tests;
|
||||
** but some systems (Sun OS) are not that ISO...
|
||||
*/
|
||||
#ifdef OLD_ANSI
|
||||
#define basicrealloc(b,os,s) ((b) == NULL ? malloc(s) : realloc(b, s))
|
||||
#define basicfree(b,s) if (b) free(b)
|
||||
#else
|
||||
#define basicrealloc(b,os,s) realloc(b,s)
|
||||
#define basicfree(b,s) free(b)
|
||||
|
||||
#ifndef l_realloc
|
||||
#define l_realloc(b,os,s) realloc(b,s)
|
||||
#define l_free(b,s) free(b)
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
|
||||
int limit, const char *errormsg) {
|
||||
void *newblock;
|
||||
|
|
@ -148,13 +45,13 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
|
|||
*/
|
||||
void *luaM_realloc (lua_State *L, void *block, luint32 oldsize, luint32 size) {
|
||||
if (size == 0) {
|
||||
basicfree(block, oldsize); /* block may be NULL; that is OK for free */
|
||||
l_free(block, oldsize); /* block may be NULL; that is OK for free */
|
||||
block = NULL;
|
||||
}
|
||||
else if (size >= MAX_SIZET)
|
||||
luaD_error(L, "memory allocation error: block too big");
|
||||
else {
|
||||
block = basicrealloc(block, oldsize, size);
|
||||
block = l_realloc(block, oldsize, size);
|
||||
if (block == NULL) {
|
||||
if (L)
|
||||
luaD_breakrun(L, LUA_ERRMEM); /* break run without error message */
|
||||
|
|
|
|||
86
ltests.c
86
ltests.c
|
|
@ -1,11 +1,12 @@
|
|||
/*
|
||||
** $Id: ltests.c,v 1.61 2001/02/01 16:03:38 roberto Exp roberto $
|
||||
** $Id: ltests.c,v 1.62 2001/02/02 15:13:05 roberto Exp roberto $
|
||||
** Internal Module for Debugging of the Lua Implementation
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
|
@ -34,6 +35,7 @@
|
|||
*/
|
||||
#ifdef LUA_DEBUG
|
||||
|
||||
|
||||
lua_State *lua_state = NULL;
|
||||
|
||||
int islocked = 0;
|
||||
|
|
@ -47,6 +49,88 @@ static void setnameval (lua_State *L, const char *name, int val) {
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================================
|
||||
** Controlled version for realloc.
|
||||
** =======================================================================
|
||||
*/
|
||||
|
||||
|
||||
/* ensures maximum alignment for HEADER */
|
||||
#define HEADER (sizeof(union L_Umaxalign))
|
||||
|
||||
#define MARKSIZE 32
|
||||
#define MARK 0x55 /* 01010101 (a nice pattern) */
|
||||
|
||||
|
||||
#define blocksize(b) ((size_t *)((char *)(b) - HEADER))
|
||||
|
||||
unsigned long memdebug_numblocks = 0;
|
||||
unsigned long memdebug_total = 0;
|
||||
unsigned long memdebug_maxmem = 0;
|
||||
unsigned long memdebug_memlimit = ULONG_MAX;
|
||||
|
||||
|
||||
static void *checkblock (void *block) {
|
||||
size_t *b = blocksize(block);
|
||||
size_t size = *b;
|
||||
int i;
|
||||
for (i=0;i<MARKSIZE;i++)
|
||||
lua_assert(*(((char *)b)+HEADER+size+i) == MARK+i); /* corrupted block? */
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
static void freeblock (void *block) {
|
||||
if (block) {
|
||||
size_t size = *blocksize(block);
|
||||
block = checkblock(block);
|
||||
memset(block, -1, size+HEADER+MARKSIZE); /* erase block */
|
||||
free(block); /* free original block */
|
||||
memdebug_numblocks--;
|
||||
memdebug_total -= size;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void *debug_realloc (void *block, size_t oldsize, size_t size) {
|
||||
lua_assert((oldsize == 0) ? block == NULL : oldsize == *blocksize(block));
|
||||
if (size == 0) {
|
||||
freeblock(block);
|
||||
return NULL;
|
||||
}
|
||||
else if (memdebug_total+size > memdebug_memlimit)
|
||||
return NULL; /* to test memory allocation errors */
|
||||
else {
|
||||
char *newblock;
|
||||
int i;
|
||||
size_t realsize = HEADER+size+MARKSIZE;
|
||||
if (realsize < size) return NULL; /* overflow! */
|
||||
newblock = (char *)malloc(realsize); /* alloc a new block */
|
||||
if (newblock == NULL) return NULL;
|
||||
if (oldsize > size) oldsize = size;
|
||||
if (block) {
|
||||
memcpy(newblock+HEADER, block, oldsize);
|
||||
freeblock(block); /* erase (and check) old copy */
|
||||
}
|
||||
/* initialize new part of the block with something `weird' */
|
||||
memset(newblock+HEADER+oldsize, -MARK, size-oldsize);
|
||||
memdebug_total += size;
|
||||
if (memdebug_total > memdebug_maxmem)
|
||||
memdebug_maxmem = memdebug_total;
|
||||
memdebug_numblocks++;
|
||||
*(size_t *)newblock = size;
|
||||
for (i=0;i<MARKSIZE;i++)
|
||||
*(newblock+HEADER+size+i) = (char)(MARK+i);
|
||||
return newblock+HEADER;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* }====================================================================== */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** Disassembler
|
||||
|
|
|
|||
12
ltests.h
12
ltests.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ltests.h,v 1.1 2001/02/02 15:12:25 roberto Exp roberto $
|
||||
** $Id: ltests.h,v 1.2 2001/02/05 19:08:01 roberto Exp roberto $
|
||||
** Internal Header for Debugging of the Lua Implementation
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -8,6 +8,8 @@
|
|||
#define ltests_h
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
#define LUA_DEBUG
|
||||
|
||||
|
|
@ -27,6 +29,14 @@ extern unsigned long memdebug_maxmem;
|
|||
extern unsigned long memdebug_memlimit;
|
||||
|
||||
|
||||
#define l_malloc(s) debug_realloc(NULL, 0, s)
|
||||
#define l_realloc(b, os, s) debug_realloc(b, os, s)
|
||||
#define l_free(b, s) debug_realloc(b, s, 0)
|
||||
|
||||
void *debug_realloc (void *block, size_t oldsize, size_t size);
|
||||
|
||||
|
||||
|
||||
/* test for lock/unlock */
|
||||
#define LUA_USERSTATE int *lock;
|
||||
extern int islocked;
|
||||
|
|
|
|||
7
lvm.c
7
lvm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.c,v 1.163 2001/02/01 17:39:55 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 1.164 2001/02/02 15:13:05 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -25,11 +25,6 @@
|
|||
#include "lvm.h"
|
||||
|
||||
|
||||
#ifdef OLD_ANSI
|
||||
#define strcoll(a,b) strcmp(a,b)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** Extra stack size to run a function:
|
||||
|
|
|
|||
Loading…
Reference in New Issue