print v string value in charval(v):
$ print ((btexptr)((telita) v).root).bcitm

print itemptr
$ print *(ip)

get bcitm address:
$ print &((btexptr)0x5555555ed1e0)->bcitm

overwrite string char at 10;
$ set ((btexptr)0x5555555ed1e0)->bcitm[10] = 'x'

casting to character array, results in .bitm already having +4 offset incorrectness
$ print (char *) &((bottomptr) p).bitm

$ print (char *) &((bottomptr) p).bitm - 4
$12 = 0x5555555ed1ec "    abcUUU"

so clearly; the character array is written to memory correctly, but the .bitm pointer to the array is assigned incorreclty (4 bytes too much offset)

32 bits;
(gdb) ptype /o btreeptr
type = struct btrnode {
/*      0      |       1 */    literal type;
/* XXX  1-byte hole      */
/*      2      |       2 */    reftype refcnt;
/*      4      |       2 */    intlet len;
/*      6      |       2 */    char filler[2];
/*      8      |       4 */    int size;
/*     12      |       4 */    char **g;

                               /* total size (bytes):   16 */


discovery notes

(gdb) print *((btexptr) ((telita) t)->root)
$5 = {type = 98 'b', refcnt = 1, len = 4, filler = "\000", size = 4, bcitm = " abc\001", '\000' <repeats 16 times>}
-32 bit;
-- 4 len
" abc\001"
" abc\001"

-- 5 len
" abc "

-- 7 len
"    abc"

-64 bit;
-- 4 len
" abc\020\345^UUU\000\000P\346^UUU\000\000\000"
" abc\220\344^UUU\000\000\320\345^UUU\000\000\000"
" abc\220\344^UUU\000\000\320\345^UUU\000\000\000"

-- 7 len
"    abcUUU\000\000\001\000\000\000\006\000\000\000\000"
"    abcUUU\000\000\001\000\000\000\006\000\000\000\000"

b i1tex.c:147
b i1tex.c:150




POWER NOTES;
// WRITE pi**5
// 64bit pi**5; 306.0196847297702
306.0196847297702
306.0196847852814
306.019684785

306.0196847297702
// v is correct: 306.019684785
// type = 48 '0', refcnt = 1, len = -1, filler = "\000", frac = 0.59769469684625265, expo = 9}

64 bit;
the 64 bit has TWO dig entries (len = 2)

// (gdb) print *(integer)r
// $4 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432284560}}

(gdb) print (*(integer)rre).dig[0]
$42 = 847297702
(gdb) print (*(integer)rre).dig[1]
$42 = 3060196

// 	(gdb) p *(integer)re
// $4 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432285312}}

however;
the 32 bit has a len of 4:

(gdb) print (*(integer)r)
$20 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {21872}}

(gdb) print (*(integer)rre).dig[0]
$4 = 2814
(gdb) print (*(integer)rre).dig[1]
$3 = 4785
(gdb) print (*(integer)rre).dig[2]
$5 = 1968
(gdb) print (*(integer)rre).dig[3]
$6 = 3060

(gdb) print (*(integer)re)
$19 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {20192}}


SO;
since it already differs in r, we have to look into where r first gets created;
this is in exactly(v) which leads to app_exactly(u)




// (gdb) print *(integer)r
// $9 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432282336}}
// (gdb) print *(integer)r ->> at line 171
// $5 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432286400}
// (gdb) print *(integer)r
// $4 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432284560}}
$1 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432284560}}

possibly a problem in value exactly(value v) {...}

// 	(gdb) p *(integer)re
// $4 = {type = 48 '0', refcnt = 1, len = -2, filler = "\000", dig = {1432285312}}
