static Tvalue *table_newkey(ktap_State *ks, Table *t, const Tvalue *key)
{
Node *mp;
mp = mainposition(t, key);
if (!isnil(gval(mp)) || isdummy(mp)) { /* main position is taken? */
Node *othern;
Node *n = getfreepos(t); /* get a free place */
if (n == NULL) { /* cannot find a free place? */
rehash(ks, t, key); /* grow table */
/* whatever called 'newkey' take care of TM cache and GC barrier */
return kp_table_set(ks, t, key); /* insert key into grown table */
}
othern = mainposition(t, gkey(mp));
if (othern != mp) { /* is colliding node out of its main position? */
/* yes; move colliding node into free position */
while (gnext(othern) != mp)
othern = gnext(othern); /* find previous */
gnext(othern) = n; /* redo the chain with `n' in place of `mp' */
*n = *mp; /* copy colliding node into free pos. (mp->next also goes) */
gnext(mp) = NULL; /* now `mp' is free */
setnilvalue(gval(mp));
} else { /* colliding node is in its own main position */
/* new node will go into free position */
gnext(n) = gnext(mp); /* chain new position */
gnext(mp) = n;
mp = n;
}
}
setobj(ks, gkey(mp), key);
return gval(mp);
}
const ktap_val_t *kp_tab_get(ktap_tab_t *t, const ktap_val_t *key)
{
int i;
switch (itype(key)) {
case KTAP_TNIL:
return niltv;
case KTAP_TNUM:
for (i = 0; i <= t->hmask; i++) {
ktap_val_t *v = gkey(gnode(t, i));
if (is_number(v) && nvalue(key) == nvalue(v))
return gval(gnode(t, i));
}
break;
case KTAP_TSTR:
for (i = 0; i <= t->hmask; i++) {
ktap_val_t *v = gkey(gnode(t, i));
if (is_string(v) && (rawtsvalue(key) == rawtsvalue(v)))
return gval(gnode(t, i));
}
break;
default:
for (i = 0; i <= t->hmask; i++) {
if (kp_obj_equal(key, gkey(gnode(t, i))))
return gval(gnode(t, i));
}
break;
}
return niltv;
}
LUA_API int lua_getn (lua_State *L, int index) {
StkId t;
const TObject *value;
int n;
lua_lock(L);
t = luaA_index(L, index);
api_check(L, ttype(t) == LUA_TTABLE);
value = luaH_getstr(hvalue(t), luaS_newliteral(L, "n")); /* = t.n */
if (ttype(value) == LUA_TNUMBER)
lua_number2int(n, nvalue(value));
else {
Node *nd;
Table *a = hvalue(t);
lua_Number max = 0;
int i;
i = a->sizearray;
while (i--) {
if (ttype(&a->array[i]) != LUA_TNIL)
break;
}
max = i+1;
i = sizenode(a);
nd = a->node;
while (i--) {
if (ttype(gkey(nd)) == LUA_TNUMBER &&
ttype(gval(nd)) != LUA_TNIL &&
nvalue(gkey(nd)) > max)
max = nvalue(gkey(nd));
nd++;
}
lua_number2int(n, max);
}
lua_unlock(L);
return n;
}
int luaH_findindex (lua_State *L, Table *t, StkId key) {
#else
static int findindex (lua_State *L, Table *t, StkId key) {
#endif /* LUAPLUS_EXTENSIONS */
int i;
if (ttisnil(key)) return -1; /* first iteration */
i = arrayindex(key);
if (0 < i && i <= t->sizearray) /* is `key' inside array part? */
return i-1; /* yes; that's the index (corrected to C) */
else {
Node *n = mainposition(t, key);
do { /* check whether `key' is somewhere in the chain */
/* key may be dead already, but it is ok to use it in `next' */
if (luaO_rawequalObj(key2tval(n), key) ||
(ttype(gkey(n)) == LUA_TDEADKEY && iscollectable(key) &&
gcvalue(gkey(n)) == gcvalue(key))) {
i = cast_int(n - gnode(t, 0)); /* key index in hash table */
/* hash elements are numbered after array ones */
return i + t->sizearray;
}
else n = gnext(n);
} while (n);
luaG_runerror(L, "invalid key to " LUA_QL("next")); /* key not found */
return 0; /* to avoid warnings */
}
}
static const char *travglobals (lua_State *L, const TObject *o) {
Table *g = hvalue(gt(L));
int i = sizenode(g);
while (i--) {
Node *n = gnode(g, i);
if (luaO_rawequalObj(o, gval(n)) && ttisstring(gkey(n)))
return getstr(tsvalue(gkey(n)));
}
return NULL;
}
/*
* search function for short strings
*/
const Tvalue *kp_table_getstr(Table *t, Tstring *key)
{
Node *n = hashstr(t, key);
do { /* check whether `key' is somewhere in the chain */
if (ttisshrstring(gkey(n)) && eqshrstr(rawtsvalue(gkey(n)), key))
return gval(n); /* that's it */
else
n = gnext(n);
} while (n);
return ktap_nilobject;
}
/*
* main search function
*/
const Tvalue *kp_table_get(Table *t, const Tvalue *key)
{
switch (ttype(key)) {
case KTAP_TNIL:
return ktap_nilobject;
case KTAP_TSHRSTR:
return kp_table_getstr(t, rawtsvalue(key));
case KTAP_TNUMBER: {
ktap_Number n = nvalue(key);
int k = (int)n;
if ((ktap_Number)k == nvalue(key)) /* index is int? */
return kp_table_getint(t, k); /* use specialized version */
/* else go through */
}
default: {
Node *n = mainposition(t, key);
do { /* check whether `key' is somewhere in the chain */
if (rawequalobj(gkey(n), key))
return gval(n); /* that's it */
else
n = gnext(n);
} while (n);
return ktap_nilobject;
}
}
}
static void setnodevector(ktap_State *ks, Table *t, int size)
{
int lsize;
if (size == 0) { /* no elements to hash part? */
t->node = (Node *)dummynode; /* use common `dummynode' */
lsize = 0;
} else {
int i;
lsize = ceillog2(size);
if (lsize > MAXBITS)
kp_runerror(ks, "table overflow");
size = twoto(lsize);
t->node = kp_malloc(ks, size * sizeof(Node));
for (i = 0; i < size; i++) {
Node *n = gnode(t, i);
gnext(n) = NULL;
setnilvalue(gkey(n));
setnilvalue(gval(n));
}
}
t->lsizenode = (u8)lsize;
t->lastfree = gnode(t, size); /* all positions are free */
}
/*
* returns the index of a `key' for table traversals. First goes all
* elements in the array part, then elements in the hash part. The
* beginning of a traversal is signaled by -1.
*/
static int findindex(ktap_State *ks, Table *t, StkId key)
{
int i;
if (ttisnil(key))
return -1; /* first iteration */
i = arrayindex(key);
if (i > 0 && i <= t->sizearray) /* is `key' inside array part? */
return i - 1; /* yes; that's the index (corrected to C) */
else {
Node *n = mainposition(t, key);
for (;;) { /* check whether `key' is somewhere in the chain */
/* key may be dead already, but it is ok to use it in `next' */
if (kp_equalobjv(ks, gkey(n), key)) {
i = n - gnode(t, 0); /* key index in hash table */
/* hash elements are numbered after array ones */
return i + t->sizearray;
} else
n = gnext(n);
if (n == NULL)
/* key not found */
kp_runerror(ks, "invalid key to next");
}
}
}
static Node *getfreepos (Table *t) {
while (t->lastfree-- > t->node) {
if (ttisnil(gkey(t->lastfree)))
return t->lastfree;
}
return NULL; /* could not find a free place */
}
/*
** open parts that may cause memory-allocation errors
*/
static void f_luaopen (lua_State *L, void *ud) {
/* create a new global state */
global_State *g = luaM_new(NULL, global_State);
UNUSED(ud);
if (g == NULL) luaD_throw(L, LUA_ERRMEM);
L->l_G = g;
g->mainthread = L;
g->GCthreshold = 0; /* mark it as unfinished state */
g->strt.size = 0;
g->strt.nuse = 0;
g->strt.hash = NULL;
setnilvalue(defaultmeta(L));
setnilvalue(registry(L));
luaZ_initbuffer(L, &g->buff);
g->panic = default_panic;
g->rootgc = NULL;
g->rootudata = NULL;
g->tmudata = NULL;
setnilvalue(gkey(g->dummynode));
setnilvalue(gval(g->dummynode));
g->dummynode->next = NULL;
g->nblocks = sizeof(lua_State) + sizeof(global_State);
stack_init(L, L); /* init stack */
/* create default meta table with a dummy table, and then close the loop */
defaultmeta(L)->tt = LUA_TTABLE;
sethvalue(defaultmeta(L), luaH_new(L, 0, 0));
hvalue(defaultmeta(L))->metatable = hvalue(defaultmeta(L));
sethvalue(gt(L), luaH_new(L, 0, 4)); /* table of globals */
sethvalue(registry(L), luaH_new(L, 4, 4)); /* registry */
luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
luaT_init(L);
luaX_init(L);
luaS_fix(luaS_newliteral(L, MEMERRMSG));
g->GCthreshold = 4*G(L)->nblocks;
}
int main()
{ /* test driver */
int i,nb,nk;
char key[32];
char block[32];
gentables();
for (i=0;i<32;i++) key[i]=0;
key[0]=1;
for (i=0;i<32;i++) block[i]=i;
for (nb=4;nb<=8;nb+=2)
for (nk=4;nk<=8;nk+=2)
{
printf("\nBlock Size= %d bits, Key Size= %d bits\n",nb*32,nk*32);
gkey(nb,nk,key);
printf("Plain= ");
for (i=0;i<nb*4;i++) printf("%02x",block[i]);
printf("\n");
encrypt(block);
printf("Encrypt= ");
for (i=0;i<nb*4;i++) printf("%02x",(unsigned char)block[i]);
printf("\n");
decrypt(block);
printf("Decrypt= ");
for (i=0;i<nb*4;i++) printf("%02x",block[i]);
printf("\n");
}
return 0;
}
static void traversestrongtable (global_State *g, Table *h) {
Node *n, *limit = gnodelast(h);
unsigned int i;
for (i = 0; i < h->sizearray; i++) /* traverse array part */
markvalue(g, &h->array[i]);
for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */
checkdeadkey(n);
if (ttisnil(gval(n))) /* entry is empty? */
removeentry(n); /* remove it */
else {
lua_assert(!ttisnil(gkey(n)));
markvalue(g, gkey(n)); /* mark key */
markvalue(g, gval(n)); /* mark value */
}
}
}
const Tvalue *kp_table_getint(Table *t, int key)
{
Node *n;
if ((unsigned int)(key - 1) < (unsigned int)t->sizearray)
return &t->array[key - 1];
n = hashnum(t, key);
do {
if (ttisnumber(gkey(n)) && nvalue(gkey(n)) == key)
return gval(n);
else
n = gnext(n);
} while (n);
return ktap_nilobject;
}
IEmbeddedStreamWriter* CNCproxy::PutData(string* key)
{
if (m_NC) {
return m_NC->PutData(key);
}
string gkey(*key);
return m_IC->GetNetCacheWriter( gkey, m_version, m_subkey);
}
NAMESPACE_LUA_BEGIN
#define GCSTEPSIZE 1024u
#define GCSWEEPMAX 40
#define GCSWEEPCOST 10
#define GCFINALIZECOST 100
#define maskmarks cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
#define makewhite(g,x) \
((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
#define white2gray(x) reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
#define black2gray(x) resetbit((x)->gch.marked, BLACKBIT)
#define stringmark(s) reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
#define isfinalized(u) testbit((u)->marked, FINALIZEDBIT)
#define markfinalized(u) l_setbit((u)->marked, FINALIZEDBIT)
#define KEYWEAK bitmask(KEYWEAKBIT)
#define VALUEWEAK bitmask(VALUEWEAKBIT)
#define markvalue(g,o) { checkconsistency(o); \
if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
#define markobject(g,t) { if (iswhite(obj2gco(t))) \
reallymarkobject(g, obj2gco(t)); }
#define setthreshold(g) (g->GCthreshold = (g->estimate/100) * g->gcpause)
static void removeentry (Node *n) {
lua_assert(ttisnil(gval(n)));
if (iscollectable(gkey(n)))
setttype(gkey(n), LUA_TDEADKEY); /* dead key; remove it */
}
static int traversetable(global_State *g, Table *h) {
int i;
int weakkey = 0;
int weakvalue = 0;
const TValue *mode;
if (h->metatable)
markobject(g, h->metatable);
mode = gfasttm(g, h->metatable, TM_MODE);
if (mode && ttisstring(mode)) { /* is there a weak mode? */
weakkey = (strchr(svalue(mode), 'k') != NULL);
weakvalue = (strchr(svalue(mode), 'v') != NULL);
if (weakkey || weakvalue) { /* is really weak? */
h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */
h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
(weakvalue << VALUEWEAKBIT));
h->gclist = g->weak; /* must be cleared after GC, ... */
g->weak = obj2gco(h); /* ... so put in the appropriate list */
}
}
if (weakkey && weakvalue)
return 1;
if (!weakvalue) {
i = h->sizearray;
while (i--)
markvalue(g, &h->array[i]);
}
i = sizenode(h);
while (i--) {
Node *n = gnode(h, i);
lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
if (ttisnil(gval(n)))
removeentry(n); /* remove empty entries */
else {
lua_assert(!ttisnil(gkey(n)));
if (!weakkey)
markvalue(g, gkey(n));
if (!weakvalue)
markvalue(g, gval(n));
}
}
return weakkey || weakvalue;
}
/*
** clear entries with unmarked keys from all weaktables in list 'l' up
** to element 'f'
*/
static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
for (; l != f; l = gco2t(l)->gclist) {
Table *h = gco2t(l);
Node *n, *limit = gnodelast(h);
for (n = gnode(h, 0); n < limit; n++) {
if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
setnilvalue(gval(n)); /* remove value ... */
removeentry(n); /* and remove entry from table */
}
}
}
}
/*
** Traverse a table with weak values and link it to proper list. During
** propagate phase, keep it in 'grayagain' list, to be revisited in the
** atomic phase. In the atomic phase, if table has any white value,
** put it in 'weak' list, to be cleared.
*/
static void traverseweakvalue (global_State *g, Table *h) {
Node *n, *limit = gnodelast(h);
/* if there is array part, assume it may have white values (it is not
worth traversing it now just to check) */
int hasclears = (h->sizearray > 0);
for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */
checkdeadkey(n);
if (ttisnil(gval(n))) /* entry is empty? */
removeentry(n); /* remove it */
else {
lua_assert(!ttisnil(gkey(n)));
markvalue(g, gkey(n)); /* mark key */
if (!hasclears && iscleared(g, gval(n))) /* is there a white value? */
hasclears = 1; /* table will have to be cleared */
}
}
if (g->gcstate == GCSpropagate)
linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */
else if (hasclears)
linkgclist(h, g->weak); /* has to be cleared later */
}
const ktap_val_t *kp_tab_getstr(ktap_tab_t *t, const ktap_str_t *ts)
{
int i;
for (i = 0; i <= t->hmask; i++) {
ktap_val_t *v = gkey(gnode(t, i));
if (is_string(v) && (ts == rawtsvalue(v)))
return gval(gnode(t, i));
}
return niltv;
}
static void traverseweakvalue (global_State *g, Table *h) {
Node *n, *limit = gnodelast(h);
/* if there is array part, assume it may have white values (do not
traverse it just to check) */
int hasclears = (h->sizearray > 0);
for (n = gnode(h, 0); n < limit; n++) {
checkdeadkey(n);
if (ttisnil(gval(n))) /* entry is empty? */
removeentry(n); /* remove it */
else {
lua_assert(!ttisnil(gkey(n)));
markvalue(g, gkey(n)); /* mark key */
if (!hasclears && iscleared(g, gval(n))) /* is there a white value? */
hasclears = 1; /* table will have to be cleared */
}
}
if (hasclears)
linktable(h, &g->weak); /* has to be cleared later */
else /* no white values */
linktable(h, &g->grayagain); /* no need to clean */
}
/*
** clear collected keys from weaktables
*/
static void cleartablekeys (lua_State *L, GCObject *l) {
while (l) {
Table *h = gcotoh(l);
int i = sizenode(h);
lua_assert(h->marked & KEYWEAK);
while (i--) {
Node *n = gnode(h, i);
if (!valismarked(gkey(n))) /* key was collected? */
removekey(L, n); /* remove entry from table */
}
l = h->gclist;
}
}
void kp_table_dump(ktap_State *ks, Table *t)
{
int i, count = 0;
kp_printf(ks, "{");
for (i = 0; i < t->sizearray; i++) {
Tvalue *v = &t->array[i];
if (isnil(v))
continue;
if (count)
kp_printf(ks, ", ");
kp_printf(ks, "(%d: ", i + 1);
kp_showobj(ks, v);
kp_printf(ks, ")");
count++;
}
for (i = 0; i < sizenode(t); i++) {
Node *n = &t->node[i];
if (isnil(gkey(n)))
continue;
if (count)
kp_printf(ks, ", ");
kp_printf(ks, "(");
kp_showobj(ks, gkey(n));
kp_printf(ks, ": ");
kp_showobj(ks, gval(n));
kp_printf(ks, ")");
count++;
}
kp_printf(ks, "}");
}
static void traversetable (GCState *st, Table *h) {
int i;
int weakkey = 0;
int weakvalue = 0;
const TObject *mode;
markvalue(st, h->metatable);
lua_assert(h->lsizenode || h->node == st->g->dummynode);
mode = gfasttm(st->g, h->metatable, TM_MODE);
if (mode && ttisstring(mode)) { /* is there a weak mode? */
weakkey = (strchr(svalue(mode), 'k') != NULL);
weakvalue = (strchr(svalue(mode), 'v') != NULL);
if (weakkey || weakvalue) { /* is really weak? */
GCObject **weaklist;
h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */
h->marked |= cast(lu_byte, (weakkey << KEYWEAKBIT) |
(weakvalue << VALUEWEAKBIT));
weaklist = (weakkey && weakvalue) ? &st->wkv :
(weakkey) ? &st->wk :
&st->wv;
h->gclist = *weaklist; /* must be cleared after GC, ... */
*weaklist = valtogco(h); /* ... so put in the appropriate list */
}
}
if (!weakvalue) {
i = h->sizearray;
while (i--)
markobject(st, &h->array[i]);
}
i = sizenode(h);
while (i--) {
Node *n = gnode(h, i);
if (!ttisnil(gval(n))) {
lua_assert(!ttisnil(gkey(n)));
condmarkobject(st, gkey(n), !weakkey);
condmarkobject(st, gval(n), !weakvalue);
}
}
}
static int numusehash(const Table *t, int *nums, int *pnasize)
{
int totaluse = 0; /* total number of elements */
int ause = 0; /* summation of `nums' */
int i = sizenode(t);
while (i--) {
Node *n = &t->node[i];
if (!isnil(gval(n))) {
ause += countint(gkey(n), nums);
totaluse++;
}
}
*pnasize += ause;
return totaluse;
}
int main()
{
//nb表示分组长度；nk表示密钥长度
int i,nb,nk;
char str[]="abcd1234567890123456789012345678901212345678901234567890123456789012";
char key[32];
char block[32];
gentables();
strtoHex(str,key);
hextoStr(key,str);
printf("Key=");
for (i=0;i<64;i++)
printf("%c",str[i]);
printf("\n");
for (i=0;i<32;i++)
block[i]=i;
for (nb=4;nb<=8;nb+=2)
for (nk=4;nk<=8;nk+=2)
{
printf("\nBlock Size= %d bits, Key Size= %d bits\n",nb*32,nk*32);
gkey(nb,nk,key);
printf("Plain= ");
for (i=0;i<nb*4;i++)
printf("%02x",block[i]);
printf("\n");
//进行加密
encrypt(block);
//输出密文
printf("Encrypt= ");
for (i=0;i<nb*4;i++)
printf("%02x",(unsigned char)block[i]);
printf("\n");
//进行解密
decrypt(block);
//输出明文
printf("Decrypt= ");
for (i=0;i<nb*4;i++)
printf("%02x",block[i]);
printf("\n");
}
system("pause");
return 0;
}
void kp_tab_setvalue(ktap_tab_t *t, const ktap_val_t *key, ktap_val_t *val)
{
const ktap_val_t *v = kp_tab_get(t, key);
if (v != niltv) {
set_obj((ktap_val_t *)v, val);
} else {
if (t->freetop == t->node) {
int size = (t->hmask + 1) * sizeof(ktap_node_t);
t->node = realloc(t->node, size * 2);
memset(t->node + t->hmask + 1, 0, size);
t->freetop = t->node + (t->hmask + 1) * 2;
t->hmask = (t->hmask + 1) * 2 - 1;
}
ktap_node_t *n = --t->freetop;
set_obj(gkey(n), key);
set_obj(gval(n), val);
}
}
int kp_table_next(ktap_State *ks, Table *t, StkId key)
{
int i = findindex(ks, 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, i+1);
setobj(ks, 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? */
setobj(ks, key, gkey(gnode(t, i)));
setobj(ks, key+1, gval(gnode(t, i)));
return 1;
}
}
return 0; /* no more elements */
}
void kp_table_resize(ktap_State *ks, Table *t, int nasize, int nhsize)
{
int i;
int oldasize = t->sizearray;
int oldhsize = t->lsizenode;
Node *nold = t->node; /* save old hash ... */
if (nasize > oldasize) /* array part must grow? */
setarrayvector(ks, t, nasize);
/* create new hash part with appropriate size */
setnodevector(ks, t, nhsize);
if (nasize < oldasize) { /* array part must shrink? */
t->sizearray = nasize;
/* re-insert elements from vanishing slice */
for (i=nasize; i<oldasize; i++) {
if (!ttisnil(&t->array[i]))
kp_table_setint(ks, t, i + 1, &t->array[i]);
}
/* shrink array */
kp_realloc(ks, t->array, oldasize, nasize, Tvalue);
}
/* re-insert elements from hash part */
for (i = twoto(oldhsize) - 1; i >= 0; i--) {
Node *old = nold+i;
if (!ttisnil(gval(old))) {
/* doesn't need barrier/invalidate cache, as entry was
* already present in the table
*/
setobj(ks, kp_table_set(ks, t, gkey(old)), gval(old));
}
}
if (!isdummy(nold))
kp_free(ks, nold); /* free old array */
}
int kp_table_length(ktap_State *ks, Table *t)
{
int i, len = 0;
for (i = 0; i < t->sizearray; i++) {
Tvalue *v = &t->array[i];
if (isnil(v))
continue;
len++;
}
for (i = 0; i < sizenode(t); i++) {
Node *n = &t->node[i];
if (isnil(gkey(n)))
continue;
len++;
}
return len;
}
