Lines Matching refs:hdr
13175 ** free. The first block has format u.hdr. u.hdr.size4x is 4 times the
13177 ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
13178 ** false if the chunk is on the freelist. The u.hdr.size4x&2 bit
13180 ** previous chunk is free. The u.hdr.prevSize field is the size of
13183 ** u.hdr.prevSize can be part of the data for that chunk and should
13199 ** the u.hdr.prevSize value of the following chunk.
13207 } hdr;
13291 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
13293 size = mem3.aPool[i-1].u.hdr.size4x/4;
13294 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
13326 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
13327 size = mem3.aPool[i-1].u.hdr.size4x/4;
13328 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
13377 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
13378 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
13379 x = mem3.aPool[i-1].u.hdr.size4x;
13380 mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
13381 mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
13382 mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
13406 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
13407 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
13408 mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
13410 mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
13411 x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
13412 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
13442 size = mem3.aPool[i-1].u.hdr.size4x;
13446 assert( i > mem3.aPool[i-1].u.hdr.prevSize );
13447 prev = i - mem3.aPool[i-1].u.hdr.prevSize;
13453 x = mem3.aPool[prev-1].u.hdr.size4x & 2;
13454 mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
13455 mem3.aPool[prev+size-1].u.hdr.prevSize = size;
13503 if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
13564 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
13565 size = mem3.aPool[i-1].u.hdr.size4x/4;
13567 mem3.aPool[i-1].u.hdr.size4x &= ~1;
13568 mem3.aPool[i+size-1].u.hdr.prevSize = size;
13569 mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
13574 while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
13575 size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
13579 x = mem3.aPool[mem3.iMaster-1].u.hdr
13580 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
13581 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
13583 x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
13584 while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
13586 mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
13587 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
13588 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
13602 assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
13603 return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
13688 mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
13689 mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
13690 mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
13728 size = mem3.aPool[i-1].u.hdr.size4x;
13734 if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
13739 if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
13756 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
13765 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
38835 int hdr; /* Offset to the page header */
38854 hdr = pPage->hdrOffset;
38857 assert( nCell==get2byte(&data[hdr+3]) );
38859 cbrk = get2byte(&data[hdr+5]);
38897 put2byte(&data[hdr+5], cbrk);
38898 data[hdr+1] = 0;
38899 data[hdr+2] = 0;
38900 data[hdr+7] = 0;
38923 const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */
38940 nFrag = data[hdr+7];
38941 assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
38943 top = get2byte(&data[hdr+5]);
38953 top = get2byte(&data[hdr+5]);
38960 for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
38974 data[hdr+7] = (u8)(nFrag + x);
38995 top = get2byte(&data[hdr+5]);
39007 put2byte(&data[hdr+5], top);
39022 int addr, pbegin, hdr;
39048 hdr = pPage->hdrOffset;
39049 addr = hdr + 1;
39068 addr = hdr + 1;
39077 if( (frag<0) || (frag>(int)data[hdr+7]) ){
39080 data[hdr+7] -= (u8)frag;
39091 if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
39093 pbegin = get2byte(&data[hdr+1]);
39094 memcpy(&data[hdr+1], &data[pbegin], 2);
39095 top = get2byte(&data[hdr+5]) + get2byte(&data[pbegin+2]);
39096 put2byte(&data[hdr+5], top);
39158 u8 hdr; /* Offset to beginning of page header */
39170 hdr = pPage->hdrOffset;
39172 if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT;
39177 pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
39178 top = get2byte(&data[hdr+5]);
39179 pPage->nCell = get2byte(&data[hdr+3]);
39219 pc = get2byte(&data[hdr+1]);
39220 nFree = data[hdr+7] + top;
39261 u8 hdr = pPage->hdrOffset;
39270 memset(&data[hdr], 0, pBt->usableSize - hdr);
39272 data[hdr] = (char)flags;
39273 first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0);
39274 memset(&data[hdr+1], 0, 4);
39275 data[hdr+7] = 0;
39276 put2byte(&data[hdr+5], pBt->usableSize);
39279 pPage->hdrOffset = hdr;
43021 int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */
43032 hdr = pPage->hdrOffset;
43033 testcase( pc==get2byte(&data[hdr+5]) );
43035 if( pc < get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
43049 put2byte(&data[hdr+3], pPage->nCell);
43167 const int hdr = pPage->hdrOffset; /* Offset of header on pPage */
43177 assert( get2byte(&data[hdr+5])==nUsable );
43187 put2byte(&data[hdr+3], nCell);
43188 put2byte(&data[hdr+5], cellbody);
45191 int hdr, cellStart;
45334 hdr = pPage->hdrOffset;
45339 u16 contentOffset = get2byte(&data[hdr+5]);
45343 nCell = get2byte(&data[hdr+3]);
45344 cellStart = hdr + 12 - 4*pPage->leaf;
45359 i = get2byte(&data[hdr+1]);
45380 if( cnt!=data[hdr+7] ){
45383 cnt, data[hdr+7], iPage);
54836 ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
54844 ** hdr-size field is also a varint which is the offset from the beginning
