Use FLEXIBLE_ARRAY_MEMBER in a number of other places.

I think we're about done with this...

diff --git a/contrib/hstore/hstore_gist.c b/contrib/hstore/hstore_gist.c
index 54e96fca38eb46188aa20b2c4d38582e48dc4c10..f375f5d3542594eaa81833a80177fc2c3b8eac35 100644 (file)
--- a/contrib/hstore/hstore_gist.c
+++ b/contrib/hstore/hstore_gist.c
@@ -41,7 +41,7 @@ typedef struct
 {
    int32       vl_len_;        /* varlena header (do not touch directly!) */
    int32       flag;
-   char        data[1];
+   char        data[FLEXIBLE_ARRAY_MEMBER];
 } GISTTYPE;
 
 #define ALLISTRUE      0x04

diff --git a/contrib/spi/timetravel.c b/contrib/spi/timetravel.c
index a37cbee8631a54824e3710acf06273c86ec68c63..0699438d6f6a7542413abe6f1521851907e71d23 100644 (file)
--- a/contrib/spi/timetravel.c
+++ b/contrib/spi/timetravel.c
@@ -35,10 +35,10 @@ static int  nPlans = 0;
 typedef struct _TTOffList
 {
    struct _TTOffList *next;
-   char        name[1];
+   char        name[FLEXIBLE_ARRAY_MEMBER];
 } TTOffList;
 
-static TTOffList TTOff = {NULL, {0}};
+static TTOffList *TTOff = NULL;
 
 static int findTTStatus(char *name);
 static EPlan *find_plan(char *ident, EPlan **eplan, int *nplans);
@@ -428,10 +428,11 @@ set_timetravel(PG_FUNCTION_ARGS)
    char       *d;
    char       *s;
    int32       ret;
-   TTOffList  *p,
+   TTOffList  *prev,
               *pp;
 
