oldest known commit

author: The Lua team <lua@tecgraf.puc-rio.br> 1993-07-28 10:18:00 -0300
committer: The Lua team <lua@tecgraf.puc-rio.br> 1993-07-28 10:18:00 -0300
commit: cd05d9c5cb69020c069f037ba7f243f705d0a48a (patch)
tree: cb7f08c0684c10970a528984741047fb3babadd3 /table.c
download: lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.tar.gz
lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.tar.bz2
lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.zip
1 files changed, 351 insertions, 0 deletions
diff --git a/table.c b/table.c
new file mode 100644
index 00000000..3bae7ebd
--- /dev/null
+++ b/table.c
@@ -0,0 +1,351 @@
+/*
+** table.c
+** Module to control static tables
+** TeCGraf - PUC-Rio
+** 11 May 93
+*/
+#include <stdlib.h>
+#include <string.h>
+#include "opcode.h"
+#include "hash.h"
+#include "inout.h"
+#include "table.h"
+#include "lua.h"
+#define streq(s1,s2)    (strcmp(s1,s2)==0)
+#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;
+#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;
+#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 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 at end of table, checking oveflow and return its index.
+** On error, return -1.
+*/
+int lua_findsymbol (char *s)
+{
+ int i;
+ for (i=0; i<lua_ntable; i++)
+  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.
+*/
+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));
+}
+/*
+** 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;
+}
+/*
+** 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.
+*/
+int lua_addfile (char *fn)
+{
+ 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;
+}
+/*
+** Return the last file name set.
+*/
+char *lua_filename (void)
+{
+ return lua_file[lua_nfile-1];
+}
+/*
+** Internal function: return next global variable
+*/
+void lua_nextvar (void)
+{
+ 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)
+ {
+  index = 0;
+ }
+ else if (tag(o) != T_STRING) 
+ { 
+  lua_error ("incorrect argument to function `nextvar'"); 
+  return;
+ }
+ else
+ {
+  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) = T_STRING;
+  svalue(&name) = lua_createstring(lua_strdup(s_name(index)));
+  if (lua_pushobject (&name)) return;
+  if (lua_pushobject (&s_object(index))) return;
+ }
+}
author	The Lua team <lua@tecgraf.puc-rio.br>	1993-07-28 10:18:00 -0300
committer	The Lua team <lua@tecgraf.puc-rio.br>	1993-07-28 10:18:00 -0300
commit	cd05d9c5cb69020c069f037ba7f243f705d0a48a (patch)
tree	cb7f08c0684c10970a528984741047fb3babadd3 /table.c
download	lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.tar.gz lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.tar.bz2 lua-cd05d9c5cb69020c069f037ba7f243f705d0a48a.zip

