一、简介
对于ziplist，实现复杂，为了逆序遍历，每个entry中包含前一个entry的长度，这样导致在ziplist中间修改或者插入entry时可能产生级联更新。为了实现更紧凑、更快的解析，更简单的实现，重写实现了ziplist,listpack由此诞生。
二、结构图
2.1 整体结构
- 头比ziplist少了4字节
- 每个元素中只有自己的总长度来实现逆序遍历，更新时不会出现级联更新
2.2 数据编码
元素编码分为三部分，encoding，data, element-total-len, 对于数字类型字符串在int64_t范围内的都可以编码为数字型，将无data字段，元素值存储在encoding中。
2.2.1 encoding编码
- 整数
- 字符串
2.2.2 element-total-len编码
element-total-len表示当前元素的总长度，用于逆序遍历listpack时使用。
- 使用大端序
- 逆序读取，从右往左逐字节读取
- 每个字节只是用7bit表示数字，最高位表示是否还有数据，1表示还需要读取下一字节，0表示结束了
三、实现
3. 1 位操作定义
#define LP_HDR_SIZE 6 /* 32 bit total len + 16 bit number of elements. */
#define LP_HDR_NUMELE_UNKNOWN UINT16_MAX
#define LP_MAX_INT_ENCODING_LEN 9
#define LP_MAX_BACKLEN_SIZE 5
#define LP_MAX_ENTRY_BACKLEN 34359738367ULL
#define LP_ENCODING_INT 0
#define LP_ENCODING_STRING 1
#define LP_ENCODING_7BIT_UINT 0
#define LP_ENCODING_7BIT_UINT_MASK 0x80
#define LP_ENCODING_IS_7BIT_UINT(byte) (((byte)&LP_ENCODING_7BIT_UINT_MASK)==LP_ENCODING_7BIT_UINT)
#define LP_ENCODING_6BIT_STR 0x80
#define LP_ENCODING_6BIT_STR_MASK 0xC0
#define LP_ENCODING_IS_6BIT_STR(byte) (((byte)&LP_ENCODING_6BIT_STR_MASK)==LP_ENCODING_6BIT_STR)
#define LP_ENCODING_13BIT_INT 0xC0
#define LP_ENCODING_13BIT_INT_MASK 0xE0
#define LP_ENCODING_IS_13BIT_INT(byte) (((byte)&LP_ENCODING_13BIT_INT_MASK)==LP_ENCODING_13BIT_INT)
#define LP_ENCODING_12BIT_STR 0xE0
#define LP_ENCODING_12BIT_STR_MASK 0xF0
#define LP_ENCODING_IS_12BIT_STR(byte) (((byte)&LP_ENCODING_12BIT_STR_MASK)==LP_ENCODING_12BIT_STR)
#define LP_ENCODING_16BIT_INT 0xF1
#define LP_ENCODING_16BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_16BIT_INT(byte) (((byte)&LP_ENCODING_16BIT_INT_MASK)==LP_ENCODING_16BIT_INT)
#define LP_ENCODING_24BIT_INT 0xF2
#define LP_ENCODING_24BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_24BIT_INT(byte) (((byte)&LP_ENCODING_24BIT_INT_MASK)==LP_ENCODING_24BIT_INT)
#define LP_ENCODING_32BIT_INT 0xF3
#define LP_ENCODING_32BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_32BIT_INT(byte) (((byte)&LP_ENCODING_32BIT_INT_MASK)==LP_ENCODING_32BIT_INT)
#define LP_ENCODING_64BIT_INT 0xF4
#define LP_ENCODING_64BIT_INT_MASK 0xFF
#define LP_ENCODING_IS_64BIT_INT(byte) (((byte)&LP_ENCODING_64BIT_INT_MASK)==LP_ENCODING_64BIT_INT)
#define LP_ENCODING_32BIT_STR 0xF0
#define LP_ENCODING_32BIT_STR_MASK 0xFF
#define LP_ENCODING_IS_32BIT_STR(byte) (((byte)&LP_ENCODING_32BIT_STR_MASK)==LP_ENCODING_32BIT_STR)
#define LP_EOF 0xFF
#define LP_ENCODING_6BIT_STR_LEN(p) ((p)[0] & 0x3F)
#define LP_ENCODING_12BIT_STR_LEN(p) ((((p)[0] & 0xF) << 8) | (p)[1])
#define LP_ENCODING_32BIT_STR_LEN(p) (((uint32_t)(p)[1]<<0) | \
((uint32_t)(p)[2]<<8) | \
((uint32_t)(p)[3]<<16) | \
((uint32_t)(p)[4]<<24))
#define lpGetTotalBytes(p) (((uint32_t)(p)[0]<<0) | \
((uint32_t)(p)[1]<<8) | \
((uint32_t)(p)[2]<<16) | \
((uint32_t)(p)[3]<<24))
#define lpGetNumElements(p) (((uint32_t)(p)[4]<<0) | \
((uint32_t)(p)[5]<<8))
#define lpSetTotalBytes(p,v) do { \
(p)[0] = (v)&0xff; \
(p)[1] = ((v)>>8)&0xff; \
(p)[2] = ((v)>>16)&0xff; \
(p)[3] = ((v)>>24)&0xff; \
} while(0)
#define lpSetNumElements(p,v) do { \
(p)[4] = (v)&0xff; \
(p)[5] = ((v)>>8)&0xff; \
} while(0)
3.2 创建一个空的listpack
unsigned char *lpNew(void) {
unsigned char *lp = lp_malloc(LP_HDR_SIZE+1);
if (lp == NULL) return NULL;
lpSetTotalBytes(lp,LP_HDR_SIZE+1);
lpSetNumElements(lp,0);
lp[LP_HDR_SIZE] = LP_EOF;
return lp;
}
3.3 插入
- 插入：p之前和p之后，实际插入时，都会转换为p’之前
3.3.1 例1.结尾插入“123”, len=3
1. 计算插入位置
unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size) {
uint64_t listpack_bytes = lpGetTotalBytes(lp);
unsigned char *eofptr = lp + listpack_bytes - 1;
return lpInsert(lp,ele,size,eofptr,LP_BEFORE,NULL);
}
2. 转换插入方式
如果是插入p之后，将跳过当前节点，指向下一个节点p`，然后插入p`之前
if (where == LP_AFTER) {
p = lpSkip(p);
where = LP_BEFORE;
}
本例中是插入之前，所以不需要
3. 计算插入位置的偏移量
用于后续扩容后，重写定位到插入位置
unsigned long poff = p-lp;
本例中poff = 6
4. 获取编码类型
- 尝试将插入的值转换位int64_t的数值，如果成功，则使用整数进行编码
- 否则使用字符串编码
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
int64_t v;
if (lpStringToInt64((const char*)ele, size, &v)) {
if (v >= 0 && v <= 127) {
/* Single byte 0-127 integer. */
intenc[0] = v;
*enclen = 1;
} else if (v >= -4096 && v <= 4095) {
/* 13 bit integer. */
if (v < 0) v = ((int64_t)1<<13)+v;
intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
intenc[1] = v&0xff;
*enclen = 2;
} else if (v >= -32768 && v <= 32767) {
/* 16 bit integer. */
if (v < 0) v = ((int64_t)1<<16)+v;
intenc[0] = LP_ENCODING_16BIT_INT;
intenc[1] = v&0xff;
intenc[2] = v>>8;
*enclen = 3;
} else if (v >= -8388608 && v <= 8388607) {
/* 24 bit integer. */
if (v < 0) v = ((int64_t)1<<24)+v;
intenc[0] = LP_ENCODING_24BIT_INT;
intenc[1] = v&0xff;
intenc[2] = (v>>8)&0xff;
intenc[3] = v>>16;
*enclen = 4;
} else if (v >= -2147483648 && v <= 2147483647) {
/* 32 bit integer. */
if (v < 0) v = ((int64_t)1<<32)+v;
intenc[0] = LP_ENCODING_32BIT_INT;
intenc[1] = v&0xff;
intenc[2] = (v>>8)&0xff;
intenc[3] = (v>>16)&0xff;
intenc[4] = v>>24;
*enclen = 5;
} else {
/* 64 bit integer. */
uint64_t uv = v;
intenc[0] = LP_ENCODING_64BIT_INT;
intenc[1] = uv&0xff;
intenc[2] = (uv>>8)&0xff;
intenc[3] = (uv>>16)&0xff;
intenc[4] = (uv>>24)&0xff;
intenc[5] = (uv>>32)&0xff;
intenc[6] = (uv>>40)&0xff;
intenc[7] = (uv>>48)&0xff;
intenc[8] = uv>>56;
*enclen = 9;
}
return LP_ENCODING_INT;
} else {
if (size < 64) *enclen = 1+size;
else if (size < 4096) *enclen = 2+size;
else *enclen = 5+size;
return LP_ENCODING_STRING;
}
}
本例中“123”可以转换为123， 并且123 在[0,127]范围内，所以只需一字节表示
intenc[0] = 123(01111011);*enclen = 1;
5. 获取插入元素的总长度编码
unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
if (l <= 127) {
if (buf) buf[0] = l;
return 1;
} else if (l < 16383) {
if (buf) {
buf[0] = l>>7;
buf[1] = (l&127)|128;
}
return 2;
} else if (l < 2097151) {
if (buf) {
buf[0] = l>>14;
buf[1] = ((l>>7)&127)|128;
buf[2] = (l&127)|128;
}
return 3;
} else if (l < 268435455) {
if (buf) {
buf[0] = l>>21;
buf[1] = ((l>>14)&127)|128;
buf[2] = ((l>>7)&127)|128;
buf[3] = (l&127)|128;
}
return 4;
} else {
if (buf) {
buf[0] = l>>28;
buf[1] = ((l>>21)&127)|128;
buf[2] = ((l>>14)&127)|128;
buf[3] = ((l>>7)&127)|128;
buf[4] = (l&127)|128;
}
return 5;
}
}
因为上一步骤计算出来总长度为1字节，1<= 127满足，所以总长度编码也只需要1字节，backlen_size=1
6. 计算新的整个listpack总长度
uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
- replaced_len;
if (new_listpack_bytes > UINT32_MAX) return NULL;
本例中是插入，所以replaced_len=0，old_listpack_bytes为原始的总长度7，new_listpack_bytes=7 + 1 + 1 - 0 = 9
7. 获取插入目标位置
unsigned char *dst = lp + poff; /* May be updated after reallocation. */
8. 扩容
/* Realloc before: we need more room. */
if (new_listpack_bytes > old_listpack_bytes) {
if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
dst = lp + poff;
}
9. 移动数据，以腾出插入位置
if(where == LP_BEFORE) {
memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
}
mommove(dst+1+1,dst, 7 - 6) -> mommove(dst+2, dst, 1)
10. 写入encoding以及data
if (enctype == LP_ENCODING_INT) {
memcpy(dst,intenc,enclen);
}
dst += enclen;
11. 写入插入节点totallen
memcpy(dst,backlen,backlen_size);
dst += backlen_size;
12. 更新元素个数
- ele为空，则表示删除节点
/* Update header. */
if (where != LP_REPLACE || ele == NULL) {
uint32_t num_elements = lpGetNumElements(lp);
if (num_elements != LP_HDR_NUMELE_UNKNOWN) {
if (ele)
lpSetNumElements(lp,num_elements+1);
else
lpSetNumElements(lp,num_elements-1);
}
}
13. 更新整个listpakc总长度
lpSetTotalBytes(lp,new_listpack_bytes);
3.3.2 例2. 尾部插入“I love redis …”， len=200
1. 计算插入位置
2. 转换插入方式
如果是插入p之后，将跳过当前节点，指向下一个节点p`，然后插入p`之前
本例中是插入之前，所以不需要
3. 计算插入位置的偏移量
poff=8
4. 获取编码类型
- 尝试将插入的值转换位int64_t的数值，如果成功，则使用整数进行编码
- 否则使用字符串编码
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
int64_t v;
if (lpStringToInt64((const char*)ele, size, &v)) {
...
return LP_ENCODING_INT;
} else {
if (size < 64) *enclen = 1+size;
else if (size < 4096) *= 2+size;
else *enclen = 5+size;
return LP_ENCODING_STRING;
}
}
本例中不能转为数值，长度200在[64, 4096), 所以需要2字节编码
*enclen = 2 + 200 = 202
5. 获取插入元素的总长度编码
202 在(127, 16383), 所以需要2字节，backlen_size=2
6. 计算新的整个listpack总长度
new_listpack_bytes = 9 + 202 + 2 - 0 = 213
7. 获取插入目标位置
8. 扩容
9. 移动数据，以腾出插入位置
memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
memmove(dst+202+2,dst, 9-8) -> mommove(dst+204, dst, 1)
10. 写入encoding以及data
void lpEncodeString(unsigned char *buf, unsigned char *s, uint32_t len) {
if (len < 64) {
buf[0] = len | LP_ENCODING_6BIT_STR;
memcpy(buf+1,s,len);
} else if (len < 4096) {
buf[0] = (len >> 8) | LP_ENCODING_12BIT_STR;
buf[1] = len & 0xff;
memcpy(buf+2,s,len);
} else {
buf[0] = LP_ENCODING_32BIT_STR;
buf[1] = len & 0xff;
buf[2] = (len >> 8) & 0xff;
buf[3] = (len >> 16) & 0xff;
buf[4] = (len >> 24) & 0xff;
memcpy(buf+5,s,len);
}
}
if (enctype == LP_ENCODING_INT) {
memcpy(dst,intenc,enclen);
} else {
lpEncodeString(dst,ele,size);
}
dst += enclen;
字符串200在[64,4096)范围内，所以需要两个字节
11. 写入插入节点totallen
总长度202（11001010）-> 0000001, 1001010
12. 更新元素个数
lpSetNumElements(lp,num_elements+1);
13. 更新整个listpakc总长度
3.4 逆序遍历
unsigned char *ele = lpLast(lp);
while (ele) {
ele = lpPrev(lp,ele);
}
- 定位到结尾
- 读取element-total-len，获取元素总长度elem-len
- 根据读取的elem-len，往前移elem-len，到元素开头
- 重复步骤2.和3.
unsigned char *lpPrev(unsigned char *lp, unsigned char *p) {
if (p-lp == LP_HDR_SIZE) return NULL;
p--; /* Seek the first backlen byte of the last element. */
uint64_t prevlen = lpDecodeBacklen(p);
prevlen += lpEncodeBacklen(NULL,prevlen);
return p-prevlen+1; /* Seek the first byte of the previous entry. */
}
unsigned char *lpLast(unsigned char *lp) {
unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
return lpPrev(lp,p); /* Will return NULL if EOF is the only element. */
}
- 定位到结尾
unsigned char *p = lp+lpGetTotalBytes(lp)-1; /* Seek EOF element. */
- 判断是否有数据，必须大于头长度
if (p-lp == LP_HDR_SIZE) return NULL;
- 定位到最后一个元素最后一个字节
p--; /* Seek the first backlen byte of the last element. */
- 计算元素总长度
uint64_t prevlen = lpDecodeBacklen(p);
uint64_t lpDecodeBacklen(unsigned char *p) {
uint64_t val = 0;
uint64_t shift = 0;
do {
val |= (uint64_t)(p[0] & 127) << shift;
if (!(p[0] & 128)) break; //判断最好位是否1，是1则表示还需要继续读取
shift += 7;
p--; //读取前一个字节
if (shift > 28) return UINT64_MAX;
} while(1);
return val;
}
这里 1001010 | （1<<7） = 11001010 = 202
- 根据计算到的元素总长度，进行计算长度编码字段
prevlen += lpEncodeBacklen(NULL,prevlen);
unsigned long lpEncodeBacklen(unsigned char *buf, uint64_t l) {
if (l <= 127) {
if (buf) buf[0] = l;
return 1;
} else if (l < 16383) {
if (buf) {
buf[0] = l>>7;
buf[1] = (l&127)|128;
}
return 2;
}
...
}
总长度202，长度编码2字节， 所以prevlen=202+2=204
- 偏移到元素开始
return p-prevlen+1; /* Seek the first byte of the previous entry. */
- 重复上述步骤
- 判断是否还有元素
if (p-lp == LP_HDR_SIZE) return NULL;本例中还有数据 - 往前移动一字节
p--; /* Seek the first backlen byte of the last element. */
- 计算元素数据总长度
00000001, 因此元素1字节 - 计算长度编码字节数
1字节长度只需要1字节表示，prevlen = 1+ 1 = 2 - 偏移到元素开头
- 重复
- 判断是否还有元素
if (p-lp == LP_HDR_SIZE) return NULL;
这里刚好等于头长度，所以没元素了
3.5 替换
3.5.1 例1. 将第一个元素替换成“-32767”
1. 计算偏移量
unsigned long poff = p-lp;
poff = p - lp = header = 6
2. 计算替换数据“-32767”的编码
if (ele) {
enctype = lpEncodeGetType(ele,size,intenc,&enclen);
- "-32767"可以转换为int64_t范围内，所以使用整数编码
- -32767在范围 [-32768, 32767]中，所以需要3字节编码
- 因为是负数，所以需要转换为正数数
if (v < 0) v = ((int64_t)1<<16)+v;， v = 32769
int lpEncodeGetType(unsigned char *ele, uint32_t size, unsigned char *intenc, uint64_t *enclen) {
int64_t v;
if (lpStringToInt64((const char*)ele, size, &v)) {
if (v >= 0 && v <= 127) {
/* Single byte 0-127 integer. */
intenc[0] = v;
*enclen = 1;
} else if (v >= -4096 && v <= 4095) {
/* 13 bit integer. */
if (v < 0) v = ((int64_t)1<<13)+v;
intenc[0] = (v>>8)|LP_ENCODING_13BIT_INT;
intenc[1] = v&0xff;
*enclen = 2;
} else if (v >= -32768 && v <= 32767) {
/* 16 bit integer. */
if (v < 0) v = ((int64_t)1<<16)+v;
intenc[0] = LP_ENCODING_16BIT_INT;
intenc[1] = v&0xff;
intenc[2] = v>>8;
*enclen = 3;
}
...
return LP_ENCODING_INT;
}
...
}
3. 计算元素长度需要的长度编码
unsigned long backlen_size = ele ? lpEncodeBacklen(backlen,enclen) : 0;
当前enclen=3，在[0,127] 范围内，所以只需要1字节， backlen_size=1
4. 计算需要替换元素的总长度
uint32_t replaced_len = 0;
if (where == LP_REPLACE) {
replaced_len = lpCurrentEncodedSize(p);
replaced_len += lpEncodeBacklen(NULL,replaced_len);
}
本例中第一个元素2字节长度， 所以replaced_len=2
5. 计算新的总大小
uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
- replaced_len;
new_listpack_bytes = 0xD5 + 3 + 1 - 2 = 0xD5 + 2 = 0xD7
6. 计算目标位置
unsigned char *dst = lp + poff; /* May be updated after reallocation. */
dst = lp + poff = lp + 6
7. 扩容
/* Realloc before: we need more room. */
if (new_listpack_bytes > old_listpack_bytes) {
if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
dst = lp + poff;
}
替换后，长度增加了，所以需要扩容
8.数据移动
/* LP_REPLACE. */
long lendiff = (enclen+backlen_size)-replaced_len;
memmove(dst+replaced_len+lendiff,
dst+replaced_len,
old_listpack_bytes-poff-replaced_len);
lendiff=(3+1)-2=2
memmove(dst+2+2,dst+2,0xD5-6-2) -> memmove(dst+4, dst+2, 205)
9. 写入数据
if (enctype == LP_ENCODING_INT) {
memcpy(dst,intenc,enclen);
} else {
lpEncodeString(dst,ele,size);
}
dst += enclen;
这里是整数
10. 写入元素长度编码
memcpy(dst,backlen,backlen_size);
dst += backlen_size;
11. 更新元素个数
不需要，未插入或者删除
12. 更新总长度
lpSetTotalBytes(lp,new_listpack_bytes);
3.6 删除
删除和替换以及插入差不多，只是elem参数为null,并且删除操作就是replace操作
unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp) {
return lpInsert(lp,NULL,0,p,LP_REPLACE,newp);
}
3.6.1 例1. 删除第二个元素
首先通过p = lpSeek(lp, 1) ;获取删除元素首指针
1. 设置方式为replace
ele为空，则表示删除，删除方式只能是replace
if (ele == NULL) where = LP_REPLACE;
2. 计算偏移量
unsigned long poff = p-lp;
poff = p - lp = 10
3. 设置数据编码长度
enctype = -1;
enclen = 0;
4. 设置长度编码
backlen_size = 0
5. 计算删除元素的总长度
if (where == LP_REPLACE) {
replaced_len = lpCurrentEncodedSize(p);
replaced_len += lpEncodeBacklen(NULL,replaced_len);
}
本例中，总长度replaced_len = 202+2 = 204
6. 计算删除后新的总长度
uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
- replaced_len;
new_listpack_bytes = 0xD7 + 0 + 0 - 204 = 11
7. 计算目标地址
unsigned char *dst = lp + poff; /* May be updated after reallocation. */
8. 移动数据
long lendiff= (enclen+backlen_size)-replaced_len;
memmove(dst+replaced_len+lendiff,
dst+replaced_len,
old_listpack_bytes-poff-replaced_len);
lendiff = (0+0)-204=-204
memmove(dst+204+(-204), dst+204, 0xD7-10-204) -> memmove(dst, dst+204, 1)
9. 缩容
/* Realloc after: we need to free space. */
if (new_listpack_bytes < old_listpack_bytes) {
if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
dst = lp + poff;
}
10. 更新元素个数
lpSetNumElements(lp,num_elements-1);
11. 更新总长度
lpSetTotalBytes(lp,new_listpack_bytes);
3.7 定位到index的元素
- index如果是负数，则逆序定位
- 如果index
unsigned char *lpSeek(unsigned char *lp, long index) {
int forward = 1; /* Seek forward by default. */
/* We want to seek from left to right or the other way around
* depending on the listpack length and the element position.
* However if the listpack length cannot be obtained in constant time,
* we always seek from left to right. */
uint32_t numele = lpGetNumElements(lp);
if (numele != LP_HDR_NUMELE_UNKNOWN) {
if (index < 0) index = (long)numele+index;
if (index < 0) return NULL; /* Index still < 0 means out of range. */
if (index >= numele) return NULL; /* Out of range the other side. */
/* We want to scan right-to-left if the element we are looking for
* is past the half of the listpack. */
if (index > numele/2) {
forward = 0;
/* Right to left scanning always expects a negative index. Convert
* our index to negative form. */
index -= numele;
}
} else {
/* If the listpack length is unspecified, for negative indexes we
* want to always scan right-to-left. */
if (index < 0) forward = 0;
}
/* Forward and backward scanning is trivially based on lpNext()/lpPrev(). */
if (forward) {
unsigned char *ele = lpFirst(lp);
while (index > 0 && ele) {
ele = lpNext(lp,ele);
index--;
}
return ele;
} else {
unsigned char *ele = lpLast(lp);
while (index < -1 && ele) {
ele = lpPrev(lp,ele);
index++;
}
return ele;
}
}
3.8 获取值
unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
int64_t val;
uint64_t uval, negstart, negmax;
if (LP_ENCODING_IS_7BIT_UINT(p[0])) {
negstart = UINT64_MAX; /* 7 bit ints are always positive. */
negmax = 0;
uval = p[0] & 0x7f;
} else if (LP_ENCODING_IS_6BIT_STR(p[0])) {
*count = LP_ENCODING_6BIT_STR_LEN(p);
return p+1;
} else if (LP_ENCODING_IS_13BIT_INT(p[0])) {
uval = ((p[0]&0x1f)<<8) | p[1];
negstart = (uint64_t)1<<12;
negmax = 8191;
} else if (LP_ENCODING_IS_16BIT_INT(p[0])) {
uval = (uint64_t)p[1] |
(uint64_t)p[2]<<8;
negstart = (uint64_t)1<<15;
negmax = UINT16_MAX;
} else if (LP_ENCODING_IS_24BIT_INT(p[0])) {
uval = (uint64_t)p[1] |
(uint64_t)p[2]<<8 |
(uint64_t)p[3]<<16;
negstart = (uint64_t)1<<23;
negmax = UINT32_MAX>>8;
} else if (LP_ENCODING_IS_32BIT_INT(p[0])) {
uval = (uint64_t)p[1] |
(uint64_t)p[2]<<8 |
(uint64_t)p[3]<<16 |
(uint64_t)p[4]<<24;
negstart = (uint64_t)1<<31;
negmax = UINT32_MAX;
} else if (LP_ENCODING_IS_64BIT_INT(p[0])) {
uval = (uint64_t)p[1] |
(uint64_t)p[2]<<8 |
(uint64_t)p[3]<<16 |
(uint64_t)p[4]<<24 |
(uint64_t)p[5]<<32 |
(uint64_t)p[6]<<40 |
(uint64_t)p[7]<<48 |
(uint64_t)p[8]<<56;
negstart = (uint64_t)1<<63;
negmax = UINT64_MAX;
} else if (LP_ENCODING_IS_12BIT_STR(p[0])) {
*count = LP_ENCODING_12BIT_STR_LEN(p);
return p+2;
} else if (LP_ENCODING_IS_32BIT_STR(p[0])) {
*count = LP_ENCODING_32BIT_STR_LEN(p);
return p+5;
} else {
uval = 12345678900000000ULL + p[0];
negstart = UINT64_MAX;
negmax = 0;
}
/* We reach this code path only for integer encodings.
* Convert the unsigned value to the signed one using two's complement
* rule. */
if (uval >= negstart) {
/* This three steps conversion should avoid undefined behaviors
* in the unsigned -> signed conversion. */
uval = negmax-uval;
val = uval;
val = -val-1;
} else {
val = uval;
}
/* Return the string representation of the integer or the value itself
* depending on intbuf being NULL or not. */
if (intbuf) {
*count = snprintf((char*)intbuf,LP_INTBUF_SIZE,"%lld",(long long)val);
return intbuf;
} else {
*count = val;
return NULL;
}
}
uval = (uint64_t)p[1] |(uint64_t)p[2]<<8 = (00000001) | (10000000)<<8 = 32769
negstart = (uint64_t)1<<15 = 32768
negmax = UINT16_MAX
uval > negstart 成立， 所以源数据为负数
uval = negmax-uval = 65535 - 32769 = 32766
val = uval = 32766
val = -val -1 = -32767， 和元素数据一致。
4141
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
