// 基于本地 Redis 仓 (unstable, 8.4 开发线), src/object.c —— 编码压缩与引用计数
robj *tryObjectEncodingEx(robj *o, int try_trim) {
    long value;
    sds s = o->ptr;
    size_t len;

    serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);     // 只处理字符串；集合类的编码转换归各类型命令管

    if (!sdsEncodedObject(o)) return o;     // 已是 INT 编码，没得再压

     if (o->refcount > 1) return o;         // 坑：被共享的对象不能原地改编码，别处还拿着旧指针/旧编码的假设

    /* Check if we can represent this string as a long integer.
     * Note that we are sure that a string larger than 20 chars is not
     * representable as a 32 nor 64 bit integer. */
    len = sdslen(s);
    if (len <= 20 && string2l(s,len,&value)) {
        /* This object is encodable as a long. */
        if (o->encoding == OBJ_ENCODING_RAW) {
            sdsfree(o->ptr);
            o->encoding = OBJ_ENCODING_INT;     // RAW 可原地改：释放 SDS，ptr 换存值
            o->ptr = (void*) value;
            return o;
        } else if (o->encoding == OBJ_ENCODING_EMBSTR) {
            decrRefCount(o);        // embstr 与 robj 连体，无法只释放字符串部分，只能整个换新对象
            return createStringObjectFromLongLongForValue(value);   // 走共享整数/INT；LRU/LFU 淘汰策略下会避开共享对象
        }
    }

    if (len <= OBJ_ENCODING_EMBSTR_SIZE_LIMIT) {
        robj *emb;

        if (o->encoding == OBJ_ENCODING_EMBSTR) return o;
        emb = createEmbeddedStringObject(s,sdslen(s));      // 短 RAW 串转 embstr（客户端解析大参数时可能先建成 RAW）
        decrRefCount(o);
        return emb;
    }

    if (try_trim)
        trimStringObjectIfNeeded(o, 0);     // 压不动了，至少把 SDS 尾部超 10% 的预留空间还给分配器

    /* Return the original object. */
    return o;
}

robj *tryObjectEncoding(robj *o) {
    return tryObjectEncodingEx(o, 1);
}

robj *makeObjectShared(robj *o) {
    serverAssert(o->refcount == 1);
    o->refcount = OBJ_SHARED_REFCOUNT;      // 打上"永生"标记后 incr/decr 都不再碰它，跨线程访问无需加锁
    return o;
}

void incrRefCount(robj *o) {
    if (o->refcount < OBJ_FIRST_SPECIAL_REFCOUNT - 1) {
        o->refcount++;      // 命令在主线程串行执行，普通 ++ 就够，不需要原子操作
    } else {
        if (o->refcount == OBJ_SHARED_REFCOUNT) {
            /* Nothing to do: this refcount is immutable. */
        } else if (o->refcount == OBJ_STATIC_REFCOUNT) {
            serverPanic("You tried to retain an object allocated in the stack");
        } else {
            serverPanic("You tried to retain an object with maximum refcount");     // 23 位上限的防御检查，7.x int 版没有
        }
    }
}

void decrRefCount(robj *o) {
    if (o->refcount == OBJ_SHARED_REFCOUNT)
        return; /* Nothing to do: this refcount is immutable. */

    if (unlikely(o->refcount <= 0)) {
        serverPanic("illegal decrRefCount for object with: type %u, encoding %u, refcount %d",
            o->type, o->encoding, o->refcount);
    }

    if (--(o->refcount) == 0) {
        void *alloc = o;

        if (o->iskvobj) {
            /* eval real allocation pointer */
            alloc = kvobjGetAllocPtr(o);    // kvobj 的元数据前缀在对象地址之前，free 的起点要往前挪
            // ...
        }

        if (o->ptr != NULL) {
            switch(o->type) {
            case OBJ_STRING: freeStringObject(o); break;    // 按 type 分发析构，C 里手写的"虚函数表"
            case OBJ_LIST: freeListObject(o); break;
            case OBJ_SET: freeSetObject(o); break;
            case OBJ_ZSET: freeZsetObject(o); break;
            case OBJ_HASH: freeHashObject(o); break;
            case OBJ_MODULE: freeModuleObject(o); break;
            case OBJ_STREAM: freeStreamObject(o); break;
            default: serverPanic("Unknown object type"); break;
            }
        }
        zfree(alloc);   // free 的是 alloc 不是 o：连元数据前缀一起还
    }
}