mirror of https://github.com/golang/go.git
828 lines
13 KiB
C
828 lines
13 KiB
C
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
#include "runtime.h"
|
|
|
|
static Map* hash[1009];
|
|
|
|
static Map*
|
|
hashmap(Sigi *si, Sigs *ss)
|
|
{
|
|
int32 ns, ni;
|
|
uint32 ihash, h;
|
|
byte *sname, *iname;
|
|
Map *m;
|
|
|
|
h = ((uint32)si + (uint32)ss) % nelem(hash);
|
|
for(m=hash[h]; m!=nil; m=m->link) {
|
|
if(m->si == si && m->ss == ss) {
|
|
if(m->bad) {
|
|
throw("bad hashmap");
|
|
m = nil;
|
|
}
|
|
// prints("old hashmap\n");
|
|
return m;
|
|
}
|
|
}
|
|
|
|
ni = si[0].offset; // first word has size
|
|
m = mal(sizeof(*m) + ni*sizeof(m->fun[0]));
|
|
m->si = si;
|
|
m->ss = ss;
|
|
|
|
ni = 1; // skip first word
|
|
ns = 0;
|
|
|
|
loop1:
|
|
// pick up next name from
|
|
// interface signature
|
|
iname = si[ni].name;
|
|
if(iname == nil) {
|
|
m->link = hash[h];
|
|
hash[h] = m;
|
|
// prints("new hashmap\n");
|
|
return m;
|
|
}
|
|
ihash = si[ni].hash;
|
|
|
|
loop2:
|
|
// pick up and comapre next name
|
|
// from structure signature
|
|
sname = ss[ns].name;
|
|
if(sname == nil) {
|
|
prints((int8*)iname);
|
|
prints(": ");
|
|
throw("hashmap: failed to find method");
|
|
m->bad = 1;
|
|
m->link = hash[h];
|
|
hash[h] = m;
|
|
return nil;
|
|
}
|
|
if(ihash != ss[ns].hash ||
|
|
strcmp(sname, iname) != 0) {
|
|
ns++;
|
|
goto loop2;
|
|
}
|
|
|
|
m->fun[si[ni].offset] = ss[ns].fun;
|
|
ni++;
|
|
goto loop1;
|
|
}
|
|
|
|
void
|
|
sys·ifaces2i(Sigi *si, Sigs *ss, Map *m, void *s)
|
|
{
|
|
|
|
if(debug) {
|
|
prints("s2i sigi=");
|
|
sys·printpointer(si);
|
|
prints(" sigs=");
|
|
sys·printpointer(ss);
|
|
prints(" s=");
|
|
sys·printpointer(s);
|
|
}
|
|
|
|
if(s == nil) {
|
|
throw("ifaces2i: nil pointer");
|
|
m = nil;
|
|
FLUSH(&m);
|
|
return;
|
|
}
|
|
|
|
m = hashmap(si, ss);
|
|
|
|
if(debug) {
|
|
prints(" returning m=");
|
|
sys·printpointer(m);
|
|
prints(" s=");
|
|
sys·printpointer(s);
|
|
prints("\n");
|
|
dump((byte*)m, 64);
|
|
}
|
|
|
|
FLUSH(&m);
|
|
}
|
|
|
|
void
|
|
sys·ifacei2i(Sigi *si, Map *m, void *s)
|
|
{
|
|
|
|
if(debug) {
|
|
prints("i2i sigi=");
|
|
sys·printpointer(si);
|
|
prints(" m=");
|
|
sys·printpointer(m);
|
|
prints(" s=");
|
|
sys·printpointer(s);
|
|
}
|
|
|
|
if(m == nil) {
|
|
throw("ifacei2i: nil map");
|
|
s = nil;
|
|
FLUSH(&s);
|
|
return;
|
|
}
|
|
|
|
if(m->si == nil) {
|
|
throw("ifacei2i: nil pointer");
|
|
return;
|
|
}
|
|
|
|
if(m->si != si) {
|
|
m = hashmap(si, m->ss);
|
|
FLUSH(&m);
|
|
}
|
|
|
|
if(debug) {
|
|
prints(" returning m=");
|
|
sys·printpointer(m);
|
|
prints(" s=");
|
|
sys·printpointer(s);
|
|
prints("\n");
|
|
dump((byte*)m, 64);
|
|
}
|
|
}
|
|
|
|
void
|
|
sys·ifacei2s(Sigs *ss, Map *m, void *s)
|
|
{
|
|
|
|
if(debug) {
|
|
prints("i2s m=");
|
|
sys·printpointer(m);
|
|
prints(" s=");
|
|
sys·printpointer(s);
|
|
prints("\n");
|
|
}
|
|
|
|
if(m == nil) {
|
|
throw("ifacei2s: nil map");
|
|
s = nil;
|
|
FLUSH(&s);
|
|
return;
|
|
}
|
|
|
|
if(m->ss != ss) {
|
|
dump((byte*)m, 64);
|
|
throw("ifacei2s: wrong pointer");
|
|
s = nil;
|
|
FLUSH(&s);
|
|
return;
|
|
}
|
|
}
|
|
|
|
enum
|
|
{
|
|
NANEXP = 2047<<20,
|
|
NANMASK = 2047<<20,
|
|
NANSIGN = 1<<31,
|
|
};
|
|
|
|
static uint64 uvnan = 0x7FF0000000000001;
|
|
static uint64 uvinf = 0x7FF0000000000000;
|
|
static uint64 uvneginf = 0xFFF0000000000000;
|
|
|
|
static int32
|
|
isInf(float64 d, int32 sign)
|
|
{
|
|
uint64 x;
|
|
|
|
x = *(uint64*)&d;
|
|
if(sign == 0) {
|
|
if(x == uvinf || x == uvneginf)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
if(sign > 0) {
|
|
if(x == uvinf)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
if(x == uvneginf)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static float64
|
|
NaN(void)
|
|
{
|
|
return *(float64*)&uvnan;
|
|
}
|
|
|
|
static int32
|
|
isNaN(float64 d)
|
|
{
|
|
uint64 x;
|
|
|
|
x = *(uint64*)&d;
|
|
return ((uint32)x>>32)==0x7FF00000 && !isInf(d, 0);
|
|
}
|
|
|
|
static float64
|
|
Inf(int32 sign)
|
|
{
|
|
if(sign < 0)
|
|
return *(float64*)&uvinf;
|
|
else
|
|
return *(float64*)&uvneginf;
|
|
}
|
|
|
|
enum
|
|
{
|
|
MASK = 0x7ffL,
|
|
SHIFT = 64-11-1,
|
|
BIAS = 1022L,
|
|
};
|
|
|
|
static float64
|
|
frexp(float64 d, int32 *ep)
|
|
{
|
|
uint64 x;
|
|
|
|
if(d == 0) {
|
|
*ep = 0;
|
|
return 0;
|
|
}
|
|
x = *(uint64*)&d;
|
|
*ep = (int32)((x >> SHIFT) & MASK) - BIAS;
|
|
x &= ~((uint64)MASK << SHIFT);
|
|
x |= (uint64)BIAS << SHIFT;
|
|
return *(float64*)&x;
|
|
}
|
|
|
|
static float64
|
|
ldexp(float64 d, int32 e)
|
|
{
|
|
uint64 x;
|
|
|
|
if(d == 0)
|
|
return 0;
|
|
x = *(uint64*)&d;
|
|
e += (int32)(x >> SHIFT) & MASK;
|
|
if(e <= 0)
|
|
return 0; /* underflow */
|
|
if(e >= MASK){ /* overflow */
|
|
if(d < 0)
|
|
return Inf(-1);
|
|
return Inf(1);
|
|
}
|
|
x &= ~((uint64)MASK << SHIFT);
|
|
x |= (uint64)e << SHIFT;
|
|
return *(float64*)&x;
|
|
}
|
|
|
|
static float64
|
|
modf(float64 d, float64 *ip)
|
|
{
|
|
float64 dd;
|
|
uint64 x;
|
|
int32 e;
|
|
|
|
if(d < 1) {
|
|
if(d < 0) {
|
|
d = modf(-d, ip);
|
|
*ip = -*ip;
|
|
return -d;
|
|
}
|
|
*ip = 0;
|
|
return d;
|
|
}
|
|
|
|
x = *(uint64*)&d;
|
|
e = (int32)((x >> SHIFT) & MASK) - BIAS;
|
|
|
|
/*
|
|
* Keep the top 11+e bits; clear the rest.
|
|
*/
|
|
if(e <= 64-11)
|
|
x &= ~((uint64)1 << (64-11-e))-1;
|
|
dd = *(float64*)&x;
|
|
*ip = dd;
|
|
return d - dd;
|
|
}
|
|
|
|
// func frexp(float64) (int32, float64); // break fp into exp,fract
|
|
void
|
|
sys·frexp(float64 din, int32 iou, float64 dou)
|
|
{
|
|
dou = frexp(din, &iou);
|
|
FLUSH(&dou);
|
|
}
|
|
|
|
//func ldexp(int32, float64) float64; // make fp from exp,fract
|
|
void
|
|
sys·ldexp(float64 din, int32 ein, float64 dou)
|
|
{
|
|
dou = ldexp(din, ein);
|
|
FLUSH(&dou);
|
|
}
|
|
|
|
//func modf(float64) (float64, float64); // break fp into double+double
|
|
float64
|
|
sys·modf(float64 din, float64 dou1, float64 dou2)
|
|
{
|
|
dou1 = modf(din, &dou2);
|
|
FLUSH(&dou2);
|
|
}
|
|
|
|
static int32 argc;
|
|
static uint8** argv;
|
|
static int32 envc;
|
|
static uint8** envv;
|
|
|
|
|
|
void
|
|
args(int32 c, uint8 **v)
|
|
{
|
|
argc = c;
|
|
argv = v;
|
|
envv = v + argc + 1; // skip 0 at end of argv
|
|
for (envc = 0; envv[envc] != 0; envc++)
|
|
;
|
|
}
|
|
|
|
//func argc() int32; // return number of arguments
|
|
void
|
|
sys·argc(int32 v)
|
|
{
|
|
v = argc;
|
|
FLUSH(&v);
|
|
}
|
|
|
|
//func envc() int32; // return number of environment variables
|
|
void
|
|
sys·envc(int32 v)
|
|
{
|
|
v = envc;
|
|
FLUSH(&v);
|
|
}
|
|
|
|
//func argv(i) string; // return argument i
|
|
void
|
|
sys·argv(int32 i, string s)
|
|
{
|
|
uint8* str;
|
|
int32 l;
|
|
|
|
if(i < 0 || i >= argc) {
|
|
s = emptystring;
|
|
goto out;
|
|
}
|
|
|
|
str = argv[i];
|
|
l = findnull((int8*)str);
|
|
s = mal(sizeof(s->len)+l);
|
|
s->len = l;
|
|
mcpy(s->str, str, l);
|
|
|
|
out:
|
|
FLUSH(&s);
|
|
}
|
|
|
|
//func envv(i) string; // return argument i
|
|
void
|
|
sys·envv(int32 i, string s)
|
|
{
|
|
uint8* str;
|
|
int32 l;
|
|
|
|
if(i < 0 || i >= envc) {
|
|
s = emptystring;
|
|
goto out;
|
|
}
|
|
|
|
str = envv[i];
|
|
l = findnull((int8*)str);
|
|
s = mal(sizeof(s->len)+l);
|
|
s->len = l;
|
|
mcpy(s->str, str, l);
|
|
|
|
out:
|
|
FLUSH(&s);
|
|
}
|
|
|
|
check(void)
|
|
{
|
|
int8 a;
|
|
uint8 b;
|
|
int16 c;
|
|
uint16 d;
|
|
int32 e;
|
|
uint32 f;
|
|
int64 g;
|
|
uint64 h;
|
|
float32 i;
|
|
float64 j;
|
|
void* k;
|
|
uint16* l;
|
|
|
|
if(sizeof(a) != 1) throw("bad a");
|
|
if(sizeof(b) != 1) throw("bad b");
|
|
if(sizeof(c) != 2) throw("bad c");
|
|
if(sizeof(d) != 2) throw("bad d");
|
|
if(sizeof(e) != 4) throw("bad e");
|
|
if(sizeof(f) != 4) throw("bad f");
|
|
if(sizeof(g) != 8) throw("bad g");
|
|
if(sizeof(h) != 8) throw("bad h");
|
|
if(sizeof(i) != 4) throw("bad i");
|
|
if(sizeof(j) != 8) throw("bad j");
|
|
if(sizeof(k) != 8) throw("bad k");
|
|
if(sizeof(l) != 8) throw("bad l");
|
|
// prints(1"check ok\n");
|
|
initsig();
|
|
}
|
|
|
|
typedef struct Link Link;
|
|
typedef struct Hmap Hmap;
|
|
typedef struct Alg Alg;
|
|
|
|
struct Alg
|
|
{
|
|
uint64 (*hash)(uint32, void*);
|
|
uint32 (*equal)(uint32, void*, void*);
|
|
void (*print)(uint32, void*);
|
|
void (*copy)(uint32, void*, void*);
|
|
};
|
|
|
|
struct Link
|
|
{
|
|
Link* link;
|
|
byte data[8];
|
|
};
|
|
|
|
struct Hmap
|
|
{
|
|
uint32 len; // must be first
|
|
uint32 keysize;
|
|
uint32 valsize;
|
|
uint32 hint;
|
|
Alg* keyalg;
|
|
Alg* valalg;
|
|
uint32 valoffset;
|
|
uint32 ko;
|
|
uint32 vo;
|
|
uint32 po;
|
|
Link* link;
|
|
};
|
|
|
|
static uint64
|
|
memhash(uint32 s, void *a)
|
|
{
|
|
prints("memhash\n");
|
|
return 0x12345;
|
|
}
|
|
|
|
static uint32
|
|
memequal(uint32 s, void *a, void *b)
|
|
{
|
|
byte *ba, *bb;
|
|
uint32 i;
|
|
|
|
ba = a;
|
|
bb = b;
|
|
for(i=0; i<s; i++)
|
|
if(ba[i] != bb[i])
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
memprint(uint32 s, void *a)
|
|
{
|
|
uint64 v;
|
|
|
|
v = 0xbadb00b;
|
|
switch(s) {
|
|
case 1:
|
|
v = *(uint8*)a;
|
|
break;
|
|
case 2:
|
|
v = *(uint16*)a;
|
|
break;
|
|
case 4:
|
|
v = *(uint32*)a;
|
|
break;
|
|
case 8:
|
|
v = *(uint64*)a;
|
|
break;
|
|
}
|
|
sys·printint(v);
|
|
}
|
|
|
|
static void
|
|
memcopy(uint32 s, void *a, void *b)
|
|
{
|
|
byte *ba, *bb;
|
|
uint32 i;
|
|
|
|
ba = a;
|
|
bb = b;
|
|
if(bb == nil) {
|
|
for(i=0; i<s; i++)
|
|
ba[i] = 0;
|
|
return;
|
|
}
|
|
for(i=0; i<s; i++)
|
|
ba[i] = bb[i];
|
|
}
|
|
|
|
static uint64
|
|
stringhash(uint32 s, string *a)
|
|
{
|
|
prints("stringhash\n");
|
|
return 0x12345;
|
|
}
|
|
|
|
static uint32
|
|
stringequal(uint32 s, string *a, string *b)
|
|
{
|
|
return cmpstring(*a, *b) == 0;
|
|
}
|
|
|
|
static void
|
|
stringprint(uint32 s, string *a)
|
|
{
|
|
sys·printstring(*a);
|
|
}
|
|
|
|
static void
|
|
stringcopy(uint32 s, string *a, string *b)
|
|
{
|
|
if(b == nil) {
|
|
*a = nil;
|
|
return;
|
|
}
|
|
*a = *b;
|
|
}
|
|
|
|
static uint64
|
|
pointerhash(uint32 s, void **a)
|
|
{
|
|
prints("pointerhash\n");
|
|
return 0x12345;
|
|
}
|
|
|
|
static uint32
|
|
pointerequal(uint32 s, void **a, void **b)
|
|
{
|
|
prints("pointerequal\n");
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
pointerprint(uint32 s, void **a)
|
|
{
|
|
prints("pointerprint\n");
|
|
}
|
|
|
|
static void
|
|
pointercopy(uint32 s, void **a, void **b)
|
|
{
|
|
if(b == nil) {
|
|
*a = nil;
|
|
return;
|
|
}
|
|
*a = *b;
|
|
}
|
|
|
|
static uint32
|
|
rnd(uint32 n, uint32 m)
|
|
{
|
|
uint32 r;
|
|
|
|
r = n % m;
|
|
if(r)
|
|
n += m-r;
|
|
return n;
|
|
}
|
|
|
|
static Alg
|
|
algarray[] =
|
|
{
|
|
{ &memhash, &memequal, &memprint, &memcopy },
|
|
{ &stringhash, &stringequal, &stringprint, &stringcopy },
|
|
{ &pointerhash, &pointerequal, &pointerprint, &pointercopy },
|
|
};
|
|
|
|
// newmap(keysize uint32, valsize uint32,
|
|
// keyalg uint32, valalg uint32,
|
|
// hint uint32) (hmap *map[any]any);
|
|
void
|
|
sys·newmap(uint32 keysize, uint32 valsize,
|
|
uint32 keyalg, uint32 valalg, uint32 hint,
|
|
Hmap* ret)
|
|
{
|
|
Hmap *m;
|
|
|
|
if(keyalg >= 2 ||
|
|
valalg >= 3) {
|
|
prints("0<=");
|
|
sys·printint(keyalg);
|
|
prints("<");
|
|
sys·printint(nelem(algarray));
|
|
prints("\n0<=");
|
|
sys·printint(valalg);
|
|
prints("<");
|
|
sys·printint(nelem(algarray));
|
|
prints("\n");
|
|
|
|
throw("sys·newmap: key/val algorithm out of range");
|
|
}
|
|
|
|
m = mal(sizeof(*m));
|
|
|
|
m->len = 0;
|
|
m->keysize = keysize;
|
|
m->valsize = valsize;
|
|
m->keyalg = &algarray[keyalg];
|
|
m->valalg = &algarray[valalg];
|
|
m->hint = hint;
|
|
|
|
// these calculations are compiler dependent
|
|
m->valoffset = rnd(keysize, valsize);
|
|
m->ko = rnd(sizeof(m), keysize);
|
|
m->vo = rnd(m->ko+keysize, valsize);
|
|
m->po = rnd(m->vo+valsize, 1);
|
|
|
|
ret = m;
|
|
FLUSH(&ret);
|
|
|
|
if(debug) {
|
|
prints("newmap: map=");
|
|
sys·printpointer(m);
|
|
prints("; keysize=");
|
|
sys·printint(keysize);
|
|
prints("; valsize=");
|
|
sys·printint(valsize);
|
|
prints("; keyalg=");
|
|
sys·printint(keyalg);
|
|
prints("; valalg=");
|
|
sys·printint(valalg);
|
|
prints("; valoffset=");
|
|
sys·printint(m->valoffset);
|
|
prints("; ko=");
|
|
sys·printint(m->ko);
|
|
prints("; vo=");
|
|
sys·printint(m->vo);
|
|
prints("; po=");
|
|
sys·printint(m->po);
|
|
prints("\n");
|
|
}
|
|
}
|
|
|
|
// mapaccess1(hmap *map[any]any, key any) (val any);
|
|
void
|
|
sys·mapaccess1(Hmap *m, ...)
|
|
{
|
|
Link *l;
|
|
byte *ak, *av;
|
|
|
|
ak = (byte*)&m + m->ko;
|
|
av = (byte*)&m + m->vo;
|
|
|
|
for(l=m->link; l!=nil; l=l->link) {
|
|
if(m->keyalg->equal(m->keysize, ak, l->data)) {
|
|
m->valalg->copy(m->valsize, av, l->data+m->valoffset);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
m->valalg->copy(m->valsize, av, 0);
|
|
|
|
out:
|
|
if(debug) {
|
|
prints("sys·mapaccess1: map=");
|
|
sys·printpointer(m);
|
|
prints("; key=");
|
|
m->keyalg->print(m->keysize, ak);
|
|
prints("; val=");
|
|
m->valalg->print(m->valsize, av);
|
|
prints("\n");
|
|
}
|
|
}
|
|
|
|
// mapaccess2(hmap *map[any]any, key any) (val any, pres bool);
|
|
void
|
|
sys·mapaccess2(Hmap *m, ...)
|
|
{
|
|
Link *l;
|
|
byte *ak, *av, *ap;
|
|
|
|
ak = (byte*)&m + m->ko;
|
|
av = (byte*)&m + m->vo;
|
|
ap = (byte*)&m + m->po;
|
|
|
|
for(l=m->link; l!=nil; l=l->link) {
|
|
if(m->keyalg->equal(m->keysize, ak, l->data)) {
|
|
*ap = true;
|
|
m->valalg->copy(m->valsize, av, l->data+m->valoffset);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
*ap = false;
|
|
m->valalg->copy(m->valsize, av, nil);
|
|
|
|
out:
|
|
if(debug) {
|
|
prints("sys·mapaccess2: map=");
|
|
sys·printpointer(m);
|
|
prints("; key=");
|
|
m->keyalg->print(m->keysize, ak);
|
|
prints("; val=");
|
|
m->valalg->print(m->valsize, av);
|
|
prints("; pres=");
|
|
sys·printbool(*ap);
|
|
prints("\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
sys·mapassign(Hmap *m, byte *ak, byte *av)
|
|
{
|
|
Link *l;
|
|
|
|
// mapassign(hmap *map[any]any, key any, val any);
|
|
|
|
for(l=m->link; l!=nil; l=l->link) {
|
|
if(m->keyalg->equal(m->keysize, ak, l->data))
|
|
goto out;
|
|
}
|
|
|
|
l = mal((sizeof(*l)-8) + m->keysize + m->valsize);
|
|
l->link = m->link;
|
|
m->link = l;
|
|
m->keyalg->copy(m->keysize, l->data, ak);
|
|
m->len++;
|
|
|
|
out:
|
|
m->valalg->copy(m->valsize, l->data+m->valoffset, av);
|
|
|
|
if(debug) {
|
|
prints("mapassign: map=");
|
|
sys·printpointer(m);
|
|
prints("; key=");
|
|
m->keyalg->print(m->keysize, ak);
|
|
prints("; val=");
|
|
m->valalg->print(m->valsize, av);
|
|
prints("\n");
|
|
}
|
|
}
|
|
|
|
// mapassign1(hmap *map[any]any, key any, val any);
|
|
void
|
|
sys·mapassign1(Hmap *m, ...)
|
|
{
|
|
Link **ll;
|
|
byte *ak, *av;
|
|
|
|
ak = (byte*)&m + m->ko;
|
|
av = (byte*)&m + m->vo;
|
|
|
|
sys·mapassign(m, ak, av);
|
|
}
|
|
|
|
// mapassign2(hmap *map[any]any, key any, val any, pres bool);
|
|
void
|
|
sys·mapassign2(Hmap *m, ...)
|
|
{
|
|
Link **ll;
|
|
byte *ak, *av, *ap;
|
|
|
|
ak = (byte*)&m + m->ko;
|
|
av = (byte*)&m + m->vo;
|
|
ap = (byte*)&m + m->po;
|
|
|
|
if(*ap == true) {
|
|
// assign
|
|
sys·mapassign(m, ak, av);
|
|
return;
|
|
}
|
|
|
|
// delete
|
|
for(ll=&m->link; (*ll)!=nil; ll=&(*ll)->link) {
|
|
if(m->keyalg->equal(m->keysize, ak, (*ll)->data)) {
|
|
m->valalg->copy(m->valsize, (*ll)->data+m->valoffset, nil);
|
|
(*ll) = (*ll)->link;
|
|
m->len--;
|
|
if(debug) {
|
|
prints("mapdelete (found): map=");
|
|
sys·printpointer(m);
|
|
prints("; key=");
|
|
m->keyalg->print(m->keysize, ak);
|
|
prints("\n");
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if(debug) {
|
|
prints("mapdelete (not found): map=");
|
|
sys·printpointer(m);
|
|
prints("; key=");
|
|
m->keyalg->print(m->keysize, ak);
|
|
prints(" *** not found\n");
|
|
}
|
|
}
|