-   for (pp = (p = &TTOff)->next; pp; pp = (p = pp)->next)
+   prev = NULL;
+   for (pp = TTOff; pp; prev = pp, pp = pp->next)
    {
        if (namestrcmp(relname, pp->name) == 0)
            break;
@@ -442,7 +443,10 @@ set_timetravel(PG_FUNCTION_ARGS)
        if (on != 0)
        {
            /* turn ON */
-           p->next = pp->next;
+           if (prev)
+               prev->next = pp->next;
+           else
+               TTOff = pp->next;
            free(pp);
        }
        ret = 0;
@@ -456,15 +460,18 @@ set_timetravel(PG_FUNCTION_ARGS)
            s = rname = DatumGetCString(DirectFunctionCall1(nameout, NameGetDatum(relname)));
            if (s)
            {
-               pp = malloc(sizeof(TTOffList) + strlen(rname));
+               pp = malloc(offsetof(TTOffList, name) +strlen(rname) + 1);
                if (pp)
                {
                    pp->next = NULL;
-                   p->next = pp;
                    d = pp->name;
                    while (*s)
                        *d++ = tolower((unsigned char) *s++);
                    *d = '\0';
+                   if (prev)
+                       prev->next = pp;
+                   else
+                       TTOff = pp;
                }
                pfree(rname);
            }
@@ -486,7 +493,7 @@ get_timetravel(PG_FUNCTION_ARGS)
    Name        relname = PG_GETARG_NAME(0);
    TTOffList  *pp;
 
-   for (pp = TTOff.next; pp; pp = pp->next)
+   for (pp = TTOff; pp; pp = pp->next)
    {
        if (namestrcmp(relname, pp->name) == 0)
            PG_RETURN_INT32(0);
@@ -499,7 +506,7 @@ findTTStatus(char *name)
 {
    TTOffList  *pp;
 
-   for (pp = TTOff.next; pp; pp = pp->next)
+   for (pp = TTOff; pp; pp = pp->next)
        if (pg_strcasecmp(name, pp->name) == 0)
            return 0;
    return 1;

diff --git a/src/backend/access/heap/syncscan.c b/src/backend/access/heap/syncscan.c
index ae7589abefd79015a56d0a78b46349e83f42e243..266c3309c0b6518af1ed6451e6956406a2c08a57 100644 (file)
--- a/src/backend/access/heap/syncscan.c
+++ b/src/backend/access/heap/syncscan.c
@@ -103,10 +103,11 @@ typedef struct ss_scan_locations_t
 {
    ss_lru_item_t *head;
    ss_lru_item_t *tail;
-   ss_lru_item_t items[1];     /* SYNC_SCAN_NELEM items */
+   ss_lru_item_t items[FLEXIBLE_ARRAY_MEMBER]; /* SYNC_SCAN_NELEM items */
 } ss_scan_locations_t;
 
-#define SizeOfScanLocations(N) offsetof(ss_scan_locations_t, items[N])
+#define SizeOfScanLocations(N) \
+   (offsetof(ss_scan_locations_t, items) + (N) * sizeof(ss_lru_item_t))
 
 /* Pointer to struct in shared memory */
 static ss_scan_locations_t *scan_locations;

diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c
index d73248ca50463edfeca54b0e3ef9b9111a3e76d5..2826b7e43c446c13497490a7b629735758a84dcf 100644 (file)
--- a/src/backend/commands/async.c
+++ b/src/backend/commands/async.c
@@ -237,8 +237,8 @@ typedef struct AsyncQueueControl
    QueuePosition tail;         /* the global tail is equivalent to the tail
                                 * of the "slowest" backend */
    TimestampTz lastQueueFillWarn;      /* time of last queue-full msg */
-   QueueBackendStatus backend[1];      /* actually of length MaxBackends+1 */
-   /* DO NOT ADD FURTHER STRUCT MEMBERS HERE */
+   QueueBackendStatus backend[FLEXIBLE_ARRAY_MEMBER];
+   /* backend[0] is not used; used entries are from [1] to [MaxBackends] */
 } AsyncQueueControl;
 
 static AsyncQueueControl *asyncQueueControl;
@@ -303,7 +303,7 @@ typedef enum
 typedef struct
 {
    ListenActionKind action;
-   char        channel[1];     /* actually, as long as needed */
+   char        channel[FLEXIBLE_ARRAY_MEMBER]; /* nul-terminated string */
 } ListenAction;
 
 static List *pendingActions = NIL;     /* list of ListenAction */
@@ -417,8 +417,8 @@ AsyncShmemSize(void)
    Size        size;
 
    /* This had better match AsyncShmemInit */
-   size = mul_size(MaxBackends, sizeof(QueueBackendStatus));
-   size = add_size(size, sizeof(AsyncQueueControl));
+   size = mul_size(MaxBackends + 1, sizeof(QueueBackendStatus));
+   size = add_size(size, offsetof(AsyncQueueControl, backend));
 
    size = add_size(size, SimpleLruShmemSize(NUM_ASYNC_BUFFERS, 0));
 
@@ -438,12 +438,11 @@ AsyncShmemInit(void)
    /*
     * Create or attach to the AsyncQueueControl structure.
     *
-    * The used entries in the backend[] array run from 1 to MaxBackends.
-    * sizeof(AsyncQueueControl) already includes space for the unused zero'th
-    * entry, but we need to add on space for the used entries.
+    * The used entries in the backend[] array run from 1 to MaxBackends; the
+    * zero'th entry is unused but must be allocated.
     */
-   size = mul_size(MaxBackends, sizeof(QueueBackendStatus));
-   size = add_size(size, sizeof(AsyncQueueControl));
+   size = mul_size(MaxBackends + 1, sizeof(QueueBackendStatus));
+   size = add_size(size, offsetof(AsyncQueueControl, backend));
 
    asyncQueueControl = (AsyncQueueControl *)
        ShmemInitStruct("Async Queue Control", size, &found);
@@ -605,7 +604,8 @@ queue_listen(ListenActionKind action, const char *channel)
    oldcontext = MemoryContextSwitchTo(CurTransactionContext);
 
    /* space for terminating null is included in sizeof(ListenAction) */
-   actrec = (ListenAction *) palloc(sizeof(ListenAction) + strlen(channel));
+   actrec = (ListenAction *) palloc(offsetof(ListenAction, channel) +
+                                    strlen(channel) + 1);
    actrec->action = action;
    strcpy(actrec->channel, channel);
 

diff --git a/src/backend/libpq/auth.c b/src/backend/libpq/auth.c
index 346f8080494c35468703a0430d1493e86b0f81d9..28b050af0e2edb527897651c700014362b4b0dc2 100644 (file)
--- a/src/backend/libpq/auth.c
+++ b/src/backend/libpq/auth.c
@@ -2172,7 +2172,7 @@ typedef struct
 {
    uint8       attribute;
    uint8       length;
-   uint8       data[1];
+   uint8       data[FLEXIBLE_ARRAY_MEMBER];
 } radius_attribute;
 
 typedef struct
@@ -2220,7 +2220,6 @@ radius_add_attribute(radius_packet *packet, uint8 type, const unsigned char *dat
             "Adding attribute code %d with length %d to radius packet would create oversize packet, ignoring",
             type, len);
        return;
-
    }
 
    attr = (radius_attribute *) ((unsigned char *) packet + packet->length);

diff --git a/src/backend/storage/buffer/freelist.c b/src/backend/storage/buffer/freelist.c
index 0d1cbd15531ccea3dfbc06b2ccc8555e34e93c7a..f0d23d68582d01c9133bcee8ce3c84e4a60c1c69 100644 (file)
--- a/src/backend/storage/buffer/freelist.c
+++ b/src/backend/storage/buffer/freelist.c
@@ -93,7 +93,7 @@ typedef struct BufferAccessStrategyData
     * simplicity this is palloc'd together with the fixed fields of the
     * struct.
     */
-   Buffer      buffers[1];     /* VARIABLE SIZE ARRAY */
+   Buffer      buffers[FLEXIBLE_ARRAY_MEMBER];
 }  BufferAccessStrategyData;
 
 

