mirror of
https://github.com/lua/lua.git
synced 2026-07-29 01:19:06 +00:00
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
b9dde086db |
29
Makefile
Normal file
29
Makefile
Normal file
@@ -0,0 +1,29 @@
|
||||
OBJS= hash.o inout.o lex_yy.o opcode.o table.o y_tab.o lua.o iolib.o mathlib.o strlib.o
|
||||
|
||||
CFLAGS= -O2 -I.
|
||||
|
||||
T= lua
|
||||
|
||||
all: $T
|
||||
|
||||
$T: $(OBJS)
|
||||
$(CC) -o $@ $(OBJS) -lm
|
||||
|
||||
A=--------------------------------------------------------------------------
|
||||
test: $T
|
||||
@echo "$A"
|
||||
./$T sort.lua main
|
||||
@echo "$A"
|
||||
./$T globals.lua | sort | column
|
||||
@echo "$A"
|
||||
./$T array.lua
|
||||
@echo "$A"
|
||||
./$T save.lua
|
||||
@echo "$A"
|
||||
./$T test.lua retorno_multiplo norma
|
||||
|
||||
clean:
|
||||
rm -f $T $(OBJS) core core.*
|
||||
|
||||
diff:
|
||||
diff . fixed | grep -v ^Only
|
||||
22
README
Normal file
22
README
Normal file
@@ -0,0 +1,22 @@
|
||||
This is Lua 1.0. It was never publicly released. This code is a snapshot of
|
||||
the status of Lua on 28 Jul 1993. It is distributed for historical curiosity
|
||||
to celebrate 10 years of Lua and is hereby placed in the public domain.
|
||||
|
||||
There is no documentation, except the test programs. The manual for Lua 1.1
|
||||
probably works for this version as well.
|
||||
|
||||
The source files for the lexer and parser have been lost: all that is left is
|
||||
the output of lex and yacc. A grammar can be found inside y_tab.c in yyreds.
|
||||
|
||||
The code compiles and runs in RedHat 5.2 with gcc 2.7.2.3. It may not run in
|
||||
newer systems, because it assumes that stdin and stdout are constants, though
|
||||
ANSI C does not promise they are. If make fails, try using the fixed modules
|
||||
provided in the "fixed" directory. To see the differences (which are really
|
||||
quite minor), do "make diff".
|
||||
|
||||
To see Lua 1.0 in action, do "make test". (The last test raises an error on
|
||||
purpose.)
|
||||
|
||||
Enjoy!
|
||||
|
||||
-- The Lua team, lua@tecgraf.puc-rio.br
|
||||
15
array.lua
Normal file
15
array.lua
Normal file
@@ -0,0 +1,15 @@
|
||||
$debug
|
||||
|
||||
a = @()
|
||||
|
||||
i=0
|
||||
while i<10 do
|
||||
a[i] = i*i
|
||||
i=i+1
|
||||
end
|
||||
|
||||
r,v = next(a,nil)
|
||||
while r ~= nil do
|
||||
print ("array["..r.."] = "..v)
|
||||
r,v = next(a,r)
|
||||
end
|
||||
175
fallback.c
175
fallback.c
@@ -1,175 +0,0 @@
|
||||
/*
|
||||
** fallback.c
|
||||
** TecCGraf - PUC-Rio
|
||||
*/
|
||||
|
||||
char *rcs_fallback="$Id: fallback.c,v 1.22 1996/03/19 22:28:37 roberto Exp roberto $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mem.h"
|
||||
#include "fallback.h"
|
||||
#include "opcode.h"
|
||||
#include "lua.h"
|
||||
|
||||
|
||||
static void errorFB (void);
|
||||
static void indexFB (void);
|
||||
static void gettableFB (void);
|
||||
static void arithFB (void);
|
||||
static void concatFB (void);
|
||||
static void orderFB (void);
|
||||
static void GDFB (void);
|
||||
static void funcFB (void);
|
||||
|
||||
|
||||
/*
|
||||
** Warning: This list must be in the same order as the #define's
|
||||
*/
|
||||
struct FB luaI_fallBacks[] = {
|
||||
{"error", {LUA_T_CFUNCTION, {errorFB}}, 1, 0},
|
||||
{"index", {LUA_T_CFUNCTION, {indexFB}}, 2, 1},
|
||||
{"gettable", {LUA_T_CFUNCTION, {gettableFB}}, 2, 1},
|
||||
{"arith", {LUA_T_CFUNCTION, {arithFB}}, 3, 1},
|
||||
{"order", {LUA_T_CFUNCTION, {orderFB}}, 3, 1},
|
||||
{"concat", {LUA_T_CFUNCTION, {concatFB}}, 2, 1},
|
||||
{"settable", {LUA_T_CFUNCTION, {gettableFB}}, 3, 0},
|
||||
{"gc", {LUA_T_CFUNCTION, {GDFB}}, 1, 0},
|
||||
{"function", {LUA_T_CFUNCTION, {funcFB}}, -1, -1},
|
||||
/* no fixed number of params or results */
|
||||
{"getglobal", {LUA_T_CFUNCTION, {indexFB}}, 1, 1}
|
||||
/* same default behavior of index FB */
|
||||
};
|
||||
|
||||
#define N_FB (sizeof(luaI_fallBacks)/sizeof(struct FB))
|
||||
|
||||
void luaI_setfallback (void)
|
||||
{
|
||||
int i;
|
||||
char *name = lua_getstring(lua_getparam(1));
|
||||
lua_Object func = lua_getparam(2);
|
||||
if (name == NULL || !lua_isfunction(func))
|
||||
lua_error("incorrect argument to function `setfallback'");
|
||||
for (i=0; i<N_FB; i++)
|
||||
{
|
||||
if (strcmp(luaI_fallBacks[i].kind, name) == 0)
|
||||
{
|
||||
luaI_pushobject(&luaI_fallBacks[i].function);
|
||||
luaI_fallBacks[i].function = *luaI_Address(func);
|
||||
return;
|
||||
}
|
||||
}
|
||||
/* name not found */
|
||||
lua_error("incorrect argument to function `setfallback'");
|
||||
}
|
||||
|
||||
|
||||
static void errorFB (void)
|
||||
{
|
||||
lua_Object o = lua_getparam(1);
|
||||
if (lua_isstring(o))
|
||||
fprintf (stderr, "lua: %s\n", lua_getstring(o));
|
||||
else
|
||||
fprintf(stderr, "lua: unknown error\n");
|
||||
}
|
||||
|
||||
|
||||
static void indexFB (void)
|
||||
{
|
||||
lua_pushnil();
|
||||
}
|
||||
|
||||
|
||||
static void gettableFB (void)
|
||||
{
|
||||
lua_error("indexed expression not a table");
|
||||
}
|
||||
|
||||
|
||||
static void arithFB (void)
|
||||
{
|
||||
lua_error("unexpected type at conversion to number");
|
||||
}
|
||||
|
||||
static void concatFB (void)
|
||||
{
|
||||
lua_error("unexpected type at conversion to string");
|
||||
}
|
||||
|
||||
|
||||
static void orderFB (void)
|
||||
{
|
||||
lua_error("unexpected type at comparison");
|
||||
}
|
||||
|
||||
static void GDFB (void) { }
|
||||
|
||||
static void funcFB (void)
|
||||
{
|
||||
lua_error("call expression not a function");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Lock routines
|
||||
*/
|
||||
|
||||
static Object *lockArray = NULL;
|
||||
static int lockSize = 0;
|
||||
|
||||
int luaI_lock (Object *object)
|
||||
{
|
||||
int i;
|
||||
int oldSize;
|
||||
if (tag(object) == LUA_T_NIL)
|
||||
return -1; /* special lock ref for nil */
|
||||
for (i=0; i<lockSize; i++)
|
||||
if (tag(&lockArray[i]) == LUA_T_NIL)
|
||||
{
|
||||
lockArray[i] = *object;
|
||||
return i;
|
||||
}
|
||||
/* no more empty spaces */
|
||||
oldSize = lockSize;
|
||||
lockSize = growvector(&lockArray, lockSize, Object, lockEM, MAX_WORD);
|
||||
for (i=oldSize; i<lockSize; i++)
|
||||
tag(&lockArray[i]) = LUA_T_NIL;
|
||||
lockArray[oldSize] = *object;
|
||||
return oldSize;
|
||||
}
|
||||
|
||||
|
||||
void lua_unlock (int ref)
|
||||
{
|
||||
if (ref >= 0 && ref < lockSize)
|
||||
tag(&lockArray[ref]) = LUA_T_NIL;
|
||||
}
|
||||
|
||||
|
||||
Object *luaI_getlocked (int ref)
|
||||
{
|
||||
static Object nul = {LUA_T_NIL, {0}};
|
||||
if (ref >= 0 && ref < lockSize)
|
||||
return &lockArray[ref];
|
||||
else
|
||||
return &nul;
|
||||
}
|
||||
|
||||
|
||||
void luaI_travlock (int (*fn)(Object *))
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<lockSize; i++)
|
||||
fn(&lockArray[i]);
|
||||
}
|
||||
|
||||
|
||||
char *luaI_travfallbacks (int (*fn)(Object *))
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<N_FB; i++)
|
||||
if (fn(&luaI_fallBacks[i].function))
|
||||
return luaI_fallBacks[i].kind;
|
||||
return NULL;
|
||||
}
|
||||
35
fallback.h
35
fallback.h
@@ -1,35 +0,0 @@
|
||||
/*
|
||||
** $Id: fallback.h,v 1.10 1995/10/17 11:52:38 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef fallback_h
|
||||
#define fallback_h
|
||||
|
||||
#include "opcode.h"
|
||||
|
||||
extern struct FB {
|
||||
char *kind;
|
||||
Object function;
|
||||
int nParams;
|
||||
int nResults;
|
||||
} luaI_fallBacks[];
|
||||
|
||||
#define FB_ERROR 0
|
||||
#define FB_INDEX 1
|
||||
#define FB_GETTABLE 2
|
||||
#define FB_ARITH 3
|
||||
#define FB_ORDER 4
|
||||
#define FB_CONCAT 5
|
||||
#define FB_SETTABLE 6
|
||||
#define FB_GC 7
|
||||
#define FB_FUNCTION 8
|
||||
#define FB_GETGLOBAL 9
|
||||
|
||||
void luaI_setfallback (void);
|
||||
int luaI_lock (Object *object);
|
||||
Object *luaI_getlocked (int ref);
|
||||
void luaI_travlock (int (*fn)(Object *));
|
||||
char *luaI_travfallbacks (int (*fn)(Object *));
|
||||
|
||||
#endif
|
||||
|
||||
402
fixed/iolib.c
Normal file
402
fixed/iolib.c
Normal file
@@ -0,0 +1,402 @@
|
||||
/*
|
||||
** iolib.c
|
||||
** Input/output library to LUA
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#ifdef __GNUC__
|
||||
#include <floatingpoint.h>
|
||||
#endif
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
static FILE *in=NULL, *out=NULL;
|
||||
|
||||
/*
|
||||
** Open a file to read.
|
||||
** LUA interface:
|
||||
** status = readfrom (filename)
|
||||
** where:
|
||||
** status = 1 -> success
|
||||
** status = 0 -> error
|
||||
*/
|
||||
static void io_readfrom (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* restore standart input */
|
||||
{
|
||||
if (in != stdin)
|
||||
{
|
||||
fclose (in);
|
||||
in = stdin;
|
||||
}
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'readfrom`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
FILE *fp = fopen (lua_getstring(o),"r");
|
||||
if (fp == NULL)
|
||||
{
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (in != stdin) fclose (in);
|
||||
in = fp;
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Open a file to write.
|
||||
** LUA interface:
|
||||
** status = writeto (filename)
|
||||
** where:
|
||||
** status = 1 -> success
|
||||
** status = 0 -> error
|
||||
*/
|
||||
static void io_writeto (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* restore standart output */
|
||||
{
|
||||
if (out != stdout)
|
||||
{
|
||||
fclose (out);
|
||||
out = stdout;
|
||||
}
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'writeto`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
FILE *fp = fopen (lua_getstring(o),"w");
|
||||
if (fp == NULL)
|
||||
{
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (out != stdout) fclose (out);
|
||||
out = fp;
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read a variable. On error put nil on stack.
|
||||
** LUA interface:
|
||||
** variable = read ([format])
|
||||
**
|
||||
** O formato pode ter um dos seguintes especificadores:
|
||||
**
|
||||
** s ou S -> para string
|
||||
** f ou F, g ou G, e ou E -> para reais
|
||||
** i ou I -> para inteiros
|
||||
**
|
||||
** Estes especificadores podem vir seguidos de numero que representa
|
||||
** o numero de campos a serem lidos.
|
||||
*/
|
||||
static void io_read (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* free format */
|
||||
{
|
||||
int c;
|
||||
char s[256];
|
||||
while (isspace(c=fgetc(in)))
|
||||
;
|
||||
if (c == '\"')
|
||||
{
|
||||
if (fscanf (in, "%[^\"]\"", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else if (c == '\'')
|
||||
{
|
||||
if (fscanf (in, "%[^\']\'", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
char *ptr;
|
||||
double d;
|
||||
ungetc (c, in);
|
||||
if (fscanf (in, "%s", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
d = strtod (s, &ptr);
|
||||
if (!(*ptr))
|
||||
{
|
||||
lua_pushnumber (d);
|
||||
return;
|
||||
}
|
||||
}
|
||||
lua_pushstring (s);
|
||||
return;
|
||||
}
|
||||
else /* formatted */
|
||||
{
|
||||
char *e = lua_getstring(o);
|
||||
char t;
|
||||
int m=0;
|
||||
while (isspace(*e)) e++;
|
||||
t = *e++;
|
||||
while (isdigit(*e))
|
||||
m = m*10 + (*e++ - '0');
|
||||
|
||||
if (m > 0)
|
||||
{
|
||||
char f[80];
|
||||
char s[256];
|
||||
sprintf (f, "%%%ds", m);
|
||||
fscanf (in, f, s);
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i':
|
||||
{
|
||||
long int l;
|
||||
sscanf (s, "%ld", &l);
|
||||
lua_pushnumber(l);
|
||||
}
|
||||
break;
|
||||
case 'f': case 'g': case 'e':
|
||||
{
|
||||
float f;
|
||||
sscanf (s, "%f", &f);
|
||||
lua_pushnumber(f);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
lua_pushstring(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i':
|
||||
{
|
||||
long int l;
|
||||
fscanf (in, "%ld", &l);
|
||||
lua_pushnumber(l);
|
||||
}
|
||||
break;
|
||||
case 'f': case 'g': case 'e':
|
||||
{
|
||||
float f;
|
||||
fscanf (in, "%f", &f);
|
||||
lua_pushnumber(f);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char s[256];
|
||||
fscanf (in, "%s", s);
|
||||
lua_pushstring(s);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Write a variable. On error put 0 on stack, otherwise put 1.
|
||||
** LUA interface:
|
||||
** status = write (variable [,format])
|
||||
**
|
||||
** O formato pode ter um dos seguintes especificadores:
|
||||
**
|
||||
** s ou S -> para string
|
||||
** f ou F, g ou G, e ou E -> para reais
|
||||
** i ou I -> para inteiros
|
||||
**
|
||||
** Estes especificadores podem vir seguidos de:
|
||||
**
|
||||
** [?][m][.n]
|
||||
**
|
||||
** onde:
|
||||
** ? -> indica justificacao
|
||||
** < = esquerda
|
||||
** | = centro
|
||||
** > = direita (default)
|
||||
** m -> numero maximo de campos (se exceder estoura)
|
||||
** n -> indica precisao para
|
||||
** reais -> numero de casas decimais
|
||||
** inteiros -> numero minimo de digitos
|
||||
** string -> nao se aplica
|
||||
*/
|
||||
static char *buildformat (char *e, lua_Object o)
|
||||
{
|
||||
static char buffer[512];
|
||||
static char f[80];
|
||||
char *string = &buffer[255];
|
||||
char t, j='r';
|
||||
int m=0, n=0, l;
|
||||
while (isspace(*e)) e++;
|
||||
t = *e++;
|
||||
if (*e == '<' || *e == '|' || *e == '>') j = *e++;
|
||||
while (isdigit(*e))
|
||||
m = m*10 + (*e++ - '0');
|
||||
e++; /* skip point */
|
||||
while (isdigit(*e))
|
||||
n = n*10 + (*e++ - '0');
|
||||
|
||||
sprintf(f,"%%");
|
||||
if (j == '<' || j == '|') sprintf(strchr(f,0),"-");
|
||||
if (m != 0) sprintf(strchr(f,0),"%d", m);
|
||||
if (n != 0) sprintf(strchr(f,0),".%d", n);
|
||||
sprintf(strchr(f,0), "%c", t);
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i': t = 'i';
|
||||
sprintf (string, f, (long int)lua_getnumber(o));
|
||||
break;
|
||||
case 'f': case 'g': case 'e': t = 'f';
|
||||
sprintf (string, f, (float)lua_getnumber(o));
|
||||
break;
|
||||
case 's': t = 's';
|
||||
sprintf (string, f, lua_getstring(o));
|
||||
break;
|
||||
default: return "";
|
||||
}
|
||||
l = strlen(string);
|
||||
if (m!=0 && l>m)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<m; i++)
|
||||
string[i] = '*';
|
||||
string[i] = 0;
|
||||
}
|
||||
else if (m!=0 && j=='|')
|
||||
{
|
||||
int i=l-1;
|
||||
while (isspace(string[i])) i--;
|
||||
string -= (m-i) / 2;
|
||||
i=0;
|
||||
while (string[i]==0) string[i++] = ' ';
|
||||
string[l] = 0;
|
||||
}
|
||||
return string;
|
||||
}
|
||||
static void io_write (void)
|
||||
{
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
if (o1 == NULL) /* new line */
|
||||
{
|
||||
fprintf (out, "\n");
|
||||
lua_pushnumber(1);
|
||||
}
|
||||
else if (o2 == NULL) /* free format */
|
||||
{
|
||||
int status=0;
|
||||
if (lua_isnumber(o1))
|
||||
status = fprintf (out, "%g", lua_getnumber(o1));
|
||||
else if (lua_isstring(o1))
|
||||
status = fprintf (out, "%s", lua_getstring(o1));
|
||||
lua_pushnumber(status);
|
||||
}
|
||||
else /* formated */
|
||||
{
|
||||
if (!lua_isstring(o2))
|
||||
{
|
||||
lua_error ("incorrect format to function `write'");
|
||||
lua_pushnumber(0);
|
||||
return;
|
||||
}
|
||||
lua_pushnumber(fprintf (out, "%s", buildformat(lua_getstring(o2),o1)));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Execute a executable program using "sustem".
|
||||
** On error put 0 on stack, otherwise put 1.
|
||||
*/
|
||||
void io_execute (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL || !lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'execute`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
system(lua_getstring(o));
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
** Remove a file.
|
||||
** On error put 0 on stack, otherwise put 1.
|
||||
*/
|
||||
void io_remove (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL || !lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'execute`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (remove(lua_getstring(o)) == 0)
|
||||
lua_pushnumber (1);
|
||||
else
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
** Open io library
|
||||
*/
|
||||
void iolib_open (void)
|
||||
{
|
||||
in=stdin; out=stdout;
|
||||
lua_register ("readfrom", io_readfrom);
|
||||
lua_register ("writeto", io_writeto);
|
||||
lua_register ("read", io_read);
|
||||
lua_register ("write", io_write);
|
||||
lua_register ("execute", io_execute);
|
||||
lua_register ("remove", io_remove);
|
||||
}
|
||||
923
fixed/lex_yy.c
Normal file
923
fixed/lex_yy.c
Normal file
@@ -0,0 +1,923 @@
|
||||
# include "stdio.h"
|
||||
# define U(x) x
|
||||
# define NLSTATE yyprevious=YYNEWLINE
|
||||
# define BEGIN yybgin = yysvec + 1 +
|
||||
# define INITIAL 0
|
||||
# define YYLERR yysvec
|
||||
# define YYSTATE (yyestate-yysvec-1)
|
||||
# define YYOPTIM 1
|
||||
# define YYLMAX BUFSIZ
|
||||
# define output(c) putc(c,yyout)
|
||||
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
|
||||
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
|
||||
# define yymore() (yymorfg=1)
|
||||
# define ECHO fprintf(yyout, "%s",yytext)
|
||||
# define REJECT { nstr = yyreject(); goto yyfussy;}
|
||||
int yyleng; extern char yytext[];
|
||||
int yymorfg;
|
||||
extern char *yysptr, yysbuf[];
|
||||
int yytchar;
|
||||
FILE *yyin = {NULL}, *yyout = {NULL};
|
||||
extern int yylineno;
|
||||
struct yysvf {
|
||||
struct yywork *yystoff;
|
||||
struct yysvf *yyother;
|
||||
int *yystops;};
|
||||
struct yysvf *yyestate;
|
||||
extern struct yysvf yysvec[], *yybgin;
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "y_tab.h"
|
||||
|
||||
#undef input
|
||||
#undef unput
|
||||
|
||||
static Input input;
|
||||
static Unput unput;
|
||||
|
||||
void lua_setinput (Input fn)
|
||||
{
|
||||
input = fn;
|
||||
}
|
||||
|
||||
void lua_setunput (Unput fn)
|
||||
{
|
||||
unput = fn;
|
||||
}
|
||||
|
||||
char *lua_lasttext (void)
|
||||
{
|
||||
return yytext;
|
||||
}
|
||||
|
||||
# define YYNEWLINE 10
|
||||
yylex(){
|
||||
int nstr; extern int yyprevious;
|
||||
while((nstr = yylook()) >= 0)
|
||||
yyfussy: switch(nstr){
|
||||
case 0:
|
||||
if(yywrap()) return(0); break;
|
||||
case 1:
|
||||
;
|
||||
break;
|
||||
case 2:
|
||||
{yylval.vInt = 1; return DEBUG;}
|
||||
break;
|
||||
case 3:
|
||||
{yylval.vInt = 0; return DEBUG;}
|
||||
break;
|
||||
case 4:
|
||||
lua_linenumber++;
|
||||
break;
|
||||
case 5:
|
||||
;
|
||||
break;
|
||||
case 6:
|
||||
return LOCAL;
|
||||
break;
|
||||
case 7:
|
||||
return IF;
|
||||
break;
|
||||
case 8:
|
||||
return THEN;
|
||||
break;
|
||||
case 9:
|
||||
return ELSE;
|
||||
break;
|
||||
case 10:
|
||||
return ELSEIF;
|
||||
break;
|
||||
case 11:
|
||||
return WHILE;
|
||||
break;
|
||||
case 12:
|
||||
return DO;
|
||||
break;
|
||||
case 13:
|
||||
return REPEAT;
|
||||
break;
|
||||
case 14:
|
||||
return UNTIL;
|
||||
break;
|
||||
case 15:
|
||||
{
|
||||
yylval.vWord = lua_nfile-1;
|
||||
return FUNCTION;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
return END;
|
||||
break;
|
||||
case 17:
|
||||
return RETURN;
|
||||
break;
|
||||
case 18:
|
||||
return LOCAL;
|
||||
break;
|
||||
case 19:
|
||||
return NIL;
|
||||
break;
|
||||
case 20:
|
||||
return AND;
|
||||
break;
|
||||
case 21:
|
||||
return OR;
|
||||
break;
|
||||
case 22:
|
||||
return NOT;
|
||||
break;
|
||||
case 23:
|
||||
return NE;
|
||||
break;
|
||||
case 24:
|
||||
return LE;
|
||||
break;
|
||||
case 25:
|
||||
return GE;
|
||||
break;
|
||||
case 26:
|
||||
return CONC;
|
||||
break;
|
||||
case 27:
|
||||
case 28:
|
||||
{
|
||||
yylval.vWord = lua_findenclosedconstant (yytext);
|
||||
return STRING;
|
||||
}
|
||||
break;
|
||||
case 29:
|
||||
case 30:
|
||||
case 31:
|
||||
case 32:
|
||||
{
|
||||
yylval.vFloat = atof(yytext);
|
||||
return NUMBER;
|
||||
}
|
||||
break;
|
||||
case 33:
|
||||
{
|
||||
yylval.vWord = lua_findsymbol (yytext);
|
||||
return NAME;
|
||||
}
|
||||
break;
|
||||
case 34:
|
||||
return *yytext;
|
||||
break;
|
||||
case -1:
|
||||
break;
|
||||
default:
|
||||
fprintf(yyout,"bad switch yylook %d",nstr);
|
||||
} return(0); }
|
||||
/* end of yylex */
|
||||
int yyvstop[] = {
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
1,
|
||||
34,
|
||||
0,
|
||||
|
||||
4,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
29,
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
27,
|
||||
0,
|
||||
|
||||
28,
|
||||
0,
|
||||
|
||||
5,
|
||||
0,
|
||||
|
||||
26,
|
||||
0,
|
||||
|
||||
30,
|
||||
0,
|
||||
|
||||
29,
|
||||
0,
|
||||
|
||||
29,
|
||||
0,
|
||||
|
||||
24,
|
||||
0,
|
||||
|
||||
25,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
12,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
7,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
21,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
23,
|
||||
0,
|
||||
|
||||
29,
|
||||
30,
|
||||
0,
|
||||
|
||||
31,
|
||||
0,
|
||||
|
||||
20,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
16,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
19,
|
||||
33,
|
||||
0,
|
||||
|
||||
22,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
32,
|
||||
0,
|
||||
|
||||
9,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
8,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
31,
|
||||
32,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
6,
|
||||
18,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
14,
|
||||
33,
|
||||
0,
|
||||
|
||||
11,
|
||||
33,
|
||||
0,
|
||||
|
||||
10,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
13,
|
||||
33,
|
||||
0,
|
||||
|
||||
17,
|
||||
33,
|
||||
0,
|
||||
|
||||
2,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
15,
|
||||
33,
|
||||
0,
|
||||
|
||||
3,
|
||||
0,
|
||||
0};
|
||||
# define YYTYPE char
|
||||
struct yywork { YYTYPE verify, advance; } yycrank[] = {
|
||||
0,0, 0,0, 1,3, 0,0,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 1,4, 1,5,
|
||||
6,29, 4,28, 0,0, 0,0,
|
||||
0,0, 0,0, 7,31, 0,0,
|
||||
6,29, 6,29, 0,0, 0,0,
|
||||
0,0, 0,0, 7,31, 7,31,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 0,0, 1,6,
|
||||
4,28, 0,0, 0,0, 0,0,
|
||||
1,7, 0,0, 0,0, 0,0,
|
||||
1,3, 6,30, 1,8, 1,9,
|
||||
0,0, 1,10, 6,29, 7,31,
|
||||
8,33, 0,0, 6,29, 0,0,
|
||||
7,32, 0,0, 0,0, 6,29,
|
||||
7,31, 1,11, 0,0, 1,12,
|
||||
2,27, 7,31, 1,13, 11,39,
|
||||
12,40, 1,13, 26,56, 0,0,
|
||||
0,0, 2,8, 2,9, 0,0,
|
||||
6,29, 0,0, 0,0, 6,29,
|
||||
0,0, 0,0, 7,31, 0,0,
|
||||
0,0, 7,31, 0,0, 0,0,
|
||||
2,11, 0,0, 2,12, 0,0,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 1,14, 0,0,
|
||||
0,0, 1,15, 1,16, 1,17,
|
||||
0,0, 22,52, 1,18, 18,47,
|
||||
23,53, 1,19, 42,63, 1,20,
|
||||
1,21, 25,55, 14,42, 1,22,
|
||||
15,43, 1,23, 1,24, 16,44,
|
||||
1,25, 16,45, 17,46, 19,48,
|
||||
21,51, 2,14, 20,49, 1,26,
|
||||
2,15, 2,16, 2,17, 24,54,
|
||||
20,50, 2,18, 44,64, 45,65,
|
||||
2,19, 46,66, 2,20, 2,21,
|
||||
27,57, 48,67, 2,22, 49,68,
|
||||
2,23, 2,24, 50,69, 2,25,
|
||||
52,70, 53,72, 27,58, 54,73,
|
||||
52,71, 9,34, 2,26, 9,35,
|
||||
9,35, 9,35, 9,35, 9,35,
|
||||
9,35, 9,35, 9,35, 9,35,
|
||||
9,35, 10,36, 55,74, 10,37,
|
||||
10,37, 10,37, 10,37, 10,37,
|
||||
10,37, 10,37, 10,37, 10,37,
|
||||
10,37, 57,75, 58,76, 64,80,
|
||||
66,81, 67,82, 70,83, 71,84,
|
||||
72,85, 73,86, 74,87, 10,38,
|
||||
10,38, 38,61, 10,38, 38,61,
|
||||
75,88, 76,89, 38,62, 38,62,
|
||||
38,62, 38,62, 38,62, 38,62,
|
||||
38,62, 38,62, 38,62, 38,62,
|
||||
80,92, 81,93, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
82,94, 83,95, 84,96, 10,38,
|
||||
10,38, 86,97, 10,38, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 87,98, 88,99, 60,79,
|
||||
60,79, 13,41, 60,79, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 33,33, 89,100, 60,79,
|
||||
60,79, 92,101, 60,79, 93,102,
|
||||
95,103, 33,33, 33,0, 96,104,
|
||||
99,105, 100,106, 102,107, 106,108,
|
||||
107,109, 35,35, 35,35, 35,35,
|
||||
35,35, 35,35, 35,35, 35,35,
|
||||
35,35, 35,35, 35,35, 108,110,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 33,33, 0,0,
|
||||
0,0, 35,59, 35,59, 33,33,
|
||||
35,59, 0,0, 0,0, 33,33,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
33,33, 0,0, 0,0, 0,0,
|
||||
0,0, 36,60, 36,60, 36,60,
|
||||
36,60, 36,60, 36,60, 36,60,
|
||||
36,60, 36,60, 36,60, 0,0,
|
||||
0,0, 33,33, 0,0, 0,0,
|
||||
33,33, 35,59, 35,59, 0,0,
|
||||
35,59, 36,38, 36,38, 59,77,
|
||||
36,38, 59,77, 0,0, 0,0,
|
||||
59,78, 59,78, 59,78, 59,78,
|
||||
59,78, 59,78, 59,78, 59,78,
|
||||
59,78, 59,78, 61,62, 61,62,
|
||||
61,62, 61,62, 61,62, 61,62,
|
||||
61,62, 61,62, 61,62, 61,62,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 36,38, 36,38, 0,0,
|
||||
36,38, 77,78, 77,78, 77,78,
|
||||
77,78, 77,78, 77,78, 77,78,
|
||||
77,78, 77,78, 77,78, 79,90,
|
||||
0,0, 79,90, 0,0, 0,0,
|
||||
79,91, 79,91, 79,91, 79,91,
|
||||
79,91, 79,91, 79,91, 79,91,
|
||||
79,91, 79,91, 90,91, 90,91,
|
||||
90,91, 90,91, 90,91, 90,91,
|
||||
90,91, 90,91, 90,91, 90,91,
|
||||
0,0};
|
||||
struct yysvf yysvec[] = {
|
||||
0, 0, 0,
|
||||
yycrank+-1, 0, yyvstop+1,
|
||||
yycrank+-28, yysvec+1, yyvstop+3,
|
||||
yycrank+0, 0, yyvstop+5,
|
||||
yycrank+4, 0, yyvstop+7,
|
||||
yycrank+0, 0, yyvstop+10,
|
||||
yycrank+-11, 0, yyvstop+12,
|
||||
yycrank+-17, 0, yyvstop+14,
|
||||
yycrank+7, 0, yyvstop+16,
|
||||
yycrank+107, 0, yyvstop+18,
|
||||
yycrank+119, 0, yyvstop+20,
|
||||
yycrank+6, 0, yyvstop+23,
|
||||
yycrank+7, 0, yyvstop+25,
|
||||
yycrank+158, 0, yyvstop+27,
|
||||
yycrank+4, yysvec+13, yyvstop+30,
|
||||
yycrank+5, yysvec+13, yyvstop+33,
|
||||
yycrank+11, yysvec+13, yyvstop+36,
|
||||
yycrank+5, yysvec+13, yyvstop+39,
|
||||
yycrank+5, yysvec+13, yyvstop+42,
|
||||
yycrank+12, yysvec+13, yyvstop+45,
|
||||
yycrank+21, yysvec+13, yyvstop+48,
|
||||
yycrank+10, yysvec+13, yyvstop+51,
|
||||
yycrank+4, yysvec+13, yyvstop+54,
|
||||
yycrank+4, yysvec+13, yyvstop+57,
|
||||
yycrank+21, yysvec+13, yyvstop+60,
|
||||
yycrank+9, yysvec+13, yyvstop+63,
|
||||
yycrank+9, 0, yyvstop+66,
|
||||
yycrank+40, 0, yyvstop+68,
|
||||
yycrank+0, yysvec+4, yyvstop+70,
|
||||
yycrank+0, yysvec+6, 0,
|
||||
yycrank+0, 0, yyvstop+72,
|
||||
yycrank+0, yysvec+7, 0,
|
||||
yycrank+0, 0, yyvstop+74,
|
||||
yycrank+-280, 0, yyvstop+76,
|
||||
yycrank+0, 0, yyvstop+78,
|
||||
yycrank+249, 0, yyvstop+80,
|
||||
yycrank+285, 0, yyvstop+82,
|
||||
yycrank+0, yysvec+10, yyvstop+84,
|
||||
yycrank+146, 0, 0,
|
||||
yycrank+0, 0, yyvstop+86,
|
||||
yycrank+0, 0, yyvstop+88,
|
||||
yycrank+0, yysvec+13, yyvstop+90,
|
||||
yycrank+10, yysvec+13, yyvstop+92,
|
||||
yycrank+0, yysvec+13, yyvstop+94,
|
||||
yycrank+19, yysvec+13, yyvstop+97,
|
||||
yycrank+35, yysvec+13, yyvstop+99,
|
||||
yycrank+27, yysvec+13, yyvstop+101,
|
||||
yycrank+0, yysvec+13, yyvstop+103,
|
||||
yycrank+42, yysvec+13, yyvstop+106,
|
||||
yycrank+35, yysvec+13, yyvstop+108,
|
||||
yycrank+30, yysvec+13, yyvstop+110,
|
||||
yycrank+0, yysvec+13, yyvstop+112,
|
||||
yycrank+36, yysvec+13, yyvstop+115,
|
||||
yycrank+48, yysvec+13, yyvstop+117,
|
||||
yycrank+35, yysvec+13, yyvstop+119,
|
||||
yycrank+61, yysvec+13, yyvstop+121,
|
||||
yycrank+0, 0, yyvstop+123,
|
||||
yycrank+76, 0, 0,
|
||||
yycrank+67, 0, 0,
|
||||
yycrank+312, 0, 0,
|
||||
yycrank+183, yysvec+36, yyvstop+125,
|
||||
yycrank+322, 0, 0,
|
||||
yycrank+0, yysvec+61, yyvstop+128,
|
||||
yycrank+0, yysvec+13, yyvstop+130,
|
||||
yycrank+78, yysvec+13, yyvstop+133,
|
||||
yycrank+0, yysvec+13, yyvstop+135,
|
||||
yycrank+81, yysvec+13, yyvstop+138,
|
||||
yycrank+84, yysvec+13, yyvstop+140,
|
||||
yycrank+0, yysvec+13, yyvstop+142,
|
||||
yycrank+0, yysvec+13, yyvstop+145,
|
||||
yycrank+81, yysvec+13, yyvstop+148,
|
||||
yycrank+66, yysvec+13, yyvstop+150,
|
||||
yycrank+74, yysvec+13, yyvstop+152,
|
||||
yycrank+80, yysvec+13, yyvstop+154,
|
||||
yycrank+78, yysvec+13, yyvstop+156,
|
||||
yycrank+94, 0, 0,
|
||||
yycrank+93, 0, 0,
|
||||
yycrank+341, 0, 0,
|
||||
yycrank+0, yysvec+77, yyvstop+158,
|
||||
yycrank+356, 0, 0,
|
||||
yycrank+99, yysvec+13, yyvstop+160,
|
||||
yycrank+89, yysvec+13, yyvstop+163,
|
||||
yycrank+108, yysvec+13, yyvstop+165,
|
||||
yycrank+120, yysvec+13, yyvstop+167,
|
||||
yycrank+104, yysvec+13, yyvstop+169,
|
||||
yycrank+0, yysvec+13, yyvstop+171,
|
||||
yycrank+113, yysvec+13, yyvstop+174,
|
||||
yycrank+148, yysvec+13, yyvstop+176,
|
||||
yycrank+133, 0, 0,
|
||||
yycrank+181, 0, 0,
|
||||
yycrank+366, 0, 0,
|
||||
yycrank+0, yysvec+90, yyvstop+178,
|
||||
yycrank+183, yysvec+13, yyvstop+181,
|
||||
yycrank+182, yysvec+13, yyvstop+183,
|
||||
yycrank+0, yysvec+13, yyvstop+185,
|
||||
yycrank+172, yysvec+13, yyvstop+189,
|
||||
yycrank+181, yysvec+13, yyvstop+191,
|
||||
yycrank+0, yysvec+13, yyvstop+193,
|
||||
yycrank+0, yysvec+13, yyvstop+196,
|
||||
yycrank+189, 0, 0,
|
||||
yycrank+195, 0, 0,
|
||||
yycrank+0, yysvec+13, yyvstop+199,
|
||||
yycrank+183, yysvec+13, yyvstop+202,
|
||||
yycrank+0, yysvec+13, yyvstop+204,
|
||||
yycrank+0, yysvec+13, yyvstop+207,
|
||||
yycrank+0, 0, yyvstop+210,
|
||||
yycrank+178, 0, 0,
|
||||
yycrank+186, yysvec+13, yyvstop+212,
|
||||
yycrank+204, 0, 0,
|
||||
yycrank+0, yysvec+13, yyvstop+214,
|
||||
yycrank+0, 0, yyvstop+217,
|
||||
0, 0, 0};
|
||||
struct yywork *yytop = yycrank+423;
|
||||
struct yysvf *yybgin = yysvec+1;
|
||||
char yymatch[] = {
|
||||
00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
011 ,01 ,'"' ,01 ,01 ,01 ,01 ,047 ,
|
||||
01 ,01 ,01 ,'+' ,01 ,'+' ,01 ,01 ,
|
||||
'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
|
||||
'0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,'A' ,'A' ,'A' ,'D' ,'D' ,'A' ,'D' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,'A' ,
|
||||
01 ,'A' ,'A' ,'A' ,'D' ,'D' ,'A' ,'D' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 ,
|
||||
0};
|
||||
char yyextra[] = {
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0};
|
||||
#ifndef lint
|
||||
static char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
|
||||
#endif
|
||||
|
||||
int yylineno =1;
|
||||
# define YYU(x) x
|
||||
# define NLSTATE yyprevious=YYNEWLINE
|
||||
char yytext[YYLMAX];
|
||||
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
|
||||
char yysbuf[YYLMAX];
|
||||
char *yysptr = yysbuf;
|
||||
int *yyfnd;
|
||||
extern struct yysvf *yyestate;
|
||||
int yyprevious = YYNEWLINE;
|
||||
yylook(){
|
||||
register struct yysvf *yystate, **lsp;
|
||||
register struct yywork *yyt;
|
||||
struct yysvf *yyz;
|
||||
int yych, yyfirst;
|
||||
struct yywork *yyr;
|
||||
# ifdef LEXDEBUG
|
||||
int debug;
|
||||
# endif
|
||||
char *yylastch;
|
||||
/* start off machines */
|
||||
# ifdef LEXDEBUG
|
||||
debug = 0;
|
||||
# endif
|
||||
yyfirst=1;
|
||||
if (!yymorfg)
|
||||
yylastch = yytext;
|
||||
else {
|
||||
yymorfg=0;
|
||||
yylastch = yytext+yyleng;
|
||||
}
|
||||
for(;;){
|
||||
lsp = yylstate;
|
||||
yyestate = yystate = yybgin;
|
||||
if (yyprevious==YYNEWLINE) yystate++;
|
||||
for (;;){
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
|
||||
# endif
|
||||
yyt = yystate->yystoff;
|
||||
if(yyt == yycrank && !yyfirst){ /* may not be any transitions */
|
||||
yyz = yystate->yyother;
|
||||
if(yyz == 0)break;
|
||||
if(yyz->yystoff == yycrank)break;
|
||||
}
|
||||
*yylastch++ = yych = input();
|
||||
yyfirst=0;
|
||||
tryagain:
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"char ");
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
yyr = yyt;
|
||||
if ( (int)yyt > (int)yycrank){
|
||||
yyt = yyr + yych;
|
||||
if (yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
}
|
||||
# ifdef YYOPTIM
|
||||
else if((int)yyt < (int)yycrank) { /* r < yycrank */
|
||||
yyt = yyr = yycrank+(yycrank-yyt);
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"compressed state\n");
|
||||
# endif
|
||||
yyt = yyt + yych;
|
||||
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
yyt = yyr + YYU(yymatch[yych]);
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"try fall back character ");
|
||||
allprint(YYU(yymatch[yych]));
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transition */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
}
|
||||
if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
|
||||
# endif
|
||||
goto tryagain;
|
||||
}
|
||||
# endif
|
||||
else
|
||||
{unput(*--yylastch);break;}
|
||||
contin:
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"state %d char ",yystate-yysvec-1);
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
;
|
||||
}
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
while (lsp-- > yylstate){
|
||||
*yylastch-- = 0;
|
||||
if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
|
||||
yyolsp = lsp;
|
||||
if(yyextra[*yyfnd]){ /* must backup */
|
||||
while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
|
||||
lsp--;
|
||||
unput(*yylastch--);
|
||||
}
|
||||
}
|
||||
yyprevious = YYU(*yylastch);
|
||||
yylsp = lsp;
|
||||
yyleng = yylastch-yytext+1;
|
||||
yytext[yyleng] = 0;
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"\nmatch ");
|
||||
sprint(yytext);
|
||||
fprintf(yyout," action %d\n",*yyfnd);
|
||||
}
|
||||
# endif
|
||||
return(*yyfnd++);
|
||||
}
|
||||
unput(*yylastch);
|
||||
}
|
||||
if (yytext[0] == 0 /* && feof(yyin) */)
|
||||
{
|
||||
yysptr=yysbuf;
|
||||
return(0);
|
||||
}
|
||||
yyprevious = yytext[0] = input();
|
||||
if (yyprevious>0)
|
||||
output(yyprevious);
|
||||
yylastch=yytext;
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)putchar('\n');
|
||||
# endif
|
||||
}
|
||||
}
|
||||
yyback(p, m)
|
||||
int *p;
|
||||
{
|
||||
if (p==0) return(0);
|
||||
while (*p)
|
||||
{
|
||||
if (*p++ == m)
|
||||
return(1);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
/* the following are only used in the lex library */
|
||||
yyinput(){
|
||||
return(input());
|
||||
}
|
||||
yyoutput(c)
|
||||
int c; {
|
||||
output(c);
|
||||
}
|
||||
yyunput(c)
|
||||
int c; {
|
||||
unput(c);
|
||||
}
|
||||
55
fixed/lua.c
Normal file
55
fixed/lua.c
Normal file
@@ -0,0 +1,55 @@
|
||||
/*
|
||||
** lua.c
|
||||
** Linguagem para Usuarios de Aplicacao
|
||||
** TeCGraf - PUC-Rio
|
||||
** 28 Apr 93
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "lua.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
void test (void)
|
||||
{
|
||||
lua_pushobject(lua_getparam(1));
|
||||
lua_call ("c", 1);
|
||||
}
|
||||
|
||||
|
||||
static void callfunc (void)
|
||||
{
|
||||
lua_Object obj = lua_getparam (1);
|
||||
if (lua_isstring(obj)) lua_call(lua_getstring(obj),0);
|
||||
}
|
||||
|
||||
static void execstr (void)
|
||||
{
|
||||
lua_Object obj = lua_getparam (1);
|
||||
if (lua_isstring(obj)) lua_dostring(lua_getstring(obj));
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
if (argc < 2)
|
||||
{
|
||||
puts ("usage: lua filename [functionnames]");
|
||||
return;
|
||||
}
|
||||
lua_register ("callfunc", callfunc);
|
||||
lua_register ("execstr", execstr);
|
||||
lua_register ("test", test);
|
||||
iolib_open ();
|
||||
strlib_open ();
|
||||
mathlib_open ();
|
||||
lua_dofile (argv[1]);
|
||||
for (i=2; i<argc; i++)
|
||||
{
|
||||
lua_call (argv[i],0);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
1
floatingpoint.h
Normal file
1
floatingpoint.h
Normal file
@@ -0,0 +1 @@
|
||||
/* empty file to please silly code in iolib.c and opcode.c */
|
||||
156
func.c
156
func.c
@@ -1,156 +0,0 @@
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "luadebug.h"
|
||||
#include "table.h"
|
||||
#include "mem.h"
|
||||
#include "func.h"
|
||||
#include "opcode.h"
|
||||
|
||||
|
||||
static TFunc *function_root = NULL;
|
||||
static LocVar *currvars = NULL;
|
||||
static int numcurrvars = 0;
|
||||
static int maxcurrvars = 0;
|
||||
|
||||
|
||||
/*
|
||||
** Initialize TFunc struct
|
||||
*/
|
||||
void luaI_initTFunc (TFunc *f)
|
||||
{
|
||||
f->next = NULL;
|
||||
f->marked = 0;
|
||||
f->size = 0;
|
||||
f->code = NULL;
|
||||
f->lineDefined = 0;
|
||||
f->fileName = NULL;
|
||||
f->locvars = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
** Insert function in list for GC
|
||||
*/
|
||||
void luaI_insertfunction (TFunc *f)
|
||||
{
|
||||
lua_pack();
|
||||
f->next = function_root;
|
||||
function_root = f;
|
||||
f->marked = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Free function
|
||||
*/
|
||||
void luaI_freefunc (TFunc *f)
|
||||
{
|
||||
luaI_free (f->code);
|
||||
luaI_free (f->locvars);
|
||||
luaI_free (f);
|
||||
}
|
||||
|
||||
/*
|
||||
** Garbage collection function.
|
||||
** This function traverse the function list freeing unindexed functions
|
||||
*/
|
||||
Long luaI_funccollector (void)
|
||||
{
|
||||
TFunc *curr = function_root;
|
||||
TFunc *prev = NULL;
|
||||
Long counter = 0;
|
||||
while (curr)
|
||||
{
|
||||
TFunc *next = curr->next;
|
||||
if (!curr->marked)
|
||||
{
|
||||
if (prev == NULL)
|
||||
function_root = next;
|
||||
else
|
||||
prev->next = next;
|
||||
luaI_freefunc (curr);
|
||||
++counter;
|
||||
}
|
||||
else
|
||||
{
|
||||
curr->marked = 0;
|
||||
prev = curr;
|
||||
}
|
||||
curr = next;
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
||||
|
||||
void lua_funcinfo (lua_Object func, char **filename, int *linedefined)
|
||||
{
|
||||
Object *f = luaI_Address(func);
|
||||
if (f->tag == LUA_T_MARK || f->tag == LUA_T_FUNCTION)
|
||||
{
|
||||
*filename = f->value.tf->fileName;
|
||||
*linedefined = f->value.tf->lineDefined;
|
||||
}
|
||||
else if (f->tag == LUA_T_CMARK || f->tag == LUA_T_CFUNCTION)
|
||||
{
|
||||
*filename = "(C)";
|
||||
*linedefined = -1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Stores information to know that variable has been declared in given line
|
||||
*/
|
||||
void luaI_registerlocalvar (TaggedString *varname, int line)
|
||||
{
|
||||
if (numcurrvars >= maxcurrvars)
|
||||
maxcurrvars = growvector(&currvars, maxcurrvars, LocVar, "", MAX_WORD);
|
||||
currvars[numcurrvars].varname = varname;
|
||||
currvars[numcurrvars].line = line;
|
||||
numcurrvars++;
|
||||
}
|
||||
|
||||
/*
|
||||
** Stores information to know that variable has been out of scope in given line
|
||||
*/
|
||||
void luaI_unregisterlocalvar (int line)
|
||||
{
|
||||
luaI_registerlocalvar(NULL, line);
|
||||
}
|
||||
|
||||
/*
|
||||
** Copies "currvars" into a new area and store it in function header.
|
||||
** The values (varname = NULL, line = -1) signal the end of vector.
|
||||
*/
|
||||
void luaI_closelocalvars (TFunc *func)
|
||||
{
|
||||
func->locvars = newvector (numcurrvars+1, LocVar);
|
||||
memcpy (func->locvars, currvars, numcurrvars*sizeof(LocVar));
|
||||
func->locvars[numcurrvars].varname = NULL;
|
||||
func->locvars[numcurrvars].line = -1;
|
||||
numcurrvars = 0; /* prepares for next function */
|
||||
}
|
||||
|
||||
/*
|
||||
** Look for n-esim local variable at line "line" in function "func".
|
||||
** Returns NULL if not found.
|
||||
*/
|
||||
char *luaI_getlocalname (TFunc *func, int local_number, int line)
|
||||
{
|
||||
int count = 0;
|
||||
char *varname = NULL;
|
||||
LocVar *lv = func->locvars;
|
||||
if (lv == NULL)
|
||||
return NULL;
|
||||
for (; lv->line != -1 && lv->line < line; lv++)
|
||||
{
|
||||
if (lv->varname) /* register */
|
||||
{
|
||||
if (++count == local_number)
|
||||
varname = lv->varname->str;
|
||||
}
|
||||
else /* unregister */
|
||||
if (--count < local_number)
|
||||
varname = NULL;
|
||||
}
|
||||
return varname;
|
||||
}
|
||||
|
||||
44
func.h
44
func.h
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
** $Id: func.h,v 1.7 1996/03/08 12:04:04 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef func_h
|
||||
#define func_h
|
||||
|
||||
#include "types.h"
|
||||
#include "lua.h"
|
||||
#include "tree.h"
|
||||
|
||||
typedef struct LocVar
|
||||
{
|
||||
TaggedString *varname; /* NULL signals end of scope */
|
||||
int line;
|
||||
} LocVar;
|
||||
|
||||
|
||||
/*
|
||||
** Function Headers
|
||||
*/
|
||||
typedef struct TFunc
|
||||
{
|
||||
struct TFunc *next;
|
||||
int marked;
|
||||
int size;
|
||||
Byte *code;
|
||||
int lineDefined;
|
||||
char *fileName;
|
||||
LocVar *locvars;
|
||||
} TFunc;
|
||||
|
||||
Long luaI_funccollector (void);
|
||||
void luaI_insertfunction (TFunc *f);
|
||||
|
||||
void luaI_initTFunc (TFunc *f);
|
||||
void luaI_freefunc (TFunc *f);
|
||||
|
||||
void luaI_registerlocalvar (TaggedString *varname, int line);
|
||||
void luaI_unregisterlocalvar (int line);
|
||||
void luaI_closelocalvars (TFunc *func);
|
||||
char *luaI_getlocalname (TFunc *func, int local_number, int line);
|
||||
|
||||
#endif
|
||||
5
globals.lua
Normal file
5
globals.lua
Normal file
@@ -0,0 +1,5 @@
|
||||
k,v=nextvar(k)
|
||||
while k do
|
||||
print(k)
|
||||
k,v=nextvar(k)
|
||||
end
|
||||
437
hash.c
437
hash.c
@@ -1,275 +1,172 @@
|
||||
/*
|
||||
** hash.c
|
||||
** hash manager for lua
|
||||
** Luiz Henrique de Figueiredo - 17 Aug 90
|
||||
** Modified by Waldemar Celes Filho
|
||||
** 12 May 93
|
||||
*/
|
||||
|
||||
char *rcs_hash="$Id: hash.c,v 2.28 1996/02/12 18:32:40 roberto Exp roberto $";
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
#include "mem.h"
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "lua.h"
|
||||
|
||||
#define streq(s1,s2) (strcmp(s1,s2)==0)
|
||||
#define strneq(s1,s2) (strcmp(s1,s2)!=0)
|
||||
|
||||
#define new(s) ((s *)malloc(sizeof(s)))
|
||||
#define newvector(n,s) ((s *)calloc(n,sizeof(s)))
|
||||
|
||||
#define nhash(t) ((t)->nhash)
|
||||
#define nuse(t) ((t)->nuse)
|
||||
#define markarray(t) ((t)->mark)
|
||||
#define nodevector(t) ((t)->node)
|
||||
#define node(t,i) (&(t)->node[i])
|
||||
#define ref(n) (&(n)->ref)
|
||||
#define val(n) (&(n)->val)
|
||||
#define nodelist(t) ((t)->list)
|
||||
#define list(t,i) ((t)->list[i])
|
||||
#define ref_tag(n) (tag(&(n)->ref))
|
||||
#define ref_nvalue(n) (nvalue(&(n)->ref))
|
||||
#define ref_svalue(n) (svalue(&(n)->ref))
|
||||
|
||||
|
||||
#define REHASH_LIMIT 0.70 /* avoid more than this % full */
|
||||
|
||||
|
||||
static Hash *listhead = NULL;
|
||||
|
||||
|
||||
/* hash dimensions values */
|
||||
static Word dimensions[] =
|
||||
{3, 5, 7, 11, 23, 47, 97, 197, 397, 797, 1597, 3203, 6421,
|
||||
12853, 25717, 51437, 65521, 0}; /* 65521 == last prime < MAX_WORD */
|
||||
|
||||
Word luaI_redimension (Word nhash)
|
||||
static int head (Hash *t, Object *ref) /* hash function */
|
||||
{
|
||||
Word i;
|
||||
for (i=0; dimensions[i]!=0; i++)
|
||||
if (tag(ref) == T_NUMBER) return (((int)nvalue(ref))%nhash(t));
|
||||
else if (tag(ref) == T_STRING)
|
||||
{
|
||||
if (dimensions[i] > nhash)
|
||||
return dimensions[i];
|
||||
}
|
||||
lua_error("table overflow");
|
||||
return 0; /* to avoid warnings */
|
||||
}
|
||||
|
||||
static Word hashindex (Hash *t, Object *ref) /* hash function */
|
||||
{
|
||||
switch (tag(ref))
|
||||
{
|
||||
case LUA_T_NIL:
|
||||
lua_error ("unexpected type to index table");
|
||||
return -1; /* UNREACHEABLE */
|
||||
case LUA_T_NUMBER:
|
||||
return (((Word)nvalue(ref))%nhash(t));
|
||||
case LUA_T_STRING:
|
||||
return (Word)((tsvalue(ref)->hash)%nhash(t)); /* make it a valid index */
|
||||
case LUA_T_FUNCTION:
|
||||
return (((IntPoint)ref->value.tf)%nhash(t));
|
||||
case LUA_T_CFUNCTION:
|
||||
return (((IntPoint)fvalue(ref))%nhash(t));
|
||||
case LUA_T_ARRAY:
|
||||
return (((IntPoint)avalue(ref))%nhash(t));
|
||||
default: /* user data */
|
||||
return (((IntPoint)uvalue(ref))%nhash(t));
|
||||
}
|
||||
}
|
||||
|
||||
int lua_equalObj (Object *t1, Object *t2)
|
||||
{
|
||||
if (tag(t1) != tag(t2)) return 0;
|
||||
switch (tag(t1))
|
||||
int h;
|
||||
char *name = svalue(ref);
|
||||
for (h=0; *name!=0; name++) /* interpret name as binary number */
|
||||
{
|
||||
case LUA_T_NIL: return 1;
|
||||
case LUA_T_NUMBER: return nvalue(t1) == nvalue(t2);
|
||||
case LUA_T_STRING: return svalue(t1) == svalue(t2);
|
||||
case LUA_T_ARRAY: return avalue(t1) == avalue(t2);
|
||||
case LUA_T_FUNCTION: return t1->value.tf == t2->value.tf;
|
||||
case LUA_T_CFUNCTION: return fvalue(t1) == fvalue(t2);
|
||||
default: return uvalue(t1) == uvalue(t2);
|
||||
h <<= 8;
|
||||
h += (unsigned char) *name; /* avoid sign extension */
|
||||
h %= nhash(t); /* make it a valid index */
|
||||
}
|
||||
}
|
||||
|
||||
static Word present (Hash *t, Object *ref)
|
||||
{
|
||||
Word h = hashindex(t, ref);
|
||||
while (tag(ref(node(t, h))) != LUA_T_NIL)
|
||||
{
|
||||
if (lua_equalObj(ref, ref(node(t, h))))
|
||||
return h;
|
||||
h = (h+1) % nhash(t);
|
||||
return h;
|
||||
}
|
||||
else
|
||||
{
|
||||
lua_reportbug ("unexpected type to index table");
|
||||
return -1;
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Alloc a vector node
|
||||
*/
|
||||
static Node *hashnodecreate (Word nhash)
|
||||
static Node *present(Hash *t, Object *ref, int h)
|
||||
{
|
||||
Word i;
|
||||
Node *v = newvector (nhash, Node);
|
||||
for (i=0; i<nhash; i++)
|
||||
tag(ref(&v[i])) = LUA_T_NIL;
|
||||
return v;
|
||||
Node *n=NULL, *p;
|
||||
if (tag(ref) == T_NUMBER)
|
||||
{
|
||||
for (p=NULL,n=list(t,h); n!=NULL; p=n, n=n->next)
|
||||
if (ref_tag(n) == T_NUMBER && nvalue(ref) == ref_nvalue(n)) break;
|
||||
}
|
||||
else if (tag(ref) == T_STRING)
|
||||
{
|
||||
for (p=NULL,n=list(t,h); n!=NULL; p=n, n=n->next)
|
||||
if (ref_tag(n) == T_STRING && streq(svalue(ref),ref_svalue(n))) break;
|
||||
}
|
||||
if (n==NULL) /* name not present */
|
||||
return NULL;
|
||||
#if 0
|
||||
if (p!=NULL) /* name present but not first */
|
||||
{
|
||||
p->next=n->next; /* move-to-front self-organization */
|
||||
n->next=list(t,h);
|
||||
list(t,h)=n;
|
||||
}
|
||||
#endif
|
||||
return n;
|
||||
}
|
||||
|
||||
static void freelist (Node *n)
|
||||
{
|
||||
while (n)
|
||||
{
|
||||
Node *next = n->next;
|
||||
free (n);
|
||||
n = next;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Create a new hash. Return the hash pointer or NULL on error.
|
||||
*/
|
||||
static Hash *hashcreate (Word nhash)
|
||||
Hash *lua_hashcreate (unsigned int nhash)
|
||||
{
|
||||
Hash *t = new(Hash);
|
||||
nhash = luaI_redimension((Word)((float)nhash/REHASH_LIMIT));
|
||||
nodevector(t) = hashnodecreate(nhash);
|
||||
Hash *t = new (Hash);
|
||||
if (t == NULL)
|
||||
{
|
||||
lua_error ("not enough memory");
|
||||
return NULL;
|
||||
}
|
||||
nhash(t) = nhash;
|
||||
nuse(t) = 0;
|
||||
markarray(t) = 0;
|
||||
nodelist(t) = newvector (nhash, Node*);
|
||||
if (nodelist(t) == NULL)
|
||||
{
|
||||
lua_error ("not enough memory");
|
||||
return NULL;
|
||||
}
|
||||
return t;
|
||||
}
|
||||
|
||||
/*
|
||||
** Delete a hash
|
||||
*/
|
||||
static void hashdelete (Hash *t)
|
||||
void lua_hashdelete (Hash *h)
|
||||
{
|
||||
luaI_free (nodevector(t));
|
||||
luaI_free(t);
|
||||
int i;
|
||||
for (i=0; i<nhash(h); i++)
|
||||
freelist (list(h,i));
|
||||
free (nodelist(h));
|
||||
free(h);
|
||||
}
|
||||
|
||||
/*
|
||||
** If the hash node is present, return its pointer, otherwise create a new
|
||||
** node for the given reference and also return its pointer.
|
||||
** On error, return NULL.
|
||||
*/
|
||||
Object *lua_hashdefine (Hash *t, Object *ref)
|
||||
{
|
||||
int h;
|
||||
Node *n;
|
||||
h = head (t, ref);
|
||||
if (h < 0) return NULL;
|
||||
|
||||
n = present(t, ref, h);
|
||||
if (n == NULL)
|
||||
{
|
||||
n = new(Node);
|
||||
if (n == NULL)
|
||||
{
|
||||
lua_error ("not enough memory");
|
||||
return NULL;
|
||||
}
|
||||
n->ref = *ref;
|
||||
tag(&n->val) = T_NIL;
|
||||
n->next = list(t,h); /* link node to head of list */
|
||||
list(t,h) = n;
|
||||
}
|
||||
return (&n->val);
|
||||
}
|
||||
|
||||
/*
|
||||
** Mark a hash and check its elements
|
||||
*/
|
||||
void lua_hashmark (Hash *h)
|
||||
{
|
||||
if (markarray(h) == 0)
|
||||
{
|
||||
Word i;
|
||||
markarray(h) = 1;
|
||||
for (i=0; i<nhash(h); i++)
|
||||
{
|
||||
Node *n = node(h,i);
|
||||
if (tag(ref(n)) != LUA_T_NIL)
|
||||
{
|
||||
lua_markobject(&n->ref);
|
||||
lua_markobject(&n->val);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void call_fallbacks (void)
|
||||
{
|
||||
Hash *curr_array;
|
||||
Object t;
|
||||
tag(&t) = LUA_T_ARRAY;
|
||||
for (curr_array = listhead; curr_array; curr_array = curr_array->next)
|
||||
if (markarray(curr_array) != 1)
|
||||
{
|
||||
avalue(&t) = curr_array;
|
||||
luaI_gcFB(&t);
|
||||
}
|
||||
tag(&t) = LUA_T_NIL;
|
||||
luaI_gcFB(&t); /* end of list */
|
||||
}
|
||||
|
||||
int i;
|
||||
|
||||
/*
|
||||
** Garbage collection to arrays
|
||||
** Delete all unmarked arrays.
|
||||
*/
|
||||
Long lua_hashcollector (void)
|
||||
{
|
||||
Hash *curr_array = listhead, *prev = NULL;
|
||||
Long counter = 0;
|
||||
call_fallbacks();
|
||||
while (curr_array != NULL)
|
||||
markarray(h) = 1;
|
||||
|
||||
for (i=0; i<nhash(h); i++)
|
||||
{
|
||||
Hash *next = curr_array->next;
|
||||
if (markarray(curr_array) != 1)
|
||||
Node *n;
|
||||
for (n = list(h,i); n != NULL; n = n->next)
|
||||
{
|
||||
if (prev == NULL) listhead = next;
|
||||
else prev->next = next;
|
||||
hashdelete(curr_array);
|
||||
++counter;
|
||||
lua_markobject (&n->ref);
|
||||
lua_markobject (&n->val);
|
||||
}
|
||||
else
|
||||
{
|
||||
markarray(curr_array) = 0;
|
||||
prev = curr_array;
|
||||
}
|
||||
curr_array = next;
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Create a new array
|
||||
** This function inserts the new array in the array list. It also
|
||||
** executes garbage collection if the number of arrays created
|
||||
** exceed a pre-defined range.
|
||||
*/
|
||||
Hash *lua_createarray (Word nhash)
|
||||
{
|
||||
Hash *array;
|
||||
lua_pack();
|
||||
array = hashcreate(nhash);
|
||||
array->next = listhead;
|
||||
listhead = array;
|
||||
return array;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Re-hash
|
||||
*/
|
||||
static void rehash (Hash *t)
|
||||
{
|
||||
Word i;
|
||||
Word nold = nhash(t);
|
||||
Node *vold = nodevector(t);
|
||||
nhash(t) = luaI_redimension(nhash(t));
|
||||
nodevector(t) = hashnodecreate(nhash(t));
|
||||
for (i=0; i<nold; i++)
|
||||
{
|
||||
Node *n = vold+i;
|
||||
if (tag(ref(n)) != LUA_T_NIL && tag(val(n)) != LUA_T_NIL)
|
||||
*node(t, present(t, ref(n))) = *n; /* copy old node to new hahs */
|
||||
}
|
||||
luaI_free(vold);
|
||||
}
|
||||
|
||||
/*
|
||||
** If the hash node is present, return its pointer, otherwise return
|
||||
** null.
|
||||
*/
|
||||
Object *lua_hashget (Hash *t, Object *ref)
|
||||
{
|
||||
Word h = present(t, ref);
|
||||
if (tag(ref(node(t, h))) != LUA_T_NIL) return val(node(t, h));
|
||||
else return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** If the hash node is present, return its pointer, otherwise create a new
|
||||
** node for the given reference and also return its pointer.
|
||||
*/
|
||||
Object *lua_hashdefine (Hash *t, Object *ref)
|
||||
{
|
||||
Word h;
|
||||
Node *n;
|
||||
h = present(t, ref);
|
||||
n = node(t, h);
|
||||
if (tag(ref(n)) == LUA_T_NIL)
|
||||
{
|
||||
nuse(t)++;
|
||||
if ((float)nuse(t) > (float)nhash(t)*REHASH_LIMIT)
|
||||
{
|
||||
rehash(t);
|
||||
h = present(t, ref);
|
||||
n = node(t, h);
|
||||
}
|
||||
*ref(n) = *ref;
|
||||
tag(val(n)) = LUA_T_NIL;
|
||||
}
|
||||
return (val(n));
|
||||
}
|
||||
|
||||
|
||||
@@ -279,44 +176,84 @@ Object *lua_hashdefine (Hash *t, Object *ref)
|
||||
** in the hash.
|
||||
** This function pushs the element value and its reference to the stack.
|
||||
*/
|
||||
static void hashnext (Hash *t, Word i)
|
||||
#include "lua.h"
|
||||
static void firstnode (Hash *a, int h)
|
||||
{
|
||||
if (i >= nhash(t))
|
||||
{
|
||||
lua_pushnil(); lua_pushnil();
|
||||
return;
|
||||
}
|
||||
while (tag(ref(node(t,i))) == LUA_T_NIL || tag(val(node(t,i))) == LUA_T_NIL)
|
||||
{
|
||||
if (++i >= nhash(t))
|
||||
if (h < nhash(a))
|
||||
{
|
||||
int i;
|
||||
for (i=h; i<nhash(a); i++)
|
||||
{
|
||||
lua_pushnil(); lua_pushnil();
|
||||
return;
|
||||
if (list(a,i) != NULL && tag(&list(a,i)->val) != T_NIL)
|
||||
{
|
||||
lua_pushobject (&list(a,i)->ref);
|
||||
lua_pushobject (&list(a,i)->val);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
luaI_pushobject(ref(node(t,i)));
|
||||
luaI_pushobject(val(node(t,i)));
|
||||
lua_pushnil();
|
||||
lua_pushnil();
|
||||
}
|
||||
|
||||
void lua_next (void)
|
||||
{
|
||||
Hash *t;
|
||||
lua_Object o = lua_getparam(1);
|
||||
lua_Object r = lua_getparam(2);
|
||||
if (o == LUA_NOOBJECT || r == LUA_NOOBJECT)
|
||||
lua_error ("too few arguments to function `next'");
|
||||
if (lua_getparam(3) != LUA_NOOBJECT)
|
||||
lua_error ("too many arguments to function `next'");
|
||||
if (!lua_istable(o))
|
||||
lua_error ("first argument of function `next' is not a table");
|
||||
t = avalue(luaI_Address(o));
|
||||
if (lua_isnil(r))
|
||||
Hash *a;
|
||||
Object *o = lua_getparam (1);
|
||||
Object *r = lua_getparam (2);
|
||||
if (o == NULL || r == NULL)
|
||||
{ lua_error ("too few arguments to function `next'"); return; }
|
||||
if (lua_getparam (3) != NULL)
|
||||
{ lua_error ("too many arguments to function `next'"); return; }
|
||||
if (tag(o) != T_ARRAY)
|
||||
{ lua_error ("first argument of function `next' is not a table"); return; }
|
||||
a = avalue(o);
|
||||
if (tag(r) == T_NIL)
|
||||
{
|
||||
hashnext(t, 0);
|
||||
firstnode (a, 0);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
Word h = present (t, luaI_Address(r));
|
||||
hashnext(t, h+1);
|
||||
int h = head (a, r);
|
||||
if (h >= 0)
|
||||
{
|
||||
Node *n = list(a,h);
|
||||
while (n)
|
||||
{
|
||||
if (memcmp(&n->ref,r,sizeof(Object)) == 0)
|
||||
{
|
||||
if (n->next == NULL)
|
||||
{
|
||||
firstnode (a, h+1);
|
||||
return;
|
||||
}
|
||||
else if (tag(&n->next->val) != T_NIL)
|
||||
{
|
||||
lua_pushobject (&n->next->ref);
|
||||
lua_pushobject (&n->next->val);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
Node *next = n->next->next;
|
||||
while (next != NULL && tag(&next->val) == T_NIL) next = next->next;
|
||||
if (next == NULL)
|
||||
{
|
||||
firstnode (a, h+1);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
lua_pushobject (&next->ref);
|
||||
lua_pushobject (&next->val);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
n = n->next;
|
||||
}
|
||||
if (n == NULL)
|
||||
lua_error ("error in function 'next': reference not found");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
25
hash.h
25
hash.h
@@ -1,38 +1,35 @@
|
||||
/*
|
||||
** hash.h
|
||||
** hash manager for lua
|
||||
** $Id: hash.h,v 2.10 1996/02/12 18:32:40 roberto Exp roberto $
|
||||
** Luiz Henrique de Figueiredo - 17 Aug 90
|
||||
** Modified by Waldemar Celes Filho
|
||||
** 26 Apr 93
|
||||
*/
|
||||
|
||||
#ifndef hash_h
|
||||
#define hash_h
|
||||
|
||||
#include "types.h"
|
||||
#include "opcode.h"
|
||||
|
||||
typedef struct node
|
||||
{
|
||||
Object ref;
|
||||
Object val;
|
||||
struct node *next;
|
||||
} Node;
|
||||
|
||||
typedef struct Hash
|
||||
{
|
||||
struct Hash *next;
|
||||
char mark;
|
||||
Word nhash;
|
||||
Word nuse;
|
||||
Node *node;
|
||||
unsigned int nhash;
|
||||
Node **list;
|
||||
} Hash;
|
||||
|
||||
#define markarray(t) ((t)->mark)
|
||||
|
||||
int lua_equalObj (Object *t1, Object *t2);
|
||||
Word luaI_redimension (Word nhash);
|
||||
Hash *lua_createarray (Word nhash);
|
||||
void lua_hashmark (Hash *h);
|
||||
Long lua_hashcollector (void);
|
||||
Object *lua_hashget (Hash *t, Object *ref);
|
||||
Hash *lua_hashcreate (unsigned int nhash);
|
||||
void lua_hashdelete (Hash *h);
|
||||
Object *lua_hashdefine (Hash *t, Object *ref);
|
||||
void lua_hashmark (Hash *h);
|
||||
|
||||
void lua_next (void);
|
||||
|
||||
#endif
|
||||
|
||||
288
inout.c
288
inout.c
@@ -2,36 +2,59 @@
|
||||
** inout.c
|
||||
** Provide function to realise the input/output function and debugger
|
||||
** facilities.
|
||||
** Also provides some predefined lua functions.
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 11 May 93
|
||||
*/
|
||||
|
||||
char *rcs_inout="$Id: inout.c,v 2.35 1996/03/19 16:50:24 roberto Exp roberto $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lex.h"
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "tree.h"
|
||||
#include "lua.h"
|
||||
#include "mem.h"
|
||||
|
||||
|
||||
/* Exported variables */
|
||||
Word lua_linenumber;
|
||||
char *lua_parsedfile;
|
||||
int lua_linenumber;
|
||||
int lua_debug;
|
||||
int lua_debugline;
|
||||
|
||||
/* Internal variables */
|
||||
#ifndef MAXFUNCSTACK
|
||||
#define MAXFUNCSTACK 32
|
||||
#endif
|
||||
static struct { int file; int function; } funcstack[MAXFUNCSTACK];
|
||||
static int nfuncstack=0;
|
||||
|
||||
static FILE *fp;
|
||||
static char *st;
|
||||
static void (*usererror) (char *s);
|
||||
|
||||
/*
|
||||
** Function to set user function to handle errors.
|
||||
*/
|
||||
void lua_errorfunction (void (*fn) (char *s))
|
||||
{
|
||||
usererror = fn;
|
||||
}
|
||||
|
||||
/*
|
||||
** Function to get the next character from the input file
|
||||
*/
|
||||
static int fileinput (void)
|
||||
{
|
||||
return fgetc (fp);
|
||||
int c = fgetc (fp);
|
||||
return (c == EOF ? 0 : c);
|
||||
}
|
||||
|
||||
/*
|
||||
** Function to unget the next character from to input file
|
||||
*/
|
||||
static void fileunput (int c)
|
||||
{
|
||||
ungetc (c, fp);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -39,28 +62,31 @@ static int fileinput (void)
|
||||
*/
|
||||
static int stringinput (void)
|
||||
{
|
||||
return *st++;
|
||||
st++;
|
||||
return (*(st-1));
|
||||
}
|
||||
|
||||
/*
|
||||
** Function to unget the next character from to input string
|
||||
*/
|
||||
static void stringunput (int c)
|
||||
{
|
||||
st--;
|
||||
}
|
||||
|
||||
/*
|
||||
** Function to open a file to be input unit.
|
||||
** Return the file.
|
||||
** Return 0 on success or 1 on error.
|
||||
*/
|
||||
FILE *lua_openfile (char *fn)
|
||||
int lua_openfile (char *fn)
|
||||
{
|
||||
lua_setinput (fileinput);
|
||||
if (fn == NULL)
|
||||
{
|
||||
fp = stdin;
|
||||
fn = "(stdin)";
|
||||
}
|
||||
else
|
||||
fp = fopen (fn, "r");
|
||||
if (fp == NULL)
|
||||
return NULL;
|
||||
lua_linenumber = 1;
|
||||
lua_parsedfile = luaI_createfixedstring(fn)->str;
|
||||
return fp;
|
||||
lua_setinput (fileinput);
|
||||
lua_setunput (fileunput);
|
||||
fp = fopen (fn, "r");
|
||||
if (fp == NULL) return 1;
|
||||
if (lua_addfile (fn)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -68,7 +94,7 @@ FILE *lua_openfile (char *fn)
|
||||
*/
|
||||
void lua_closefile (void)
|
||||
{
|
||||
if (fp != NULL && fp != stdin)
|
||||
if (fp != NULL)
|
||||
{
|
||||
fclose (fp);
|
||||
fp = NULL;
|
||||
@@ -78,169 +104,85 @@ void lua_closefile (void)
|
||||
/*
|
||||
** Function to open a string to be input unit
|
||||
*/
|
||||
void lua_openstring (char *s)
|
||||
int lua_openstring (char *s)
|
||||
{
|
||||
lua_setinput (stringinput);
|
||||
st = s;
|
||||
lua_linenumber = 1;
|
||||
lua_parsedfile = luaI_createfixedstring("(string)")->str;
|
||||
lua_setinput (stringinput);
|
||||
lua_setunput (stringunput);
|
||||
st = s;
|
||||
{
|
||||
char sn[64];
|
||||
sprintf (sn, "String: %10.10s...", s);
|
||||
if (lua_addfile (sn)) return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
** Function to close an opened string
|
||||
** Call user function to handle error messages, if registred. Or report error
|
||||
** using standard function (fprintf).
|
||||
*/
|
||||
void lua_closestring (void)
|
||||
void lua_error (char *s)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Internal function: do a string
|
||||
*/
|
||||
void lua_internaldostring (void)
|
||||
{
|
||||
lua_Object obj = lua_getparam (1);
|
||||
if (lua_isstring(obj) && !lua_dostring(lua_getstring(obj)))
|
||||
lua_pushnumber(1);
|
||||
else
|
||||
lua_pushnil();
|
||||
if (usererror != NULL) usererror (s);
|
||||
else fprintf (stderr, "lua: %s\n", s);
|
||||
}
|
||||
|
||||
/*
|
||||
** Internal function: do a file
|
||||
** Called to execute SETFUNCTION opcode, this function pushs a function into
|
||||
** function stack. Return 0 on success or 1 on error.
|
||||
*/
|
||||
void lua_internaldofile (void)
|
||||
int lua_pushfunction (int file, int function)
|
||||
{
|
||||
lua_Object obj = lua_getparam (1);
|
||||
char *fname = NULL;
|
||||
if (lua_isstring(obj))
|
||||
fname = lua_getstring(obj);
|
||||
else if (obj != LUA_NOOBJECT)
|
||||
lua_error("invalid argument to function `dofile'");
|
||||
/* else fname = NULL */
|
||||
if (!lua_dofile(fname))
|
||||
lua_pushnumber(1);
|
||||
else
|
||||
lua_pushnil();
|
||||
if (nfuncstack >= MAXFUNCSTACK-1)
|
||||
{
|
||||
lua_error ("function stack overflow");
|
||||
return 1;
|
||||
}
|
||||
funcstack[nfuncstack].file = file;
|
||||
funcstack[nfuncstack].function = function;
|
||||
nfuncstack++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static char *tostring (lua_Object obj)
|
||||
/*
|
||||
** Called to execute RESET opcode, this function pops a function from
|
||||
** function stack.
|
||||
*/
|
||||
void lua_popfunction (void)
|
||||
{
|
||||
char *buff = luaI_buffer(20);
|
||||
if (lua_isstring(obj)) /* get strings and numbers */
|
||||
return lua_getstring(obj);
|
||||
else switch(lua_type(obj))
|
||||
nfuncstack--;
|
||||
}
|
||||
|
||||
/*
|
||||
** Report bug building a message and sending it to lua_error function.
|
||||
*/
|
||||
void lua_reportbug (char *s)
|
||||
{
|
||||
char msg[1024];
|
||||
strcpy (msg, s);
|
||||
if (lua_debugline != 0)
|
||||
{
|
||||
int i;
|
||||
if (nfuncstack > 0)
|
||||
{
|
||||
case LUA_T_FUNCTION:
|
||||
sprintf(buff, "function: %p", (luaI_Address(obj))->value.tf);
|
||||
break;
|
||||
case LUA_T_CFUNCTION:
|
||||
sprintf(buff, "cfunction: %p", lua_getcfunction(obj));
|
||||
break;
|
||||
case LUA_T_ARRAY:
|
||||
sprintf(buff, "table: %p", avalue(luaI_Address(obj)));
|
||||
break;
|
||||
case LUA_T_NIL:
|
||||
sprintf(buff, "nil");
|
||||
break;
|
||||
default:
|
||||
sprintf(buff, "userdata: %p", lua_getuserdata(obj));
|
||||
break;
|
||||
sprintf (strchr(msg,0),
|
||||
"\n\tin statement begining at line %d in function \"%s\" of file \"%s\"",
|
||||
lua_debugline, s_name(funcstack[nfuncstack-1].function),
|
||||
lua_file[funcstack[nfuncstack-1].file]);
|
||||
sprintf (strchr(msg,0), "\n\tactive stack\n");
|
||||
for (i=nfuncstack-1; i>=0; i--)
|
||||
sprintf (strchr(msg,0), "\t-> function \"%s\" of file \"%s\"\n",
|
||||
s_name(funcstack[i].function),
|
||||
lua_file[funcstack[i].file]);
|
||||
}
|
||||
return buff;
|
||||
}
|
||||
|
||||
void luaI_tostring (void)
|
||||
{
|
||||
lua_pushstring(tostring(lua_getparam(1)));
|
||||
}
|
||||
|
||||
void luaI_print (void)
|
||||
{
|
||||
int i = 1;
|
||||
lua_Object obj;
|
||||
while ((obj = lua_getparam(i++)) != LUA_NOOBJECT)
|
||||
printf("%s\n", tostring(obj));
|
||||
}
|
||||
|
||||
/*
|
||||
** Internal function: return an object type.
|
||||
*/
|
||||
void luaI_type (void)
|
||||
{
|
||||
lua_Object o = lua_getparam(1);
|
||||
int t;
|
||||
if (o == LUA_NOOBJECT)
|
||||
lua_error("no parameter to function 'type'");
|
||||
t = lua_type(o);
|
||||
switch (t)
|
||||
{
|
||||
case LUA_T_NIL :
|
||||
lua_pushliteral("nil");
|
||||
break;
|
||||
case LUA_T_NUMBER :
|
||||
lua_pushliteral("number");
|
||||
break;
|
||||
case LUA_T_STRING :
|
||||
lua_pushliteral("string");
|
||||
break;
|
||||
case LUA_T_ARRAY :
|
||||
lua_pushliteral("table");
|
||||
break;
|
||||
case LUA_T_FUNCTION :
|
||||
case LUA_T_CFUNCTION :
|
||||
lua_pushliteral("function");
|
||||
break;
|
||||
default :
|
||||
lua_pushliteral("userdata");
|
||||
break;
|
||||
}
|
||||
lua_pushnumber(t);
|
||||
}
|
||||
|
||||
/*
|
||||
** Internal function: convert an object to a number
|
||||
*/
|
||||
void lua_obj2number (void)
|
||||
{
|
||||
lua_Object o = lua_getparam(1);
|
||||
if (lua_isnumber(o))
|
||||
lua_pushnumber(lua_getnumber(o));
|
||||
else
|
||||
lua_pushnil();
|
||||
{
|
||||
sprintf (strchr(msg,0),
|
||||
"\n\tin statement begining at line %d of file \"%s\"",
|
||||
lua_debugline, lua_filename());
|
||||
}
|
||||
}
|
||||
lua_error (msg);
|
||||
}
|
||||
|
||||
|
||||
void luaI_error (void)
|
||||
{
|
||||
char *s = lua_getstring(lua_getparam(1));
|
||||
if (s == NULL) s = "(no message)";
|
||||
lua_error(s);
|
||||
}
|
||||
|
||||
void luaI_assert (void)
|
||||
{
|
||||
lua_Object p = lua_getparam(1);
|
||||
if (p == LUA_NOOBJECT || lua_isnil(p))
|
||||
lua_error("assertion failed!");
|
||||
}
|
||||
|
||||
void luaI_setglobal (void)
|
||||
{
|
||||
lua_Object name = lua_getparam(1);
|
||||
lua_Object value = lua_getparam(2);
|
||||
if (!lua_isstring(name))
|
||||
lua_error("incorrect argument to function `setglobal'");
|
||||
lua_pushobject(value);
|
||||
lua_storeglobal(lua_getstring(name));
|
||||
lua_pushobject(value); /* return given value */
|
||||
}
|
||||
|
||||
void luaI_getglobal (void)
|
||||
{
|
||||
lua_Object name = lua_getparam(1);
|
||||
if (!lua_isstring(name))
|
||||
lua_error("incorrect argument to function `getglobal'");
|
||||
lua_pushobject(lua_getglobal(lua_getstring(name)));
|
||||
}
|
||||
|
||||
35
inout.h
35
inout.h
@@ -1,33 +1,24 @@
|
||||
/*
|
||||
** $Id: inout.h,v 1.14 1996/03/15 13:13:13 roberto Exp roberto $
|
||||
** inout.h
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 11 May 93
|
||||
*/
|
||||
|
||||
|
||||
#ifndef inout_h
|
||||
#define inout_h
|
||||
|
||||
#include "types.h"
|
||||
#include <stdio.h>
|
||||
extern int lua_linenumber;
|
||||
extern int lua_debug;
|
||||
extern int lua_debugline;
|
||||
|
||||
|
||||
extern Word lua_linenumber;
|
||||
extern Word lua_debugline;
|
||||
extern char *lua_parsedfile;
|
||||
|
||||
FILE *lua_openfile (char *fn);
|
||||
int lua_openfile (char *fn);
|
||||
void lua_closefile (void);
|
||||
void lua_openstring (char *s);
|
||||
void lua_closestring (void);
|
||||
|
||||
void lua_internaldofile (void);
|
||||
void lua_internaldostring (void);
|
||||
void luaI_tostring (void);
|
||||
void luaI_print (void);
|
||||
void luaI_type (void);
|
||||
void lua_obj2number (void);
|
||||
void luaI_error (void);
|
||||
void luaI_assert (void);
|
||||
void luaI_setglobal (void);
|
||||
void luaI_getglobal (void);
|
||||
int lua_openstring (char *s);
|
||||
int lua_pushfunction (int file, int function);
|
||||
void lua_popfunction (void);
|
||||
void lua_reportbug (char *s);
|
||||
|
||||
#endif
|
||||
|
||||
753
iolib.c
753
iolib.c
@@ -1,62 +1,23 @@
|
||||
/*
|
||||
** iolib.c
|
||||
** Input/output library to LUA
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
char *rcs_iolib="$Id: iolib.c,v 1.39 1996/03/14 15:55:18 roberto Exp roberto $";
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "lua.h"
|
||||
#include "luadebug.h"
|
||||
#include "lualib.h"
|
||||
|
||||
static FILE *in=stdin, *out=stdout;
|
||||
|
||||
|
||||
#ifdef POPEN
|
||||
FILE *popen();
|
||||
int pclose();
|
||||
#else
|
||||
#define popen(x,y) NULL /* that is, popen always fails */
|
||||
#define pclose(x) (-1)
|
||||
#ifdef __GNUC__
|
||||
#include <floatingpoint.h>
|
||||
#endif
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
static void pushresult (int i)
|
||||
{
|
||||
if (i)
|
||||
lua_pushnumber (1);
|
||||
else
|
||||
lua_pushnil();
|
||||
}
|
||||
|
||||
static void closeread (void)
|
||||
{
|
||||
if (in != stdin)
|
||||
{
|
||||
if (pclose(in) == -1)
|
||||
fclose(in);
|
||||
in = stdin;
|
||||
}
|
||||
}
|
||||
|
||||
static void closewrite (void)
|
||||
{
|
||||
if (out != stdout)
|
||||
{
|
||||
if (pclose(out) == -1)
|
||||
fclose(out);
|
||||
out = stdout;
|
||||
}
|
||||
}
|
||||
static FILE *in=stdin, *out=stdout;
|
||||
|
||||
/*
|
||||
** Open a file to read.
|
||||
@@ -64,27 +25,41 @@ static void closewrite (void)
|
||||
** status = readfrom (filename)
|
||||
** where:
|
||||
** status = 1 -> success
|
||||
** status = nil -> error
|
||||
** status = 0 -> error
|
||||
*/
|
||||
static void io_readfrom (void)
|
||||
{
|
||||
if (lua_getparam (1) == LUA_NOOBJECT)
|
||||
{ /* restore standart input */
|
||||
closeread();
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* restore standart input */
|
||||
{
|
||||
if (in != stdin)
|
||||
{
|
||||
fclose (in);
|
||||
in = stdin;
|
||||
}
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
else
|
||||
{
|
||||
char *s = lua_check_string(1, "readfrom");
|
||||
FILE *fp = (*s == '|') ? popen(s+1, "r") : fopen(s, "r");
|
||||
if (!lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'readfrom`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
FILE *fp = fopen (lua_getstring(o),"r");
|
||||
if (fp == NULL)
|
||||
lua_pushnil();
|
||||
{
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
closeread();
|
||||
if (in != stdin) fclose (in);
|
||||
in = fp;
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -95,96 +70,45 @@ static void io_readfrom (void)
|
||||
** status = writeto (filename)
|
||||
** where:
|
||||
** status = 1 -> success
|
||||
** status = nil -> error
|
||||
** status = 0 -> error
|
||||
*/
|
||||
static void io_writeto (void)
|
||||
{
|
||||
if (lua_getparam (1) == LUA_NOOBJECT) /* restore standart output */
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* restore standart output */
|
||||
{
|
||||
closewrite();
|
||||
if (out != stdout)
|
||||
{
|
||||
fclose (out);
|
||||
out = stdout;
|
||||
}
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
else
|
||||
{
|
||||
char *s = lua_check_string(1, "writeto");
|
||||
FILE *fp = (*s == '|') ? popen(s+1,"w") : fopen(s,"w");
|
||||
if (!lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'writeto`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
FILE *fp = fopen (lua_getstring(o),"w");
|
||||
if (fp == NULL)
|
||||
lua_pushnil();
|
||||
{
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
closewrite();
|
||||
if (out != stdout) fclose (out);
|
||||
out = fp;
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Open a file to write appended.
|
||||
** LUA interface:
|
||||
** status = appendto (filename)
|
||||
** where:
|
||||
** status = 2 -> success (already exist)
|
||||
** status = 1 -> success (new file)
|
||||
** status = nil -> error
|
||||
*/
|
||||
static void io_appendto (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "appendto");
|
||||
struct stat st;
|
||||
int r = (stat(s, &st) == -1) ? 1 : 2;
|
||||
FILE *fp = fopen (s, "a");
|
||||
if (fp == NULL)
|
||||
lua_pushnil();
|
||||
else
|
||||
{
|
||||
if (out != stdout) fclose (out);
|
||||
out = fp;
|
||||
lua_pushnumber (r);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static char getformat (char *f, int *just, int *m, int *n)
|
||||
{
|
||||
int t;
|
||||
switch (*f++)
|
||||
{
|
||||
case 'q': case 'Q':
|
||||
case 's': case 'S':
|
||||
case 'i': case 'I':
|
||||
t = tolower(*(f-1));
|
||||
break;
|
||||
case 'f': case 'F': case 'g': case 'G': case 'e': case 'E':
|
||||
t = 'f';
|
||||
break;
|
||||
default:
|
||||
t = 0; /* to avoid compiler warnings */
|
||||
lua_arg_error("read/write (format)");
|
||||
}
|
||||
*just = (*f == '<' || *f == '>' || *f == '|') ? *f++ : '>';
|
||||
if (isdigit(*f))
|
||||
{
|
||||
*m = 0;
|
||||
while (isdigit(*f))
|
||||
*m = *m*10 + (*f++ - '0');
|
||||
}
|
||||
else
|
||||
*m = -1;
|
||||
if (*f == '.')
|
||||
{
|
||||
f++; /* skip point */
|
||||
*n = 0;
|
||||
while (isdigit(*f))
|
||||
*n = *n*10 + (*f++ - '0');
|
||||
}
|
||||
else
|
||||
*n = -1;
|
||||
return t;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read a variable. On error put nil on stack.
|
||||
** LUA interface:
|
||||
@@ -199,130 +123,116 @@ static char getformat (char *f, int *just, int *m, int *n)
|
||||
** Estes especificadores podem vir seguidos de numero que representa
|
||||
** o numero de campos a serem lidos.
|
||||
*/
|
||||
|
||||
static int read_until_char (int del)
|
||||
{
|
||||
int c;
|
||||
while((c = fgetc(in)) != EOF && c != del)
|
||||
luaI_addchar(c);
|
||||
return c;
|
||||
}
|
||||
|
||||
static void read_until_blank (void)
|
||||
{
|
||||
int c;
|
||||
while((c = fgetc(in)) != EOF && !isspace(c))
|
||||
luaI_addchar(c);
|
||||
if (c != EOF) ungetc(c,in);
|
||||
}
|
||||
|
||||
static void read_m (int m)
|
||||
{
|
||||
int c;
|
||||
while (m-- && (c = fgetc(in)) != EOF)
|
||||
luaI_addchar(c);
|
||||
}
|
||||
|
||||
|
||||
static void read_free (void)
|
||||
static void io_read (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL) /* free format */
|
||||
{
|
||||
int c;
|
||||
char s[256];
|
||||
while (isspace(c=fgetc(in)))
|
||||
;
|
||||
if (c == EOF)
|
||||
if (c == '\"')
|
||||
{
|
||||
lua_pushnil();
|
||||
if (fscanf (in, "%[^\"]\"", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (c == '\"' || c == '\'')
|
||||
{ /* string */
|
||||
c = read_until_char(c);
|
||||
if (c == EOF)
|
||||
lua_pushnil();
|
||||
else
|
||||
lua_pushstring(luaI_addchar(0));
|
||||
else if (c == '\'')
|
||||
{
|
||||
if (fscanf (in, "%[^\']\'", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
double d;
|
||||
char dummy;
|
||||
char *s;
|
||||
luaI_addchar(c);
|
||||
read_until_blank();
|
||||
s = luaI_addchar(0);
|
||||
if (sscanf(s, "%lf %c", &d, &dummy) == 1)
|
||||
lua_pushnumber(d);
|
||||
else
|
||||
lua_pushstring(s);
|
||||
char *ptr;
|
||||
double d;
|
||||
ungetc (c, in);
|
||||
if (fscanf (in, "%s", s) != 1)
|
||||
{
|
||||
lua_pushnil ();
|
||||
return;
|
||||
}
|
||||
d = strtod (s, &ptr);
|
||||
if (!(*ptr))
|
||||
{
|
||||
lua_pushnumber (d);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void io_read (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
luaI_addchar(0); /* initialize buffer */
|
||||
if (o == LUA_NOOBJECT) /* free format */
|
||||
read_free();
|
||||
else /* formatted */
|
||||
lua_pushstring (s);
|
||||
return;
|
||||
}
|
||||
else /* formatted */
|
||||
{
|
||||
char *e = lua_getstring(o);
|
||||
char t;
|
||||
int m=0;
|
||||
while (isspace(*e)) e++;
|
||||
t = *e++;
|
||||
while (isdigit(*e))
|
||||
m = m*10 + (*e++ - '0');
|
||||
|
||||
if (m > 0)
|
||||
{
|
||||
int m, dummy1, dummy2;
|
||||
switch (getformat(lua_check_string(1, "read"), &dummy1, &m, &dummy2))
|
||||
char f[80];
|
||||
char s[256];
|
||||
sprintf (f, "%%%ds", m);
|
||||
fscanf (in, f, s);
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i':
|
||||
{
|
||||
case 's':
|
||||
{
|
||||
char *s;
|
||||
if (m < 0)
|
||||
read_until_blank();
|
||||
else
|
||||
read_m(m);
|
||||
s = luaI_addchar(0);
|
||||
if ((m >= 0 && strlen(s) == m) || (m < 0 && strlen(s) > 0))
|
||||
lua_pushstring(s);
|
||||
else
|
||||
lua_pushnil();
|
||||
break;
|
||||
}
|
||||
|
||||
case 'i': /* can read as float, since it makes no difference to Lua */
|
||||
case 'f':
|
||||
{
|
||||
double d;
|
||||
int result;
|
||||
if (m < 0)
|
||||
result = fscanf(in, "%lf", &d);
|
||||
else
|
||||
{
|
||||
read_m(m);
|
||||
result = sscanf(luaI_addchar(0), "%lf", &d);
|
||||
}
|
||||
if (result == 1)
|
||||
lua_pushnumber(d);
|
||||
else
|
||||
lua_pushnil();
|
||||
break;
|
||||
}
|
||||
default:
|
||||
lua_arg_error("read (format)");
|
||||
long int l;
|
||||
sscanf (s, "%ld", &l);
|
||||
lua_pushnumber(l);
|
||||
}
|
||||
break;
|
||||
case 'f': case 'g': case 'e':
|
||||
{
|
||||
float f;
|
||||
sscanf (s, "%f", &f);
|
||||
lua_pushnumber(f);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
lua_pushstring(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Read characters until a given one. The delimiter is not read.
|
||||
*/
|
||||
static void io_readuntil (void)
|
||||
{
|
||||
int del, c;
|
||||
lua_Object p = lua_getparam(1);
|
||||
luaI_addchar(0); /* initialize buffer */
|
||||
if (p == LUA_NOOBJECT || lua_isnil(p))
|
||||
del = EOF;
|
||||
else
|
||||
del = *lua_check_string(1, "readuntil");
|
||||
c = read_until_char(del);
|
||||
if (c != EOF) ungetc(c,in);
|
||||
lua_pushstring(luaI_addchar(0));
|
||||
else
|
||||
{
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i':
|
||||
{
|
||||
long int l;
|
||||
fscanf (in, "%ld", &l);
|
||||
lua_pushnumber(l);
|
||||
}
|
||||
break;
|
||||
case 'f': case 'g': case 'e':
|
||||
{
|
||||
float f;
|
||||
fscanf (in, "%f", &f);
|
||||
lua_pushnumber(f);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char s[256];
|
||||
fscanf (in, "%s", s);
|
||||
lua_pushstring(s);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -352,252 +262,131 @@ static void io_readuntil (void)
|
||||
** inteiros -> numero minimo de digitos
|
||||
** string -> nao se aplica
|
||||
*/
|
||||
|
||||
static int write_fill (int n, int c)
|
||||
static char *buildformat (char *e, lua_Object o)
|
||||
{
|
||||
while (n--)
|
||||
if (fputc(c, out) == EOF)
|
||||
return 0;
|
||||
return 1;
|
||||
static char buffer[512];
|
||||
static char f[80];
|
||||
char *string = &buffer[255];
|
||||
char t, j='r';
|
||||
int m=0, n=0, l;
|
||||
while (isspace(*e)) e++;
|
||||
t = *e++;
|
||||
if (*e == '<' || *e == '|' || *e == '>') j = *e++;
|
||||
while (isdigit(*e))
|
||||
m = m*10 + (*e++ - '0');
|
||||
e++; /* skip point */
|
||||
while (isdigit(*e))
|
||||
n = n*10 + (*e++ - '0');
|
||||
|
||||
sprintf(f,"%%");
|
||||
if (j == '<' || j == '|') sprintf(strchr(f,0),"-");
|
||||
if (m != 0) sprintf(strchr(f,0),"%d", m);
|
||||
if (n != 0) sprintf(strchr(f,0),".%d", n);
|
||||
sprintf(strchr(f,0), "%c", t);
|
||||
switch (tolower(t))
|
||||
{
|
||||
case 'i': t = 'i';
|
||||
sprintf (string, f, (long int)lua_getnumber(o));
|
||||
break;
|
||||
case 'f': case 'g': case 'e': t = 'f';
|
||||
sprintf (string, f, (float)lua_getnumber(o));
|
||||
break;
|
||||
case 's': t = 's';
|
||||
sprintf (string, f, lua_getstring(o));
|
||||
break;
|
||||
default: return "";
|
||||
}
|
||||
l = strlen(string);
|
||||
if (m!=0 && l>m)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<m; i++)
|
||||
string[i] = '*';
|
||||
string[i] = 0;
|
||||
}
|
||||
else if (m!=0 && j=='|')
|
||||
{
|
||||
int i=l-1;
|
||||
while (isspace(string[i])) i--;
|
||||
string -= (m-i) / 2;
|
||||
i=0;
|
||||
while (string[i]==0) string[i++] = ' ';
|
||||
string[l] = 0;
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
static int write_string (char *s, int just, int m)
|
||||
{
|
||||
int status;
|
||||
int l = strlen(s);
|
||||
int pre; /* number of blanks before string */
|
||||
if (m < 0) m = l;
|
||||
else if (l > m)
|
||||
{
|
||||
write_fill(m, '*');
|
||||
return 0;
|
||||
}
|
||||
pre = (just == '<') ? 0 : (just == '>') ? m-l : (m-l)/2;
|
||||
status = write_fill(pre, ' ');
|
||||
status = status && fprintf(out, "%s", s) >= 0;
|
||||
status = status && write_fill(m-(l+pre), ' ');
|
||||
return status;
|
||||
}
|
||||
|
||||
static int write_quoted (int just, int m)
|
||||
{
|
||||
luaI_addchar(0);
|
||||
luaI_addquoted(lua_check_string(1, "write"));
|
||||
return write_string(luaI_addchar(0), just, m);
|
||||
}
|
||||
|
||||
static int write_float (int just, int m, int n)
|
||||
{
|
||||
char buffer[100];
|
||||
lua_Object p = lua_getparam(1);
|
||||
float number;
|
||||
if (!lua_isnumber(p)) return 0;
|
||||
number = lua_getnumber(p);
|
||||
if (n >= 0)
|
||||
sprintf(buffer, "%.*f", n, number);
|
||||
else
|
||||
sprintf(buffer, "%g", number);
|
||||
return write_string(buffer, just, m);
|
||||
}
|
||||
|
||||
|
||||
static int write_int (int just, int m, int n)
|
||||
{
|
||||
char buffer[100];
|
||||
lua_Object p = lua_getparam(1);
|
||||
int number;
|
||||
if (!lua_isnumber(p)) return 0;
|
||||
number = (int)lua_getnumber(p);
|
||||
if (n >= 0)
|
||||
sprintf(buffer, "%.*d", n, number);
|
||||
else
|
||||
sprintf(buffer, "%d", number);
|
||||
return write_string(buffer, just, m);
|
||||
}
|
||||
|
||||
|
||||
static void io_write (void)
|
||||
{
|
||||
int status = 0;
|
||||
if (lua_getparam (2) == LUA_NOOBJECT) /* free format */
|
||||
{
|
||||
lua_Object o1 = lua_getparam(1);
|
||||
int t = lua_type(o1);
|
||||
if (t == LUA_T_NUMBER)
|
||||
status = fprintf (out, "%g", lua_getnumber(o1)) >= 0;
|
||||
else if (t == LUA_T_STRING)
|
||||
status = fprintf (out, "%s", lua_getstring(o1)) >= 0;
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
if (o1 == NULL) /* new line */
|
||||
{
|
||||
fprintf (out, "\n");
|
||||
lua_pushnumber(1);
|
||||
}
|
||||
else if (o2 == NULL) /* free format */
|
||||
{
|
||||
int status=0;
|
||||
if (lua_isnumber(o1))
|
||||
status = fprintf (out, "%g", lua_getnumber(o1));
|
||||
else if (lua_isstring(o1))
|
||||
status = fprintf (out, "%s", lua_getstring(o1));
|
||||
lua_pushnumber(status);
|
||||
}
|
||||
else /* formated */
|
||||
{
|
||||
if (!lua_isstring(o2))
|
||||
{
|
||||
lua_error ("incorrect format to function `write'");
|
||||
lua_pushnumber(0);
|
||||
return;
|
||||
}
|
||||
else /* formated */
|
||||
{
|
||||
int just, m, n;
|
||||
switch (getformat(lua_check_string(2, "write"), &just, &m, &n))
|
||||
{
|
||||
case 's':
|
||||
{
|
||||
lua_Object p = lua_getparam(1);
|
||||
if (lua_isstring(p))
|
||||
status = write_string(lua_getstring(p), just, m);
|
||||
else
|
||||
status = 0;
|
||||
break;
|
||||
}
|
||||
case 'q':
|
||||
status = write_quoted(just, m);
|
||||
break;
|
||||
case 'f':
|
||||
status = write_float(just, m, n);
|
||||
break;
|
||||
case 'i':
|
||||
status = write_int(just, m, n);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (status)
|
||||
lua_pushnumber(status);
|
||||
lua_pushnumber(fprintf (out, "%s", buildformat(lua_getstring(o2),o1)));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Execute a executable program using "sustem".
|
||||
** On error put 0 on stack, otherwise put 1.
|
||||
*/
|
||||
void io_execute (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL || !lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'execute`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
system(lua_getstring(o));
|
||||
lua_pushnumber (1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
** Remove a file.
|
||||
** On error put 0 on stack, otherwise put 1.
|
||||
*/
|
||||
void io_remove (void)
|
||||
{
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL || !lua_isstring (o))
|
||||
{
|
||||
lua_error ("incorrect argument to function 'execute`");
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (remove(lua_getstring(o)) == 0)
|
||||
lua_pushnumber (1);
|
||||
else
|
||||
lua_pushnil();
|
||||
lua_pushnumber (0);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
** Execute a executable program using "system".
|
||||
** Return the result of execution.
|
||||
*/
|
||||
static void io_execute (void)
|
||||
{
|
||||
lua_pushnumber(system(lua_check_string(1, "execute")));
|
||||
}
|
||||
|
||||
/*
|
||||
** Remove a file. On error return nil.
|
||||
*/
|
||||
static void io_remove (void)
|
||||
{
|
||||
pushresult(remove(lua_check_string(1, "remove")) == 0);
|
||||
}
|
||||
|
||||
static void io_rename (void)
|
||||
{
|
||||
char *f1 = lua_check_string(1, "rename");
|
||||
char *f2 = lua_check_string(2, "rename");
|
||||
pushresult(rename(f1, f2) == 0);
|
||||
}
|
||||
|
||||
static void io_tmpname (void)
|
||||
{
|
||||
lua_pushstring(tmpnam(NULL));
|
||||
}
|
||||
|
||||
static void io_errorno (void)
|
||||
{
|
||||
/* lua_pushstring(strerror(errno));*/
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** To get a environment variable
|
||||
*/
|
||||
static void io_getenv (void)
|
||||
{
|
||||
char *env = getenv(lua_check_string(1, "getenv"));
|
||||
lua_pushstring(env); /* if NULL push nil */
|
||||
}
|
||||
|
||||
/*
|
||||
** Return user formatted time stamp
|
||||
*/
|
||||
static void io_date (void)
|
||||
{
|
||||
time_t t;
|
||||
struct tm *tm;
|
||||
char *s;
|
||||
char b[BUFSIZ];
|
||||
if (lua_getparam(1) == LUA_NOOBJECT)
|
||||
s = "%c";
|
||||
else
|
||||
s = lua_check_string(1, "date");
|
||||
time(&t); tm = localtime(&t);
|
||||
if (strftime(b,sizeof(b),s,tm))
|
||||
lua_pushstring(b);
|
||||
else
|
||||
lua_error("invalid `date' format");
|
||||
}
|
||||
|
||||
/*
|
||||
** To exit
|
||||
*/
|
||||
static void io_exit (void)
|
||||
{
|
||||
lua_Object o = lua_getparam(1);
|
||||
if (lua_isstring(o))
|
||||
fprintf(stderr, "%s\n", lua_getstring(o));
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/*
|
||||
** To debug a lua program. Start a dialog with the user, interpreting
|
||||
lua commands until an 'cont'.
|
||||
*/
|
||||
static void io_debug (void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
char buffer[250];
|
||||
fprintf(stderr, "lua_debug> ");
|
||||
if (fgets(buffer, sizeof(buffer), stdin) == 0) return;
|
||||
if (strcmp(buffer, "cont") == 0) return;
|
||||
lua_dostring(buffer);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void lua_printstack (FILE *f)
|
||||
{
|
||||
int level = 0;
|
||||
lua_Object func;
|
||||
fprintf(f, "Active Stack:\n");
|
||||
while ((func = lua_stackedfunction(level++)) != LUA_NOOBJECT)
|
||||
{
|
||||
char *name;
|
||||
int currentline;
|
||||
fprintf(f, "\t");
|
||||
switch (*lua_getobjname(func, &name))
|
||||
{
|
||||
case 'g':
|
||||
fprintf(f, "function %s", name);
|
||||
break;
|
||||
case 'f':
|
||||
fprintf(f, "`%s' fallback", name);
|
||||
break;
|
||||
default:
|
||||
{
|
||||
char *filename;
|
||||
int linedefined;
|
||||
lua_funcinfo(func, &filename, &linedefined);
|
||||
if (linedefined == 0)
|
||||
fprintf(f, "main of %s", filename);
|
||||
else if (linedefined < 0)
|
||||
fprintf(f, "%s", filename);
|
||||
else
|
||||
fprintf(f, "function (%s:%d)", filename, linedefined);
|
||||
}
|
||||
}
|
||||
if ((currentline = lua_currentline(func)) > 0)
|
||||
fprintf(f, " at line %d", currentline);
|
||||
fprintf(f, "\n");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void errorfb (void)
|
||||
{
|
||||
lua_Object o = lua_getparam(1);
|
||||
char *s = lua_isstring(o) ? lua_getstring(o) : "(no messsage)";
|
||||
fprintf(stderr, "lua: %s\n", s);
|
||||
lua_printstack(stderr);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Open io library
|
||||
*/
|
||||
@@ -605,20 +394,8 @@ void iolib_open (void)
|
||||
{
|
||||
lua_register ("readfrom", io_readfrom);
|
||||
lua_register ("writeto", io_writeto);
|
||||
lua_register ("appendto", io_appendto);
|
||||
lua_register ("read", io_read);
|
||||
lua_register ("readuntil",io_readuntil);
|
||||
lua_register ("write", io_write);
|
||||
lua_register ("execute", io_execute);
|
||||
lua_register ("remove", io_remove);
|
||||
lua_register ("rename", io_rename);
|
||||
lua_register ("tmpname", io_tmpname);
|
||||
lua_register ("ioerror", io_errorno);
|
||||
lua_register ("getenv", io_getenv);
|
||||
lua_register ("date", io_date);
|
||||
lua_register ("exit", io_exit);
|
||||
lua_register ("debug", io_debug);
|
||||
lua_register ("print_stack", errorfb);
|
||||
lua_setfallback("error", errorfb);
|
||||
}
|
||||
|
||||
|
||||
326
lex.c
326
lex.c
@@ -1,326 +0,0 @@
|
||||
char *rcs_lex = "$Id: lex.c,v 2.31 1996/03/19 16:50:24 roberto Exp roberto $";
|
||||
|
||||
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mem.h"
|
||||
#include "tree.h"
|
||||
#include "table.h"
|
||||
#include "lex.h"
|
||||
#include "inout.h"
|
||||
#include "luadebug.h"
|
||||
#include "parser.h"
|
||||
|
||||
#define MINBUFF 260
|
||||
|
||||
#define next() { current = input(); }
|
||||
#define save(x) { *yytextLast++ = (x); }
|
||||
#define save_and_next() { save(current); next(); }
|
||||
|
||||
static int current;
|
||||
static char *yytext = NULL;
|
||||
static int textsize = 0;
|
||||
static char *yytextLast;
|
||||
|
||||
static Input input;
|
||||
|
||||
void lua_setinput (Input fn)
|
||||
{
|
||||
current = ' ';
|
||||
input = fn;
|
||||
if (yytext == NULL)
|
||||
{
|
||||
textsize = MINBUFF;
|
||||
yytext = newvector(textsize, char);
|
||||
}
|
||||
}
|
||||
|
||||
char *lua_lasttext (void)
|
||||
{
|
||||
*yytextLast = 0;
|
||||
return yytext;
|
||||
}
|
||||
|
||||
|
||||
static struct
|
||||
{
|
||||
char *name;
|
||||
int token;
|
||||
} reserved [] = {
|
||||
{"and", AND},
|
||||
{"do", DO},
|
||||
{"else", ELSE},
|
||||
{"elseif", ELSEIF},
|
||||
{"end", END},
|
||||
{"function", FUNCTION},
|
||||
{"if", IF},
|
||||
{"local", LOCAL},
|
||||
{"nil", NIL},
|
||||
{"not", NOT},
|
||||
{"or", OR},
|
||||
{"repeat", REPEAT},
|
||||
{"return", RETURN},
|
||||
{"then", THEN},
|
||||
{"until", UNTIL},
|
||||
{"while", WHILE} };
|
||||
|
||||
|
||||
#define RESERVEDSIZE (sizeof(reserved)/sizeof(reserved[0]))
|
||||
|
||||
|
||||
void luaI_addReserved (void)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<RESERVEDSIZE; i++)
|
||||
{
|
||||
TaggedString *ts = lua_createstring(reserved[i].name);
|
||||
ts->marked = reserved[i].token; /* reserved word (always > 255) */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void growtext (void)
|
||||
{
|
||||
int size = yytextLast - yytext;
|
||||
textsize = growvector(&yytext, textsize, char, lexEM, MAX_WORD);
|
||||
yytextLast = yytext + size;
|
||||
}
|
||||
|
||||
|
||||
static int read_long_string (void)
|
||||
{
|
||||
int cont = 0;
|
||||
int spaceleft = textsize - (yytextLast - yytext);
|
||||
while (1)
|
||||
{
|
||||
if (spaceleft <= 2) /* may read more than 1 char in one cicle */
|
||||
{
|
||||
growtext();
|
||||
spaceleft = textsize - (yytextLast - yytext);
|
||||
}
|
||||
switch (current)
|
||||
{
|
||||
case EOF:
|
||||
case 0:
|
||||
return WRONGTOKEN;
|
||||
case '[':
|
||||
save_and_next(); spaceleft--;
|
||||
if (current == '[')
|
||||
{
|
||||
cont++;
|
||||
save_and_next(); spaceleft--;
|
||||
}
|
||||
continue;
|
||||
case ']':
|
||||
save_and_next(); spaceleft--;
|
||||
if (current == ']')
|
||||
{
|
||||
if (cont == 0) return STRING;
|
||||
cont--;
|
||||
save_and_next(); spaceleft--;
|
||||
}
|
||||
continue;
|
||||
case '\n':
|
||||
lua_linenumber++; /* goes through */
|
||||
default:
|
||||
save_and_next(); spaceleft--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int luaY_lex (void)
|
||||
{
|
||||
double a;
|
||||
static int linelasttoken = 0;
|
||||
if (lua_debug)
|
||||
luaI_codedebugline(linelasttoken);
|
||||
linelasttoken = lua_linenumber;
|
||||
while (1)
|
||||
{
|
||||
yytextLast = yytext;
|
||||
switch (current)
|
||||
{
|
||||
case EOF:
|
||||
case 0:
|
||||
return 0;
|
||||
case '\n': linelasttoken = ++lua_linenumber;
|
||||
case ' ':
|
||||
case '\r': /* CR: to avoid problems with DOS/Windows */
|
||||
case '\t':
|
||||
next();
|
||||
continue;
|
||||
|
||||
case '$':
|
||||
next();
|
||||
while (isalnum(current) || current == '_')
|
||||
save_and_next();
|
||||
*yytextLast = 0;
|
||||
if (strcmp(yytext, "debug") == 0)
|
||||
{
|
||||
luaY_lval.vInt = 1;
|
||||
return DEBUG;
|
||||
}
|
||||
else if (strcmp(yytext, "nodebug") == 0)
|
||||
{
|
||||
luaY_lval.vInt = 0;
|
||||
return DEBUG;
|
||||
}
|
||||
return WRONGTOKEN;
|
||||
|
||||
case '-':
|
||||
save_and_next();
|
||||
if (current != '-') return '-';
|
||||
do { next(); } while (current != '\n' && current != 0);
|
||||
continue;
|
||||
|
||||
case '[':
|
||||
save_and_next();
|
||||
if (current != '[') return '[';
|
||||
else
|
||||
{
|
||||
save_and_next(); /* pass the second '[' */
|
||||
if (read_long_string() == WRONGTOKEN)
|
||||
return WRONGTOKEN;
|
||||
save_and_next(); /* pass the second ']' */
|
||||
*(yytextLast-2) = 0; /* erases ']]' */
|
||||
luaY_lval.vWord = luaI_findconstantbyname(yytext+2);
|
||||
return STRING;
|
||||
}
|
||||
|
||||
case '=':
|
||||
save_and_next();
|
||||
if (current != '=') return '=';
|
||||
else { save_and_next(); return EQ; }
|
||||
|
||||
case '<':
|
||||
save_and_next();
|
||||
if (current != '=') return '<';
|
||||
else { save_and_next(); return LE; }
|
||||
|
||||
case '>':
|
||||
save_and_next();
|
||||
if (current != '=') return '>';
|
||||
else { save_and_next(); return GE; }
|
||||
|
||||
case '~':
|
||||
save_and_next();
|
||||
if (current != '=') return '~';
|
||||
else { save_and_next(); return NE; }
|
||||
|
||||
case '"':
|
||||
case '\'':
|
||||
{
|
||||
int del = current;
|
||||
int spaceleft = textsize - (yytextLast - yytext);
|
||||
next(); /* skip the delimiter */
|
||||
while (current != del)
|
||||
{
|
||||
if (spaceleft <= 2) /* may read more than 1 char in one cicle */
|
||||
{
|
||||
growtext();
|
||||
spaceleft = textsize - (yytextLast - yytext);
|
||||
}
|
||||
spaceleft--;
|
||||
switch (current)
|
||||
{
|
||||
case EOF:
|
||||
case 0:
|
||||
case '\n':
|
||||
return WRONGTOKEN;
|
||||
case '\\':
|
||||
next(); /* do not save the '\' */
|
||||
switch (current)
|
||||
{
|
||||
case 'n': save('\n'); next(); break;
|
||||
case 't': save('\t'); next(); break;
|
||||
case 'r': save('\r'); next(); break;
|
||||
case '\n': lua_linenumber++; /* goes through */
|
||||
default : save(current); next(); break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
save_and_next();
|
||||
}
|
||||
}
|
||||
next(); /* skip the delimiter */
|
||||
*yytextLast = 0;
|
||||
luaY_lval.vWord = luaI_findconstantbyname(yytext);
|
||||
return STRING;
|
||||
}
|
||||
|
||||
case 'a': case 'b': case 'c': case 'd': case 'e':
|
||||
case 'f': case 'g': case 'h': case 'i': case 'j':
|
||||
case 'k': case 'l': case 'm': case 'n': case 'o':
|
||||
case 'p': case 'q': case 'r': case 's': case 't':
|
||||
case 'u': case 'v': case 'w': case 'x': case 'y':
|
||||
case 'z':
|
||||
case 'A': case 'B': case 'C': case 'D': case 'E':
|
||||
case 'F': case 'G': case 'H': case 'I': case 'J':
|
||||
case 'K': case 'L': case 'M': case 'N': case 'O':
|
||||
case 'P': case 'Q': case 'R': case 'S': case 'T':
|
||||
case 'U': case 'V': case 'W': case 'X': case 'Y':
|
||||
case 'Z':
|
||||
case '_':
|
||||
{
|
||||
TaggedString *ts;
|
||||
do { save_and_next(); } while (isalnum(current) || current == '_');
|
||||
*yytextLast = 0;
|
||||
ts = lua_createstring(yytext);
|
||||
if (ts->marked > 2)
|
||||
return ts->marked; /* reserved word */
|
||||
luaY_lval.pTStr = ts;
|
||||
ts->marked = 2; /* avoid GC */
|
||||
return NAME;
|
||||
}
|
||||
|
||||
case '.':
|
||||
save_and_next();
|
||||
if (current == '.')
|
||||
{
|
||||
save_and_next();
|
||||
return CONC;
|
||||
}
|
||||
else if (!isdigit(current)) return '.';
|
||||
/* current is a digit: goes through to number */
|
||||
a=0.0;
|
||||
goto fraction;
|
||||
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
a=0.0;
|
||||
do { a=10.0*a+(current-'0'); save_and_next(); } while (isdigit(current));
|
||||
if (current == '.') save_and_next();
|
||||
fraction:
|
||||
{ double da=0.1;
|
||||
while (isdigit(current))
|
||||
{a+=(current-'0')*da; da/=10.0; save_and_next()};
|
||||
if (current == 'e' || current == 'E')
|
||||
{
|
||||
int e=0;
|
||||
int neg;
|
||||
double ea;
|
||||
save_and_next();
|
||||
neg=(current=='-');
|
||||
if (current == '+' || current == '-') save_and_next();
|
||||
if (!isdigit(current)) return WRONGTOKEN;
|
||||
do { e=10.0*e+(current-'0'); save_and_next(); } while (isdigit(current));
|
||||
for (ea=neg?0.1:10.0; e>0; e>>=1)
|
||||
{
|
||||
if (e & 1) a*=ea;
|
||||
ea*=ea;
|
||||
}
|
||||
}
|
||||
luaY_lval.vFloat = a;
|
||||
return NUMBER;
|
||||
}
|
||||
|
||||
default: /* also end of file */
|
||||
{
|
||||
save_and_next();
|
||||
return yytext[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
19
lex.h
19
lex.h
@@ -1,19 +0,0 @@
|
||||
/*
|
||||
** lex.h
|
||||
** TecCGraf - PUC-Rio
|
||||
** $Id: lex.h,v 1.1 1996/02/13 17:30:39 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef lex_h
|
||||
#define lex_h
|
||||
|
||||
|
||||
typedef int (*Input) (void);
|
||||
|
||||
void lua_setinput (Input fn);
|
||||
char *lua_lasttext (void);
|
||||
int luaY_lex (void);
|
||||
void luaI_addReserved (void);
|
||||
|
||||
|
||||
#endif
|
||||
923
lex_yy.c
Normal file
923
lex_yy.c
Normal file
@@ -0,0 +1,923 @@
|
||||
# include "stdio.h"
|
||||
# define U(x) x
|
||||
# define NLSTATE yyprevious=YYNEWLINE
|
||||
# define BEGIN yybgin = yysvec + 1 +
|
||||
# define INITIAL 0
|
||||
# define YYLERR yysvec
|
||||
# define YYSTATE (yyestate-yysvec-1)
|
||||
# define YYOPTIM 1
|
||||
# define YYLMAX BUFSIZ
|
||||
# define output(c) putc(c,yyout)
|
||||
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
|
||||
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
|
||||
# define yymore() (yymorfg=1)
|
||||
# define ECHO fprintf(yyout, "%s",yytext)
|
||||
# define REJECT { nstr = yyreject(); goto yyfussy;}
|
||||
int yyleng; extern char yytext[];
|
||||
int yymorfg;
|
||||
extern char *yysptr, yysbuf[];
|
||||
int yytchar;
|
||||
FILE *yyin = {stdin}, *yyout = {stdout};
|
||||
extern int yylineno;
|
||||
struct yysvf {
|
||||
struct yywork *yystoff;
|
||||
struct yysvf *yyother;
|
||||
int *yystops;};
|
||||
struct yysvf *yyestate;
|
||||
extern struct yysvf yysvec[], *yybgin;
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "y_tab.h"
|
||||
|
||||
#undef input
|
||||
#undef unput
|
||||
|
||||
static Input input;
|
||||
static Unput unput;
|
||||
|
||||
void lua_setinput (Input fn)
|
||||
{
|
||||
input = fn;
|
||||
}
|
||||
|
||||
void lua_setunput (Unput fn)
|
||||
{
|
||||
unput = fn;
|
||||
}
|
||||
|
||||
char *lua_lasttext (void)
|
||||
{
|
||||
return yytext;
|
||||
}
|
||||
|
||||
# define YYNEWLINE 10
|
||||
yylex(){
|
||||
int nstr; extern int yyprevious;
|
||||
while((nstr = yylook()) >= 0)
|
||||
yyfussy: switch(nstr){
|
||||
case 0:
|
||||
if(yywrap()) return(0); break;
|
||||
case 1:
|
||||
;
|
||||
break;
|
||||
case 2:
|
||||
{yylval.vInt = 1; return DEBUG;}
|
||||
break;
|
||||
case 3:
|
||||
{yylval.vInt = 0; return DEBUG;}
|
||||
break;
|
||||
case 4:
|
||||
lua_linenumber++;
|
||||
break;
|
||||
case 5:
|
||||
;
|
||||
break;
|
||||
case 6:
|
||||
return LOCAL;
|
||||
break;
|
||||
case 7:
|
||||
return IF;
|
||||
break;
|
||||
case 8:
|
||||
return THEN;
|
||||
break;
|
||||
case 9:
|
||||
return ELSE;
|
||||
break;
|
||||
case 10:
|
||||
return ELSEIF;
|
||||
break;
|
||||
case 11:
|
||||
return WHILE;
|
||||
break;
|
||||
case 12:
|
||||
return DO;
|
||||
break;
|
||||
case 13:
|
||||
return REPEAT;
|
||||
break;
|
||||
case 14:
|
||||
return UNTIL;
|
||||
break;
|
||||
case 15:
|
||||
{
|
||||
yylval.vWord = lua_nfile-1;
|
||||
return FUNCTION;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
return END;
|
||||
break;
|
||||
case 17:
|
||||
return RETURN;
|
||||
break;
|
||||
case 18:
|
||||
return LOCAL;
|
||||
break;
|
||||
case 19:
|
||||
return NIL;
|
||||
break;
|
||||
case 20:
|
||||
return AND;
|
||||
break;
|
||||
case 21:
|
||||
return OR;
|
||||
break;
|
||||
case 22:
|
||||
return NOT;
|
||||
break;
|
||||
case 23:
|
||||
return NE;
|
||||
break;
|
||||
case 24:
|
||||
return LE;
|
||||
break;
|
||||
case 25:
|
||||
return GE;
|
||||
break;
|
||||
case 26:
|
||||
return CONC;
|
||||
break;
|
||||
case 27:
|
||||
case 28:
|
||||
{
|
||||
yylval.vWord = lua_findenclosedconstant (yytext);
|
||||
return STRING;
|
||||
}
|
||||
break;
|
||||
case 29:
|
||||
case 30:
|
||||
case 31:
|
||||
case 32:
|
||||
{
|
||||
yylval.vFloat = atof(yytext);
|
||||
return NUMBER;
|
||||
}
|
||||
break;
|
||||
case 33:
|
||||
{
|
||||
yylval.vWord = lua_findsymbol (yytext);
|
||||
return NAME;
|
||||
}
|
||||
break;
|
||||
case 34:
|
||||
return *yytext;
|
||||
break;
|
||||
case -1:
|
||||
break;
|
||||
default:
|
||||
fprintf(yyout,"bad switch yylook %d",nstr);
|
||||
} return(0); }
|
||||
/* end of yylex */
|
||||
int yyvstop[] = {
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
1,
|
||||
34,
|
||||
0,
|
||||
|
||||
4,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
29,
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
33,
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
34,
|
||||
0,
|
||||
|
||||
1,
|
||||
0,
|
||||
|
||||
27,
|
||||
0,
|
||||
|
||||
28,
|
||||
0,
|
||||
|
||||
5,
|
||||
0,
|
||||
|
||||
26,
|
||||
0,
|
||||
|
||||
30,
|
||||
0,
|
||||
|
||||
29,
|
||||
0,
|
||||
|
||||
29,
|
||||
0,
|
||||
|
||||
24,
|
||||
0,
|
||||
|
||||
25,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
12,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
7,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
21,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
23,
|
||||
0,
|
||||
|
||||
29,
|
||||
30,
|
||||
0,
|
||||
|
||||
31,
|
||||
0,
|
||||
|
||||
20,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
16,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
19,
|
||||
33,
|
||||
0,
|
||||
|
||||
22,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
32,
|
||||
0,
|
||||
|
||||
9,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
8,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
31,
|
||||
32,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
6,
|
||||
18,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
14,
|
||||
33,
|
||||
0,
|
||||
|
||||
11,
|
||||
33,
|
||||
0,
|
||||
|
||||
10,
|
||||
33,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
13,
|
||||
33,
|
||||
0,
|
||||
|
||||
17,
|
||||
33,
|
||||
0,
|
||||
|
||||
2,
|
||||
0,
|
||||
|
||||
33,
|
||||
0,
|
||||
|
||||
15,
|
||||
33,
|
||||
0,
|
||||
|
||||
3,
|
||||
0,
|
||||
0};
|
||||
# define YYTYPE char
|
||||
struct yywork { YYTYPE verify, advance; } yycrank[] = {
|
||||
0,0, 0,0, 1,3, 0,0,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 1,4, 1,5,
|
||||
6,29, 4,28, 0,0, 0,0,
|
||||
0,0, 0,0, 7,31, 0,0,
|
||||
6,29, 6,29, 0,0, 0,0,
|
||||
0,0, 0,0, 7,31, 7,31,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 0,0, 1,6,
|
||||
4,28, 0,0, 0,0, 0,0,
|
||||
1,7, 0,0, 0,0, 0,0,
|
||||
1,3, 6,30, 1,8, 1,9,
|
||||
0,0, 1,10, 6,29, 7,31,
|
||||
8,33, 0,0, 6,29, 0,0,
|
||||
7,32, 0,0, 0,0, 6,29,
|
||||
7,31, 1,11, 0,0, 1,12,
|
||||
2,27, 7,31, 1,13, 11,39,
|
||||
12,40, 1,13, 26,56, 0,0,
|
||||
0,0, 2,8, 2,9, 0,0,
|
||||
6,29, 0,0, 0,0, 6,29,
|
||||
0,0, 0,0, 7,31, 0,0,
|
||||
0,0, 7,31, 0,0, 0,0,
|
||||
2,11, 0,0, 2,12, 0,0,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 1,14, 0,0,
|
||||
0,0, 1,15, 1,16, 1,17,
|
||||
0,0, 22,52, 1,18, 18,47,
|
||||
23,53, 1,19, 42,63, 1,20,
|
||||
1,21, 25,55, 14,42, 1,22,
|
||||
15,43, 1,23, 1,24, 16,44,
|
||||
1,25, 16,45, 17,46, 19,48,
|
||||
21,51, 2,14, 20,49, 1,26,
|
||||
2,15, 2,16, 2,17, 24,54,
|
||||
20,50, 2,18, 44,64, 45,65,
|
||||
2,19, 46,66, 2,20, 2,21,
|
||||
27,57, 48,67, 2,22, 49,68,
|
||||
2,23, 2,24, 50,69, 2,25,
|
||||
52,70, 53,72, 27,58, 54,73,
|
||||
52,71, 9,34, 2,26, 9,35,
|
||||
9,35, 9,35, 9,35, 9,35,
|
||||
9,35, 9,35, 9,35, 9,35,
|
||||
9,35, 10,36, 55,74, 10,37,
|
||||
10,37, 10,37, 10,37, 10,37,
|
||||
10,37, 10,37, 10,37, 10,37,
|
||||
10,37, 57,75, 58,76, 64,80,
|
||||
66,81, 67,82, 70,83, 71,84,
|
||||
72,85, 73,86, 74,87, 10,38,
|
||||
10,38, 38,61, 10,38, 38,61,
|
||||
75,88, 76,89, 38,62, 38,62,
|
||||
38,62, 38,62, 38,62, 38,62,
|
||||
38,62, 38,62, 38,62, 38,62,
|
||||
80,92, 81,93, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
82,94, 83,95, 84,96, 10,38,
|
||||
10,38, 86,97, 10,38, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 87,98, 88,99, 60,79,
|
||||
60,79, 13,41, 60,79, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 13,41, 13,41, 13,41,
|
||||
13,41, 33,33, 89,100, 60,79,
|
||||
60,79, 92,101, 60,79, 93,102,
|
||||
95,103, 33,33, 33,0, 96,104,
|
||||
99,105, 100,106, 102,107, 106,108,
|
||||
107,109, 35,35, 35,35, 35,35,
|
||||
35,35, 35,35, 35,35, 35,35,
|
||||
35,35, 35,35, 35,35, 108,110,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 0,0, 33,33, 0,0,
|
||||
0,0, 35,59, 35,59, 33,33,
|
||||
35,59, 0,0, 0,0, 33,33,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
33,33, 0,0, 0,0, 0,0,
|
||||
0,0, 36,60, 36,60, 36,60,
|
||||
36,60, 36,60, 36,60, 36,60,
|
||||
36,60, 36,60, 36,60, 0,0,
|
||||
0,0, 33,33, 0,0, 0,0,
|
||||
33,33, 35,59, 35,59, 0,0,
|
||||
35,59, 36,38, 36,38, 59,77,
|
||||
36,38, 59,77, 0,0, 0,0,
|
||||
59,78, 59,78, 59,78, 59,78,
|
||||
59,78, 59,78, 59,78, 59,78,
|
||||
59,78, 59,78, 61,62, 61,62,
|
||||
61,62, 61,62, 61,62, 61,62,
|
||||
61,62, 61,62, 61,62, 61,62,
|
||||
0,0, 0,0, 0,0, 0,0,
|
||||
0,0, 36,38, 36,38, 0,0,
|
||||
36,38, 77,78, 77,78, 77,78,
|
||||
77,78, 77,78, 77,78, 77,78,
|
||||
77,78, 77,78, 77,78, 79,90,
|
||||
0,0, 79,90, 0,0, 0,0,
|
||||
79,91, 79,91, 79,91, 79,91,
|
||||
79,91, 79,91, 79,91, 79,91,
|
||||
79,91, 79,91, 90,91, 90,91,
|
||||
90,91, 90,91, 90,91, 90,91,
|
||||
90,91, 90,91, 90,91, 90,91,
|
||||
0,0};
|
||||
struct yysvf yysvec[] = {
|
||||
0, 0, 0,
|
||||
yycrank+-1, 0, yyvstop+1,
|
||||
yycrank+-28, yysvec+1, yyvstop+3,
|
||||
yycrank+0, 0, yyvstop+5,
|
||||
yycrank+4, 0, yyvstop+7,
|
||||
yycrank+0, 0, yyvstop+10,
|
||||
yycrank+-11, 0, yyvstop+12,
|
||||
yycrank+-17, 0, yyvstop+14,
|
||||
yycrank+7, 0, yyvstop+16,
|
||||
yycrank+107, 0, yyvstop+18,
|
||||
yycrank+119, 0, yyvstop+20,
|
||||
yycrank+6, 0, yyvstop+23,
|
||||
yycrank+7, 0, yyvstop+25,
|
||||
yycrank+158, 0, yyvstop+27,
|
||||
yycrank+4, yysvec+13, yyvstop+30,
|
||||
yycrank+5, yysvec+13, yyvstop+33,
|
||||
yycrank+11, yysvec+13, yyvstop+36,
|
||||
yycrank+5, yysvec+13, yyvstop+39,
|
||||
yycrank+5, yysvec+13, yyvstop+42,
|
||||
yycrank+12, yysvec+13, yyvstop+45,
|
||||
yycrank+21, yysvec+13, yyvstop+48,
|
||||
yycrank+10, yysvec+13, yyvstop+51,
|
||||
yycrank+4, yysvec+13, yyvstop+54,
|
||||
yycrank+4, yysvec+13, yyvstop+57,
|
||||
yycrank+21, yysvec+13, yyvstop+60,
|
||||
yycrank+9, yysvec+13, yyvstop+63,
|
||||
yycrank+9, 0, yyvstop+66,
|
||||
yycrank+40, 0, yyvstop+68,
|
||||
yycrank+0, yysvec+4, yyvstop+70,
|
||||
yycrank+0, yysvec+6, 0,
|
||||
yycrank+0, 0, yyvstop+72,
|
||||
yycrank+0, yysvec+7, 0,
|
||||
yycrank+0, 0, yyvstop+74,
|
||||
yycrank+-280, 0, yyvstop+76,
|
||||
yycrank+0, 0, yyvstop+78,
|
||||
yycrank+249, 0, yyvstop+80,
|
||||
yycrank+285, 0, yyvstop+82,
|
||||
yycrank+0, yysvec+10, yyvstop+84,
|
||||
yycrank+146, 0, 0,
|
||||
yycrank+0, 0, yyvstop+86,
|
||||
yycrank+0, 0, yyvstop+88,
|
||||
yycrank+0, yysvec+13, yyvstop+90,
|
||||
yycrank+10, yysvec+13, yyvstop+92,
|
||||
yycrank+0, yysvec+13, yyvstop+94,
|
||||
yycrank+19, yysvec+13, yyvstop+97,
|
||||
yycrank+35, yysvec+13, yyvstop+99,
|
||||
yycrank+27, yysvec+13, yyvstop+101,
|
||||
yycrank+0, yysvec+13, yyvstop+103,
|
||||
yycrank+42, yysvec+13, yyvstop+106,
|
||||
yycrank+35, yysvec+13, yyvstop+108,
|
||||
yycrank+30, yysvec+13, yyvstop+110,
|
||||
yycrank+0, yysvec+13, yyvstop+112,
|
||||
yycrank+36, yysvec+13, yyvstop+115,
|
||||
yycrank+48, yysvec+13, yyvstop+117,
|
||||
yycrank+35, yysvec+13, yyvstop+119,
|
||||
yycrank+61, yysvec+13, yyvstop+121,
|
||||
yycrank+0, 0, yyvstop+123,
|
||||
yycrank+76, 0, 0,
|
||||
yycrank+67, 0, 0,
|
||||
yycrank+312, 0, 0,
|
||||
yycrank+183, yysvec+36, yyvstop+125,
|
||||
yycrank+322, 0, 0,
|
||||
yycrank+0, yysvec+61, yyvstop+128,
|
||||
yycrank+0, yysvec+13, yyvstop+130,
|
||||
yycrank+78, yysvec+13, yyvstop+133,
|
||||
yycrank+0, yysvec+13, yyvstop+135,
|
||||
yycrank+81, yysvec+13, yyvstop+138,
|
||||
yycrank+84, yysvec+13, yyvstop+140,
|
||||
yycrank+0, yysvec+13, yyvstop+142,
|
||||
yycrank+0, yysvec+13, yyvstop+145,
|
||||
yycrank+81, yysvec+13, yyvstop+148,
|
||||
yycrank+66, yysvec+13, yyvstop+150,
|
||||
yycrank+74, yysvec+13, yyvstop+152,
|
||||
yycrank+80, yysvec+13, yyvstop+154,
|
||||
yycrank+78, yysvec+13, yyvstop+156,
|
||||
yycrank+94, 0, 0,
|
||||
yycrank+93, 0, 0,
|
||||
yycrank+341, 0, 0,
|
||||
yycrank+0, yysvec+77, yyvstop+158,
|
||||
yycrank+356, 0, 0,
|
||||
yycrank+99, yysvec+13, yyvstop+160,
|
||||
yycrank+89, yysvec+13, yyvstop+163,
|
||||
yycrank+108, yysvec+13, yyvstop+165,
|
||||
yycrank+120, yysvec+13, yyvstop+167,
|
||||
yycrank+104, yysvec+13, yyvstop+169,
|
||||
yycrank+0, yysvec+13, yyvstop+171,
|
||||
yycrank+113, yysvec+13, yyvstop+174,
|
||||
yycrank+148, yysvec+13, yyvstop+176,
|
||||
yycrank+133, 0, 0,
|
||||
yycrank+181, 0, 0,
|
||||
yycrank+366, 0, 0,
|
||||
yycrank+0, yysvec+90, yyvstop+178,
|
||||
yycrank+183, yysvec+13, yyvstop+181,
|
||||
yycrank+182, yysvec+13, yyvstop+183,
|
||||
yycrank+0, yysvec+13, yyvstop+185,
|
||||
yycrank+172, yysvec+13, yyvstop+189,
|
||||
yycrank+181, yysvec+13, yyvstop+191,
|
||||
yycrank+0, yysvec+13, yyvstop+193,
|
||||
yycrank+0, yysvec+13, yyvstop+196,
|
||||
yycrank+189, 0, 0,
|
||||
yycrank+195, 0, 0,
|
||||
yycrank+0, yysvec+13, yyvstop+199,
|
||||
yycrank+183, yysvec+13, yyvstop+202,
|
||||
yycrank+0, yysvec+13, yyvstop+204,
|
||||
yycrank+0, yysvec+13, yyvstop+207,
|
||||
yycrank+0, 0, yyvstop+210,
|
||||
yycrank+178, 0, 0,
|
||||
yycrank+186, yysvec+13, yyvstop+212,
|
||||
yycrank+204, 0, 0,
|
||||
yycrank+0, yysvec+13, yyvstop+214,
|
||||
yycrank+0, 0, yyvstop+217,
|
||||
0, 0, 0};
|
||||
struct yywork *yytop = yycrank+423;
|
||||
struct yysvf *yybgin = yysvec+1;
|
||||
char yymatch[] = {
|
||||
00 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,011 ,012 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,01 ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
011 ,01 ,'"' ,01 ,01 ,01 ,01 ,047 ,
|
||||
01 ,01 ,01 ,'+' ,01 ,'+' ,01 ,01 ,
|
||||
'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
|
||||
'0' ,'0' ,01 ,01 ,01 ,01 ,01 ,01 ,
|
||||
01 ,'A' ,'A' ,'A' ,'D' ,'D' ,'A' ,'D' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,'A' ,
|
||||
01 ,'A' ,'A' ,'A' ,'D' ,'D' ,'A' ,'D' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
|
||||
'A' ,'A' ,'A' ,01 ,01 ,01 ,01 ,01 ,
|
||||
0};
|
||||
char yyextra[] = {
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0,0,0,0,0,0,0,0,
|
||||
0};
|
||||
#ifndef lint
|
||||
static char ncform_sccsid[] = "@(#)ncform 1.6 88/02/08 SMI"; /* from S5R2 1.2 */
|
||||
#endif
|
||||
|
||||
int yylineno =1;
|
||||
# define YYU(x) x
|
||||
# define NLSTATE yyprevious=YYNEWLINE
|
||||
char yytext[YYLMAX];
|
||||
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
|
||||
char yysbuf[YYLMAX];
|
||||
char *yysptr = yysbuf;
|
||||
int *yyfnd;
|
||||
extern struct yysvf *yyestate;
|
||||
int yyprevious = YYNEWLINE;
|
||||
yylook(){
|
||||
register struct yysvf *yystate, **lsp;
|
||||
register struct yywork *yyt;
|
||||
struct yysvf *yyz;
|
||||
int yych, yyfirst;
|
||||
struct yywork *yyr;
|
||||
# ifdef LEXDEBUG
|
||||
int debug;
|
||||
# endif
|
||||
char *yylastch;
|
||||
/* start off machines */
|
||||
# ifdef LEXDEBUG
|
||||
debug = 0;
|
||||
# endif
|
||||
yyfirst=1;
|
||||
if (!yymorfg)
|
||||
yylastch = yytext;
|
||||
else {
|
||||
yymorfg=0;
|
||||
yylastch = yytext+yyleng;
|
||||
}
|
||||
for(;;){
|
||||
lsp = yylstate;
|
||||
yyestate = yystate = yybgin;
|
||||
if (yyprevious==YYNEWLINE) yystate++;
|
||||
for (;;){
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
|
||||
# endif
|
||||
yyt = yystate->yystoff;
|
||||
if(yyt == yycrank && !yyfirst){ /* may not be any transitions */
|
||||
yyz = yystate->yyother;
|
||||
if(yyz == 0)break;
|
||||
if(yyz->yystoff == yycrank)break;
|
||||
}
|
||||
*yylastch++ = yych = input();
|
||||
yyfirst=0;
|
||||
tryagain:
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"char ");
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
yyr = yyt;
|
||||
if ( (int)yyt > (int)yycrank){
|
||||
yyt = yyr + yych;
|
||||
if (yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
}
|
||||
# ifdef YYOPTIM
|
||||
else if((int)yyt < (int)yycrank) { /* r < yycrank */
|
||||
yyt = yyr = yycrank+(yycrank-yyt);
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"compressed state\n");
|
||||
# endif
|
||||
yyt = yyt + yych;
|
||||
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transitions */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
yyt = yyr + YYU(yymatch[yych]);
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"try fall back character ");
|
||||
allprint(YYU(yymatch[yych]));
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
if(yyt <= yytop && yyt->verify+yysvec == yystate){
|
||||
if(yyt->advance+yysvec == YYLERR) /* error transition */
|
||||
{unput(*--yylastch);break;}
|
||||
*lsp++ = yystate = yyt->advance+yysvec;
|
||||
goto contin;
|
||||
}
|
||||
}
|
||||
if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
|
||||
# endif
|
||||
goto tryagain;
|
||||
}
|
||||
# endif
|
||||
else
|
||||
{unput(*--yylastch);break;}
|
||||
contin:
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"state %d char ",yystate-yysvec-1);
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
;
|
||||
}
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
|
||||
allprint(yych);
|
||||
putchar('\n');
|
||||
}
|
||||
# endif
|
||||
while (lsp-- > yylstate){
|
||||
*yylastch-- = 0;
|
||||
if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
|
||||
yyolsp = lsp;
|
||||
if(yyextra[*yyfnd]){ /* must backup */
|
||||
while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
|
||||
lsp--;
|
||||
unput(*yylastch--);
|
||||
}
|
||||
}
|
||||
yyprevious = YYU(*yylastch);
|
||||
yylsp = lsp;
|
||||
yyleng = yylastch-yytext+1;
|
||||
yytext[yyleng] = 0;
|
||||
# ifdef LEXDEBUG
|
||||
if(debug){
|
||||
fprintf(yyout,"\nmatch ");
|
||||
sprint(yytext);
|
||||
fprintf(yyout," action %d\n",*yyfnd);
|
||||
}
|
||||
# endif
|
||||
return(*yyfnd++);
|
||||
}
|
||||
unput(*yylastch);
|
||||
}
|
||||
if (yytext[0] == 0 /* && feof(yyin) */)
|
||||
{
|
||||
yysptr=yysbuf;
|
||||
return(0);
|
||||
}
|
||||
yyprevious = yytext[0] = input();
|
||||
if (yyprevious>0)
|
||||
output(yyprevious);
|
||||
yylastch=yytext;
|
||||
# ifdef LEXDEBUG
|
||||
if(debug)putchar('\n');
|
||||
# endif
|
||||
}
|
||||
}
|
||||
yyback(p, m)
|
||||
int *p;
|
||||
{
|
||||
if (p==0) return(0);
|
||||
while (*p)
|
||||
{
|
||||
if (*p++ == m)
|
||||
return(1);
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
/* the following are only used in the lex library */
|
||||
yyinput(){
|
||||
return(input());
|
||||
}
|
||||
yyoutput(c)
|
||||
int c; {
|
||||
output(c);
|
||||
}
|
||||
yyunput(c)
|
||||
int c; {
|
||||
unput(c);
|
||||
}
|
||||
88
lua.c
88
lua.c
@@ -1,92 +1,54 @@
|
||||
/*
|
||||
** lua.c
|
||||
** Linguagem para Usuarios de Aplicacao
|
||||
** TeCGraf - PUC-Rio
|
||||
** 28 Apr 93
|
||||
*/
|
||||
|
||||
char *rcs_lua="$Id: lua.c,v 1.7 1995/10/31 17:05:35 roberto Exp roberto $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
#include "lualib.h"
|
||||
|
||||
static int lua_argc;
|
||||
static char **lua_argv;
|
||||
|
||||
/*
|
||||
** although this function is POSIX, there is no standard header file that
|
||||
** defines it
|
||||
*/
|
||||
int isatty (int fd);
|
||||
|
||||
/*
|
||||
%F Allow Lua code to access argv strings.
|
||||
%i Receive from Lua the argument number (starting with 1).
|
||||
%o Return to Lua the argument, or nil if it does not exist.
|
||||
*/
|
||||
static void lua_getargv (void)
|
||||
void test (void)
|
||||
{
|
||||
lua_Object lo = lua_getparam(1);
|
||||
if (!lua_isnumber(lo))
|
||||
lua_pushnil();
|
||||
else
|
||||
{
|
||||
int n = (int)lua_getnumber(lo);
|
||||
if (n < 1 || n > lua_argc) lua_pushnil();
|
||||
else lua_pushstring(lua_argv[n]);
|
||||
}
|
||||
lua_pushobject(lua_getparam(1));
|
||||
lua_call ("c", 1);
|
||||
}
|
||||
|
||||
|
||||
static void manual_input (void)
|
||||
static void callfunc (void)
|
||||
{
|
||||
if (isatty(fileno(stdin)))
|
||||
{
|
||||
char buffer[250];
|
||||
while (fgets(buffer, sizeof(buffer), stdin) != 0)
|
||||
lua_dostring(buffer);
|
||||
}
|
||||
else
|
||||
lua_dofile(NULL); /* executes stdin as a file */
|
||||
lua_Object obj = lua_getparam (1);
|
||||
if (lua_isstring(obj)) lua_call(lua_getstring(obj),0);
|
||||
}
|
||||
|
||||
static void execstr (void)
|
||||
{
|
||||
lua_Object obj = lua_getparam (1);
|
||||
if (lua_isstring(obj)) lua_dostring(lua_getstring(obj));
|
||||
}
|
||||
|
||||
int main (int argc, char *argv[])
|
||||
void main (int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
int result = 0;
|
||||
if (argc < 2)
|
||||
{
|
||||
puts ("usage: lua filename [functionnames]");
|
||||
return;
|
||||
}
|
||||
lua_register ("callfunc", callfunc);
|
||||
lua_register ("execstr", execstr);
|
||||
lua_register ("test", test);
|
||||
iolib_open ();
|
||||
strlib_open ();
|
||||
mathlib_open ();
|
||||
|
||||
lua_register("argv", lua_getargv);
|
||||
|
||||
if (argc < 2)
|
||||
manual_input();
|
||||
else
|
||||
lua_dofile (argv[1]);
|
||||
for (i=2; i<argc; i++)
|
||||
{
|
||||
for (i=1; i<argc; i++)
|
||||
if (strcmp(argv[i], "--") == 0)
|
||||
{
|
||||
lua_argc = argc-i-1;
|
||||
lua_argv = argv+i;
|
||||
break;
|
||||
}
|
||||
for (i=1; i<argc; i++)
|
||||
{
|
||||
if (strcmp(argv[i], "--") == 0)
|
||||
break;
|
||||
else if (strcmp(argv[i], "-") == 0)
|
||||
manual_input();
|
||||
else if (strcmp(argv[i], "-v") == 0)
|
||||
printf("%s %s\n(written by %s)\n\n",
|
||||
LUA_VERSION, LUA_COPYRIGHT, LUA_AUTHORS);
|
||||
else
|
||||
result = lua_dofile (argv[i]);
|
||||
}
|
||||
lua_call (argv[i],0);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
121
lua.h
121
lua.h
@@ -2,108 +2,53 @@
|
||||
** LUA - Linguagem para Usuarios de Aplicacao
|
||||
** Grupo de Tecnologia em Computacao Grafica
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: lua.h,v 3.24 1996/03/19 22:28:37 roberto Exp roberto $
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
|
||||
#ifndef lua_h
|
||||
#define lua_h
|
||||
|
||||
#define LUA_VERSION "Lua 2.4 (beta)"
|
||||
#define LUA_COPYRIGHT "Copyright (C) 1994, 1995 TeCGraf"
|
||||
#define LUA_AUTHORS "W. Celes, R. Ierusalimschy & L. H. de Figueiredo"
|
||||
|
||||
|
||||
/* Private Part */
|
||||
|
||||
typedef enum
|
||||
{
|
||||
LUA_T_NIL = -1,
|
||||
LUA_T_NUMBER = -2,
|
||||
LUA_T_STRING = -3,
|
||||
LUA_T_ARRAY = -4,
|
||||
LUA_T_FUNCTION = -5,
|
||||
LUA_T_CFUNCTION= -6,
|
||||
LUA_T_MARK = -7,
|
||||
LUA_T_CMARK = -8,
|
||||
LUA_T_LINE = -9,
|
||||
LUA_T_USERDATA = 0
|
||||
} lua_Type;
|
||||
|
||||
|
||||
/* Public Part */
|
||||
|
||||
#define LUA_NOOBJECT 0
|
||||
|
||||
typedef void (*lua_CFunction) (void);
|
||||
typedef unsigned int lua_Object;
|
||||
|
||||
lua_Object lua_setfallback (char *name, lua_CFunction fallback);
|
||||
|
||||
void lua_error (char *s);
|
||||
int lua_dofile (char *filename);
|
||||
int lua_dostring (char *string);
|
||||
int lua_callfunction (lua_Object function);
|
||||
int lua_call (char *funcname);
|
||||
|
||||
void lua_beginblock (void);
|
||||
void lua_endblock (void);
|
||||
|
||||
lua_Object lua_getparam (int number);
|
||||
#define lua_getresult(_) lua_getparam(_)
|
||||
|
||||
#define lua_isnil(_) (lua_type(_)==LUA_T_NIL)
|
||||
#define lua_istable(_) (lua_type(_)==LUA_T_ARRAY)
|
||||
#define lua_isuserdata(_) (lua_type(_)>=LUA_T_USERDATA)
|
||||
#define lua_iscfunction(_) (lua_type(_)==LUA_T_CFUNCTION)
|
||||
int lua_isnumber (lua_Object object);
|
||||
int lua_isstring (lua_Object object);
|
||||
int lua_isfunction (lua_Object object);
|
||||
|
||||
float lua_getnumber (lua_Object object);
|
||||
char *lua_getstring (lua_Object object);
|
||||
lua_CFunction lua_getcfunction (lua_Object object);
|
||||
void *lua_getuserdata (lua_Object object);
|
||||
|
||||
void lua_pushnil (void);
|
||||
void lua_pushnumber (float n);
|
||||
void lua_pushstring (char *s);
|
||||
void lua_pushcfunction (lua_CFunction fn);
|
||||
void lua_pushusertag (void *u, int tag);
|
||||
void lua_pushobject (lua_Object object);
|
||||
|
||||
lua_Object lua_getglobal (char *name);
|
||||
void lua_storeglobal (char *name);
|
||||
|
||||
void lua_storesubscript (void);
|
||||
lua_Object lua_getsubscript (void);
|
||||
|
||||
int lua_type (lua_Object object);
|
||||
|
||||
int lua_lock (void);
|
||||
lua_Object lua_getlocked (int ref);
|
||||
void lua_pushlocked (int ref);
|
||||
void lua_unlock (int ref);
|
||||
|
||||
lua_Object lua_createtable (void);
|
||||
|
||||
|
||||
/* some useful macros */
|
||||
|
||||
#define lua_lockobject(o) (lua_pushobject(o), lua_lock())
|
||||
typedef struct Object *lua_Object;
|
||||
|
||||
#define lua_register(n,f) (lua_pushcfunction(f), lua_storeglobal(n))
|
||||
|
||||
#define lua_pushuserdata(u) lua_pushusertag(u, LUA_T_USERDATA)
|
||||
|
||||
void lua_errorfunction (void (*fn) (char *s));
|
||||
void lua_error (char *s);
|
||||
int lua_dofile (char *filename);
|
||||
int lua_dostring (char *string);
|
||||
int lua_call (char *functionname, int nparam);
|
||||
|
||||
/* for compatibility with old versions. Avoid using these macros */
|
||||
lua_Object lua_getparam (int number);
|
||||
float lua_getnumber (lua_Object object);
|
||||
char *lua_getstring (lua_Object object);
|
||||
char *lua_copystring (lua_Object object);
|
||||
lua_CFunction lua_getcfunction (lua_Object object);
|
||||
void *lua_getuserdata (lua_Object object);
|
||||
lua_Object lua_getfield (lua_Object object, char *field);
|
||||
lua_Object lua_getindexed (lua_Object object, float index);
|
||||
lua_Object lua_getglobal (char *name);
|
||||
|
||||
#define lua_pushliteral(o) lua_pushstring(o)
|
||||
lua_Object lua_pop (void);
|
||||
|
||||
#define lua_getindexed(o,n) (lua_pushobject(o), lua_pushnumber(n), lua_getsubscript())
|
||||
#define lua_getfield(o,f) (lua_pushobject(o), lua_pushliteral(f), lua_getsubscript())
|
||||
int lua_pushnil (void);
|
||||
int lua_pushnumber (float n);
|
||||
int lua_pushstring (char *s);
|
||||
int lua_pushcfunction (lua_CFunction fn);
|
||||
int lua_pushuserdata (void *u);
|
||||
int lua_pushobject (lua_Object object);
|
||||
|
||||
#define lua_copystring(o) (strdup(lua_getstring(o)))
|
||||
int lua_storeglobal (char *name);
|
||||
int lua_storefield (lua_Object object, char *field);
|
||||
int lua_storeindexed (lua_Object object, float index);
|
||||
|
||||
int lua_isnil (lua_Object object);
|
||||
int lua_isnumber (lua_Object object);
|
||||
int lua_isstring (lua_Object object);
|
||||
int lua_istable (lua_Object object);
|
||||
int lua_iscfunction (lua_Object object);
|
||||
int lua_isuserdata (lua_Object object);
|
||||
|
||||
#endif
|
||||
|
||||
788
lua.stx
788
lua.stx
@@ -1,788 +0,0 @@
|
||||
%{
|
||||
|
||||
char *rcs_luastx = "$Id: lua.stx,v 3.35 1996/03/08 12:02:37 roberto Exp roberto $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "luadebug.h"
|
||||
#include "mem.h"
|
||||
#include "lex.h"
|
||||
#include "opcode.h"
|
||||
#include "hash.h"
|
||||
#include "inout.h"
|
||||
#include "tree.h"
|
||||
#include "table.h"
|
||||
#include "lua.h"
|
||||
#include "func.h"
|
||||
|
||||
/* to avoid warnings generated by yacc */
|
||||
int yyparse (void);
|
||||
#define malloc luaI_malloc
|
||||
#define realloc luaI_realloc
|
||||
#define free luaI_free
|
||||
|
||||
#ifndef LISTING
|
||||
#define LISTING 0
|
||||
#endif
|
||||
|
||||
#ifndef CODE_BLOCK
|
||||
#define CODE_BLOCK 256
|
||||
#endif
|
||||
static int maxcode;
|
||||
static int maxmain;
|
||||
static int maxcurr;
|
||||
static Byte *funcCode = NULL;
|
||||
static Byte **initcode;
|
||||
static Byte *basepc;
|
||||
static int maincode;
|
||||
static int pc;
|
||||
|
||||
|
||||
#define MAXVAR 32
|
||||
static Long varbuffer[MAXVAR]; /* variables in an assignment list;
|
||||
it's long to store negative Word values */
|
||||
static int nvarbuffer=0; /* number of variables at a list */
|
||||
|
||||
#define MAXLOCALS 32
|
||||
static TaggedString *localvar[MAXLOCALS]; /* store local variable names */
|
||||
static int nlocalvar=0; /* number of local variables */
|
||||
|
||||
#define MAXFIELDS FIELDS_PER_FLUSH*2
|
||||
static Word fields[MAXFIELDS]; /* fieldnames to be flushed */
|
||||
static int nfields=0;
|
||||
|
||||
int lua_debug = 0;
|
||||
|
||||
/* Internal functions */
|
||||
|
||||
static void yyerror (char *s)
|
||||
{
|
||||
char msg[256];
|
||||
char *token = lua_lasttext();
|
||||
if (token[0] == 0)
|
||||
token = "<eof>";
|
||||
sprintf (msg,"%s; last token read: \"%s\" at line %d in file `%s'",
|
||||
s, token, lua_linenumber, lua_parsedfile);
|
||||
lua_error (msg);
|
||||
}
|
||||
|
||||
static void code_byte (Byte c)
|
||||
{
|
||||
if (pc>maxcurr-2) /* 1 byte free to code HALT of main code */
|
||||
maxcurr = growvector(&basepc, maxcurr, Byte, codeEM, MAX_INT);
|
||||
basepc[pc++] = c;
|
||||
}
|
||||
|
||||
static void code_word (Word n)
|
||||
{
|
||||
CodeWord code;
|
||||
code.w = n;
|
||||
code_byte(code.m.c1);
|
||||
code_byte(code.m.c2);
|
||||
}
|
||||
|
||||
static void code_float (float n)
|
||||
{
|
||||
CodeFloat code;
|
||||
code.f = n;
|
||||
code_byte(code.m.c1);
|
||||
code_byte(code.m.c2);
|
||||
code_byte(code.m.c3);
|
||||
code_byte(code.m.c4);
|
||||
}
|
||||
|
||||
static void code_code (TFunc *tf)
|
||||
{
|
||||
CodeCode code;
|
||||
code.tf = tf;
|
||||
code_byte(code.m.c1);
|
||||
code_byte(code.m.c2);
|
||||
code_byte(code.m.c3);
|
||||
code_byte(code.m.c4);
|
||||
}
|
||||
|
||||
static void code_word_at (Byte *p, int n)
|
||||
{
|
||||
CodeWord code;
|
||||
if ((Word)n != n)
|
||||
yyerror("block too big");
|
||||
code.w = (Word)n;
|
||||
*p++ = code.m.c1;
|
||||
*p++ = code.m.c2;
|
||||
}
|
||||
|
||||
static void push_field (Word name)
|
||||
{
|
||||
if (nfields < MAXFIELDS)
|
||||
fields[nfields++] = name;
|
||||
else
|
||||
yyerror ("too many fields in nested constructors");
|
||||
}
|
||||
|
||||
static void flush_record (int n)
|
||||
{
|
||||
int i;
|
||||
if (n == 0) return;
|
||||
code_byte(STORERECORD);
|
||||
code_byte(n);
|
||||
for (i=0; i<n; i++)
|
||||
code_word(fields[--nfields]);
|
||||
}
|
||||
|
||||
static void flush_list (int m, int n)
|
||||
{
|
||||
if (n == 0) return;
|
||||
if (m == 0)
|
||||
code_byte(STORELIST0);
|
||||
else
|
||||
if (m < 255)
|
||||
{
|
||||
code_byte(STORELIST);
|
||||
code_byte(m);
|
||||
}
|
||||
else
|
||||
yyerror ("list constructor too long");
|
||||
code_byte(n);
|
||||
}
|
||||
|
||||
static void store_localvar (TaggedString *name, int n)
|
||||
{
|
||||
if (nlocalvar+n < MAXLOCALS)
|
||||
localvar[nlocalvar+n] = name;
|
||||
else
|
||||
yyerror ("too many local variables");
|
||||
if (lua_debug)
|
||||
luaI_registerlocalvar(name, lua_linenumber);
|
||||
}
|
||||
|
||||
static void add_localvar (TaggedString *name)
|
||||
{
|
||||
store_localvar(name, 0);
|
||||
nlocalvar++;
|
||||
}
|
||||
|
||||
static void add_varbuffer (Long var)
|
||||
{
|
||||
if (nvarbuffer < MAXVAR)
|
||||
varbuffer[nvarbuffer++] = var;
|
||||
else
|
||||
yyerror ("variable buffer overflow");
|
||||
}
|
||||
|
||||
static void code_number (float f)
|
||||
{
|
||||
Word i = (Word)f;
|
||||
if (f == (float)i) /* f has an (short) integer value */
|
||||
{
|
||||
if (i <= 2) code_byte(PUSH0 + i);
|
||||
else if (i <= 255)
|
||||
{
|
||||
code_byte(PUSHBYTE);
|
||||
code_byte(i);
|
||||
}
|
||||
else
|
||||
{
|
||||
code_byte(PUSHWORD);
|
||||
code_word(i);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
code_byte(PUSHFLOAT);
|
||||
code_float(f);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Search a local name and if find return its index. If do not find return -1
|
||||
*/
|
||||
static int lua_localname (TaggedString *n)
|
||||
{
|
||||
int i;
|
||||
for (i=nlocalvar-1; i >= 0; i--)
|
||||
if (n == localvar[i]) return i; /* local var */
|
||||
return -1; /* global var */
|
||||
}
|
||||
|
||||
/*
|
||||
** Push a variable given a number. If number is positive, push global variable
|
||||
** indexed by (number -1). If negative, push local indexed by ABS(number)-1.
|
||||
** Otherwise, if zero, push indexed variable (record).
|
||||
*/
|
||||
static void lua_pushvar (Long number)
|
||||
{
|
||||
if (number > 0) /* global var */
|
||||
{
|
||||
code_byte(PUSHGLOBAL);
|
||||
code_word(number-1);
|
||||
}
|
||||
else if (number < 0) /* local var */
|
||||
{
|
||||
number = (-number) - 1;
|
||||
if (number < 10) code_byte(PUSHLOCAL0 + number);
|
||||
else
|
||||
{
|
||||
code_byte(PUSHLOCAL);
|
||||
code_byte(number);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
code_byte(PUSHINDEXED);
|
||||
}
|
||||
}
|
||||
|
||||
static void lua_codeadjust (int n)
|
||||
{
|
||||
if (n+nlocalvar == 0)
|
||||
code_byte(ADJUST0);
|
||||
else
|
||||
{
|
||||
code_byte(ADJUST);
|
||||
code_byte(n+nlocalvar);
|
||||
}
|
||||
}
|
||||
|
||||
static void change2main (void)
|
||||
{
|
||||
/* (re)store main values */
|
||||
pc=maincode; basepc=*initcode; maxcurr=maxmain;
|
||||
nlocalvar=0;
|
||||
}
|
||||
|
||||
static void savemain (void)
|
||||
{
|
||||
/* save main values */
|
||||
maincode=pc; *initcode=basepc; maxmain=maxcurr;
|
||||
}
|
||||
|
||||
static void init_func (void)
|
||||
{
|
||||
if (funcCode == NULL) /* first function */
|
||||
{
|
||||
funcCode = newvector(CODE_BLOCK, Byte);
|
||||
maxcode = CODE_BLOCK;
|
||||
}
|
||||
savemain(); /* save main values */
|
||||
/* set func values */
|
||||
pc=0; basepc=funcCode; maxcurr=maxcode;
|
||||
nlocalvar = 0;
|
||||
luaI_codedebugline(lua_linenumber);
|
||||
}
|
||||
|
||||
static void codereturn (void)
|
||||
{
|
||||
if (nlocalvar == 0)
|
||||
code_byte(RETCODE0);
|
||||
else
|
||||
{
|
||||
code_byte(RETCODE);
|
||||
code_byte(nlocalvar);
|
||||
}
|
||||
}
|
||||
|
||||
void luaI_codedebugline (int line)
|
||||
{
|
||||
static int lastline = 0;
|
||||
if (lua_debug && line != lastline)
|
||||
{
|
||||
code_byte(SETLINE);
|
||||
code_word(line);
|
||||
lastline = line;
|
||||
}
|
||||
}
|
||||
|
||||
static int adjust_functioncall (Long exp, int i)
|
||||
{
|
||||
if (exp <= 0)
|
||||
return -exp; /* exp is -list length */
|
||||
else
|
||||
{
|
||||
int temp = basepc[exp];
|
||||
basepc[exp] = i;
|
||||
return temp+i;
|
||||
}
|
||||
}
|
||||
|
||||
static void adjust_mult_assign (int vars, Long exps, int temps)
|
||||
{
|
||||
if (exps > 0)
|
||||
{ /* must correct function call */
|
||||
int diff = vars - basepc[exps];
|
||||
if (diff >= 0)
|
||||
adjust_functioncall(exps, diff);
|
||||
else
|
||||
{
|
||||
adjust_functioncall(exps, 0);
|
||||
lua_codeadjust(temps);
|
||||
}
|
||||
}
|
||||
else if (vars != -exps)
|
||||
lua_codeadjust(temps);
|
||||
}
|
||||
|
||||
static void storesinglevar (Long v)
|
||||
{
|
||||
if (v > 0) /* global var */
|
||||
{
|
||||
code_byte(STOREGLOBAL);
|
||||
code_word(v-1);
|
||||
}
|
||||
else if (v < 0) /* local var */
|
||||
{
|
||||
int number = (-v) - 1;
|
||||
if (number < 10) code_byte(STORELOCAL0 + number);
|
||||
else
|
||||
{
|
||||
code_byte(STORELOCAL);
|
||||
code_byte(number);
|
||||
}
|
||||
}
|
||||
else
|
||||
code_byte(STOREINDEXED0);
|
||||
}
|
||||
|
||||
static void lua_codestore (int i)
|
||||
{
|
||||
if (varbuffer[i] != 0) /* global or local var */
|
||||
storesinglevar(varbuffer[i]);
|
||||
else /* indexed var */
|
||||
{
|
||||
int j;
|
||||
int upper=0; /* number of indexed variables upper */
|
||||
int param; /* number of itens until indexed expression */
|
||||
for (j=i+1; j <nvarbuffer; j++)
|
||||
if (varbuffer[j] == 0) upper++;
|
||||
param = upper*2 + i;
|
||||
if (param == 0)
|
||||
code_byte(STOREINDEXED0);
|
||||
else
|
||||
{
|
||||
code_byte(STOREINDEXED);
|
||||
code_byte(param);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void codeIf (Long thenAdd, Long elseAdd)
|
||||
{
|
||||
Long elseinit = elseAdd+sizeof(Word)+1;
|
||||
if (pc == elseinit) /* no else */
|
||||
{
|
||||
pc -= sizeof(Word)+1;
|
||||
elseinit = pc;
|
||||
}
|
||||
else
|
||||
{
|
||||
basepc[elseAdd] = JMP;
|
||||
code_word_at(basepc+elseAdd+1, pc-elseinit);
|
||||
}
|
||||
basepc[thenAdd] = IFFJMP;
|
||||
code_word_at(basepc+thenAdd+1,elseinit-(thenAdd+sizeof(Word)+1));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Parse LUA code.
|
||||
*/
|
||||
void lua_parse (TFunc *tf)
|
||||
{
|
||||
initcode = &(tf->code);
|
||||
*initcode = newvector(CODE_BLOCK, Byte);
|
||||
maincode = 0;
|
||||
maxmain = CODE_BLOCK;
|
||||
change2main();
|
||||
if (yyparse ()) lua_error("parse error");
|
||||
savemain();
|
||||
(*initcode)[maincode++] = RETCODE0;
|
||||
tf->size = maincode;
|
||||
#if LISTING
|
||||
{ static void PrintCode (Byte *c, Byte *end);
|
||||
PrintCode(*initcode,*initcode+maincode); }
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
%}
|
||||
|
||||
|
||||
%union
|
||||
{
|
||||
int vInt;
|
||||
float vFloat;
|
||||
char *pChar;
|
||||
Word vWord;
|
||||
Long vLong;
|
||||
TFunc *pFunc;
|
||||
TaggedString *pTStr;
|
||||
}
|
||||
|
||||
%start functionlist
|
||||
|
||||
%token WRONGTOKEN
|
||||
%token NIL
|
||||
%token IF THEN ELSE ELSEIF WHILE DO REPEAT UNTIL END
|
||||
%token RETURN
|
||||
%token LOCAL
|
||||
%token FUNCTION
|
||||
%token <vFloat> NUMBER
|
||||
%token <vWord> STRING
|
||||
%token <pTStr> NAME
|
||||
%token <vInt> DEBUG
|
||||
|
||||
%type <vLong> PrepJump
|
||||
%type <vLong> exprlist, exprlist1 /* if > 0, points to function return
|
||||
counter (which has list length); if <= 0, -list lenght */
|
||||
%type <vLong> functioncall, expr /* if != 0, points to function return
|
||||
counter */
|
||||
%type <vInt> varlist1, funcParams, funcvalue
|
||||
%type <vInt> fieldlist, localdeclist, decinit
|
||||
%type <vInt> ffieldlist, ffieldlist1, semicolonpart
|
||||
%type <vInt> lfieldlist, lfieldlist1
|
||||
%type <vInt> parlist
|
||||
%type <vLong> var, singlevar, funcname
|
||||
%type <pFunc> body
|
||||
|
||||
%left AND OR
|
||||
%left EQ NE '>' '<' LE GE
|
||||
%left CONC
|
||||
%left '+' '-'
|
||||
%left '*' '/'
|
||||
%left UNARY NOT
|
||||
%right '^'
|
||||
|
||||
|
||||
%% /* beginning of rules section */
|
||||
|
||||
|
||||
functionlist : /* empty */
|
||||
| functionlist globalstat
|
||||
| functionlist function
|
||||
;
|
||||
|
||||
globalstat : stat sc
|
||||
| setdebug
|
||||
;
|
||||
|
||||
function : FUNCTION funcname body
|
||||
{
|
||||
code_byte(PUSHFUNCTION);
|
||||
code_code($3);
|
||||
storesinglevar($2);
|
||||
}
|
||||
;
|
||||
|
||||
funcname : var { $$ =$1; init_func(); }
|
||||
| varexp ':' NAME
|
||||
{
|
||||
code_byte(PUSHSTRING);
|
||||
code_word(luaI_findconstant($3));
|
||||
$$ = 0; /* indexed variable */
|
||||
init_func();
|
||||
add_localvar(luaI_createfixedstring("self"));
|
||||
}
|
||||
;
|
||||
|
||||
body : '(' parlist ')' block END
|
||||
{
|
||||
codereturn();
|
||||
$$ = new(TFunc);
|
||||
luaI_initTFunc($$);
|
||||
$$->size = pc;
|
||||
$$->code = newvector(pc, Byte);
|
||||
$$->fileName = lua_parsedfile;
|
||||
$$->lineDefined = $2;
|
||||
memcpy($$->code, basepc, pc*sizeof(Byte));
|
||||
if (lua_debug)
|
||||
luaI_closelocalvars($$);
|
||||
/* save func values */
|
||||
funcCode = basepc; maxcode=maxcurr;
|
||||
#if LISTING
|
||||
PrintCode(funcCode,funcCode+pc);
|
||||
#endif
|
||||
change2main(); /* change back to main code */
|
||||
}
|
||||
;
|
||||
|
||||
statlist : /* empty */
|
||||
| statlist stat sc
|
||||
;
|
||||
|
||||
sc : /* empty */ | ';' ;
|
||||
|
||||
stat : IF expr1 THEN PrepJump block PrepJump elsepart END
|
||||
{ codeIf($4, $6); }
|
||||
|
||||
| WHILE {$<vLong>$=pc;} expr1 DO PrepJump block PrepJump END
|
||||
{
|
||||
basepc[$5] = IFFJMP;
|
||||
code_word_at(basepc+$5+1, pc - ($5 + sizeof(Word)+1));
|
||||
basepc[$7] = UPJMP;
|
||||
code_word_at(basepc+$7+1, pc - ($<vLong>2));
|
||||
}
|
||||
|
||||
| REPEAT {$<vLong>$=pc;} block UNTIL expr1 PrepJump
|
||||
{
|
||||
basepc[$6] = IFFUPJMP;
|
||||
code_word_at(basepc+$6+1, pc - ($<vLong>2));
|
||||
}
|
||||
|
||||
| varlist1 '=' exprlist1
|
||||
{
|
||||
{
|
||||
int i;
|
||||
adjust_mult_assign(nvarbuffer, $3, $1 * 2 + nvarbuffer);
|
||||
for (i=nvarbuffer-1; i>=0; i--)
|
||||
lua_codestore (i);
|
||||
if ($1 > 1 || ($1 == 1 && varbuffer[0] != 0))
|
||||
lua_codeadjust (0);
|
||||
}
|
||||
}
|
||||
| functioncall
|
||||
| LOCAL localdeclist decinit
|
||||
{ nlocalvar += $2;
|
||||
adjust_mult_assign($2, $3, 0);
|
||||
}
|
||||
;
|
||||
|
||||
elsepart : /* empty */
|
||||
| ELSE block
|
||||
| ELSEIF expr1 THEN PrepJump block PrepJump elsepart
|
||||
{ codeIf($4, $6); }
|
||||
;
|
||||
|
||||
block : {$<vInt>$ = nlocalvar;} statlist ret
|
||||
{
|
||||
if (nlocalvar != $<vInt>1)
|
||||
{
|
||||
if (lua_debug)
|
||||
for (; nlocalvar > $<vInt>1; nlocalvar--)
|
||||
luaI_unregisterlocalvar(lua_linenumber);
|
||||
else
|
||||
nlocalvar = $<vInt>1;
|
||||
lua_codeadjust (0);
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
ret : /* empty */
|
||||
| RETURN exprlist sc
|
||||
{
|
||||
adjust_functioncall($2, MULT_RET);
|
||||
codereturn();
|
||||
}
|
||||
;
|
||||
|
||||
PrepJump : /* empty */
|
||||
{
|
||||
$$ = pc;
|
||||
code_byte(0); /* open space */
|
||||
code_word (0);
|
||||
}
|
||||
|
||||
expr1 : expr { adjust_functioncall($1, 1); }
|
||||
;
|
||||
|
||||
expr : '(' expr ')' { $$ = $2; }
|
||||
| expr1 EQ expr1 { code_byte(EQOP); $$ = 0; }
|
||||
| expr1 '<' expr1 { code_byte(LTOP); $$ = 0; }
|
||||
| expr1 '>' expr1 { code_byte(GTOP); $$ = 0; }
|
||||
| expr1 NE expr1 { code_byte(EQOP); code_byte(NOTOP); $$ = 0; }
|
||||
| expr1 LE expr1 { code_byte(LEOP); $$ = 0; }
|
||||
| expr1 GE expr1 { code_byte(GEOP); $$ = 0; }
|
||||
| expr1 '+' expr1 { code_byte(ADDOP); $$ = 0; }
|
||||
| expr1 '-' expr1 { code_byte(SUBOP); $$ = 0; }
|
||||
| expr1 '*' expr1 { code_byte(MULTOP); $$ = 0; }
|
||||
| expr1 '/' expr1 { code_byte(DIVOP); $$ = 0; }
|
||||
| expr1 '^' expr1 { code_byte(POWOP); $$ = 0; }
|
||||
| expr1 CONC expr1 { code_byte(CONCOP); $$ = 0; }
|
||||
| '-' expr1 %prec UNARY { code_byte(MINUSOP); $$ = 0;}
|
||||
| table { $$ = 0; }
|
||||
| varexp { $$ = 0;}
|
||||
| NUMBER { code_number($1); $$ = 0; }
|
||||
| STRING
|
||||
{
|
||||
code_byte(PUSHSTRING);
|
||||
code_word($1);
|
||||
$$ = 0;
|
||||
}
|
||||
| NIL {code_byte(PUSHNIL); $$ = 0; }
|
||||
| functioncall { $$ = $1; }
|
||||
| NOT expr1 { code_byte(NOTOP); $$ = 0;}
|
||||
| expr1 AND PrepJump {code_byte(POP); } expr1
|
||||
{
|
||||
basepc[$3] = ONFJMP;
|
||||
code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1));
|
||||
$$ = 0;
|
||||
}
|
||||
| expr1 OR PrepJump {code_byte(POP); } expr1
|
||||
{
|
||||
basepc[$3] = ONTJMP;
|
||||
code_word_at(basepc+$3+1, pc - ($3 + sizeof(Word)+1));
|
||||
$$ = 0;
|
||||
}
|
||||
;
|
||||
|
||||
table :
|
||||
{
|
||||
code_byte(CREATEARRAY);
|
||||
$<vLong>$ = pc; code_word(0);
|
||||
}
|
||||
'{' fieldlist '}'
|
||||
{
|
||||
code_word_at(basepc+$<vLong>1, $3);
|
||||
}
|
||||
;
|
||||
|
||||
functioncall : funcvalue funcParams
|
||||
{
|
||||
code_byte(CALLFUNC);
|
||||
code_byte($1+$2);
|
||||
$$ = pc;
|
||||
code_byte(0); /* may be modified by other rules */
|
||||
}
|
||||
;
|
||||
|
||||
funcvalue : varexp { $$ = 0; }
|
||||
| varexp ':' NAME
|
||||
{
|
||||
code_byte(PUSHSELF);
|
||||
code_word(luaI_findconstant($3));
|
||||
$$ = 1;
|
||||
}
|
||||
;
|
||||
|
||||
funcParams : '(' exprlist ')'
|
||||
{ $$ = adjust_functioncall($2, 1); }
|
||||
| table { $$ = 1; }
|
||||
;
|
||||
|
||||
exprlist : /* empty */ { $$ = 0; }
|
||||
| exprlist1 { $$ = $1; }
|
||||
;
|
||||
|
||||
exprlist1 : expr { if ($1 != 0) $$ = $1; else $$ = -1; }
|
||||
| exprlist1 ',' { $<vLong>$ = adjust_functioncall($1, 1); } expr
|
||||
{
|
||||
if ($4 == 0) $$ = -($<vLong>3 + 1); /* -length */
|
||||
else
|
||||
{
|
||||
adjust_functioncall($4, $<vLong>3);
|
||||
$$ = $4;
|
||||
}
|
||||
}
|
||||
;
|
||||
|
||||
parlist : /* empty */ { lua_codeadjust(0); $$ = lua_linenumber; }
|
||||
| parlist1 { lua_codeadjust(0); $$ = lua_linenumber; }
|
||||
;
|
||||
|
||||
parlist1 : NAME { add_localvar($1); }
|
||||
| parlist1 ',' NAME { add_localvar($3); }
|
||||
;
|
||||
|
||||
fieldlist : lfieldlist
|
||||
{ flush_list($1/FIELDS_PER_FLUSH, $1%FIELDS_PER_FLUSH); }
|
||||
semicolonpart
|
||||
{ $$ = $1+$3; }
|
||||
| ffieldlist1 lastcomma
|
||||
{ $$ = $1; flush_record($1%FIELDS_PER_FLUSH); }
|
||||
;
|
||||
|
||||
semicolonpart : /* empty */
|
||||
{ $$ = 0; }
|
||||
| ';' ffieldlist
|
||||
{ $$ = $2; flush_record($2%FIELDS_PER_FLUSH); }
|
||||
;
|
||||
|
||||
lastcomma : /* empty */
|
||||
| ','
|
||||
;
|
||||
|
||||
ffieldlist : /* empty */ { $$ = 0; }
|
||||
| ffieldlist1 lastcomma { $$ = $1; }
|
||||
;
|
||||
|
||||
ffieldlist1 : ffield {$$=1;}
|
||||
| ffieldlist1 ',' ffield
|
||||
{
|
||||
$$=$1+1;
|
||||
if ($$%FIELDS_PER_FLUSH == 0) flush_record(FIELDS_PER_FLUSH);
|
||||
}
|
||||
;
|
||||
|
||||
ffield : NAME '=' expr1
|
||||
{
|
||||
push_field(luaI_findconstant($1));
|
||||
}
|
||||
;
|
||||
|
||||
lfieldlist : /* empty */ { $$ = 0; }
|
||||
| lfieldlist1 lastcomma { $$ = $1; }
|
||||
;
|
||||
|
||||
lfieldlist1 : expr1 {$$=1;}
|
||||
| lfieldlist1 ',' expr1
|
||||
{
|
||||
$$=$1+1;
|
||||
if ($$%FIELDS_PER_FLUSH == 0)
|
||||
flush_list($$/FIELDS_PER_FLUSH - 1, FIELDS_PER_FLUSH);
|
||||
}
|
||||
;
|
||||
|
||||
varlist1 : var
|
||||
{
|
||||
nvarbuffer = 0;
|
||||
add_varbuffer($1);
|
||||
$$ = ($1 == 0) ? 1 : 0;
|
||||
}
|
||||
| varlist1 ',' var
|
||||
{
|
||||
add_varbuffer($3);
|
||||
$$ = ($3 == 0) ? $1 + 1 : $1;
|
||||
}
|
||||
;
|
||||
|
||||
var : singlevar { $$ = $1; }
|
||||
| varexp '[' expr1 ']'
|
||||
{
|
||||
$$ = 0; /* indexed variable */
|
||||
}
|
||||
| varexp '.' NAME
|
||||
{
|
||||
code_byte(PUSHSTRING);
|
||||
code_word(luaI_findconstant($3));
|
||||
$$ = 0; /* indexed variable */
|
||||
}
|
||||
;
|
||||
|
||||
singlevar : NAME
|
||||
{
|
||||
int local = lua_localname($1);
|
||||
if (local == -1) /* global var */
|
||||
$$ = luaI_findsymbol($1)+1; /* return positive value */
|
||||
else
|
||||
$$ = -(local+1); /* return negative value */
|
||||
}
|
||||
;
|
||||
|
||||
varexp : var { lua_pushvar($1); }
|
||||
;
|
||||
|
||||
localdeclist : NAME {store_localvar($1, 0); $$ = 1;}
|
||||
| localdeclist ',' NAME
|
||||
{
|
||||
store_localvar($3, $1);
|
||||
$$ = $1+1;
|
||||
}
|
||||
;
|
||||
|
||||
decinit : /* empty */ { $$ = 0; }
|
||||
| '=' exprlist1 { $$ = $2; }
|
||||
;
|
||||
|
||||
setdebug : DEBUG { lua_debug = $1; }
|
||||
;
|
||||
|
||||
%%
|
||||
31
luadebug.h
31
luadebug.h
@@ -1,31 +0,0 @@
|
||||
/*
|
||||
** LUA - Linguagem para Usuarios de Aplicacao
|
||||
** Grupo de Tecnologia em Computacao Grafica
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: luadebug.h,v 1.5 1996/02/08 17:03:20 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
|
||||
#ifndef luadebug_h
|
||||
#define luadebug_h
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
typedef lua_Object lua_Function;
|
||||
|
||||
typedef void (*lua_LHFunction) (int line);
|
||||
typedef void (*lua_CHFunction) (lua_Function func, char *file, int line);
|
||||
|
||||
lua_Function lua_stackedfunction (int level);
|
||||
void lua_funcinfo (lua_Object func, char **filename, int *linedefined);
|
||||
int lua_currentline (lua_Function func);
|
||||
char *lua_getobjname (lua_Object o, char **name);
|
||||
|
||||
lua_Object lua_getlocal (lua_Function func, int local_number, char **name);
|
||||
int lua_setlocal (lua_Function func, int local_number);
|
||||
|
||||
extern lua_LHFunction lua_linehook;
|
||||
extern lua_CHFunction lua_callhook;
|
||||
extern int lua_debug;
|
||||
|
||||
#endif
|
||||
13
lualib.h
13
lualib.h
@@ -1,8 +1,8 @@
|
||||
/*
|
||||
** Libraries to be used in LUA programs
|
||||
** Libraries to use in LUA programs
|
||||
** Grupo de Tecnologia em Computacao Grafica
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: lualib.h,v 1.6 1996/02/09 19:00:23 roberto Exp roberto $
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
#ifndef lualib_h
|
||||
@@ -12,13 +12,4 @@ void iolib_open (void);
|
||||
void strlib_open (void);
|
||||
void mathlib_open (void);
|
||||
|
||||
|
||||
/* auxiliar functions (private) */
|
||||
void lua_arg_error(char *funcname);
|
||||
char *lua_check_string (int numArg, char *funcname);
|
||||
double lua_check_number (int numArg, char *funcname);
|
||||
char *luaI_addchar (int c);
|
||||
void luaI_addquoted (char *s);
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
70
luamem.c
70
luamem.c
@@ -1,70 +0,0 @@
|
||||
/*
|
||||
** mem.c
|
||||
** TecCGraf - PUC-Rio
|
||||
*/
|
||||
|
||||
char *rcs_mem = "$Id: mem.c,v 1.10 1996/03/21 16:31:32 roberto Exp roberto $";
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "mem.h"
|
||||
#include "lua.h"
|
||||
#include "table.h"
|
||||
|
||||
|
||||
#define mem_error() lua_error(memEM)
|
||||
|
||||
|
||||
void luaI_free (void *block)
|
||||
{
|
||||
if (block)
|
||||
{
|
||||
*((int *)block) = -1; /* to catch errors */
|
||||
free(block);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void *luaI_malloc (unsigned long size)
|
||||
{
|
||||
void *block = malloc((size_t)size);
|
||||
if (block == NULL)
|
||||
mem_error();
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
void *luaI_realloc (void *oldblock, unsigned long size)
|
||||
{
|
||||
void *block = oldblock ? realloc(oldblock, (size_t)size) :
|
||||
malloc((size_t)size);
|
||||
if (block == NULL)
|
||||
mem_error();
|
||||
return block;
|
||||
}
|
||||
|
||||
|
||||
int luaI_growvector (void **block, unsigned long nelems, int size,
|
||||
char *errormsg, unsigned long limit)
|
||||
{
|
||||
if (nelems >= limit)
|
||||
lua_error(errormsg);
|
||||
nelems = (nelems == 0) ? 20 : nelems*2;
|
||||
if (nelems > limit)
|
||||
nelems = limit;
|
||||
*block = luaI_realloc(*block, nelems*size);
|
||||
return (int) nelems;
|
||||
}
|
||||
|
||||
|
||||
void* luaI_buffer (unsigned long size)
|
||||
{
|
||||
static unsigned long buffsize = 0;
|
||||
static char* buffer = NULL;
|
||||
if (size > buffsize)
|
||||
buffer = luaI_realloc(buffer, buffsize=size);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
39
luamem.h
39
luamem.h
@@ -1,39 +0,0 @@
|
||||
/*
|
||||
** mem.c
|
||||
** memory manager for lua
|
||||
** $Id: mem.h,v 1.5 1996/03/21 16:31:32 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef mem_h
|
||||
#define mem_h
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
#endif
|
||||
|
||||
|
||||
/* memory error messages */
|
||||
#define codeEM "code size overflow"
|
||||
#define symbolEM "symbol table overflow"
|
||||
#define constantEM "constant table overflow"
|
||||
#define stackEM "stack size overflow"
|
||||
#define lexEM "lex buffer overflow"
|
||||
#define lockEM "lock table overflow"
|
||||
#define tableEM "table overflow"
|
||||
#define memEM "not enough memory"
|
||||
|
||||
|
||||
void luaI_free (void *block);
|
||||
void *luaI_malloc (unsigned long size);
|
||||
void *luaI_realloc (void *oldblock, unsigned long size);
|
||||
void *luaI_buffer (unsigned long size);
|
||||
int luaI_growvector (void **block, unsigned long nelems, int size,
|
||||
char *errormsg, unsigned long limit);
|
||||
|
||||
#define new(s) ((s *)luaI_malloc(sizeof(s)))
|
||||
#define newvector(n,s) ((s *)luaI_malloc((n)*sizeof(s)))
|
||||
#define growvector(old,n,s,e,l) \
|
||||
(luaI_growvector((void**)old,n,sizeof(s),e,l))
|
||||
|
||||
#endif
|
||||
|
||||
91
makefile
91
makefile
@@ -1,91 +0,0 @@
|
||||
# $Id: makefile,v 1.21 1996/03/05 15:57:53 roberto Exp roberto $
|
||||
|
||||
#configuration
|
||||
|
||||
# define (undefine) POPEN if your system (does not) support piped I/O
|
||||
CONFIG = -DPOPEN
|
||||
# Compilation parameters
|
||||
CC = gcc
|
||||
CFLAGS = $(CONFIG) -I/usr/5include -Wall -Wmissing-prototypes -Wshadow -ansi -O2
|
||||
|
||||
#CC = acc
|
||||
#CFLAGS = -fast -I/usr/5include
|
||||
|
||||
AR = ar
|
||||
ARFLAGS = rvl
|
||||
|
||||
# Aplication modules
|
||||
LUAOBJS = \
|
||||
parser.o \
|
||||
lex.o \
|
||||
opcode.o \
|
||||
hash.o \
|
||||
table.o \
|
||||
inout.o \
|
||||
tree.o \
|
||||
fallback.o \
|
||||
mem.o \
|
||||
func.o \
|
||||
undump.o
|
||||
|
||||
LIBOBJS = \
|
||||
iolib.o \
|
||||
mathlib.o \
|
||||
strlib.o
|
||||
|
||||
|
||||
lua : lua.o lua.a lualib.a
|
||||
$(CC) $(CFLAGS) -o $@ lua.o lua.a lualib.a -lm
|
||||
|
||||
lua.a : $(LUAOBJS)
|
||||
$(AR) $(ARFLAGS) $@ $?
|
||||
ranlib lua.a
|
||||
|
||||
lualib.a : $(LIBOBJS)
|
||||
$(AR) $(ARFLAGS) $@ $?
|
||||
ranlib $@
|
||||
|
||||
liblua.so.1.0 : lua.o
|
||||
ld -o liblua.so.1.0 $(LUAOBJS)
|
||||
|
||||
y.tab.c y.tab.h : lua.stx
|
||||
yacc++ -d lua.stx
|
||||
|
||||
parser.c : y.tab.c
|
||||
sed -e 's/yy/luaY_/g' y.tab.c > parser.c
|
||||
|
||||
parser.h : y.tab.h
|
||||
sed -e 's/yy/luaY_/g' y.tab.h > parser.h
|
||||
|
||||
clear :
|
||||
rcsclean
|
||||
rm -f *.o
|
||||
rm -f parser.c parser.h y.tab.c y.tab.h
|
||||
co lua.h lualib.h luadebug.h
|
||||
|
||||
|
||||
% : RCS/%,v
|
||||
co $@
|
||||
|
||||
|
||||
|
||||
fallback.o : fallback.c mem.h fallback.h opcode.h lua.h types.h tree.h func.h
|
||||
func.o : func.c luadebug.h lua.h table.h tree.h types.h opcode.h func.h mem.h
|
||||
hash.o : hash.c mem.h opcode.h lua.h types.h tree.h func.h hash.h table.h
|
||||
inout.o : inout.c lex.h opcode.h lua.h types.h tree.h func.h inout.h table.h \
|
||||
mem.h
|
||||
iolib.o : iolib.c lua.h luadebug.h lualib.h
|
||||
lex.o : lex.c mem.h tree.h types.h table.h opcode.h lua.h func.h lex.h inout.h \
|
||||
luadebug.h parser.h
|
||||
lua.o : lua.c lua.h lualib.h
|
||||
mathlib.o : mathlib.c lualib.h lua.h
|
||||
mem.o : mem.c mem.h lua.h table.h tree.h types.h opcode.h func.h
|
||||
opcode.o : opcode.c luadebug.h lua.h mem.h opcode.h types.h tree.h func.h hash.h \
|
||||
inout.h table.h fallback.h undump.h
|
||||
parser.o : parser.c luadebug.h lua.h mem.h lex.h opcode.h types.h tree.h func.h \
|
||||
hash.h inout.h table.h
|
||||
strlib.o : strlib.c lua.h lualib.h
|
||||
table.o : table.c mem.h opcode.h lua.h types.h tree.h func.h hash.h table.h \
|
||||
inout.h fallback.h luadebug.h
|
||||
tree.o : tree.c mem.h lua.h tree.h types.h lex.h hash.h opcode.h func.h table.h
|
||||
undump.o : undump.c opcode.h lua.h types.h tree.h func.h mem.h table.h undump.h
|
||||
2153
manual.tex
2153
manual.tex
File diff suppressed because it is too large
Load Diff
233
mathlib.c
233
mathlib.c
@@ -1,25 +1,26 @@
|
||||
/*
|
||||
** mathlib.c
|
||||
** Mathematics library to LUA
|
||||
** Mathematica library to LUA
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
char *rcs_mathlib="$Id: mathlib.c,v 1.13 1995/11/10 17:54:31 roberto Exp roberto $";
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h> /* NULL */
|
||||
#include <math.h>
|
||||
|
||||
#include "lualib.h"
|
||||
#include "lua.h"
|
||||
|
||||
#ifndef PI
|
||||
#define PI 3.14159265358979323846
|
||||
#endif
|
||||
#define TODEGREE(a) ((a)*180.0/PI)
|
||||
#define TORAD(a) ((a)*PI/180.0)
|
||||
|
||||
static void math_abs (void)
|
||||
{
|
||||
double d = lua_check_number(1, "abs");
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `abs'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `abs'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
if (d < 0) d = -d;
|
||||
lua_pushnumber (d);
|
||||
}
|
||||
@@ -27,173 +28,188 @@ static void math_abs (void)
|
||||
|
||||
static void math_sin (void)
|
||||
{
|
||||
double d = lua_check_number(1, "sin");
|
||||
lua_pushnumber (sin(TORAD(d)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `sin'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `sin'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (sin(d));
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void math_cos (void)
|
||||
{
|
||||
double d = lua_check_number(1, "cos");
|
||||
lua_pushnumber (cos(TORAD(d)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `cos'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `cos'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (cos(d));
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void math_tan (void)
|
||||
{
|
||||
double d = lua_check_number(1, "tan");
|
||||
lua_pushnumber (tan(TORAD(d)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `tan'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `tan'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (tan(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_asin (void)
|
||||
{
|
||||
double d = lua_check_number(1, "asin");
|
||||
lua_pushnumber (TODEGREE(asin(d)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `asin'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `asin'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (asin(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_acos (void)
|
||||
{
|
||||
double d = lua_check_number(1, "acos");
|
||||
lua_pushnumber (TODEGREE(acos(d)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `acos'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `acos'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (acos(d));
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void math_atan (void)
|
||||
{
|
||||
double d = lua_check_number(1, "atan");
|
||||
lua_pushnumber (TODEGREE(atan(d)));
|
||||
}
|
||||
|
||||
|
||||
static void math_atan2 (void)
|
||||
{
|
||||
double d1 = lua_check_number(1, "atan2");
|
||||
double d2 = lua_check_number(2, "atan2");
|
||||
lua_pushnumber (TODEGREE(atan2(d1, d2)));
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `atan'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `atan'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (atan(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_ceil (void)
|
||||
{
|
||||
double d = lua_check_number(1, "ceil");
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `ceil'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `ceil'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (ceil(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_floor (void)
|
||||
{
|
||||
double d = lua_check_number(1, "floor");
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `floor'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `floor'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (floor(d));
|
||||
}
|
||||
|
||||
static void math_mod (void)
|
||||
{
|
||||
int d1 = (int)lua_check_number(1, "mod");
|
||||
int d2 = (int)lua_check_number(2, "mod");
|
||||
int d1, d2;
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
if (!lua_isnumber(o1) || !lua_isnumber(o2))
|
||||
{ lua_error ("incorrect arguments to function `mod'"); return; }
|
||||
d1 = (int) lua_getnumber(o1);
|
||||
d2 = (int) lua_getnumber(o2);
|
||||
lua_pushnumber (d1%d2);
|
||||
}
|
||||
|
||||
|
||||
static void math_sqrt (void)
|
||||
{
|
||||
double d = lua_check_number(1, "sqrt");
|
||||
double d;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `sqrt'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `sqrt'"); return; }
|
||||
d = lua_getnumber(o);
|
||||
lua_pushnumber (sqrt(d));
|
||||
}
|
||||
|
||||
static int old_pow;
|
||||
|
||||
static void math_pow (void)
|
||||
{
|
||||
double d1, d2;
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
lua_Object op = lua_getparam(3);
|
||||
if (!lua_isnumber(o1) || !lua_isnumber(o2) || *(lua_getstring(op)) != 'p')
|
||||
{
|
||||
lua_Object old = lua_getlocked(old_pow);
|
||||
lua_pushobject(o1);
|
||||
lua_pushobject(o2);
|
||||
lua_pushobject(op);
|
||||
if (lua_callfunction(old) != 0)
|
||||
lua_error(NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
double d1 = lua_getnumber(o1);
|
||||
double d2 = lua_getnumber(o2);
|
||||
lua_pushnumber (pow(d1,d2));
|
||||
}
|
||||
if (!lua_isnumber(o1) || !lua_isnumber(o2))
|
||||
{ lua_error ("incorrect arguments to function `pow'"); return; }
|
||||
d1 = lua_getnumber(o1);
|
||||
d2 = lua_getnumber(o2);
|
||||
lua_pushnumber (pow(d1,d2));
|
||||
}
|
||||
|
||||
static void math_min (void)
|
||||
{
|
||||
int i=1;
|
||||
double dmin = lua_check_number(i, "min");
|
||||
while (lua_getparam(++i) != LUA_NOOBJECT)
|
||||
double d, dmin;
|
||||
lua_Object o;
|
||||
if ((o = lua_getparam(i++)) == NULL)
|
||||
{ lua_error ("too few arguments to function `min'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `min'"); return; }
|
||||
dmin = lua_getnumber (o);
|
||||
while ((o = lua_getparam(i++)) != NULL)
|
||||
{
|
||||
double d = lua_check_number(i, "min");
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `min'"); return; }
|
||||
d = lua_getnumber (o);
|
||||
if (d < dmin) dmin = d;
|
||||
}
|
||||
lua_pushnumber (dmin);
|
||||
}
|
||||
|
||||
|
||||
static void math_max (void)
|
||||
{
|
||||
int i=1;
|
||||
double dmax = lua_check_number(i, "max");
|
||||
while (lua_getparam(++i) != LUA_NOOBJECT)
|
||||
double d, dmax;
|
||||
lua_Object o;
|
||||
if ((o = lua_getparam(i++)) == NULL)
|
||||
{ lua_error ("too few arguments to function `max'"); return; }
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `max'"); return; }
|
||||
dmax = lua_getnumber (o);
|
||||
while ((o = lua_getparam(i++)) != NULL)
|
||||
{
|
||||
double d = lua_check_number(i, "max");
|
||||
if (!lua_isnumber(o))
|
||||
{ lua_error ("incorrect arguments to function `max'"); return; }
|
||||
d = lua_getnumber (o);
|
||||
if (d > dmax) dmax = d;
|
||||
}
|
||||
lua_pushnumber (dmax);
|
||||
}
|
||||
|
||||
static void math_log (void)
|
||||
{
|
||||
double d = lua_check_number(1, "log");
|
||||
lua_pushnumber (log(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_log10 (void)
|
||||
{
|
||||
double d = lua_check_number(1, "log10");
|
||||
lua_pushnumber (log10(d));
|
||||
}
|
||||
|
||||
|
||||
static void math_exp (void)
|
||||
{
|
||||
double d = lua_check_number(1, "exp");
|
||||
lua_pushnumber (exp(d));
|
||||
}
|
||||
|
||||
static void math_deg (void)
|
||||
{
|
||||
float d = lua_check_number(1, "deg");
|
||||
lua_pushnumber (d*180./PI);
|
||||
}
|
||||
|
||||
static void math_rad (void)
|
||||
{
|
||||
float d = lua_check_number(1, "rad");
|
||||
lua_pushnumber (d/180.*PI);
|
||||
}
|
||||
|
||||
static void math_random (void)
|
||||
{
|
||||
lua_pushnumber((double)(rand()%RAND_MAX) / (double)RAND_MAX);
|
||||
}
|
||||
|
||||
static void math_randomseed (void)
|
||||
{
|
||||
srand(lua_check_number(1, "randomseed"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
@@ -208,20 +224,11 @@ void mathlib_open (void)
|
||||
lua_register ("asin", math_asin);
|
||||
lua_register ("acos", math_acos);
|
||||
lua_register ("atan", math_atan);
|
||||
lua_register ("atan2", math_atan2);
|
||||
lua_register ("ceil", math_ceil);
|
||||
lua_register ("floor", math_floor);
|
||||
lua_register ("mod", math_mod);
|
||||
lua_register ("sqrt", math_sqrt);
|
||||
lua_register ("pow", math_pow);
|
||||
lua_register ("min", math_min);
|
||||
lua_register ("max", math_max);
|
||||
lua_register ("log", math_log);
|
||||
lua_register ("log10", math_log10);
|
||||
lua_register ("exp", math_exp);
|
||||
lua_register ("deg", math_deg);
|
||||
lua_register ("rad", math_rad);
|
||||
lua_register ("random", math_random);
|
||||
lua_register ("randomseed", math_randomseed);
|
||||
|
||||
old_pow = lua_lockobject(lua_setfallback("arith", math_pow));
|
||||
}
|
||||
|
||||
13
mathlib.h
13
mathlib.h
@@ -1,13 +0,0 @@
|
||||
/*
|
||||
** Math library to LUA
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: $
|
||||
*/
|
||||
|
||||
|
||||
#ifndef strlib_h
|
||||
|
||||
void mathlib_open (void);
|
||||
|
||||
#endif
|
||||
|
||||
113
opcode.h
113
opcode.h
@@ -1,57 +1,56 @@
|
||||
/*
|
||||
** opcode.h
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: opcode.h,v 3.19 1996/03/06 13:11:23 roberto Exp $
|
||||
** 16 Apr 92
|
||||
*/
|
||||
|
||||
#ifndef opcode_h
|
||||
#define opcode_h
|
||||
|
||||
#include "lua.h"
|
||||
#include "types.h"
|
||||
#include "tree.h"
|
||||
#include "func.h"
|
||||
#ifndef STACKGAP
|
||||
#define STACKGAP 128
|
||||
#endif
|
||||
|
||||
#ifndef real
|
||||
#define real float
|
||||
#endif
|
||||
|
||||
#define FIELDS_PER_FLUSH 40
|
||||
typedef unsigned char Byte;
|
||||
|
||||
typedef unsigned short Word;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
NOP,
|
||||
PUSHNIL,
|
||||
PUSH0, PUSH1, PUSH2,
|
||||
PUSHBYTE,
|
||||
PUSHWORD,
|
||||
PUSHFLOAT,
|
||||
PUSHSTRING,
|
||||
PUSHFUNCTION,
|
||||
PUSHLOCAL0, PUSHLOCAL1, PUSHLOCAL2, PUSHLOCAL3, PUSHLOCAL4,
|
||||
PUSHLOCAL5, PUSHLOCAL6, PUSHLOCAL7, PUSHLOCAL8, PUSHLOCAL9,
|
||||
PUSHLOCAL,
|
||||
PUSHGLOBAL,
|
||||
PUSHINDEXED,
|
||||
PUSHSELF,
|
||||
PUSHMARK,
|
||||
PUSHOBJECT,
|
||||
STORELOCAL0, STORELOCAL1, STORELOCAL2, STORELOCAL3, STORELOCAL4,
|
||||
STORELOCAL5, STORELOCAL6, STORELOCAL7, STORELOCAL8, STORELOCAL9,
|
||||
STORELOCAL,
|
||||
STOREGLOBAL,
|
||||
STOREINDEXED0,
|
||||
STOREINDEXED,
|
||||
STORELIST0,
|
||||
STORELIST,
|
||||
STORERECORD,
|
||||
ADJUST0,
|
||||
STOREFIELD,
|
||||
ADJUST,
|
||||
CREATEARRAY,
|
||||
EQOP,
|
||||
LTOP,
|
||||
LEOP,
|
||||
GTOP,
|
||||
GEOP,
|
||||
ADDOP,
|
||||
SUBOP,
|
||||
MULTOP,
|
||||
DIVOP,
|
||||
POWOP,
|
||||
CONCOP,
|
||||
MINUSOP,
|
||||
NOTOP,
|
||||
@@ -63,81 +62,83 @@ typedef enum
|
||||
IFFUPJMP,
|
||||
POP,
|
||||
CALLFUNC,
|
||||
RETCODE0,
|
||||
RETCODE,
|
||||
SETLINE
|
||||
HALT,
|
||||
SETFUNCTION,
|
||||
SETLINE,
|
||||
RESET
|
||||
} OpCode;
|
||||
|
||||
#define MULT_RET 255
|
||||
typedef enum
|
||||
{
|
||||
T_MARK,
|
||||
T_NIL,
|
||||
T_NUMBER,
|
||||
T_STRING,
|
||||
T_ARRAY,
|
||||
T_FUNCTION,
|
||||
T_CFUNCTION,
|
||||
T_USERDATA
|
||||
} Type;
|
||||
|
||||
typedef void (*Cfunction) (void);
|
||||
typedef int (*Input) (void);
|
||||
typedef void (*Unput) (int );
|
||||
|
||||
typedef union
|
||||
{
|
||||
lua_CFunction f;
|
||||
real n;
|
||||
TaggedString *ts;
|
||||
TFunc *tf;
|
||||
Cfunction f;
|
||||
real n;
|
||||
char *s;
|
||||
Byte *b;
|
||||
struct Hash *a;
|
||||
void *u;
|
||||
int i;
|
||||
} Value;
|
||||
|
||||
typedef struct Object
|
||||
{
|
||||
lua_Type tag;
|
||||
Type tag;
|
||||
Value value;
|
||||
} Object;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char *name;
|
||||
Object object;
|
||||
} Symbol;
|
||||
|
||||
/* Macros to access structure members */
|
||||
#define tag(o) ((o)->tag)
|
||||
#define nvalue(o) ((o)->value.n)
|
||||
#define svalue(o) ((o)->value.ts->str)
|
||||
#define tsvalue(o) ((o)->value.ts)
|
||||
#define svalue(o) ((o)->value.s)
|
||||
#define bvalue(o) ((o)->value.b)
|
||||
#define avalue(o) ((o)->value.a)
|
||||
#define fvalue(o) ((o)->value.f)
|
||||
#define uvalue(o) ((o)->value.u)
|
||||
|
||||
/* Macros to access symbol table */
|
||||
#define s_name(i) (lua_table[i].name)
|
||||
#define s_object(i) (lua_table[i].object)
|
||||
#define s_tag(i) (tag(&s_object(i)))
|
||||
#define s_nvalue(i) (nvalue(&s_object(i)))
|
||||
#define s_svalue(i) (svalue(&s_object(i)))
|
||||
#define s_bvalue(i) (bvalue(&s_object(i)))
|
||||
#define s_avalue(i) (avalue(&s_object(i)))
|
||||
#define s_fvalue(i) (fvalue(&s_object(i)))
|
||||
#define s_uvalue(i) (uvalue(&s_object(i)))
|
||||
|
||||
typedef union
|
||||
{
|
||||
struct {Byte c1; Byte c2;} m;
|
||||
Word w;
|
||||
} CodeWord;
|
||||
#define get_word(code,pc) {code.m.c1 = *pc++; code.m.c2 = *pc++;}
|
||||
|
||||
typedef union
|
||||
{
|
||||
struct {Byte c1; Byte c2; Byte c3; Byte c4;} m;
|
||||
float f;
|
||||
} CodeFloat;
|
||||
#define get_float(code,pc) {code.m.c1 = *pc++; code.m.c2 = *pc++;\
|
||||
code.m.c3 = *pc++; code.m.c4 = *pc++;}
|
||||
|
||||
typedef union
|
||||
{
|
||||
struct {Byte c1; Byte c2; Byte c3; Byte c4;} m;
|
||||
TFunc *tf;
|
||||
} CodeCode;
|
||||
#define get_code(code,pc) {code.m.c1 = *pc++; code.m.c2 = *pc++;\
|
||||
code.m.c3 = *pc++; code.m.c4 = *pc++;}
|
||||
|
||||
|
||||
/* Exported functions */
|
||||
void lua_parse (TFunc *tf); /* from "lua.stx" module */
|
||||
void luaI_codedebugline (int line); /* from "lua.stx" module */
|
||||
void lua_travstack (int (*fn)(Object *));
|
||||
Object *luaI_Address (lua_Object o);
|
||||
void luaI_pushobject (Object *o);
|
||||
void luaI_gcFB (Object *o);
|
||||
int luaI_dorun (TFunc *tf);
|
||||
int lua_execute (Byte *pc);
|
||||
void lua_markstack (void);
|
||||
char *lua_strdup (char *l);
|
||||
|
||||
void lua_setinput (Input fn); /* from "lua.lex" module */
|
||||
void lua_setunput (Unput fn); /* from "lua.lex" module */
|
||||
char *lua_lasttext (void); /* from "lua.lex" module */
|
||||
int lua_parse (void); /* from "lua.stx" module */
|
||||
void lua_type (void);
|
||||
void lua_obj2number (void);
|
||||
void lua_print (void);
|
||||
|
||||
#endif
|
||||
|
||||
47
save.lua
Normal file
47
save.lua
Normal file
@@ -0,0 +1,47 @@
|
||||
$debug
|
||||
|
||||
|
||||
function savevar (n,v)
|
||||
if v = nil then return end;
|
||||
if type(v) = "number" then print(n.."="..v) return end
|
||||
if type(v) = "string" then print(n.."='"..v.."'") return end
|
||||
if type(v) = "table" then
|
||||
if v.__visited__ ~= nil then
|
||||
print(n .. "=" .. v.__visited__);
|
||||
else
|
||||
print(n.."=@()")
|
||||
v.__visited__ = n;
|
||||
local r,f;
|
||||
r,f = next(v,nil);
|
||||
while r ~= nil do
|
||||
if r ~= "__visited__" then
|
||||
if type(r) = 'string' then
|
||||
savevar(n.."['"..r.."']",f)
|
||||
else
|
||||
savevar(n.."["..r.."]",f)
|
||||
end
|
||||
end
|
||||
r,f = next(v,r)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function save ()
|
||||
local n,v
|
||||
n,v = nextvar(nil)
|
||||
while n ~= nil do
|
||||
savevar(n,v);
|
||||
n,v = nextvar(n)
|
||||
end
|
||||
end
|
||||
|
||||
a = 3
|
||||
x = @{a = 4, b = "name", l=@[4,5,67]}
|
||||
|
||||
b = @{t=5}
|
||||
x.next = b
|
||||
|
||||
|
||||
save()
|
||||
|
||||
56
sort.lua
Normal file
56
sort.lua
Normal file
@@ -0,0 +1,56 @@
|
||||
$debug
|
||||
|
||||
function quicksort(r,s)
|
||||
if s<=r then return end -- caso basico da recursao
|
||||
local v=x[r]
|
||||
local i=r
|
||||
local j=s+1
|
||||
i=i+1; while x[i]<v do i=i+1 end
|
||||
j=j-1; while x[j]>v do j=j-1 end
|
||||
x[i],x[j]=x[j],x[i]
|
||||
while j>i do -- separacao
|
||||
i=i+1; while x[i]<v do i=i+1 end
|
||||
j=j-1; while x[j]>v do j=j-1 end
|
||||
x[i],x[j]=x[j],x[i]
|
||||
end
|
||||
x[i],x[j]=x[j],x[i] -- undo last swap
|
||||
x[j],x[r]=x[r],x[j]
|
||||
quicksort(r,j-1) -- recursao
|
||||
quicksort(j+1,s)
|
||||
end
|
||||
|
||||
function sort(a,n) -- selection sort
|
||||
local i=1
|
||||
while i<=n do
|
||||
local m=i
|
||||
local j=i+1
|
||||
while j<=n do
|
||||
if a[j]<a[m] then m=j end
|
||||
j=j+1
|
||||
end
|
||||
a[i],a[m]=a[m],a[i] -- swap a[i] and a[m]
|
||||
i=i+1
|
||||
end
|
||||
end
|
||||
|
||||
function main()
|
||||
x=@()
|
||||
n=-1
|
||||
n=n+1; x[n]="a"
|
||||
n=n+1; x[n]="waldemar"
|
||||
n=n+1; x[n]="luiz"
|
||||
n=n+1; x[n]="lula"
|
||||
n=n+1; x[n]="peter"
|
||||
n=n+1; x[n]="raquel"
|
||||
n=n+1; x[n]="camilo"
|
||||
n=n+1; x[n]="andre"
|
||||
n=n+1; x[n]="marcelo"
|
||||
n=n+1; x[n]="sedrez"
|
||||
n=n+1; x[n]="z"
|
||||
-- quicksort(1,n-1)
|
||||
print(x[0]..","..x[1]..","..x[2]..","..x[3]..","..x[4]..","..x[5]..","..x[6]..","..x[7]..","..x[8]..","..x[9]..","..x[10])
|
||||
sort (x, n-1)
|
||||
print(x[0]..","..x[1]..","..x[2]..","..x[3]..","..x[4]..","..x[5]..","..x[6]..","..x[7]..","..x[8]..","..x[9]..","..x[10])
|
||||
end
|
||||
|
||||
|
||||
255
strlib.c
255
strlib.c
@@ -1,97 +1,36 @@
|
||||
/*
|
||||
** strlib.c
|
||||
** String library to LUA
|
||||
**
|
||||
** Waldemar Celes Filho
|
||||
** TeCGraf - PUC-Rio
|
||||
** 19 May 93
|
||||
*/
|
||||
|
||||
char *rcs_strlib="$Id: strlib.c,v 1.21 1996/03/21 22:18:08 roberto Exp roberto $";
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <limits.h>
|
||||
|
||||
|
||||
#include "lua.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
void lua_arg_error(char *funcname)
|
||||
{
|
||||
char buff[100];
|
||||
sprintf(buff, "incorrect arguments to function `%s'", funcname);
|
||||
lua_error(buff);
|
||||
}
|
||||
|
||||
char *lua_check_string (int numArg, char *funcname)
|
||||
{
|
||||
lua_Object o = lua_getparam(numArg);
|
||||
if (!lua_isstring(o))
|
||||
lua_arg_error(funcname);
|
||||
return lua_getstring(o);
|
||||
}
|
||||
|
||||
double lua_check_number (int numArg, char *funcname)
|
||||
{
|
||||
lua_Object o = lua_getparam(numArg);
|
||||
if (!lua_isnumber(o))
|
||||
lua_arg_error(funcname);
|
||||
return lua_getnumber(o);
|
||||
}
|
||||
|
||||
static int lua_opt_number (int numArg, int def, char *funcname)
|
||||
{
|
||||
return (lua_getparam(numArg) == LUA_NOOBJECT) ? def :
|
||||
(int)lua_check_number(numArg, funcname);
|
||||
}
|
||||
|
||||
char *luaI_addchar (int c)
|
||||
{
|
||||
static char *buff = NULL;
|
||||
static int max = 0;
|
||||
static int n = 0;
|
||||
if (n >= max)
|
||||
{
|
||||
if (max == 0)
|
||||
{
|
||||
max = 100;
|
||||
buff = (char *)malloc(max);
|
||||
}
|
||||
else
|
||||
{
|
||||
max *= 2;
|
||||
buff = (char *)realloc(buff, max);
|
||||
}
|
||||
if (buff == NULL)
|
||||
lua_error("memory overflow");
|
||||
}
|
||||
buff[n++] = c;
|
||||
if (c == 0)
|
||||
n = 0; /* prepare for next string */
|
||||
return buff;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Return the position of the first caracter of a substring into a string
|
||||
** LUA interface:
|
||||
** n = strfind (string, substring, init, end)
|
||||
** n = strfind (string, substring)
|
||||
*/
|
||||
static void str_find (void)
|
||||
{
|
||||
char *s1 = lua_check_string(1, "strfind");
|
||||
char *s2 = lua_check_string(2, "strfind");
|
||||
int init = lua_opt_number(3, 1, "strfind") - 1;
|
||||
char *f = (init>=0 && init<=strlen(s1)) ? strstr(s1+init,s2) : NULL;
|
||||
if (f != NULL)
|
||||
{
|
||||
int pos = f-s1+1;
|
||||
if (lua_opt_number(4, INT_MAX, "strfind") >= pos+strlen(s2)-1)
|
||||
lua_pushnumber (pos);
|
||||
else
|
||||
lua_pushnil();
|
||||
}
|
||||
else
|
||||
lua_pushnil();
|
||||
int n;
|
||||
char *s1, *s2;
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
if (!lua_isstring(o1) || !lua_isstring(o2))
|
||||
{ lua_error ("incorrect arguments to function `strfind'"); return; }
|
||||
s1 = lua_getstring(o1);
|
||||
s2 = lua_getstring(o2);
|
||||
n = strstr(s1,s2) - s1 + 1;
|
||||
lua_pushnumber (n);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -101,8 +40,10 @@ static void str_find (void)
|
||||
*/
|
||||
static void str_len (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "strlen");
|
||||
lua_pushnumber(strlen(s));
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (!lua_isstring(o))
|
||||
{ lua_error ("incorrect arguments to function `strlen'"); return; }
|
||||
lua_pushnumber(strlen(lua_getstring(o)));
|
||||
}
|
||||
|
||||
|
||||
@@ -113,18 +54,24 @@ static void str_len (void)
|
||||
*/
|
||||
static void str_sub (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "strsub");
|
||||
int start = (int)lua_check_number(2, "strsub");
|
||||
int end = lua_opt_number(3, strlen(s), "strsub");
|
||||
int start, end;
|
||||
char *s;
|
||||
lua_Object o1 = lua_getparam (1);
|
||||
lua_Object o2 = lua_getparam (2);
|
||||
lua_Object o3 = lua_getparam (3);
|
||||
if (!lua_isstring(o1) || !lua_isnumber(o2) || !lua_isnumber(o3))
|
||||
{ lua_error ("incorrect arguments to function `strsub'"); return; }
|
||||
s = strdup (lua_getstring(o1));
|
||||
start = lua_getnumber (o2);
|
||||
end = lua_getnumber (o3);
|
||||
if (end < start || start < 1 || end > strlen(s))
|
||||
lua_pushliteral("");
|
||||
lua_pushstring ("");
|
||||
else
|
||||
{
|
||||
luaI_addchar(0);
|
||||
while (start <= end)
|
||||
luaI_addchar(s[start++ - 1]);
|
||||
lua_pushstring (luaI_addchar(0));
|
||||
s[end] = 0;
|
||||
lua_pushstring (&s[start-1]);
|
||||
}
|
||||
free (s);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -134,12 +81,19 @@ static void str_sub (void)
|
||||
*/
|
||||
static void str_lower (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "strlower");
|
||||
luaI_addchar(0);
|
||||
while (*s)
|
||||
luaI_addchar(tolower(*s++));
|
||||
lua_pushstring(luaI_addchar(0));
|
||||
}
|
||||
char *s, *c;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (!lua_isstring(o))
|
||||
{ lua_error ("incorrect arguments to function `strlower'"); return; }
|
||||
c = s = strdup(lua_getstring(o));
|
||||
while (*c != 0)
|
||||
{
|
||||
*c = tolower(*c);
|
||||
c++;
|
||||
}
|
||||
lua_pushstring(s);
|
||||
free(s);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
@@ -149,104 +103,19 @@ static void str_lower (void)
|
||||
*/
|
||||
static void str_upper (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "strupper");
|
||||
luaI_addchar(0);
|
||||
while (*s)
|
||||
luaI_addchar(toupper(*s++));
|
||||
lua_pushstring(luaI_addchar(0));
|
||||
}
|
||||
|
||||
/*
|
||||
** get ascii value of a character in a string
|
||||
*/
|
||||
static void str_ascii (void)
|
||||
{
|
||||
char *s = lua_check_string(1, "ascii");
|
||||
int pos = lua_opt_number(2, 1, "ascii") - 1;
|
||||
if (pos<0 || pos>=strlen(s))
|
||||
lua_arg_error("ascii");
|
||||
lua_pushnumber(s[pos]);
|
||||
}
|
||||
|
||||
void luaI_addquoted (char *s)
|
||||
{
|
||||
luaI_addchar('"');
|
||||
for (; *s; s++)
|
||||
{
|
||||
if (*s == '"' || *s == '\\' || *s == '\n')
|
||||
luaI_addchar('\\');
|
||||
luaI_addchar(*s);
|
||||
}
|
||||
luaI_addchar('"');
|
||||
}
|
||||
|
||||
#define MAX_CONVERTION 2000
|
||||
#define MAX_FORMAT 50
|
||||
|
||||
static void str_format (void)
|
||||
{
|
||||
int arg = 1;
|
||||
char *strfrmt = lua_check_string(arg++, "format");
|
||||
luaI_addchar(0); /* initialize */
|
||||
while (*strfrmt)
|
||||
{
|
||||
if (*strfrmt != '%')
|
||||
luaI_addchar(*strfrmt++);
|
||||
else if (*++strfrmt == '%')
|
||||
luaI_addchar(*strfrmt++); /* %% */
|
||||
else
|
||||
{ /* format item */
|
||||
char form[MAX_FORMAT]; /* store the format ('%...') */
|
||||
char buff[MAX_CONVERTION]; /* store the formated value */
|
||||
int size = 0;
|
||||
int i = 0;
|
||||
form[i++] = '%';
|
||||
form[i] = *strfrmt++;
|
||||
while (!isalpha(form[i]))
|
||||
{
|
||||
if (isdigit(form[i]))
|
||||
{
|
||||
size = size*10 + form[i]-'0';
|
||||
if (size >= MAX_CONVERTION)
|
||||
lua_error("format size/precision too long in function `format'");
|
||||
}
|
||||
else if (form[i] == '.')
|
||||
size = 0; /* re-start */
|
||||
if (++i >= MAX_FORMAT)
|
||||
lua_error("bad format in function `format'");
|
||||
form[i] = *strfrmt++;
|
||||
}
|
||||
form[i+1] = 0; /* ends string */
|
||||
switch (form[i])
|
||||
{
|
||||
case 'q':
|
||||
luaI_addquoted(lua_check_string(arg++, "format"));
|
||||
buff[0] = '\0'; /* addchar already done */
|
||||
break;
|
||||
case 's':
|
||||
{
|
||||
char *s = lua_check_string(arg++, "format");
|
||||
if (strlen(s) >= MAX_CONVERTION)
|
||||
lua_error("string argument too long in function `format'");
|
||||
sprintf(buff, form, s);
|
||||
break;
|
||||
}
|
||||
case 'c': case 'd': case 'i': case 'o':
|
||||
case 'u': case 'x': case 'X':
|
||||
sprintf(buff, form, (int)lua_check_number(arg++, "format"));
|
||||
break;
|
||||
case 'e': case 'E': case 'f': case 'g':
|
||||
sprintf(buff, form, lua_check_number(arg++, "format"));
|
||||
break;
|
||||
default: /* also treat cases 'pnLlh' */
|
||||
lua_error("invalid format option in function `format'");
|
||||
}
|
||||
for (i=0; buff[i]; i++) /* move formated value to result */
|
||||
luaI_addchar(buff[i]);
|
||||
}
|
||||
}
|
||||
lua_pushstring(luaI_addchar(0)); /* push the result */
|
||||
}
|
||||
char *s, *c;
|
||||
lua_Object o = lua_getparam (1);
|
||||
if (!lua_isstring(o))
|
||||
{ lua_error ("incorrect arguments to function `strlower'"); return; }
|
||||
c = s = strdup(lua_getstring(o));
|
||||
while (*c != 0)
|
||||
{
|
||||
*c = toupper(*c);
|
||||
c++;
|
||||
}
|
||||
lua_pushstring(s);
|
||||
free(s);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
@@ -259,6 +128,4 @@ void strlib_open (void)
|
||||
lua_register ("strsub", str_sub);
|
||||
lua_register ("strlower", str_lower);
|
||||
lua_register ("strupper", str_upper);
|
||||
lua_register ("ascii", str_ascii);
|
||||
lua_register ("format", str_format);
|
||||
}
|
||||
|
||||
13
strlib.h
13
strlib.h
@@ -1,13 +0,0 @@
|
||||
/*
|
||||
** String library to LUA
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: $
|
||||
*/
|
||||
|
||||
|
||||
#ifndef strlib_h
|
||||
|
||||
void strlib_open (void);
|
||||
|
||||
#endif
|
||||
|
||||
515
table.c
515
table.c
@@ -1,266 +1,351 @@
|
||||
/*
|
||||
** table.c
|
||||
** Module to control static tables
|
||||
** TeCGraf - PUC-Rio
|
||||
** 11 May 93
|
||||
*/
|
||||
|
||||
char *rcs_table="$Id: table.c,v 2.50 1996/03/21 16:31:32 roberto Exp roberto $";
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "mem.h"
|
||||
#include "opcode.h"
|
||||
#include "tree.h"
|
||||
#include "hash.h"
|
||||
#include "table.h"
|
||||
#include "inout.h"
|
||||
#include "table.h"
|
||||
#include "lua.h"
|
||||
#include "fallback.h"
|
||||
#include "luadebug.h"
|
||||
|
||||
#define streq(s1,s2) (strcmp(s1,s2)==0)
|
||||
|
||||
#define BUFFER_BLOCK 256
|
||||
#ifndef MAXSYMBOL
|
||||
#define MAXSYMBOL 512
|
||||
#endif
|
||||
static Symbol tablebuffer[MAXSYMBOL] = {
|
||||
{"type",{T_CFUNCTION,{lua_type}}},
|
||||
{"tonumber",{T_CFUNCTION,{lua_obj2number}}},
|
||||
{"next",{T_CFUNCTION,{lua_next}}},
|
||||
{"nextvar",{T_CFUNCTION,{lua_nextvar}}},
|
||||
{"print",{T_CFUNCTION,{lua_print}}}
|
||||
};
|
||||
Symbol *lua_table=tablebuffer;
|
||||
Word lua_ntable=5;
|
||||
|
||||
Symbol *lua_table = NULL;
|
||||
Word lua_ntable = 0;
|
||||
static Long lua_maxsymbol = 0;
|
||||
#ifndef MAXCONSTANT
|
||||
#define MAXCONSTANT 256
|
||||
#endif
|
||||
static char *constantbuffer[MAXCONSTANT] = {"mark","nil","number",
|
||||
"string","table",
|
||||
"function","cfunction"
|
||||
};
|
||||
char **lua_constant = constantbuffer;
|
||||
Word lua_nconstant=T_CFUNCTION+1;
|
||||
|
||||
TaggedString **lua_constant = NULL;
|
||||
Word lua_nconstant = 0;
|
||||
static Long lua_maxconstant = 0;
|
||||
#ifndef MAXSTRING
|
||||
#define MAXSTRING 512
|
||||
#endif
|
||||
static char *stringbuffer[MAXSTRING];
|
||||
char **lua_string = stringbuffer;
|
||||
Word lua_nstring=0;
|
||||
|
||||
#ifndef MAXARRAY
|
||||
#define MAXARRAY 512
|
||||
#endif
|
||||
static Hash *arraybuffer[MAXARRAY];
|
||||
Hash **lua_array = arraybuffer;
|
||||
Word lua_narray=0;
|
||||
|
||||
#define GARBAGE_BLOCK 1024
|
||||
#define MIN_GARBAGE_BLOCK (GARBAGE_BLOCK/2)
|
||||
|
||||
static void lua_nextvar (void);
|
||||
|
||||
/*
|
||||
** Internal functions
|
||||
*/
|
||||
static struct {
|
||||
char *name;
|
||||
lua_CFunction func;
|
||||
} int_funcs[] = {
|
||||
{"assert", luaI_assert},
|
||||
{"dofile", lua_internaldofile},
|
||||
{"dostring", lua_internaldostring},
|
||||
{"error", luaI_error},
|
||||
{"getglobal", luaI_getglobal},
|
||||
{"next", lua_next},
|
||||
{"nextvar", lua_nextvar},
|
||||
{"print", luaI_print},
|
||||
{"setfallback", luaI_setfallback},
|
||||
{"setglobal", luaI_setglobal},
|
||||
{"tonumber", lua_obj2number},
|
||||
{"tostring", luaI_tostring},
|
||||
{"type", luaI_type}
|
||||
};
|
||||
|
||||
#define INTFUNCSIZE (sizeof(int_funcs)/sizeof(int_funcs[0]))
|
||||
|
||||
|
||||
void luaI_initsymbol (void)
|
||||
{
|
||||
int i;
|
||||
lua_maxsymbol = BUFFER_BLOCK;
|
||||
lua_table = newvector(lua_maxsymbol, Symbol);
|
||||
for (i=0; i<INTFUNCSIZE; i++)
|
||||
{
|
||||
Word n = luaI_findsymbolbyname(int_funcs[i].name);
|
||||
s_tag(n) = LUA_T_CFUNCTION; s_fvalue(n) = int_funcs[i].func;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Initialise constant table with pre-defined constants
|
||||
*/
|
||||
void luaI_initconstant (void)
|
||||
{
|
||||
lua_maxconstant = BUFFER_BLOCK;
|
||||
lua_constant = newvector(lua_maxconstant, TaggedString *);
|
||||
/* pre-register mem error messages, to avoid loop when error arises */
|
||||
luaI_findconstantbyname(tableEM);
|
||||
luaI_findconstantbyname(memEM);
|
||||
}
|
||||
#define MAXFILE 20
|
||||
char *lua_file[MAXFILE];
|
||||
int lua_nfile;
|
||||
|
||||
|
||||
/*
|
||||
** Given a name, search it at symbol table and return its index. If not
|
||||
** found, allocate it.
|
||||
** found, allocate at end of table, checking oveflow and return its index.
|
||||
** On error, return -1.
|
||||
*/
|
||||
Word luaI_findsymbol (TaggedString *t)
|
||||
int lua_findsymbol (char *s)
|
||||
{
|
||||
if (t->varindex == NOT_USED)
|
||||
{
|
||||
if (lua_ntable == lua_maxsymbol)
|
||||
lua_maxsymbol = growvector(&lua_table, lua_maxsymbol, Symbol,
|
||||
symbolEM, MAX_WORD);
|
||||
t->varindex = lua_ntable;
|
||||
lua_table[lua_ntable].varname = t;
|
||||
s_tag(lua_ntable) = LUA_T_NIL;
|
||||
lua_ntable++;
|
||||
}
|
||||
return t->varindex;
|
||||
}
|
||||
|
||||
|
||||
Word luaI_findsymbolbyname (char *name)
|
||||
{
|
||||
return luaI_findsymbol(luaI_createfixedstring(name));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Given a tree node, check it is has a correspondent constant index. If not,
|
||||
** allocate it.
|
||||
*/
|
||||
Word luaI_findconstant (TaggedString *t)
|
||||
{
|
||||
if (t->constindex == NOT_USED)
|
||||
{
|
||||
if (lua_nconstant == lua_maxconstant)
|
||||
lua_maxconstant = growvector(&lua_constant, lua_maxconstant, TaggedString *,
|
||||
constantEM, MAX_WORD);
|
||||
t->constindex = lua_nconstant;
|
||||
lua_constant[lua_nconstant] = t;
|
||||
lua_nconstant++;
|
||||
}
|
||||
return t->constindex;
|
||||
}
|
||||
|
||||
|
||||
Word luaI_findconstantbyname (char *name)
|
||||
{
|
||||
return luaI_findconstant(luaI_createfixedstring(name));
|
||||
}
|
||||
|
||||
TaggedString *luaI_createfixedstring (char *name)
|
||||
{
|
||||
TaggedString *ts = lua_createstring(name);
|
||||
if (!ts->marked)
|
||||
ts->marked = 2; /* avoid GC */
|
||||
return ts;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Traverse symbol table objects
|
||||
*/
|
||||
static char *lua_travsymbol (int (*fn)(Object *))
|
||||
{
|
||||
Word i;
|
||||
int i;
|
||||
for (i=0; i<lua_ntable; i++)
|
||||
if (fn(&s_object(i)))
|
||||
return lua_table[i].varname->str;
|
||||
return NULL;
|
||||
if (streq(s,s_name(i)))
|
||||
return i;
|
||||
if (lua_ntable >= MAXSYMBOL-1)
|
||||
{
|
||||
lua_error ("symbol table overflow");
|
||||
return -1;
|
||||
}
|
||||
s_name(lua_ntable) = strdup(s);
|
||||
if (s_name(lua_ntable) == NULL)
|
||||
{
|
||||
lua_error ("not enough memory");
|
||||
return -1;
|
||||
}
|
||||
s_tag(lua_ntable++) = T_NIL;
|
||||
|
||||
return (lua_ntable-1);
|
||||
}
|
||||
|
||||
/*
|
||||
** Given a constant string, eliminate its delimeters (" or '), search it at
|
||||
** constant table and return its index. If not found, allocate at end of
|
||||
** the table, checking oveflow and return its index.
|
||||
**
|
||||
** For each allocation, the function allocate a extra char to be used to
|
||||
** mark used string (it's necessary to deal with constant and string
|
||||
** uniformily). The function store at the table the second position allocated,
|
||||
** that represents the beginning of the real string. On error, return -1.
|
||||
**
|
||||
*/
|
||||
int lua_findenclosedconstant (char *s)
|
||||
{
|
||||
int i, j, l=strlen(s);
|
||||
char *c = calloc (l, sizeof(char)); /* make a copy */
|
||||
|
||||
c++; /* create mark space */
|
||||
|
||||
/* introduce scape characters */
|
||||
for (i=1,j=0; i<l-1; i++)
|
||||
{
|
||||
if (s[i] == '\\')
|
||||
{
|
||||
switch (s[++i])
|
||||
{
|
||||
case 'n': c[j++] = '\n'; break;
|
||||
case 't': c[j++] = '\t'; break;
|
||||
case 'r': c[j++] = '\r'; break;
|
||||
default : c[j++] = '\\'; c[j++] = c[i]; break;
|
||||
}
|
||||
}
|
||||
else
|
||||
c[j++] = s[i];
|
||||
}
|
||||
c[j++] = 0;
|
||||
|
||||
for (i=0; i<lua_nconstant; i++)
|
||||
if (streq(c,lua_constant[i]))
|
||||
{
|
||||
free (c-1);
|
||||
return i;
|
||||
}
|
||||
if (lua_nconstant >= MAXCONSTANT-1)
|
||||
{
|
||||
lua_error ("lua: constant string table overflow");
|
||||
return -1;
|
||||
}
|
||||
lua_constant[lua_nconstant++] = c;
|
||||
return (lua_nconstant-1);
|
||||
}
|
||||
|
||||
/*
|
||||
** Given a constant string, search it at constant table and return its index.
|
||||
** If not found, allocate at end of the table, checking oveflow and return
|
||||
** its index.
|
||||
**
|
||||
** For each allocation, the function allocate a extra char to be used to
|
||||
** mark used string (it's necessary to deal with constant and string
|
||||
** uniformily). The function store at the table the second position allocated,
|
||||
** that represents the beginning of the real string. On error, return -1.
|
||||
**
|
||||
*/
|
||||
int lua_findconstant (char *s)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<lua_nconstant; i++)
|
||||
if (streq(s,lua_constant[i]))
|
||||
return i;
|
||||
if (lua_nconstant >= MAXCONSTANT-1)
|
||||
{
|
||||
lua_error ("lua: constant string table overflow");
|
||||
return -1;
|
||||
}
|
||||
{
|
||||
char *c = calloc(strlen(s)+2,sizeof(char));
|
||||
c++; /* create mark space */
|
||||
lua_constant[lua_nconstant++] = strcpy(c,s);
|
||||
}
|
||||
return (lua_nconstant-1);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Mark an object if it is a string or a unmarked array.
|
||||
*/
|
||||
int lua_markobject (Object *o)
|
||||
{/* if already marked, does not change mark value */
|
||||
if (tag(o) == LUA_T_STRING && !tsvalue(o)->marked)
|
||||
tsvalue(o)->marked = 1;
|
||||
else if (tag(o) == LUA_T_ARRAY)
|
||||
void lua_markobject (Object *o)
|
||||
{
|
||||
if (tag(o) == T_STRING)
|
||||
lua_markstring (svalue(o)) = 1;
|
||||
else if (tag(o) == T_ARRAY && markarray(avalue(o)) == 0)
|
||||
lua_hashmark (avalue(o));
|
||||
else if ((o->tag == LUA_T_FUNCTION || o->tag == LUA_T_MARK)
|
||||
&& !o->value.tf->marked)
|
||||
o->value.tf->marked = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
** Mark all strings and arrays used by any object stored at symbol table.
|
||||
*/
|
||||
static void lua_marktable (void)
|
||||
{
|
||||
int i;
|
||||
for (i=0; i<lua_ntable; i++)
|
||||
lua_markobject (&s_object(i));
|
||||
}
|
||||
|
||||
/*
|
||||
** Simulate a garbage colection. When string table or array table overflows,
|
||||
** this function check if all allocated strings and arrays are in use. If
|
||||
** there are unused ones, pack (compress) the tables.
|
||||
*/
|
||||
static void lua_pack (void)
|
||||
{
|
||||
lua_markstack ();
|
||||
lua_marktable ();
|
||||
|
||||
{ /* pack string */
|
||||
int i, j;
|
||||
for (i=j=0; i<lua_nstring; i++)
|
||||
if (lua_markstring(lua_string[i]) == 1)
|
||||
{
|
||||
lua_string[j++] = lua_string[i];
|
||||
lua_markstring(lua_string[i]) = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
free (lua_string[i]-1);
|
||||
}
|
||||
lua_nstring = j;
|
||||
}
|
||||
|
||||
{ /* pack array */
|
||||
int i, j;
|
||||
for (i=j=0; i<lua_narray; i++)
|
||||
if (markarray(lua_array[i]) == 1)
|
||||
{
|
||||
lua_array[j++] = lua_array[i];
|
||||
markarray(lua_array[i]) = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
lua_hashdelete (lua_array[i]);
|
||||
}
|
||||
lua_narray = j;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** Allocate a new string at string table. The given string is already
|
||||
** allocated with mark space and the function puts it at the end of the
|
||||
** table, checking overflow, and returns its own pointer, or NULL on error.
|
||||
*/
|
||||
char *lua_createstring (char *s)
|
||||
{
|
||||
if (s == NULL) return NULL;
|
||||
|
||||
if (lua_nstring >= MAXSTRING-1)
|
||||
{
|
||||
lua_pack ();
|
||||
if (lua_nstring >= MAXSTRING-1)
|
||||
{
|
||||
lua_error ("string table overflow");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
lua_string[lua_nstring++] = s;
|
||||
return s;
|
||||
}
|
||||
|
||||
/*
|
||||
** Allocate a new array, already created, at array table. The function puts
|
||||
** it at the end of the table, checking overflow, and returns its own pointer,
|
||||
** or NULL on error.
|
||||
*/
|
||||
void *lua_createarray (void *a)
|
||||
{
|
||||
if (a == NULL) return NULL;
|
||||
|
||||
if (lua_narray >= MAXARRAY-1)
|
||||
{
|
||||
lua_pack ();
|
||||
if (lua_narray >= MAXARRAY-1)
|
||||
{
|
||||
lua_error ("indexed table overflow");
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
lua_array[lua_narray++] = a;
|
||||
return a;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Garbage collection.
|
||||
** Delete all unused strings and arrays.
|
||||
** Add a file name at file table, checking overflow. This function also set
|
||||
** the external variable "lua_filename" with the function filename set.
|
||||
** Return 0 on success or 1 on error.
|
||||
*/
|
||||
Long luaI_collectgarbage (void)
|
||||
int lua_addfile (char *fn)
|
||||
{
|
||||
Long recovered = 0;
|
||||
lua_travstack(lua_markobject); /* mark stack objects */
|
||||
lua_travsymbol(lua_markobject); /* mark symbol table objects */
|
||||
luaI_travlock(lua_markobject); /* mark locked objects */
|
||||
luaI_travfallbacks(lua_markobject); /* mark fallbacks */
|
||||
recovered += lua_strcollector();
|
||||
recovered += lua_hashcollector();
|
||||
recovered += luaI_funccollector();
|
||||
return recovered;
|
||||
}
|
||||
if (lua_nfile >= MAXFILE-1)
|
||||
{
|
||||
lua_error ("too many files");
|
||||
return 1;
|
||||
}
|
||||
if ((lua_file[lua_nfile++] = strdup (fn)) == NULL)
|
||||
{
|
||||
lua_error ("not enough memory");
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void lua_pack (void)
|
||||
/*
|
||||
** Return the last file name set.
|
||||
*/
|
||||
char *lua_filename (void)
|
||||
{
|
||||
static Long block = GARBAGE_BLOCK; /* when garbage collector will be called */
|
||||
static Long nentity = 0; /* counter of new entities (strings and arrays) */
|
||||
Long recovered = 0;
|
||||
if (nentity++ < block) return;
|
||||
recovered = luaI_collectgarbage();
|
||||
nentity = 0; /* reset counter */
|
||||
block=(16*block-7*recovered)/12; /* adapt block size */
|
||||
if (block < MIN_GARBAGE_BLOCK) block = MIN_GARBAGE_BLOCK;
|
||||
}
|
||||
|
||||
return lua_file[lua_nfile-1];
|
||||
}
|
||||
|
||||
/*
|
||||
** Internal function: return next global variable
|
||||
*/
|
||||
static void lua_nextvar (void)
|
||||
void lua_nextvar (void)
|
||||
{
|
||||
Word next;
|
||||
lua_Object o = lua_getparam(1);
|
||||
if (o == LUA_NOOBJECT)
|
||||
lua_error("too few arguments to function `nextvar'");
|
||||
if (lua_getparam(2) != LUA_NOOBJECT)
|
||||
lua_error("too many arguments to function `nextvar'");
|
||||
if (lua_isnil(o))
|
||||
next = 0;
|
||||
else if (!lua_isstring(o))
|
||||
int index;
|
||||
Object *o = lua_getparam (1);
|
||||
if (o == NULL)
|
||||
{ lua_error ("too few arguments to function `nextvar'"); return; }
|
||||
if (lua_getparam (2) != NULL)
|
||||
{ lua_error ("too many arguments to function `nextvar'"); return; }
|
||||
if (tag(o) == T_NIL)
|
||||
{
|
||||
lua_error("incorrect argument to function `nextvar'");
|
||||
return; /* to avoid warnings */
|
||||
index = 0;
|
||||
}
|
||||
else
|
||||
next = luaI_findsymbolbyname(lua_getstring(o)) + 1;
|
||||
while (next < lua_ntable && s_tag(next) == LUA_T_NIL) next++;
|
||||
if (next >= lua_ntable)
|
||||
{
|
||||
lua_pushnil();
|
||||
lua_pushnil();
|
||||
else if (tag(o) != T_STRING)
|
||||
{
|
||||
lua_error ("incorrect argument to function `nextvar'");
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
TaggedString *t = lua_table[next].varname;
|
||||
for (index=0; index<lua_ntable; index++)
|
||||
if (streq(s_name(index),svalue(o))) break;
|
||||
if (index == lua_ntable)
|
||||
{
|
||||
lua_error ("name not found in function `nextvar'");
|
||||
return;
|
||||
}
|
||||
index++;
|
||||
while (index < lua_ntable-1 && tag(&s_object(index)) == T_NIL) index++;
|
||||
|
||||
if (index == lua_ntable-1)
|
||||
{
|
||||
lua_pushnil();
|
||||
lua_pushnil();
|
||||
return;
|
||||
}
|
||||
}
|
||||
{
|
||||
Object name;
|
||||
tag(&name) = LUA_T_STRING;
|
||||
tsvalue(&name) = t;
|
||||
luaI_pushobject(&name);
|
||||
luaI_pushobject(&s_object(next));
|
||||
tag(&name) = T_STRING;
|
||||
svalue(&name) = lua_createstring(lua_strdup(s_name(index)));
|
||||
if (lua_pushobject (&name)) return;
|
||||
if (lua_pushobject (&s_object(index))) return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static Object *functofind;
|
||||
static int checkfunc (Object *o)
|
||||
{
|
||||
if (o->tag == LUA_T_FUNCTION)
|
||||
return
|
||||
((functofind->tag == LUA_T_FUNCTION || functofind->tag == LUA_T_MARK)
|
||||
&& (functofind->value.tf == o->value.tf));
|
||||
if (o->tag == LUA_T_CFUNCTION)
|
||||
return
|
||||
((functofind->tag == LUA_T_CFUNCTION || functofind->tag == LUA_T_CMARK)
|
||||
&& (functofind->value.f == o->value.f));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
char *lua_getobjname (lua_Object o, char **name)
|
||||
{ /* try to find a name for given function */
|
||||
functofind = luaI_Address(o);
|
||||
if ((*name = luaI_travfallbacks(checkfunc)) != NULL)
|
||||
return "fallback";
|
||||
else if ((*name = lua_travsymbol(checkfunc)) != NULL)
|
||||
return "global";
|
||||
else return "";
|
||||
}
|
||||
|
||||
|
||||
50
table.h
50
table.h
@@ -1,37 +1,39 @@
|
||||
/*
|
||||
** table.c
|
||||
** Module to control static tables
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: table.h,v 2.19 1996/02/26 21:00:27 roberto Exp roberto $
|
||||
** 11 May 93
|
||||
*/
|
||||
|
||||
#ifndef table_h
|
||||
#define table_h
|
||||
|
||||
#include "tree.h"
|
||||
#include "opcode.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Object object;
|
||||
TaggedString *varname;
|
||||
} Symbol;
|
||||
|
||||
|
||||
extern Symbol *lua_table;
|
||||
extern Word lua_ntable;
|
||||
extern TaggedString **lua_constant;
|
||||
extern Word lua_nconstant;
|
||||
extern Word lua_ntable;
|
||||
|
||||
void luaI_initsymbol (void);
|
||||
void luaI_initconstant (void);
|
||||
Word luaI_findsymbolbyname (char *name);
|
||||
Word luaI_findsymbol (TaggedString *t);
|
||||
Word luaI_findconstant (TaggedString *t);
|
||||
Word luaI_findconstantbyname (char *name);
|
||||
TaggedString *luaI_createfixedstring (char *str);
|
||||
int lua_markobject (Object *o);
|
||||
Long luaI_collectgarbage (void);
|
||||
void lua_pack (void);
|
||||
extern char **lua_constant;
|
||||
extern Word lua_nconstant;
|
||||
|
||||
extern char **lua_string;
|
||||
extern Word lua_nstring;
|
||||
|
||||
extern Hash **lua_array;
|
||||
extern Word lua_narray;
|
||||
|
||||
extern char *lua_file[];
|
||||
extern int lua_nfile;
|
||||
|
||||
#define lua_markstring(s) (*((s)-1))
|
||||
|
||||
|
||||
int lua_findsymbol (char *s);
|
||||
int lua_findenclosedconstant (char *s);
|
||||
int lua_findconstant (char *s);
|
||||
void lua_markobject (Object *o);
|
||||
char *lua_createstring (char *s);
|
||||
void *lua_createarray (void *a);
|
||||
int lua_addfile (char *fn);
|
||||
char *lua_filename (void);
|
||||
void lua_nextvar (void);
|
||||
|
||||
#endif
|
||||
|
||||
15
test.lua
Normal file
15
test.lua
Normal file
@@ -0,0 +1,15 @@
|
||||
$debug
|
||||
|
||||
|
||||
function somaP (x1,y1,x2,y2)
|
||||
return x1+x2, y1+y2
|
||||
end
|
||||
|
||||
function norma (x,y)
|
||||
return x*x+y*y
|
||||
end
|
||||
|
||||
function retorno_multiplo ()
|
||||
print (norma(somaP(2,3,4,5)))
|
||||
end
|
||||
|
||||
145
tree.c
145
tree.c
@@ -1,145 +0,0 @@
|
||||
/*
|
||||
** tree.c
|
||||
** TecCGraf - PUC-Rio
|
||||
*/
|
||||
|
||||
char *rcs_tree="$Id: tree.c,v 1.19 1996/02/22 20:34:33 roberto Exp $";
|
||||
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "mem.h"
|
||||
#include "lua.h"
|
||||
#include "tree.h"
|
||||
#include "lex.h"
|
||||
#include "hash.h"
|
||||
#include "table.h"
|
||||
|
||||
|
||||
#define NUM_HASHS 64
|
||||
|
||||
typedef struct {
|
||||
int size;
|
||||
int nuse; /* number of elements (including EMPTYs) */
|
||||
TaggedString **hash;
|
||||
} stringtable;
|
||||
|
||||
static int initialized = 0;
|
||||
|
||||
static stringtable string_root[NUM_HASHS];
|
||||
|
||||
static TaggedString EMPTY = {NOT_USED, NOT_USED, 0, 2, {0}};
|
||||
|
||||
|
||||
static unsigned long hash (char *str)
|
||||
{
|
||||
unsigned long h = 0;
|
||||
while (*str)
|
||||
h = ((h<<5)-h)^(unsigned char)*(str++);
|
||||
return h;
|
||||
}
|
||||
|
||||
static void initialize (void)
|
||||
{
|
||||
initialized = 1;
|
||||
luaI_addReserved();
|
||||
luaI_initsymbol();
|
||||
luaI_initconstant();
|
||||
}
|
||||
|
||||
|
||||
static void grow (stringtable *tb)
|
||||
{
|
||||
int newsize = luaI_redimension(tb->size);
|
||||
TaggedString **newhash = newvector(newsize, TaggedString *);
|
||||
int i;
|
||||
for (i=0; i<newsize; i++)
|
||||
newhash[i] = NULL;
|
||||
/* rehash */
|
||||
tb->nuse = 0;
|
||||
for (i=0; i<tb->size; i++)
|
||||
if (tb->hash[i] != NULL && tb->hash[i] != &EMPTY)
|
||||
{
|
||||
int h = tb->hash[i]->hash%newsize;
|
||||
while (newhash[h])
|
||||
h = (h+1)%newsize;
|
||||
newhash[h] = tb->hash[i];
|
||||
tb->nuse++;
|
||||
}
|
||||
luaI_free(tb->hash);
|
||||
tb->size = newsize;
|
||||
tb->hash = newhash;
|
||||
}
|
||||
|
||||
static TaggedString *insert (char *str, stringtable *tb)
|
||||
{
|
||||
TaggedString *ts;
|
||||
unsigned long h = hash(str);
|
||||
int i;
|
||||
int j = -1;
|
||||
if ((Long)tb->nuse*3 >= (Long)tb->size*2)
|
||||
{
|
||||
if (!initialized)
|
||||
initialize();
|
||||
grow(tb);
|
||||
}
|
||||
i = h%tb->size;
|
||||
while (tb->hash[i])
|
||||
{
|
||||
if (tb->hash[i] == &EMPTY)
|
||||
j = i;
|
||||
else if (strcmp(str, tb->hash[i]->str) == 0)
|
||||
return tb->hash[i];
|
||||
i = (i+1)%tb->size;
|
||||
}
|
||||
/* not found */
|
||||
lua_pack();
|
||||
if (j != -1) /* is there an EMPTY space? */
|
||||
i = j;
|
||||
else
|
||||
tb->nuse++;
|
||||
ts = tb->hash[i] = (TaggedString *)luaI_malloc(sizeof(TaggedString)+strlen(str));
|
||||
strcpy(ts->str, str);
|
||||
ts->marked = 0;
|
||||
ts->hash = h;
|
||||
ts->varindex = ts->constindex = NOT_USED;
|
||||
return ts;
|
||||
}
|
||||
|
||||
TaggedString *lua_createstring (char *str)
|
||||
{
|
||||
return insert(str, &string_root[(unsigned)str[0]%NUM_HASHS]);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Garbage collection function.
|
||||
** This function traverse the string list freeing unindexed strings
|
||||
*/
|
||||
Long lua_strcollector (void)
|
||||
{
|
||||
Long counter = 0;
|
||||
int i;
|
||||
for (i=0; i<NUM_HASHS; i++)
|
||||
{
|
||||
stringtable *tb = &string_root[i];
|
||||
int j;
|
||||
for (j=0; j<tb->size; j++)
|
||||
{
|
||||
TaggedString *t = tb->hash[j];
|
||||
if (t != NULL && t->marked <= 1)
|
||||
{
|
||||
if (t->marked)
|
||||
t->marked = 0;
|
||||
else
|
||||
{
|
||||
luaI_free(t);
|
||||
tb->hash[j] = &EMPTY;
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return counter;
|
||||
}
|
||||
|
||||
28
tree.h
28
tree.h
@@ -1,28 +0,0 @@
|
||||
/*
|
||||
** tree.h
|
||||
** TecCGraf - PUC-Rio
|
||||
** $Id: tree.h,v 1.13 1996/02/14 13:35:51 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef tree_h
|
||||
#define tree_h
|
||||
|
||||
#include "types.h"
|
||||
|
||||
#define NOT_USED 0xFFFE
|
||||
|
||||
|
||||
typedef struct TaggedString
|
||||
{
|
||||
Word varindex; /* != NOT_USED if this is a symbol */
|
||||
Word constindex; /* != NOT_USED if this is a constant */
|
||||
unsigned long hash; /* 0 if not initialized */
|
||||
int marked; /* for garbage collection; never collect (nor change) if > 1 */
|
||||
char str[1]; /* \0 byte already reserved */
|
||||
} TaggedString;
|
||||
|
||||
|
||||
TaggedString *lua_createstring (char *str);
|
||||
Long lua_strcollector (void);
|
||||
|
||||
#endif
|
||||
35
type.lua
Normal file
35
type.lua
Normal file
@@ -0,0 +1,35 @@
|
||||
$debug
|
||||
|
||||
function check (object, class)
|
||||
local v = next(object,nil);
|
||||
while v ~= nil do
|
||||
if class[v] = nil then print("unknown field: " .. v)
|
||||
elseif type(object[v]) ~= class[v].type
|
||||
then print("wrong type for field " .. v)
|
||||
end
|
||||
v = next(object,v);
|
||||
end
|
||||
v = next(class,nil);
|
||||
while v ~= nil do
|
||||
if object[v] = nil then
|
||||
if class[v].default ~= nil then
|
||||
object[v] = class[v].default
|
||||
else print("field "..v.." not initialized")
|
||||
end
|
||||
end
|
||||
v = next(class,v);
|
||||
end
|
||||
end
|
||||
|
||||
typetrilha = @{x = @{default = 0, type = "number"},
|
||||
y = @{default = 0, type = "number"},
|
||||
name = @{type = "string"}
|
||||
}
|
||||
|
||||
function trilha (t) check(t,typetrilha) end
|
||||
|
||||
t1 = @trilha{ x = 4, name = "3"}
|
||||
|
||||
a = "na".."me"
|
||||
|
||||
|
||||
29
types.h
29
types.h
@@ -1,29 +0,0 @@
|
||||
/*
|
||||
** TeCGraf - PUC-Rio
|
||||
** $Id: types.h,v 1.3 1995/02/06 19:32:43 roberto Exp roberto $
|
||||
*/
|
||||
|
||||
#ifndef types_h
|
||||
#define types_h
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#ifndef real
|
||||
#define real float
|
||||
#endif
|
||||
|
||||
#define Byte lua_Byte /* some systems have Byte as a predefined type */
|
||||
typedef unsigned char Byte; /* unsigned 8 bits */
|
||||
|
||||
#define Word lua_Word /* some systems have Word as a predefined type */
|
||||
typedef unsigned short Word; /* unsigned 16 bits */
|
||||
|
||||
#define MAX_WORD (USHRT_MAX-2) /* maximum value of a word (-2 for safety) */
|
||||
#define MAX_INT (INT_MAX-2) /* maximum value of a int (-2 for safety) */
|
||||
|
||||
#define Long lua_Long /* some systems have Long as a predefined type */
|
||||
typedef signed long Long; /* 32 bits */
|
||||
|
||||
typedef unsigned int IntPoint; /* unsigned with same size as a pointer (for hashing) */
|
||||
|
||||
#endif
|
||||
326
undump.c
326
undump.c
@@ -1,326 +0,0 @@
|
||||
/*
|
||||
** undump.c
|
||||
** load bytecodes from files
|
||||
*/
|
||||
|
||||
char* rcs_undump="$Id: undump.c,v 1.13 1996/03/12 20:00:40 lhf Exp lhf $";
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "opcode.h"
|
||||
#include "mem.h"
|
||||
#include "table.h"
|
||||
#include "undump.h"
|
||||
|
||||
static int swapword=0;
|
||||
static int swapfloat=0;
|
||||
static TFunc* Main=NULL; /* functions in a chunk */
|
||||
static TFunc* lastF=NULL;
|
||||
|
||||
static void warn(char* s) /* TODO: remove */
|
||||
{
|
||||
#if 0
|
||||
fprintf(stderr,"undump: %s\n",s);
|
||||
#endif
|
||||
}
|
||||
|
||||
static void FixCode(Byte* code, Byte* end) /* swap words */
|
||||
{
|
||||
Byte* p;
|
||||
for (p=code; p!=end;)
|
||||
{
|
||||
OpCode op=(OpCode)*p;
|
||||
switch (op)
|
||||
{
|
||||
case PUSHNIL:
|
||||
case PUSH0:
|
||||
case PUSH1:
|
||||
case PUSH2:
|
||||
case PUSHLOCAL0:
|
||||
case PUSHLOCAL1:
|
||||
case PUSHLOCAL2:
|
||||
case PUSHLOCAL3:
|
||||
case PUSHLOCAL4:
|
||||
case PUSHLOCAL5:
|
||||
case PUSHLOCAL6:
|
||||
case PUSHLOCAL7:
|
||||
case PUSHLOCAL8:
|
||||
case PUSHLOCAL9:
|
||||
case PUSHINDEXED:
|
||||
case STORELOCAL0:
|
||||
case STORELOCAL1:
|
||||
case STORELOCAL2:
|
||||
case STORELOCAL3:
|
||||
case STORELOCAL4:
|
||||
case STORELOCAL5:
|
||||
case STORELOCAL6:
|
||||
case STORELOCAL7:
|
||||
case STORELOCAL8:
|
||||
case STORELOCAL9:
|
||||
case STOREINDEXED0:
|
||||
case ADJUST0:
|
||||
case EQOP:
|
||||
case LTOP:
|
||||
case LEOP:
|
||||
case GTOP:
|
||||
case GEOP:
|
||||
case ADDOP:
|
||||
case SUBOP:
|
||||
case MULTOP:
|
||||
case DIVOP:
|
||||
case POWOP:
|
||||
case CONCOP:
|
||||
case MINUSOP:
|
||||
case NOTOP:
|
||||
case POP:
|
||||
case RETCODE0:
|
||||
p++;
|
||||
break;
|
||||
case PUSHBYTE:
|
||||
case PUSHLOCAL:
|
||||
case STORELOCAL:
|
||||
case STOREINDEXED:
|
||||
case STORELIST0:
|
||||
case ADJUST:
|
||||
case RETCODE:
|
||||
p+=2;
|
||||
break;
|
||||
case STORELIST:
|
||||
case CALLFUNC:
|
||||
p+=3;
|
||||
break;
|
||||
case PUSHFUNCTION:
|
||||
p+=5;
|
||||
break;
|
||||
case PUSHWORD:
|
||||
case PUSHSELF:
|
||||
case CREATEARRAY:
|
||||
case ONTJMP:
|
||||
case ONFJMP:
|
||||
case JMP:
|
||||
case UPJMP:
|
||||
case IFFJMP:
|
||||
case IFFUPJMP:
|
||||
case SETLINE:
|
||||
case PUSHSTRING:
|
||||
case PUSHGLOBAL:
|
||||
case STOREGLOBAL:
|
||||
{
|
||||
Byte t;
|
||||
t=p[1]; p[1]=p[2]; p[2]=t;
|
||||
p+=3;
|
||||
break;
|
||||
}
|
||||
case PUSHFLOAT:
|
||||
{
|
||||
Byte t;
|
||||
t=p[1]; p[1]=p[4]; p[4]=t;
|
||||
t=p[2]; p[2]=p[3]; p[3]=t;
|
||||
p+=5;
|
||||
break;
|
||||
}
|
||||
case STORERECORD:
|
||||
{
|
||||
int n=*++p;
|
||||
p++;
|
||||
while (n--)
|
||||
{
|
||||
Byte t;
|
||||
t=p[0]; p[0]=p[1]; p[1]=t;
|
||||
p+=2;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
lua_error("corrupt binary file");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void Unthread(Byte* code, int i, int v)
|
||||
{
|
||||
while (i!=0)
|
||||
{
|
||||
CodeWord c;
|
||||
Byte* p=code+i;
|
||||
get_word(c,p);
|
||||
i=c.w;
|
||||
c.w=v;
|
||||
p[-2]=c.m.c1;
|
||||
p[-1]=c.m.c2;
|
||||
}
|
||||
}
|
||||
|
||||
static int LoadWord(FILE* D)
|
||||
{
|
||||
Word w;
|
||||
fread(&w,sizeof(w),1,D);
|
||||
if (swapword)
|
||||
{
|
||||
Byte* p=(Byte*)&w; /* TODO: need union? */
|
||||
Byte t;
|
||||
t=p[0]; p[0]=p[1]; p[1]=t;
|
||||
}
|
||||
return w;
|
||||
}
|
||||
|
||||
static int LoadSize(FILE* D)
|
||||
{
|
||||
Word hi=LoadWord(D);
|
||||
Word lo=LoadWord(D);
|
||||
int s=(hi<<16)|lo;
|
||||
if ((Word)s != s) lua_error("code too long");
|
||||
return s;
|
||||
}
|
||||
|
||||
static char* LoadBlock(int size, FILE* D)
|
||||
{
|
||||
char* b=luaI_malloc(size);
|
||||
fread(b,size,1,D);
|
||||
return b;
|
||||
}
|
||||
|
||||
static char* LoadString(FILE* D)
|
||||
{
|
||||
int size=LoadWord(D);
|
||||
char *b=luaI_buffer(size);
|
||||
fread(b,size,1,D);
|
||||
return b;
|
||||
}
|
||||
|
||||
static char* LoadNewString(FILE* D)
|
||||
{
|
||||
return LoadBlock(LoadWord(D),D);
|
||||
}
|
||||
|
||||
static void LoadFunction(FILE* D)
|
||||
{
|
||||
TFunc* tf=new(TFunc);
|
||||
tf->next=NULL;
|
||||
tf->locvars=NULL;
|
||||
tf->size=LoadSize(D);
|
||||
tf->lineDefined=LoadWord(D);
|
||||
if (IsMain(tf)) /* new main */
|
||||
{
|
||||
tf->fileName=LoadNewString(D);
|
||||
Main=lastF=tf;
|
||||
}
|
||||
else /* fix PUSHFUNCTION */
|
||||
{
|
||||
CodeCode c;
|
||||
Byte* p;
|
||||
tf->marked=LoadWord(D);
|
||||
tf->fileName=Main->fileName;
|
||||
p=Main->code+tf->marked;
|
||||
c.tf=tf;
|
||||
*p++=c.m.c1; *p++=c.m.c2; *p++=c.m.c3; *p++=c.m.c4;
|
||||
lastF=lastF->next=tf;
|
||||
}
|
||||
tf->code=LoadBlock(tf->size,D);
|
||||
if (swapword || swapfloat) FixCode(tf->code,tf->code+tf->size);
|
||||
while (1) /* unthread */
|
||||
{
|
||||
int c=getc(D);
|
||||
if (c==ID_VAR) /* global var */
|
||||
{
|
||||
int i=LoadWord(D);
|
||||
char* s=LoadString(D);
|
||||
int v=luaI_findsymbolbyname(s);
|
||||
Unthread(tf->code,i,v);
|
||||
}
|
||||
else if (c==ID_STR) /* constant string */
|
||||
{
|
||||
int i=LoadWord(D);
|
||||
char* s=LoadString(D);
|
||||
int v=luaI_findconstantbyname(s);
|
||||
Unthread(tf->code,i,v);
|
||||
}
|
||||
else
|
||||
{
|
||||
ungetc(c,D);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void LoadSignature(FILE* D)
|
||||
{
|
||||
char* s=SIGNATURE;
|
||||
while (*s!=0 && getc(D)==*s)
|
||||
++s;
|
||||
if (*s!=0) lua_error("bad signature");
|
||||
}
|
||||
|
||||
static void LoadHeader(FILE* D) /* TODO: error handling */
|
||||
{
|
||||
Word w,tw=TEST_WORD;
|
||||
float f,tf=TEST_FLOAT;
|
||||
LoadSignature(D);
|
||||
getc(D); /* skip version */
|
||||
fread(&w,sizeof(w),1,D); /* test word */
|
||||
if (w!=tw)
|
||||
{
|
||||
swapword=1;
|
||||
warn("different byte order");
|
||||
}
|
||||
fread(&f,sizeof(f),1,D); /* test float */
|
||||
if (f!=tf)
|
||||
{
|
||||
Byte* p=(Byte*)&f; /* TODO: need union? */
|
||||
Byte t;
|
||||
swapfloat=1;
|
||||
t=p[0]; p[0]=p[3]; p[3]=t;
|
||||
t=p[1]; p[1]=p[2]; p[2]=t;
|
||||
if (f!=tf) /* TODO: try another perm? */
|
||||
lua_error("different float representation");
|
||||
else
|
||||
warn("different byte order in floats");
|
||||
}
|
||||
}
|
||||
|
||||
static void LoadChunk(FILE* D)
|
||||
{
|
||||
LoadHeader(D);
|
||||
while (1)
|
||||
{
|
||||
int c=getc(D);
|
||||
if (c==ID_FUN) LoadFunction(D); else { ungetc(c,D); break; }
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** load one chunk from a file.
|
||||
** return list of functions found, headed by main, or NULL at EOF.
|
||||
*/
|
||||
TFunc* luaI_undump1(FILE* D)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
int c=getc(D);
|
||||
if (c==ID_CHUNK)
|
||||
{
|
||||
LoadChunk(D);
|
||||
return Main;
|
||||
}
|
||||
else if (c==EOF)
|
||||
return NULL;
|
||||
else
|
||||
lua_error("not a lua binary file");
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** load and run all chunks in a file
|
||||
*/
|
||||
int luaI_undump(FILE* D)
|
||||
{
|
||||
TFunc* m;
|
||||
while ((m=luaI_undump1(D)))
|
||||
{
|
||||
int status=luaI_dorun(m);
|
||||
luaI_freefunc(m);
|
||||
if (status!=0) return status;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
23
undump.h
23
undump.h
@@ -1,23 +0,0 @@
|
||||
/*
|
||||
** undump.h
|
||||
** definitions for lua decompiler
|
||||
** $Id: undump.h,v 1.1 1996/03/08 21:43:21 lhf Exp lhf $
|
||||
*/
|
||||
|
||||
#include "func.h"
|
||||
|
||||
#define IsMain(f) (f->lineDefined==0)
|
||||
|
||||
/* definitions for chunk headers */
|
||||
|
||||
#define ID_CHUNK 27 /* ESC */
|
||||
#define ID_FUN 'F'
|
||||
#define ID_VAR 'V'
|
||||
#define ID_STR 'S'
|
||||
#define SIGNATURE "Lua"
|
||||
#define VERSION 0x23 /* 2.3 */
|
||||
#define TEST_WORD 0x1234 /* a word for testing byte ordering */
|
||||
#define TEST_FLOAT 0.123456789e-23 /* a float for testing representation */
|
||||
|
||||
TFunc* luaI_undump1(FILE* D); /* load one chunk */
|
||||
int luaI_undump(FILE* D); /* load all chunks */
|
||||
35
y_tab.h
Normal file
35
y_tab.h
Normal file
@@ -0,0 +1,35 @@
|
||||
|
||||
typedef union
|
||||
{
|
||||
int vInt;
|
||||
long vLong;
|
||||
float vFloat;
|
||||
Word vWord;
|
||||
Byte *pByte;
|
||||
} YYSTYPE;
|
||||
extern YYSTYPE yylval;
|
||||
# define NIL 257
|
||||
# define IF 258
|
||||
# define THEN 259
|
||||
# define ELSE 260
|
||||
# define ELSEIF 261
|
||||
# define WHILE 262
|
||||
# define DO 263
|
||||
# define REPEAT 264
|
||||
# define UNTIL 265
|
||||
# define END 266
|
||||
# define RETURN 267
|
||||
# define LOCAL 268
|
||||
# define NUMBER 269
|
||||
# define FUNCTION 270
|
||||
# define NAME 271
|
||||
# define STRING 272
|
||||
# define DEBUG 273
|
||||
# define NOT 274
|
||||
# define AND 275
|
||||
# define OR 276
|
||||
# define NE 277
|
||||
# define LE 278
|
||||
# define GE 279
|
||||
# define CONC 280
|
||||
# define UNARY 281
|
||||
Reference in New Issue
Block a user