/*
** 'global state', shared by all threads of this state
  全局状态，所有线程共享这个状态
*/
typedef struct global_State {
  // 内存分配函数，以及关联的用户数据
  lua_Alloc frealloc;  /* function to reallocate memory */
  void *ud;         /* auxiliary data to 'frealloc' */
  // 短字符串哈希表
  stringtable strt;  /* hash table for strings */
  // 全局注册表
  TValue l_registry;
  // 随机函数种子
  unsigned int seed;  /* randomized seed for hashes */
  // 终止函数
  lua_CFunction panic;  /* to be called in unprotected errors */
  // 主线程
  struct lua_State *mainthread;
  // 版本号
  const lua_Number *version;  /* pointer to version number */
  // 错误消息
  TString *memerrmsg;  /* memory-error message */
  // 元方法名，初始化在luaT_init
  TString *tmname[TM_N];  /* array with tag-method names */ 
  // 基本类型的元方法，表和userdata之外的元表放这儿
  struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */  
  // 零结尾的字符串缓存
  TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
} global_State;

// 默认的分配器：
// nsize == 0 : 行为和free一样
// nsize != 0: 行为和realloc一样，当ptr==NULL时，realloc和malloc一样；否则重分配内存，注意返回的地址和ptr可能不一样。
static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
  (void)ud; (void)osize;  /* not used */
  if (nsize == 0) {
    free(ptr);
    return NULL;
  }
  else
    return realloc(ptr, nsize);
}

// 线程对象
struct lua_State {
  // CallInfo数量，一个CallInfo代表一层函数调用
  unsigned short nci;  /* number of items in 'ci' list */
  // 线程状态：LUA_OK...
  lu_byte status;
  // 栈顶地址
  StkId top;  /* first free slot in the stack */
  // 全局状态
  global_State *l_G;
  // 当前函数的调用信息
  CallInfo *ci;  /* call info for current function */
  // [stack, stack_last]这个范围的栈槽位可用
  StkId stack_last;  /* last free slot in the stack */
  // 栈的起始地址
  StkId stack;  /* stack base */
  // 错误处理链表：当前的恢复点，看luaD_rawrunprotected
  struct lua_longjmp *errorJmp;  /* current error recover point */
  // 初始调用信息
  CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
  // 栈大小
  int stacksize;
};

// 检查当前线程的栈空间是否足够，如果不够会扩大整个栈，
// 同时如果当前函数的栈范围不够，也会扩大
LUA_API int lua_checkstack (lua_State *L, int n) {
  int res;
  // 当前的函数调用信息
  CallInfo *ci = L->ci;
  lua_lock(L);
  api_check(L, n >= 0, "negative 'n'");
  if (L->stack_last - L->top > n)  /* stack large enough? */
    res = 1;  /* yes; check is OK */
  else {  /* no; need to grow stack */
    // 计算出正在使用的大小，EXTRA_STACK也认为是使用的部分
    int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;
    if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */
      res = 0;  /* no */
    else  /* try to grow stack */
      // 在保护模式下调用growstack
      res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);
  }
  // 调整当前CI的栈顶
  if (res && ci->top < L->top + n)
    ci->top = L->top + n;  /* adjust frame top */
  lua_unlock(L);
  return res;
}

// 重新分配栈空间
void luaD_reallocstack (lua_State *L, int newsize) {
  TValue *oldstack = L->stack;
  int lim = L->stacksize;
  lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
  luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
  // 对多出来的槽位填充为nil
  for (; lim < newsize; lim++)
    setnilvalue(L->stack + lim); /* erase new segment */
  // 调整大小字段
  L->stacksize = newsize;
  L->stack_last = L->stack + newsize - EXTRA_STACK;
  // 分配完之后，可能L->stack和oldstack为不同的地址，所以要矫正依赖于栈地址的其他数据
  correctstack(L, oldstack);
}

// 重新分配栈之后，可能L->stack和oldstack为不同的地址，所以要矫正依赖于栈地址的其他数据
static void correctstack (lua_State *L, TValue *oldstack) {
  CallInfo *ci;
  UpVal *up;
  // 矫正栈顶
  L->top = (L->top - oldstack) + L->stack;
  // open upvalue
  for (up = L->openupval; up != NULL; up = up->u.open.next)
    up->v = (up->v - oldstack) + L->stack;
  // 调用栈帧
  for (ci = L->ci; ci != NULL; ci = ci->previous) {
    ci->top = (ci->top - oldstack) + L->stack;
    ci->func = (ci->func - oldstack) + L->stack;
    if (isLua(ci))
      ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
  }
}

// 创建一个虚拟机，L为虚拟机的主线程
lua_State *L = luaL_newstate();
// 打开标准库，如果不需要标准库，下面这一行都可以不要。
luaL_openlibs(L);

// 创建虚拟机，并设置panic回调
LUALIB_API lua_State *luaL_newstate (void) {
  lua_State *L = lua_newstate(l_alloc, NULL); 
  if (L) lua_atpanic(L, &panic);
  return L;
}

typedef struct LG {
  LX l;
  global_State g;
} LG;

typedef struct LX {
  lu_byte extra_[LUA_EXTRASPACE];
  lua_State l;
} LX;

#define fromstate(L)    (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
LX *l = fromstate(L1);
luaM_free(L, l);

static void f_luaopen (lua_State *L, void *ud) {
  global_State *g = G(L);
  UNUSED(ud);
  // 初始化主线程的栈
  stack_init(L, L);  /* init stack */
  // 注册表
  init_registry(L, g);
  // 字符串
  luaS_init(L);
  // 元表
  luaT_init(L);
  // 标识符
  luaX_init(L);
  // 开启GC
  g->gcrunning = 1;  /* allow gc */
  // 版本号
  g->version = lua_version(NULL);
  luai_userstateopen(L);
}

static void init_registry (lua_State *L, global_State *g) {
  TValue temp;
  /* create registry */
  // 创建注册表
  Table *registry = luaH_new(L);
  sethvalue(L, &g->l_registry, registry);
  luaH_resize(L, registry, LUA_RIDX_LAST, 0);
  /* registry[LUA_RIDX_MAINTHREAD] = L */
  // 保存主线程
  setthvalue(L, &temp, L);  /* temp = L */
  luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &temp);
  /* registry[LUA_RIDX_GLOBALS] = table of globals */
  // 创建全局环境
  sethvalue(L, &temp, luaH_new(L));  /* temp = new table (global table) */
  luaH_setint(L, registry, LUA_RIDX_GLOBALS, &temp);
}