diff --git a/src/backend/storage/ipc/sinvaladt.c b/src/backend/storage/ipc/sinvaladt.c
index bb3e604e671c46be8b73fced06235388adae473b..81b85c0e42009b51ae5628a8ceaca5d919fe8f97 100644 (file)
--- a/src/backend/storage/ipc/sinvaladt.c
+++ b/src/backend/storage/ipc/sinvaladt.c
@@ -184,12 +184,9 @@ typedef struct SISeg
    SharedInvalidationMessage buffer[MAXNUMMESSAGES];
 
    /*
-    * Per-backend state info.
-    *
-    * We declare procState as 1 entry because C wants a fixed-size array, but
-    * actually it is maxBackends entries long.
+    * Per-backend invalidation state info (has MaxBackends entries).
     */
-   ProcState   procState[1];   /* reflects the invalidation state */
+   ProcState   procState[FLEXIBLE_ARRAY_MEMBER];
 } SISeg;
 
 static SISeg *shmInvalBuffer;  /* pointer to the shared inval buffer */
@@ -221,16 +218,12 @@ SInvalShmemSize(void)
 void
 CreateSharedInvalidationState(void)
 {
-   Size        size;
    int         i;
    bool        found;
 
    /* Allocate space in shared memory */
-   size = offsetof(SISeg, procState);
-   size = add_size(size, mul_size(sizeof(ProcState), MaxBackends));
-
    shmInvalBuffer = (SISeg *)
-       ShmemInitStruct("shmInvalBuffer", size, &found);
+       ShmemInitStruct("shmInvalBuffer", SInvalShmemSize(), &found);
    if (found)
        return;
 

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 1e7a176c60dd858a0e54205f7ee3edbd736f78db..715917bab347f33e4c569e522ced4e8874f8c378 100644 (file)
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -123,14 +123,14 @@ typedef int16 NumericDigit;
 struct NumericShort
 {
    uint16      n_header;       /* Sign + display scale + weight */
-   NumericDigit n_data[1];     /* Digits */
+   NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]; /* Digits */
 };
 
 struct NumericLong
 {
    uint16      n_sign_dscale;  /* Sign + display scale */
    int16       n_weight;       /* Weight of 1st digit  */
-   NumericDigit n_data[1];     /* Digits */
+   NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]; /* Digits */
 };
 
 union NumericChoice
