ltable.h-Dateireferenz

#include "lobject.h"

Include-Abhängigkeitsdiagramm für ltable.h:

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	gnode(t, i)   (&(t)->node[i])
#define	gkey(n)   (&(n)->i_key.nk)
#define	gval(n)   (&(n)->i_val)
#define	gnext(n)   ((n)->i_key.nk.next)
#define	key2tval(n)   (&(n)->i_key.tvk)

Funktionen
LUAI_FUNC const TValue *	luaH_getnum (Table *t, int key)
LUAI_FUNC TValue *	luaH_setnum (lua_State *L, Table *t, int key)
LUAI_FUNC const TValue *	luaH_getstr (Table *t, TString *key)
LUAI_FUNC TValue *	luaH_setstr (lua_State *L, Table *t, TString *key)
LUAI_FUNC const TValue *	luaH_get (Table *t, const TValue *key)
LUAI_FUNC TValue *	luaH_set (lua_State *L, Table *t, const TValue *key)
LUAI_FUNC Table *	luaH_new (lua_State *L, int narray, int lnhash)
LUAI_FUNC void	luaH_resizearray (lua_State *L, Table *t, int nasize)
LUAI_FUNC void	luaH_free (lua_State *L, Table *t)
LUAI_FUNC int	luaH_next (lua_State *L, Table *t, StkId key)
LUAI_FUNC int	luaH_getn (Table *t)

Makro-Dokumentation

#define gkey

(

n)

(&(n)->i_key.nk)

Definiert in Zeile 14 der Datei ltable.h.

#define gnext

(

n)

((n)->i_key.nk.next)

Definiert in Zeile 16 der Datei ltable.h.

#define gnode	(		t,
			i
	)		(&(t)->node[i])

Definiert in Zeile 13 der Datei ltable.h.

#define gval

(

n)

(&(n)->i_val)

Definiert in Zeile 15 der Datei ltable.h.

#define key2tval

(

n)

(&(n)->i_key.tvk)

Definiert in Zeile 18 der Datei ltable.h.

Dokumentation der Funktionen

LUAI_FUNC void luaH_free	(	lua_State *	L,
		Table *	t
	)

Definiert in Zeile 374 der Datei ltable.c.

                                                  {
  if (t->node != dummynode)
    luaM_freearray(L, t->node, sizenode(t), Node);
  luaM_freearray(L, t->array, t->sizearray, TValue);
  luaM_free(L, t);
}

LUAI_FUNC const TValue* luaH_get	(	Table *	t,
		const TValue *	key
	)

Definiert in Zeile 469 der Datei ltable.c.

                                                               {
  switch (ttype(key)) {
    case LUA_TNIL: return luaO_nilobject;
    case LUA_TSTRING: return luaH_getstr(t, rawtsvalue(key));
    case LUA_TNUMBER: {
      int k;
      lua_Number n = nvalue(key);
      lua_number2int(k, n);
      if (luai_numeq(cast_num(k), nvalue(key))) /* index is int? */
        return luaH_getnum(t, k);  /* use specialized version */
      /* else go through */
    }
    default: {
      Node *n = mainposition(t, key);
      do {  /* check whether `key' is somewhere in the chain */
        if (luaO_rawequalObj(key2tval(n), key))
          return gval(n);  /* that's it */
        else n = gnext(n);
      } while (n);
      return luaO_nilobject;
    }
  }
}

LUAI_FUNC int luaH_getn

(

Table *

t)

Definiert in Zeile 560 der Datei ltable.c.

                                   {
  unsigned int j = t->sizearray;
  if (j > 0 && ttisnil(&t->array[j - 1])) {
    /* there is a boundary in the array part: (binary) search for it */
    unsigned int i = 0;
    while (j - i > 1) {
      unsigned int m = (i+j)/2;
      if (ttisnil(&t->array[m - 1])) j = m;
      else i = m;
    }
    return i;
  }
  /* else must find a boundary in hash part */
  else if (t->node == dummynode)  /* hash part is empty? */
    return j;  /* that is easy... */
  else return unbound_search(t, j);
}

