{
     AttrMissing *attrmiss = NULL;
     int         attnum;
 -   int         firstmissingnum = 0;
 +   int         firstmissingnum;
     bool        hasNulls = HeapTupleHasNulls(sourceTuple);
     HeapTupleHeader targetTHeader;
     HeapTupleHeader sourceTHeader = sourceTuple->t_data;
          void
  gistfillbuffer(Page page, IndexTuple *itup, int len, OffsetNumber off)
  {
 -   OffsetNumber l = InvalidOffsetNumber;
     int         i;
  
     if (off == InvalidOffsetNumber)
      for (i = 0; i < len; i++)
     {
         Size        sz = IndexTupleSize(itup[i]);
 +       OffsetNumber l;
  
         l = PageAddItem(page, (Item) itup[i], sz, off, false, false);
         if (l == InvalidOffsetNumber)
             ScanKeyData notnullkeys[INDEX_MAX_KEYS];
     int         keysCount = 0;
     int         i;
 -   bool        status = true;
 +   bool        status;
     StrategyNumber strat_total;
     BTScanPosItem *currItem;
     BlockNumber blkno;
   {
     BTScanOpaque so = (BTScanOpaque) scan->opaque;
     BlockNumber blkno = InvalidBlockNumber;
 -   bool        status = true;
 +   bool        status;
  
     Assert(BTScanPosIsValid(so->currPos));
  
      Relation    rel;
     Page        page;
     BTPageOpaque opaque;
 -   bool        status = true;
 +   bool        status;
  
     rel = scan->indexRelation;
  
             PendingRelDelete *prev;
     PendingRelDelete *next;
     int         nrels = 0,
 -               i = 0,
                 maxrels = 0;
     SMgrRelation *srels = NULL;
  
      {
         smgrdounlinkall(srels, nrels, false);
  
 -       for (i = 0; i < nrels; i++)
 +       for (int i = 0; i < nrels; i++)
             smgrclose(srels[i]);
  
         pfree(srels);
          asyncQueueReadAllNotifications(void)
  {
     volatile QueuePosition pos;
 -   QueuePosition oldpos;
     QueuePosition head;
     Snapshot    snapshot;
  
      LWLockAcquire(NotifyQueueLock, LW_SHARED);
     /* Assert checks that we have a valid state entry */
     Assert(MyProcPid == QUEUE_BACKEND_PID(MyBackendId));
 -   pos = oldpos = QUEUE_BACKEND_POS(MyBackendId);
 +   pos = QUEUE_BACKEND_POS(MyBackendId);
     head = QUEUE_HEAD;
     LWLockRelease(NotifyQueueLock);
  
          {
     ProcArrayStruct *arrayP = procArray;
     int         index;
 -   pid_t       pid = 0;
  
     /* tell all backends to die */
     LWLockAcquire(ProcArrayLock, LW_EXCLUSIVE);
          if (databaseid == InvalidOid || proc->databaseId == databaseid)
         {
             VirtualTransactionId procvxid;
 +           pid_t       pid;
  
             GET_VXID_FROM_PGPROC(procvxid, *proc);
  
          NISortDictionary(IspellDict *Conf)
  {
     int         i;
 -   int         naffix = 0;
 +   int         naffix;
     int         curaffix;
  
     /* compress affixes */
          get_th(char *num, int type)
  {
     int         len = strlen(num),
 -               last,
 -               seclast;
 +               last;
  
     last = *(num + (len - 1));
     if (!isdigit((unsigned char) last))
       * All "teens" (<x>1[0-9]) get 'TH/th', while <x>[02-9][123] still get
      * 'ST/st', 'ND/nd', 'RD/rd', respectively
      */
 -   if ((len > 1) && ((seclast = num[len - 2]) == '1'))
 +   if ((len > 1) && (num[len - 2] == '1'))
         last = 0;
  
     switch (last)
   static char *
  int_to_roman(int number)
  {
 -   int         len = 0,
 -               num = 0;
 -   char       *p = NULL,
 +   int         len,
 +               num;
 +   char       *p,
                *result,
                 numstr[12];
  
   
     for (p = numstr; *p != '\0'; p++, --len)
     {
 -       num = *p - 49;          /* 48 ascii + 1 */
 +       num = *p - ('0' + 1);
         if (num < 0)
             continue;
  
          x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
                                                 NumericGetDatum(value),
                                                 Int32GetDatum(0)));
 -       numstr = orgnum =
 +       numstr =
             int_to_roman(DatumGetInt32(DirectFunctionCall1(numeric_int4,
                                                            NumericGetDatum(x))));
     }
       * On DateType depend part (int32)
      */
     if (IS_ROMAN(&Num))
 -       numstr = orgnum = int_to_roman(value);
 +       numstr = int_to_roman(value);
     else if (IS_EEEE(&Num))
     {
         /* we can do it easily because float8 won't lose any precision */
      if (IS_ROMAN(&Num))
     {
         /* Currently don't support int8 conversion to roman... */
 -       numstr = orgnum = int_to_roman(DatumGetInt32(DirectFunctionCall1(int84, Int64GetDatum(value))));
 +       numstr = int_to_roman(DatumGetInt32(DirectFunctionCall1(int84, Int64GetDatum(value))));
     }
     else if (IS_EEEE(&Num))
     {
             double      Wdoc = 0.0;
     double      invws[lengthof(weights)];
     double      SumDist = 0.0,
 -               PrevExtPos = 0.0,
 -               CurExtPos = 0.0;
 +               PrevExtPos = 0.0;
     int         NExtent = 0;
     QueryRepresentation qr;
  
      {
         double      Cpos = 0.0;
         double      InvSum = 0.0;
 +       double      CurExtPos;
         int         nNoise;
         DocRepresentation *ptr = ext.begin;
  
             size_t      blkLen;
     char       *buf = NULL;
     int         buflen = 0;
 -   size_t      cnt;
  
     blkLen = ReadInt(AH);
     while (blkLen != 0)
                  buf = (char *) pg_malloc(blkLen);
                 buflen = blkLen;
             }
 -           if ((cnt = fread(buf, 1, blkLen, AH->FH)) != blkLen)
 +           if (fread(buf, 1, blkLen, AH->FH) != blkLen)
             {
                 if (feof(AH->FH))
                     fatal("could not read from input file: end of file");
   static int
  _WriteByte(ArchiveHandle *AH, const int i)
  {
 -   int         res;
 -
 -   if ((res = fputc(i, AH->FH)) == EOF)
 +   if (fputc(i, AH->FH) == EOF)
         WRITE_ERROR_EXIT;
  
     return 1;