@@ -1262,7 +1262,7 @@ numeric_floor(PG_FUNCTION_ARGS)
 /*
  * generate_series_numeric() -
  *
- *  Generate series of numeric.
+ * Generate series of numeric.
  */
 Datum
 generate_series_numeric(PG_FUNCTION_ARGS)
@@ -1297,7 +1297,7 @@ generate_series_step_numeric(PG_FUNCTION_ARGS)
        /* see if we were given an explicit step size */
        if (PG_NARGS() == 3)
        {
-           Numeric step_num = PG_GETARG_NUMERIC(2);
+           Numeric     step_num = PG_GETARG_NUMERIC(2);
 
            if (NUMERIC_IS_NAN(step_num))
                ereport(ERROR,
@@ -1356,7 +1356,7 @@ generate_series_step_numeric(PG_FUNCTION_ARGS)
        (fctx->step.sign == NUMERIC_NEG &&
         cmp_var(&fctx->current, &fctx->stop) >= 0))
    {
-       Numeric result = make_result(&fctx->current);
+       Numeric     result = make_result(&fctx->current);
 
        /* switch to memory context appropriate for iteration calculation */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);

diff --git a/src/backend/utils/adt/tsgistidx.c b/src/backend/utils/adt/tsgistidx.c
index b56aa91bcb4c5fb2b069b58d5f0a85236e49b147..25132be441acf33184d8fc5b9146b2380d85ea6c 100644 (file)
--- a/src/backend/utils/adt/tsgistidx.c
+++ b/src/backend/utils/adt/tsgistidx.c
@@ -50,7 +50,7 @@ typedef struct
 {
    int32       vl_len_;        /* varlena header (do not touch directly!) */
    int32       flag;
-   char        data[1];
+   char        data[FLEXIBLE_ARRAY_MEMBER];
 } SignTSVector;
 
 #define ARRKEY     0x01

diff --git a/src/backend/utils/adt/tsvector_op.c b/src/backend/utils/adt/tsvector_op.c
index 3ac15f4d1f0b7d8cd53ae221d53f3e5bf2082c27..266a728ef6a3e781f6143b2dcb8a933568b3b894 100644 (file)
--- a/src/backend/utils/adt/tsvector_op.c
+++ b/src/backend/utils/adt/tsvector_op.c
@@ -44,7 +44,7 @@ typedef struct StatEntry
    struct StatEntry *left;
    struct StatEntry *right;
    uint32      lenlexeme;
-   char        lexeme[1];
+   char        lexeme[FLEXIBLE_ARRAY_MEMBER];
 } StatEntry;
 
 #define STATENTRYHDRSZ (offsetof(StatEntry, lexeme))

diff --git a/src/backend/utils/adt/txid.c b/src/backend/utils/adt/txid.c
index 8c7fe7018ab564c5a1a993103f23230203754587..f973ef936c5a3c122dbb851f1a2f0c007d28ec05 100644 (file)
--- a/src/backend/utils/adt/txid.c
+++ b/src/backend/utils/adt/txid.c
@@ -64,7 +64,8 @@ typedef struct
    uint32      nxip;           /* number of txids in xip array */
    txid        xmin;
    txid        xmax;
-   txid        xip[1];         /* in-progress txids, xmin <= xip[i] < xmax */
+   /* in-progress txids, xmin <= xip[i] < xmax: */
+   txid        xip[FLEXIBLE_ARRAY_MEMBER];
 } TxidSnapshot;
 
 #define TXID_SNAPSHOT_SIZE(nxip) \