LUAI_FUNC const TValue* luaH_getnum	(	Table *	t,
		int	key
	)

Definiert in Zeile 435 der Datei ltable.c.

                                                        {
  /* (1 <= key && key <= t->sizearray) */
  if (cast(unsigned int, key-1) < cast(unsigned int, t->sizearray))
    return &t->array[key-1];
  else {
    lua_Number nk = cast_num(key);
    Node *n = hashnum(t, nk);
    do {  /* check whether `key' is somewhere in the chain */
      if (ttisnumber(gkey(n)) && luai_numeq(nvalue(gkey(n)), nk))
        return gval(n);  /* that's it */
      else n = gnext(n);
    } while (n);
    return luaO_nilobject;
  }
}

LUAI_FUNC const TValue* luaH_getstr	(	Table *	t,
		TString *	key
	)

Definiert in Zeile 455 der Datei ltable.c.

                                                             {
  Node *n = hashstr(t, key);
  do {  /* check whether `key' is somewhere in the chain */
    if (ttisstring(gkey(n)) && rawtsvalue(gkey(n)) == key)
      return gval(n);  /* that's it */
    else n = gnext(n);
  } while (n);
  return luaO_nilobject;
}

LUAI_FUNC Table* luaH_new	(	lua_State *	L,
		int	narray,
		int	lnhash
	)

Definiert in Zeile 358 der Datei ltable.c.

                                                                {
  Table *t = luaM_new(L, Table);
  luaC_link(L, obj2gco(t), LUA_TTABLE);
  t->metatable = NULL;
  t->flags = cast_byte(~0);
  /* temporary values (kept only if some malloc fails) */
  t->array = NULL;
  t->sizearray = 0;
  t->lsizenode = 0;
  t->node = cast(Node *, dummynode);
  setarrayvector(L, t, narray);
  setnodevector(L, t, nhash);
  return t;
}

LUAI_FUNC int luaH_next	(	lua_State *	L,
		Table *	t,
		StkId	key
	)

Definiert in Zeile 162 der Datei ltable.c.

                                                            {
  int i = findindex(L, t, key);  /* find original element */
  for (i++; i < t->sizearray; i++) {  /* try first array part */
    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
      setnvalue(key, cast_num(i+1));
      setobj2s(L, key+1, &t->array[i]);
      return 1;
    }
  }
  for (i -= t->sizearray; i < sizenode(t); i++) {  /* then hash part */
    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
      setobj2s(L, key, key2tval(gnode(t, i)));
      setobj2s(L, key+1, gval(gnode(t, i)));
      return 1;
    }
  }
  return 0;  /* no more elements */
}

LUAI_FUNC void luaH_resizearray	(	lua_State *	L,
		Table *	t,
		int	nasize
	)

Definiert in Zeile 327 der Datei ltable.c.

                                                                     {
  int nsize = (t->node == dummynode) ? 0 : sizenode(t);
  resize(L, t, nasize, nsize);
}

LUAI_FUNC TValue* luaH_set	(	lua_State *	L,
		Table *	t,
		const TValue *	key
	)

Definiert in Zeile 494 der Datei ltable.c.

                                                                       {
  const TValue *p = luaH_get(t, key);
  t->flags = 0;
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
      luaG_runerror(L, "table index is NaN");
    return newkey(L, t, key);
  }
}

LUAI_FUNC TValue* luaH_setnum	(	lua_State *	L,
		Table *	t,
		int	key
	)

Definiert in Zeile 508 der Datei ltable.c.

                                                                {
  const TValue *p = luaH_getnum(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setnvalue(&k, cast_num(key));
    return newkey(L, t, &k);
  }
}

LUAI_FUNC TValue* luaH_setstr	(	lua_State *	L,
		Table *	t,
		TString *	key
	)

Definiert in Zeile 520 der Datei ltable.c.

                                                                     {
  const TValue *p = luaH_getstr(t, key);
  if (p != luaO_nilobject)
    return cast(TValue *, p);
  else {
    TValue k;
    setsvalue(L, &k, key);
    return newkey(L, t, &k);
  }
}