Lua1.0 代碼分析 table.c

table.c 代碼分析
全局符號，常量，字符串，關聯數組，文件列表的定義。
全局符號：
初始有 5 個基本的符號，Lua 預設的函數和庫函數都註冊在裏面。
常量：
初始的幾個常量是 Lua 中 type 的名字。
字符串表，關聯數組表，文件列表 全部的這些在 table.c 中定義的這些數組能夠認爲是 Lua 的全局註冊表空間，Lua 的環境。
函數分析

/*
** 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);
}

註釋說得比較清楚了：
給定一個名字，在符號表中查找，若是找到，返回它的索引。若是沒有找到，在數組尾部添加註意不要越界。
若是出錯， 返回 －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);
}

和上面的操做差很少，沒有上面的複雜。上面的針對的是長的字符串（字符串中的特殊符號的，例如字符串的有單引號或雙引號的），下面的針對的是短字符串。因爲 Lua1.0 的詞法分析和語法分析都沒有源文件，暫時這麼認爲。到之後的版本中再看相似的問題。

/*
** 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));
}

標記字符串，數組及在符號數組中的 Object.

/*
** 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;
 }
}

垃圾回收，當新建字符串或者數組時，若是內存溢出，就會被調到。若是字符串或者數組有沒有用到的，釋放它。
標記 stack 上全部的 object
標記 table
壓縮字符串數組
壓縮數組。
lua_createstring
lua_createarray
lua_addfile
註釋的比較清楚，再也不細說。

/*
** 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;
 }
}

得到下一個全局變量。
必須傳入一個參數，但參數能夠爲空，若是參數爲空，則返回第一個全局變量。
參數的類型必須爲字符串型。
在全局表中查找給定的字符串，若是沒找到，返回錯誤。若是找到，則在全局變量中找它後面第一個不爲空的全局變量。