ref: 858ba07669c28ac1e8e88ef0283fb71615cd86c4
dir: /lib/std/introspect.myr/
use "types" use "die" pkg std = type typedesc = union `Tynone /* atomic types */ `Tyvoid `Tybool `Tychar `Tyint8 `Tyint16 `Tyint `Tyint32 `Tyint64 `Tybyte `Tyuint8 `Tyuint16 `Tyuint `Tyuint32 `Tyuint64 `Tyflt32 `Tyflt64 `Tyvalist /* compound types */ `Typtr byte[:] `Tyfunc typecursor `Tyslice byte[:] `Tyarray (size, byte[:]) /* aggregate types */ `Tytuple typecursor `Tystruct typecursor `Tyunion typecursor /* name info */ `Tyname (byte[:], byte[:]) ;; type typecursor = struct nelt : size rem : byte[:] isnamed : bool isiter : bool ;; type typeinfo = struct size : size align : size ;; generic typeof : (v : @a -> byte[:]) const typeenc : (p : ...# -> typecursor) const typeenccursor : (e : byte[:] -> typecursor) const typedesc : (e : byte[:] -> typedesc) const typeinfo : (e : byte[:] -> typeinfo) const tcnext : (t : typecursor# -> byte[:]) const tcpeek : (t : typecursor# -> byte[:]) const ncpeek : (t : typecursor# -> (byte[:], byte[:])) const ncnext : (t : typecursor# -> (byte[:], byte[:])) ;; extern const put : (fmt : byte[:], args : ... -> size) const Encnone : byte = 0 const Encvoid : byte = 1 const Encbool : byte = 2 const Encchar : byte = 3 const Encint8 : byte = 4 const Encint16 : byte = 5 const Encint : byte = 6 const Encint32 : byte = 7 const Encint64 : byte = 8 const Encbyte : byte = 9 const Encuint8 : byte = 10 const Encuint16 : byte = 11 const Encuint : byte = 12 const Encuint32 : byte = 13 const Encuint64 : byte = 14 const Encflt32 : byte = 15 const Encflt64 : byte = 16 const Encvalist : byte = 17 /* compound types */ const Encptr : byte = 18 const Encfunc : byte = 19 const Encslice : byte = 20 const Encarray : byte = 21 /* aggregate types */ const Enctuple : byte = 22 const Encstruct : byte = 23 const Encunion : byte = 24 const Encname : byte = 28 const Encindname :byte = 28 | 0x80 generic typeof = {v : @a -> byte[:] var tc tc = typesof(v) -> tcnext(&tc) } const typeenc = {ap : ...# var e e = getenc((ap : byte##)) e = skiptypeinfo(e[1:]) -> lentypecursor(e) } const typeenccursor = {e -> [.nelt=1, .rem=e, .isiter=false] } const typesof : (a : ... -> typecursor) = {a : ... -> typeenc(&a) } const tcnext = {tc var enc (_, enc) = ncnext(tc) -> enc } const tcpeek = {tc var enc (_, enc) = ncpeek(tc) -> enc } const ncpeek = {tc var name, enc, rem var n, sz if tc.rem.len == 0 || tc.nelt == 0 -> ("", "") elif !tc.isiter -> ("", tc.rem) ;; n = 0 sz = 0 name = "" rem = tc.rem if tc.isnamed /* get the name */ (n, sz) = getipacked(tc.rem) name = rem[sz:sz+n] rem = rem[sz+n:] ;; /* and the type */ (n, sz) = getipacked(rem) enc = rem[sz:sz+n] -> (name, enc) } const ncnext = {tc var n, sz, name, enc if tc.rem.len == 0 || tc.nelt == 0 -> ("", "") elif !tc.isiter /* a bit of a trick, if we want to fake arrays */ tc.nelt-- -> ("", tc.rem) ;; n = 0 sz = 0 name = "" if tc.isnamed /* get the name */ (n, sz) = getipacked(tc.rem) name = tc.rem[sz:sz+n] tc.rem = tc.rem[sz+n:] ;; /* and the type */ (n, sz) = getipacked(tc.rem) enc = tc.rem[sz:sz+n] tc.rem = tc.rem[sz+n:] -> (name, enc) } const getenc = {p : byte## var val, sz, x (val, sz) = getipacked(p#[:8]) x = (&sz : byte#) -> p#[sz:sz+val] } const typedesc = {ti var len,sz, p match ti[0] | Encnone: -> `Tynone | Encvoid: -> `Tyvoid | Encbool: -> `Tybool | Encchar: -> `Tychar | Encint8: -> `Tyint8 | Encint16: -> `Tyint16 | Encint: -> `Tyint | Encint32: -> `Tyint32 | Encint64: -> `Tyint64 | Encbyte: -> `Tybyte | Encuint8: -> `Tyuint8 | Encuint16: -> `Tyuint16 | Encuint: -> `Tyuint | Encuint32: -> `Tyuint32 | Encuint64: -> `Tyuint64 | Encflt32: -> `Tyflt32 | Encflt64: -> `Tyflt64 | Encvalist: -> `Tyvalist /* compound types */ | Encptr: -> `Typtr getsub(ti[1:]) | Encfunc: -> `Tyfunc lentypecursor(ti[1:]) | Encslice: -> `Tyslice getsub(ti[1:]) | Encarray: ti = skiptypeinfo(ti[1:]) (len, sz) = getipacked(ti) -> `Tyarray (len, getsub(ti[sz:])) /* aggregate types */ | Enctuple: ti = skiptypeinfo(ti[1:]) -> `Tytuple lentypecursor(ti) | Encstruct: ti = skiptypeinfo(ti[1:]) -> `Tystruct lennamecursor(ti) | Encunion: ti = skiptypeinfo(ti[1:]) -> `Tyunion lennamecursor(ti) | Encname: -> `Tyname namedesc(ti[1:]) | Encindname: /* ugly hack: the slice contains a pointer to the value, so if we cast it to a byte##, we can pull the indirect value out of the pointer. */ p = (ti[1:] : byte##) -> typedesc(getenc(p)) | _: std.die("unknown type encoding") ;; } const typeinfo = {ti var p match ti[0] | Encnone: -> [.size=0, .align=1] | Encvoid: -> [.size=0, .align=1] | Encbool: -> [.size=0, .align=1] | Encchar: -> [.size=4, .align=4] | Encint8: -> [.size=1, .align=1] | Encint16: -> [.size=2, .align=2] | Encint: -> [.size=4, .align=4] | Encint32: -> [.size=4, .align=4] | Encint64: -> [.size=8, .align=8] | Encbyte: -> [.size=1, .align=1] | Encuint8: -> [.size=1, .align=1] | Encuint16: -> [.size=2, .align=2] | Encuint: -> [.size=4, .align=4] | Encuint32: -> [.size=4, .align=4] | Encuint64: -> [.size=8, .align=8] | Encflt32: -> [.size=4, .align=4] | Encflt64: -> [.size=8, .align=8] | Encvalist: -> [.size=8, .align=8] /* compound types */ | Encptr: -> [.size=8, .align=8] | Encfunc: -> [.size=8, .align=8] | Encslice: -> [.size=16, .align=8] | Encarray: -> gettypeinfo(ti[1:]) | Enctuple: -> gettypeinfo(ti[1:]) | Encstruct: -> gettypeinfo(ti[1:]) | Encunion: -> gettypeinfo(ti[1:]) | Encname: -> getnameinfo(ti[1:]) | Encindname: p = (ti[1:] : byte##) -> typeinfo(getenc(p)) | _: std.die("unknown type encoding") ;; } const gettypeinfo = {e var size, align, sz (size, sz) = getipacked(e) /* size */ e = e[sz:] (align, sz) = getipacked(e) /* align */ -> [.size = size, .align = align] } const skiptypeinfo = {e var ignore, sz (ignore, sz) = getipacked(e) /* size */ e = e[sz:] (ignore, sz) = getipacked(e) /* align */ -> e[sz:] } const getnameinfo = {e var n, name, sz, enc (n, sz) = getipacked(e) name = e[sz:n+sz] e = e[n+sz:] (n, sz) = getipacked(e) enc = e[sz:n+sz] -> typeinfo(enc) } const namedesc = {e var n, sz, name, enc (n, sz) = getipacked(e) name = e[sz:n+sz] e = e[n+sz:] (n, sz) = getipacked(e) enc = e[sz:n+sz] -> (name, enc) } const lentypecursor = {e var n, sz (n, sz) = getipacked(e) -> [.nelt=n, .rem=e[sz:], .isnamed=false, .isiter=true] } const lennamecursor = {e var n, sz (n, sz) = getipacked(e) -> [.nelt=n, .rem=e[sz:], .isnamed=true, .isiter=true] } const getsub = {e var n, sz (n, sz) = getipacked(e) -> e[sz:sz+n] } const getipacked : (p : byte[:] -> (size, size)) = {p : byte[:] var mask, val, len, shift, i mask = 0x80 val = 0 len = 1 shift = 8 - len while p[0] & mask != mask << 1 len++ mask >>= 1 mask |= 0x80 ;; shift = 8 - len val = (p[0] : size) & ~(~0 << shift) for i = 1; i < len; i++ val |= (p[i] : size) << (i*8 - len) ;; -> (val, len) }