diff --git a/table.c b/table.c new file mode 100644 index 00000000..3bae7ebd --- /dev/null +++ b/table.c
@@ -0,0 +1,351 @@
	1	/*
	2	** table.c
	3	** Module to control static tables
	4	** TeCGraf - PUC-Rio
	5	** 11 May 93
	6	*/
	7
	8	#include <stdlib.h>
	9	#include <string.h>
	10
	11	#include "opcode.h"
	12	#include "hash.h"
	13	#include "inout.h"
	14	#include "table.h"
	15	#include "lua.h"
	16
	17	#define streq(s1,s2) (strcmp(s1,s2)==0)
	18
	19	#ifndef MAXSYMBOL
	20	#define MAXSYMBOL 512
	21	#endif
	22	static Symbol tablebuffer[MAXSYMBOL] = {
	23	{"type",{T_CFUNCTION,{lua_type}}},
	24	{"tonumber",{T_CFUNCTION,{lua_obj2number}}},
	25	{"next",{T_CFUNCTION,{lua_next}}},
	26	{"nextvar",{T_CFUNCTION,{lua_nextvar}}},
	27	{"print",{T_CFUNCTION,{lua_print}}}
	28	};
	29	Symbol *lua_table=tablebuffer;
	30	Word lua_ntable=5;
	31
	32	#ifndef MAXCONSTANT
	33	#define MAXCONSTANT 256
	34	#endif
	35	static char *constantbuffer[MAXCONSTANT] = {"mark","nil","number",
	36	"string","table",
	37	"function","cfunction"
	38	};
	39	char **lua_constant = constantbuffer;
	40	Word lua_nconstant=T_CFUNCTION+1;
	41
	42	#ifndef MAXSTRING
	43	#define MAXSTRING 512
	44	#endif
	45	static char *stringbuffer[MAXSTRING];
	46	char **lua_string = stringbuffer;
	47	Word lua_nstring=0;
	48
	49	#ifndef MAXARRAY
	50	#define MAXARRAY 512
	51	#endif
	52	static Hash *arraybuffer[MAXARRAY];
	53	Hash **lua_array = arraybuffer;
	54	Word lua_narray=0;
	55
	56	#define MAXFILE 20
	57	char *lua_file[MAXFILE];
	58	int lua_nfile;
	59
	60
	61	/*
	62	** Given a name, search it at symbol table and return its index. If not
	63	** found, allocate at end of table, checking oveflow and return its index.
	64	** On error, return -1.
	65	*/
	66	int lua_findsymbol (char *s)
	67	{
	68	int i;
	69	for (i=0; i<lua_ntable; i++)
	70	if (streq(s,s_name(i)))
	71	return i;
	72	if (lua_ntable >= MAXSYMBOL-1)
	73	{
	74	lua_error ("symbol table overflow");
	75	return -1;
	76	}
	77	s_name(lua_ntable) = strdup(s);
	78	if (s_name(lua_ntable) == NULL)
	79	{
	80	lua_error ("not enough memory");
	81	return -1;
	82	}
	83	s_tag(lua_ntable++) = T_NIL;
	84
	85	return (lua_ntable-1);
	86	}
	87
	88	/*
	89	** Given a constant string, eliminate its delimeters (" or '), search it at
	90	** constant table and return its index. If not found, allocate at end of
	91	** the table, checking oveflow and return its index.
	92	**
	93	** For each allocation, the function allocate a extra char to be used to
	94	** mark used string (it's necessary to deal with constant and string
	95	** uniformily). The function store at the table the second position allocated,
	96	** that represents the beginning of the real string. On error, return -1.
	97	**
	98	*/
	99	int lua_findenclosedconstant (char *s)
	100	{
	101	int i, j, l=strlen(s);
	102	char c = calloc (l, sizeof(char)); / make a copy */
	103
	104	c++; /* create mark space */
	105
	106	/* introduce scape characters */
	107	for (i=1,j=0; i<l-1; i++)
	108	{
	109	if (s[i] == '\\')
	110	{
	111	switch (s[++i])
	112	{
	113	case 'n': c[j++] = '\n'; break;
	114	case 't': c[j++] = '\t'; break;
	115	case 'r': c[j++] = '\r'; break;
	116	default : c[j++] = '\\'; c[j++] = c[i]; break;
	117	}
	118	}
	119	else
	120	c[j++] = s[i];
	121	}
	122	c[j++] = 0;
	123
	124	for (i=0; i<lua_nconstant; i++)
	125	if (streq(c,lua_constant[i]))
	126	{
	127	free (c-1);
	128	return i;
	129	}
	130	if (lua_nconstant >= MAXCONSTANT-1)
	131	{
	132	lua_error ("lua: constant string table overflow");
	133	return -1;
	134	}
	135	lua_constant[lua_nconstant++] = c;
	136	return (lua_nconstant-1);
	137	}
	138
	139	/*
	140	** Given a constant string, search it at constant table and return its index.
	141	** If not found, allocate at end of the table, checking oveflow and return
	142	** its index.
	143	**
	144	** For each allocation, the function allocate a extra char to be used to
	145	** mark used string (it's necessary to deal with constant and string
	146	** uniformily). The function store at the table the second position allocated,
	147	** that represents the beginning of the real string. On error, return -1.
	148	**
	149	*/
	150	int lua_findconstant (char *s)
	151	{
	152	int i;
	153	for (i=0; i<lua_nconstant; i++)
	154	if (streq(s,lua_constant[i]))
	155	return i;
	156	if (lua_nconstant >= MAXCONSTANT-1)
	157	{
	158	lua_error ("lua: constant string table overflow");
	159	return -1;
	160	}
	161	{
	162	char *c = calloc(strlen(s)+2,sizeof(char));
	163	c++; /* create mark space */
	164	lua_constant[lua_nconstant++] = strcpy(c,s);
	165	}
	166	return (lua_nconstant-1);
	167	}
	168
	169
	170	/*
	171	** Mark an object if it is a string or a unmarked array.
	172	*/
	173	void lua_markobject (Object *o)
	174	{
	175	if (tag(o) == T_STRING)
	176	lua_markstring (svalue(o)) = 1;
	177	else if (tag(o) == T_ARRAY && markarray(avalue(o)) == 0)
	178	lua_hashmark (avalue(o));
	179	}
	180
	181	/*
	182	** Mark all strings and arrays used by any object stored at symbol table.
	183	*/
	184	static void lua_marktable (void)
	185	{
	186	int i;
	187	for (i=0; i<lua_ntable; i++)
	188	lua_markobject (&s_object(i));
	189	}
	190
	191	/*
	192	** Simulate a garbage colection. When string table or array table overflows,
	193	** this function check if all allocated strings and arrays are in use. If
	194	** there are unused ones, pack (compress) the tables.
	195	*/
	196	static void lua_pack (void)
	197	{
	198	lua_markstack ();
	199	lua_marktable ();
	200
	201	{ /* pack string */
	202	int i, j;
	203	for (i=j=0; i<lua_nstring; i++)
	204	if (lua_markstring(lua_string[i]) == 1)
	205	{
	206	lua_string[j++] = lua_string[i];
	207	lua_markstring(lua_string[i]) = 0;
	208	}
	209	else
	210	{
	211	free (lua_string[i]-1);
	212	}
	213	lua_nstring = j;
	214	}
	215
	216	{ /* pack array */
	217	int i, j;
	218	for (i=j=0; i<lua_narray; i++)
	219	if (markarray(lua_array[i]) == 1)
	220	{
	221	lua_array[j++] = lua_array[i];
	222	markarray(lua_array[i]) = 0;
	223	}
	224	else
	225	{
	226	lua_hashdelete (lua_array[i]);
	227	}
	228	lua_narray = j;
	229	}
	230	}
	231
	232	/*
	233	** Allocate a new string at string table. The given string is already
	234	** allocated with mark space and the function puts it at the end of the
	235	** table, checking overflow, and returns its own pointer, or NULL on error.
	236	*/
	237	char lua_createstring (char s)
	238	{
	239	if (s == NULL) return NULL;
	240
	241	if (lua_nstring >= MAXSTRING-1)
	242	{
	243	lua_pack ();
	244	if (lua_nstring >= MAXSTRING-1)
	245	{
	246	lua_error ("string table overflow");
	247	return NULL;
	248	}
	249	}
	250	lua_string[lua_nstring++] = s;
	251	return s;
	252	}
	253
	254	/*
	255	** Allocate a new array, already created, at array table. The function puts
	256	** it at the end of the table, checking overflow, and returns its own pointer,
	257	** or NULL on error.
	258	*/
	259	void lua_createarray (void a)
	260	{
	261	if (a == NULL) return NULL;
	262
	263	if (lua_narray >= MAXARRAY-1)
	264	{
	265	lua_pack ();
	266	if (lua_narray >= MAXARRAY-1)
	267	{
	268	lua_error ("indexed table overflow");
	269	return NULL;
	270	}
	271	}
	272	lua_array[lua_narray++] = a;
	273	return a;
	274	}
	275
	276
	277	/*
	278	** Add a file name at file table, checking overflow. This function also set
	279	** the external variable "lua_filename" with the function filename set.
	280	** Return 0 on success or 1 on error.
	281	*/
	282	int lua_addfile (char *fn)
	283	{
	284	if (lua_nfile >= MAXFILE-1)
	285	{
	286	lua_error ("too many files");
	287	return 1;
	288	}
	289	if ((lua_file[lua_nfile++] = strdup (fn)) == NULL)
	290	{
	291	lua_error ("not enough memory");
	292	return 1;
	293	}
	294	return 0;
	295	}
	296
	297	/*
	298	** Return the last file name set.
	299	*/
	300	char *lua_filename (void)
	301	{
	302	return lua_file[lua_nfile-1];
	303	}
	304
	305	/*
	306	** Internal function: return next global variable
	307	*/
	308	void lua_nextvar (void)
	309	{
	310	int index;
	311	Object *o = lua_getparam (1);
	312	if (o == NULL)
	313	{ lua_error ("too few arguments to function `nextvar'"); return; }
	314	if (lua_getparam (2) != NULL)
	315	{ lua_error ("too many arguments to function `nextvar'"); return; }
	316	if (tag(o) == T_NIL)
	317	{
	318	index = 0;
	319	}
	320	else if (tag(o) != T_STRING)
	321	{
	322	lua_error ("incorrect argument to function `nextvar'");
	323	return;
	324	}
	325	else
	326	{
	327	for (index=0; index<lua_ntable; index++)
	328	if (streq(s_name(index),svalue(o))) break;
	329	if (index == lua_ntable)
	330	{
	331	lua_error ("name not found in function `nextvar'");
	332	return;
	333	}
	334	index++;
	335	while (index < lua_ntable-1 && tag(&s_object(index)) == T_NIL) index++;
	336
	337	if (index == lua_ntable-1)
	338	{
	339	lua_pushnil();
	340	lua_pushnil();
	341	return;
	342	}
	343	}
	344	{
	345	Object name;
	346	tag(&name) = T_STRING;
	347	svalue(&name) = lua_createstring(lua_strdup(s_name(index)));
	348	if (lua_pushobject (&name)) return;
	349	if (lua_pushobject (&s_object(index))) return;
	350	}
	351	}