limits now are in `llims.n'

This commit is contained in:
Roberto Ierusalimschy 2000-03-24 14:26:08 -03:00
parent 47b4bf5964
commit 213e9febc8
9 changed files with 26 additions and 164 deletions

View File

@ -1,5 +1,5 @@
/*
** $Id: lbuiltin.c,v 1.95 2000/03/09 00:19:22 roberto Exp roberto $
** $Id: lbuiltin.c,v 1.96 2000/03/10 18:37:44 roberto Exp roberto $
** Built-in functions
** See Copyright Notice in lua.h
*/
@ -130,10 +130,6 @@ void luaB__ERRORMESSAGE (lua_State *L) {
** model but changing `fputs' to put the strings at a proper place
** (a console window or a log file, for instance).
*/
#ifndef MAXPRINT
#define MAXPRINT 40 /* arbitrary limit */
#endif
void luaB_print (lua_State *L) {
lua_Object args[MAXPRINT];
lua_Object obj;

View File

@ -1,5 +1,5 @@
/*
** $Id: lcode.c,v 1.16 2000/03/20 19:15:37 roberto Exp roberto $
** $Id: lcode.c,v 1.17 2000/03/24 12:18:30 roberto Exp roberto $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
@ -212,10 +212,6 @@ void luaK_kstr (LexState *ls, int c) {
}
#ifndef LOOKBACKNUMS
#define LOOKBACKNUMS 20 /* arbitrary limit */
#endif
static int real_constant (FuncState *fs, Number r) {
/* check whether `r' has appeared within the last LOOKBACKNUMS entries */
Proto *f = fs->f;

6
ldo.h
View File

@ -1,5 +1,5 @@
/*
** $Id: ldo.h,v 1.16 1999/12/30 18:28:40 roberto Exp roberto $
** $Id: ldo.h,v 1.17 2000/01/19 12:00:45 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@ -12,10 +12,6 @@
#include "lstate.h"
#define MULT_RET 255
/*
** macro to increment stack top.
** There must be always an empty slot at the L->stack.top

6
llex.c
View File

@ -1,5 +1,5 @@
/*
** $Id: llex.c,v 1.52 2000/03/03 14:58:26 roberto Exp roberto $
** $Id: llex.c,v 1.53 2000/03/10 18:37:44 roberto Exp roberto $
** Lexical Analyzer
** See Copyright Notice in lua.h
*/
@ -114,10 +114,6 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z) {
** =======================================================
*/
#ifndef PRAGMASIZE
#define PRAGMASIZE 80 /* arbitrary limit */
#endif
static void skipspace (LexState *LS) {
while (LS->current == ' ' || LS->current == '\t' || LS->current == '\r')
next(LS);

6
llex.h
View File

@ -1,5 +1,5 @@
/*
** $Id: llex.h,v 1.19 2000/03/03 14:58:26 roberto Exp roberto $
** $Id: llex.h,v 1.20 2000/03/10 18:37:44 roberto Exp roberto $
** Lexical Analyzer
** See Copyright Notice in lua.h
*/
@ -35,10 +35,6 @@ enum RESERVED {
#define NUM_RESERVED ((int)(TK_WHILE-FIRST_RESERVED+1))
#ifndef MAX_IFS
#define MAX_IFS 5 /* arbitrary limit */
#endif
/* `ifState' keeps the state of each nested $if the lexical is dealing with. */
struct ifState {

View File

@ -1,5 +1,5 @@
/*
** $Id: lobject.h,v 1.52 2000/03/16 21:06:16 roberto Exp roberto $
** $Id: lobject.h,v 1.53 2000/03/20 19:14:54 roberto Exp roberto $
** Type definitions for Lua objects
** See Copyright Notice in lua.h
*/
@ -8,8 +8,7 @@
#define lobject_h
#include <limits.h>
#include "llims.h"
#include "lua.h"
@ -26,39 +25,6 @@
#define UNUSED(x) (void)x /* to avoid warnings */
/*
** Define the type `number' of Lua
** GREP LUA_NUMBER to change that
*/
#ifndef LUA_NUM_TYPE
#define LUA_NUM_TYPE double
#endif
typedef LUA_NUM_TYPE Number;
/*
** type for virtual-machine instructions
** must be an unsigned with 4 bytes (see details in lopcodes.h)
*/
typedef unsigned long Instruction;
#define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */
/* conversion of pointer to int (for hashing only) */
/* (the shift removes bits that are usually 0 because of alignment) */
#define IntPoint(L, p) (((unsigned long)(p)) >> 3)
/*
** number of `blocks' for garbage collection: each reference to other
** objects count 1, and each 32 bytes of `raw' memory count 1; we add
** 2 to the total as a minimum (and also to count the overhead of malloc)
*/
#define numblocks(L, o,b) ((o)+((b)>>5)+2)
/*
** Lua TYPES
@ -112,7 +78,6 @@ typedef struct TObject {
} TObject;
typedef struct GlobalVar {
TObject value;
struct GlobalVar *next;
@ -142,8 +107,6 @@ typedef struct TString {
} TString;
/*
** Function Prototypes
*/
@ -173,8 +136,6 @@ typedef struct LocVar {
/* Macros to access structure members */
#define ttype(o) ((o)->ttype)
#define nvalue(o) ((o)->value.n)
@ -199,7 +160,6 @@ typedef struct Closure {
} Closure;
typedef struct Node {
TObject key;
TObject val;
@ -221,8 +181,6 @@ extern const TObject luaO_nilobject;
#define luaO_typename(o) luaO_typenames[ttype(o)]
#define MINPOWER2 4 /* minimum size for "growing" vectors */
unsigned long luaO_power2 (unsigned long n);
#define luaO_equalObj(t1,t2) (ttype(t1) == ttype(t2) && luaO_equalval(t1,t2))

View File

@ -1,5 +1,5 @@
/*
** $Id: lopcodes.h,v 1.49 2000/03/13 20:37:16 roberto Exp roberto $
** $Id: lopcodes.h,v 1.50 2000/03/16 18:03:09 roberto Exp roberto $
** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -7,36 +7,32 @@
#ifndef lopcodes_h
#define lopcodes_h
#include "llims.h"
/*===========================================================================
We assume that instructions are unsigned numbers with 4 bytes.
All instructions have an opcode in the 8 bits. Moreover,
We assume that instructions are unsigned numbers.
All instructions have an opcode in the first 6 bits. Moreover,
an instruction can have 0, 1, or 2 arguments. There are 4 types of
Instructions:
type 0: no arguments
type 1: 1 unsigned argument in the higher 24 bits (called `U')
type 2: 1 signed argument in the higher 24 bits (`S')
type 3: 1st unsigned argument in the higher 16 bits (`A')
2nd unsigned argument in the middle 8 bits (`B')
type 1: 1 unsigned argument in the higher bits (called `U')
type 2: 1 signed argument in the higher bits (`S')
type 3: 1st unsigned argument in the higher bits (`A')
2nd unsigned argument in the middle bits (`B')
The signed argument is represented in excess 2^23; that is, the number
value is the usigned value minus 2^23.
The signed argument is represented in excess 2^K; that is, the number
value is the usigned value minus 2^K.
The size of each argument is defined in `llims.h'. The usual is an
instruction with 32 bits, U and S arguments with 26 bits (32-6), B
argument with 9 bits, and A argument with 17 bits (32-6-9). For small
instalations, the instruction size can be 16, so U and S have 10 bits,
and A and B have 5 bits each.
===========================================================================*/
#define SIZE_INSTRUCTION 32
#define SIZE_OP 8
#define SIZE_U (SIZE_INSTRUCTION-SIZE_OP)
#define POS_U SIZE_OP
#define SIZE_S (SIZE_INSTRUCTION-SIZE_OP)
#define POS_S SIZE_OP
#define SIZE_B 8
#define POS_B SIZE_OP
#define SIZE_A (SIZE_INSTRUCTION-(SIZE_OP+SIZE_B))
#define POS_A (SIZE_OP+SIZE_B)
#define EXCESS_S (1<<(SIZE_S-1)) /* == 2^23 */
#define EXCESS_S (1<<(SIZE_S-1)) /* == 2^K */
/* creates a mask with `n' 1 bits at position `p' */
@ -49,11 +45,6 @@
** the following macros help to manipulate instructions
*/
#define MAXARG_U ((1<<SIZE_U)-1)
#define MAXARG_S ((1<<(SIZE_S-1))-1) /* `S' is signed */
#define MAXARG_A ((1<<SIZE_A)-1)
#define MAXARG_B ((1<<SIZE_B)-1)
#define GET_OPCODE(i) ((OpCode)((i)&MASK1(SIZE_OP,0)))
#define GETARG_U(i) ((int)((i)>>POS_U))
#define GETARG_S(i) ((int)((i)>>POS_S)-EXCESS_S)
@ -157,29 +148,4 @@ OP_SETLINE/* U - - LINE=u */
#define ISJUMP(o) (OP_IFNEQJMP <= (o) && (o) <= OP_JMP)
#define RFIELDS_PER_FLUSH 32 /* records (SETMAP) */
#define LFIELDS_PER_FLUSH 64 /* FPF - lists (SETLIST) (<=MAXARG_B) */
/*
** we use int to manipulte most arguments, so they must fit
*/
#if MAXARG_U > MAX_INT
#undef MAXARG_U
#define MAXARG_U MAX_INT
#endif
#if MAXARG_S > MAX_INT
#undef MAXARG_S
#define MAXARG_S MAX_INT
#endif
#if MAXARG_A > MAX_INT
#undef MAXARG_A
#define MAXARG_A MAX_INT
#endif
#if MAXARG_B > MAX_INT
#undef MAXARG_B
#define MAXARG_B MAX_INT
#endif
#endif

View File

@ -1,5 +1,5 @@
/*
** $Id: lparser.c,v 1.71 2000/03/20 19:15:37 roberto Exp roberto $
** $Id: lparser.c,v 1.72 2000/03/24 12:17:53 roberto Exp roberto $
** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h
*/
@ -22,17 +22,6 @@
#include "lstring.h"
/*
** check whether arbitrary limits fit into respective opcode types
*/
#if MAXLOCALS > MAXARG_U || MAXUPVALUES > MAXARG_B || MAXVARSLH > MAXARG_B || \
MAXPARAMS > MAXLOCALS || MAXSTACK > MAXARG_A || \
LFIELDS_PER_FLUSH > MAXARG_B || MULT_RET > MAXARG_B
#error invalid limits
#endif
/*
** Constructors descriptor:
** `n' indicates number of elements, and `k' signals whether

View File

@ -1,5 +1,5 @@
/*
** $Id: lparser.h,v 1.12 2000/03/10 18:37:44 roberto Exp roberto $
** $Id: lparser.h,v 1.13 2000/03/13 20:37:16 roberto Exp roberto $
** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h
*/
@ -11,37 +11,6 @@
#include "lzio.h"
/* maximum number of local variables */
#ifndef MAXLOCALS
#define MAXLOCALS 200 /* arbitrary limit (<=MAXARG_B) */
#endif
/* maximum number of upvalues */
#ifndef MAXUPVALUES
#define MAXUPVALUES 32 /* arbitrary limit (<=MAXARG_B) */
#endif
/* maximum number of variables in the left side of an assignment */
#ifndef MAXVARSLH
#define MAXVARSLH 100 /* arbitrary limit (<=MAXARG_B) */
#endif
/* maximum number of parameters in a function */
#ifndef MAXPARAMS
#define MAXPARAMS 100 /* arbitrary limit (<=MAXLOCALS) */
#endif
/* maximum stack size in a function */
#ifndef MAXSTACK
#define MAXSTACK 256 /* arbitrary limit (<=MAXARG_A) */
#endif
/*
** Expression descriptor
*/