diff --git a/src/backend/utils/fmgr/dfmgr.c b/src/backend/utils/fmgr/dfmgr.c
index 1b6932235cb85a8fdf0de5fa8747ec355eab04a6..7476a26b791f1871e0580731ee4a1c1c6c000332 100644 (file)
--- a/src/backend/utils/fmgr/dfmgr.c
+++ b/src/backend/utils/fmgr/dfmgr.c
@@ -51,12 +51,7 @@ typedef struct df_files
    ino_t       inode;          /* Inode number of file */
 #endif
    void       *handle;         /* a handle for pg_dl* functions */
-   char        filename[1];    /* Full pathname of file */
-
-   /*
-    * we allocate the block big enough for actual length of pathname.
-    * filename[] must be last item in struct!
-    */
+   char        filename[FLEXIBLE_ARRAY_MEMBER];        /* Full pathname of file */
 } DynamicFileList;
 
 static DynamicFileList *file_list = NULL;
@@ -217,13 +212,13 @@ internal_load_library(const char *libname)
         * File not loaded yet.
         */
        file_scanner = (DynamicFileList *)
-           malloc(sizeof(DynamicFileList) + strlen(libname));
+           malloc(offsetof(DynamicFileList, filename) +strlen(libname) + 1);
        if (file_scanner == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_OUT_OF_MEMORY),
                     errmsg("out of memory")));
 
-       MemSet(file_scanner, 0, sizeof(DynamicFileList));
+       MemSet(file_scanner, 0, offsetof(DynamicFileList, filename));
        strcpy(file_scanner->filename, libname);
        file_scanner->device = stat_buf.st_dev;
 #ifndef WIN32

diff --git a/src/backend/utils/sort/logtape.c b/src/backend/utils/sort/logtape.c
index 21030423ed2ecba4fd2fbe0b4352dbbd2cd2510d..252ba2207121f732ecc0dd4b43dd1fa6cb08e1db 100644 (file)
--- a/src/backend/utils/sort/logtape.c
+++ b/src/backend/utils/sort/logtape.c
@@ -166,12 +166,9 @@ struct LogicalTapeSet
    int         nFreeBlocks;    /* # of currently free blocks */
    int         freeBlocksLen;  /* current allocated length of freeBlocks[] */
 
-   /*
-    * tapes[] is declared size 1 since C wants a fixed size, but actually it
-    * is of length nTapes.
-    */
+   /* The array of logical tapes. */
    int         nTapes;         /* # of logical tapes in set */
-   LogicalTape tapes[1];       /* must be last in struct! */
+   LogicalTape tapes[FLEXIBLE_ARRAY_MEMBER];   /* has nTapes nentries */
 };
 
 static void ltsWriteBlock(LogicalTapeSet *lts, long blocknum, void *buffer);
@@ -519,12 +516,11 @@ LogicalTapeSetCreate(int ntapes)
    int         i;
 
    /*
-    * Create top-level struct including per-tape LogicalTape structs. First
-    * LogicalTape struct is already counted in sizeof(LogicalTapeSet).
+    * Create top-level struct including per-tape LogicalTape structs.
     */
    Assert(ntapes > 0);
-   lts = (LogicalTapeSet *) palloc(sizeof(LogicalTapeSet) +
-                                   (ntapes - 1) *sizeof(LogicalTape));
+   lts = (LogicalTapeSet *) palloc(offsetof(LogicalTapeSet, tapes) +
+                                   ntapes * sizeof(LogicalTape));
    lts->pfile = BufFileCreateTemp(false);
    lts->nFileBlocks = 0L;
    lts->forgetFreeSpace = false;

diff --git a/src/interfaces/ecpg/ecpglib/extern.h b/src/interfaces/ecpg/ecpglib/extern.h
index 2b670e0d00426a012aef666deed66900e1df5929..ca3bf05181690385f88b46374ba08c5f793b0e6f 100644 (file)
--- a/src/interfaces/ecpg/ecpglib/extern.h
+++ b/src/interfaces/ecpg/ecpglib/extern.h
@@ -33,7 +33,7 @@ enum ARRAY_TYPE
 struct ECPGgeneric_varchar
 {
    int         len;
-   char        arr[1];
+   char        arr[FLEXIBLE_ARRAY_MEMBER];
 };
 
 /*