无法编译hiredis sds文件

eqoofvh9  于 2021-06-09  发布在  Redis
关注(0)|答案(1)|浏览(367)

将指针延迟到不完整的类型structerror无效sizof应用到不完整的类型struct我正在尝试编译此sds文件以在qt的帮助下运行redis。我使用了中描述的pack宏https://stackoverflow.com/a/3312896 并对分号的定义和分号问题进行了讨论。我正在使用qt creater运行rdm，并在mingw的帮助下构建它（\rdm\build-rdm-desktop\uqt\u5\u9\umingw\u32bit-release）。当我构建它的时候，我得到了一个错误“无效的sizeof应用到一个结构不完整的类型”。我还将附加相同的快照。需要帮助来解决这个问题。

  1. `/* SDSLib 2.0 -- A C dynamic strings library
  2.      *
  3.      * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
  4.      * Copyright (c) 2015, Oran Agra
  5.      * Copyright (c) 2015, Redis Labs, Inc
  6.      * All rights reserved.
  7.      *
  8.      * Redistribution and use in source and binary forms, with or without
  9.      * modification, are permitted provided that the following conditions are met:
  10.      *
  11.      *   * Redistributions of source code must retain the above copyright notice,
  12.      *     this list of conditions and the following disclaimer.
  13.      *   * Redistributions in binary form must reproduce the above copyright
  14.      *     notice, this list of conditions and the following disclaimer in the
  15.      *     documentation and/or other materials provided with the distribution.
  16.      *   * Neither the name of Redis nor the names of its contributors may be used
  17.      *     to endorse or promote products derived from this software without
  18.      *     specific prior written permission.
  19.      *
  20.      * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21.      * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22.      * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23.      * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  24.      * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25.      * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26.      * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27.      * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28.      * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29.      * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30.      * POSSIBILITY OF SUCH DAMAGE.
  31.      */
  33.     #ifndef __SDS_H
  34.     #define __SDS_H
  36.     #define SDS_MAX_PREALLOC (1024*1024)
  38.     #include <sys/types.h>
  39.     #include <stdarg.h>
  40.     #include <stdint.h>
  42.     #ifdef __GNUC__
  43.     #define PACK( __Declaration__ ) VA_ARGS __attribute__((__packed__))
  44.     #endif
  46.     #ifdef _MSC_VER
  47.     #define PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop))
  48.     #endif
  50.     typedef char *sds;
  52.     /* Note: sdshdr5 is never used, we just access the flags byte directly.
  53.      * However is here to document the layout of type 5 SDS strings. */
  54.     PACK(struct __attribute__ ((__packed__)) sdshdr5
  55.     {
  56.         unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
  57.         char buf[];
  58.     });
  59.     PACK(struct __attribute__ ((__packed__)) sdshdr8
  60.     {
  61.         uint8_t len; /* used */
  62.         uint8_t alloc; /* excluding the header and null terminator */
  63.         unsigned char flags; /* 3 lsb of type, 5 unused bits */
  64.         char buf[];
  65.     });
  66.     PACK(struct __attribute__ ((__packed__)) sdshdr16 {
  67.         uint16_t len; /* used */
  68.         uint16_t alloc; /* excluding the header and null terminator */
  69.         unsigned char flags; /* 3 lsb of type, 5 unused bits */
  70.         char buf[];
  71.     });
  72.     PACK(struct __attribute__ ((__packed__)) sdshdr32 {
  73.         uint32_t len; /* used */
  74.         uint32_t alloc; /* excluding the header and null terminator */
  75.         unsigned char flags; /* 3 lsb of type, 5 unused bits */
  76.         char buf[];
  77.     });
  78.     PACK(struct __attribute__ ((__packed__)) sdshdr64 {
  79.         uint64_t len; /* used */
  80.         uint64_t alloc; /* excluding the header and null terminator */
  81.         unsigned char flags; /* 3 lsb of type, 5 unused bits */
  82.         char buf[];
  83.     });
  85.     #define SDS_TYPE_5  0
  86.     #define SDS_TYPE_8  1
  87.     #define SDS_TYPE_16 2
  88.     #define SDS_TYPE_32 3
  89.     #define SDS_TYPE_64 4
  90.     #define SDS_TYPE_MASK 7
  91.     #define SDS_TYPE_BITS 3
  92.     #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T)));
  93.     #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
  94.     #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
  96.     static inline size_t sdslen(const sds s) {
  97.         unsigned char flags = s[-1];
  98.         switch(flags&SDS_TYPE_MASK) {
  99.             case SDS_TYPE_5:
  100.                 return SDS_TYPE_5_LEN(flags);
  101.             case SDS_TYPE_8:
  102.                 return SDS_HDR(8,s)->len;
  103.             case SDS_TYPE_16:
  104.                 return SDS_HDR(16,s)->len;
  105.             case SDS_TYPE_32:
  106.                 return SDS_HDR(32,s)->len;
  107.             case SDS_TYPE_64:
  108.                 return SDS_HDR(64,s)->len;
  109.         }
  110.         return 0;
  111.     }
  113.     static inline size_t sdsavail(const sds s) {
  114.         unsigned char flags = s[-1];
  115.         switch(flags&SDS_TYPE_MASK) {
  116.             case SDS_TYPE_5: {
  117.                 return 0;
  118.             }
  119.             case SDS_TYPE_8: {
  120.                 SDS_HDR_VAR(8,s);
  121.                 return sh->alloc - sh->len;
  122.             }
  123.             case SDS_TYPE_16: {
  124.                 SDS_HDR_VAR(16,s);
  125.                 return sh->alloc - sh->len;
  126.             }
  127.             case SDS_TYPE_32: {
  128.                 SDS_HDR_VAR(32,s);
  129.                 return sh->alloc - sh->len;
  130.             }
  131.             case SDS_TYPE_64: {
  132.                 SDS_HDR_VAR(64,s);
  133.                 return sh->alloc - sh->len;
  134.             }
  135.         }
  136.         return 0;
  137.     }
  139.     static inline void sdssetlen(sds s, size_t newlen) {
  140.         unsigned char flags = s[-1];
  141.         switch(flags&SDS_TYPE_MASK) {
  142.             case SDS_TYPE_5:
  143.                 {
  144.                     unsigned char *fp = ((unsigned char*)s)-1;
  145.                     *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
  146.                 }
  147.                 break;
  148.             case SDS_TYPE_8:
  149.                 SDS_HDR(8,s)->len = newlen;
  150.                 break;
  151.             case SDS_TYPE_16:
  152.                 SDS_HDR(16,s)->len = newlen;
  153.                 break;
  154.             case SDS_TYPE_32:
  155.                 SDS_HDR(32,s)->len = newlen;
  156.                 break;
  157.             case SDS_TYPE_64:
  158.                 SDS_HDR(64,s)->len = newlen;
  159.                 break;
  160.         }
  161.     }
  163.     static inline void sdsinclen(sds s, size_t inc) {
  164.         unsigned char flags = s[-1];
  165.         switch(flags&SDS_TYPE_MASK) {
  166.             case SDS_TYPE_5:
  167.                 {
  168.                     unsigned char *fp = ((unsigned char*)s)-1;
  169.                     unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
  170.                     *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
  171.                 }
  172.                 break;
  173.             case SDS_TYPE_8:
  174.                 SDS_HDR(8,s)->len += inc;
  175.                 break;
  176.             case SDS_TYPE_16:
  177.                 SDS_HDR(16,s)->len += inc;
  178.                 break;
  179.             case SDS_TYPE_32:
  180.                 SDS_HDR(32,s)->len += inc;
  181.                 break;
  182.             case SDS_TYPE_64:
  183.                 SDS_HDR(64,s)->len += inc;
  184.                 break;
  185.         }
  186.     }
  188.     /* sdsalloc() = sdsavail() + sdslen() */
  189.     static inline size_t sdsalloc(const sds s) {
  190.         unsigned char flags = s[-1];
  191.         switch(flags&SDS_TYPE_MASK) {
  192.             case SDS_TYPE_5:
  193.                 return SDS_TYPE_5_LEN(flags);
  194.             case SDS_TYPE_8:
  195.                 return SDS_HDR(8,s)->alloc;
  196.             case SDS_TYPE_16:
  197.                 return SDS_HDR(16,s)->alloc;
  198.             case SDS_TYPE_32:
  199.                 return SDS_HDR(32,s)->alloc;
  200.             case SDS_TYPE_64:
  201.                 return SDS_HDR(64,s)->alloc;
  202.         }
  203.         return 0;
  204.     }
  206.     static inline void sdssetalloc(sds s, size_t newlen) {
  207.         unsigned char flags = s[-1];
  208.         switch(flags&SDS_TYPE_MASK) {
  209.             case SDS_TYPE_5:
  210.                 /* Nothing to do, this type has no total allocation info. */
  211.                 break;
  212.             case SDS_TYPE_8:
  213.                 SDS_HDR(8,s)->alloc = newlen;
  214.                 break;
  215.             case SDS_TYPE_16:
  216.                 SDS_HDR(16,s)->alloc = newlen;
  217.                 break;
  218.             case SDS_TYPE_32:
  219.                 SDS_HDR(32,s)->alloc = newlen;
  220.                 break;
  221.             case SDS_TYPE_64:
  222.                 SDS_HDR(64,s)->alloc = newlen;
  223.                 break;
  224.         }
  225.     }
  227.     sds sdsnewlen(const void *init, size_t initlen);
  228.     sds sdsnew(const char *init);
  229.     sds sdsempty(void);
  230.     sds sdsdup(const sds s);
  231.     void sdsfree(sds s);
  232.     sds sdsgrowzero(sds s, size_t len);
  233.     sds sdscatlen(sds s, const void *t, size_t len);
  234.     sds sdscat(sds s, const char *t);
  235.     sds sdscatsds(sds s, const sds t);
  236.     sds sdscpylen(sds s, const char *t, size_t len);
  237.     sds sdscpy(sds s, const char *t);
  239.     sds sdscatvprintf(sds s, const char *fmt, va_list ap);
  240.     #ifdef __GNUC__
  241.     sds sdscatprintf(sds s, const char *fmt, ...)
  242.         __attribute__((format(printf, 2, 3)));
  243.     #else
  244.     sds sdscatprintf(sds s, const char *fmt, ...);
  245.     #endif
  247.     sds sdscatfmt(sds s, char const *fmt, ...);
  248.     sds sdstrim(sds s, const char *cset);
  249.     void sdsrange(sds s, int start, int end);
  250.     void sdsupdatelen(sds s);
  251.     void sdsclear(sds s);
  252.     int sdscmp(const sds s1, const sds s2);
  253.     sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
  254.     void sdsfreesplitres(sds *tokens, int count);
  255.     void sdstolower(sds s);
  256.     void sdstoupper(sds s);
  257.     sds sdsfromlonglong(long long value);
  258.     sds sdscatrepr(sds s, const char *p, size_t len);
  259.     sds *sdssplitargs(const char *line, int *argc);
  260.     sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
  261.     sds sdsjoin(char**argv, int argc, char *sep);
  262.     sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
  264.     /* Low level functions exposed to the user API */
  265.     sds sdsMakeRoomFor(sds s, size_t addlen);
  266.     void sdsIncrLen(sds s, int incr);
  267.     sds sdsRemoveFreeSpace(sds s);
  268.     size_t sdsAllocSize(sds s);
  269.     void *sdsAllocPtr(sds s);
  271.     /* Export the allocator used by SDS to the program using SDS.
  272.      * Sometimes the program SDS is linked to, may use a different set of
  273.      * allocators, but may want to allocate or free things that SDS will
  274.      * respectively free or allocate. */
  275.     void *sds_malloc(size_t size);
  276.     void *sds_realloc(void *ptr, size_t size);
  277.     void sds_free(void *ptr);
  279.     #ifdef REDIS_TEST
  280.     int sdsTest(int argc, char *argv[]);
  281.     #endif
  283.     #endif
  284.     `
redisstructhiredis

1条答案

按热度按时间
q43xntqr

q43xntqr1#

它的意思是 sizeof(struct sdshdr##T) 不起作用，因为编译时 struct sdshdr##T 尚未定义，因此其大小尚未确定。
通常需要在这之前定义结构，例如通过包含定义它的头文件。

赞(0）分享  回复(0）举报  2021-06-09
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com