Take care of two Clang warnings.

source/i18n/decNumber.c

 /* ------------------------------------------------------------------ */
 /* Decimal Number arithmetic module                                   */
 /* ------------------------------------------------------------------ */
 /* Copyright (c) IBM Corporation, 2000-2010.  All rights reserved.    */
 /*                                                                    */
 /* This software is made available under the terms of the             */
 /* ICU License -- ICU 1.8.1 and later.                                */
 /*                                                                    */
 /* The description and User's Guide ("The decNumber C Library") for   */
 /* this software is called decNumber.pdf.  This document is           */
@@ skipping 1484 matching lines @@
     needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
     if (needbytes>sizeof(bufb)) {       /* need malloc space  */
       allocbufb=(decNumber *)malloc(needbytes);
       if (allocbufb==NULL) {            /* hopeless -- abandon  */
         status|=DEC_Insufficient_storage;
         break;}
       b=allocbufb;                      /* use the allocated space  */
       }
     uprv_decNumberZero(w);                   /* set up 10...  */
     #if DECDPUN==1
+    #ifdef __clang__

[Nico, 2012/02/17 00:29:37]

You don't need the #ifdef, compilers are supposed to ignore #pragmas they don't
understand.

+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Warray-bounds"
+    #endif
     w->lsu[1]=1; w->lsu[0]=0;           /* ..  */
+    #ifdef __clang__
+    #pragma clang diagnostic pop
+    #endif
     #else
     w->lsu[0]=10;                       /* ..  */
     #endif
     w->digits=2;                        /* ..  */
 
     aset.digits=p;
     decLnOp(b, w, &aset, &ignore);      /* b=ln(10)  */
 
     aset.digits=set->digits;            /* for final divide  */
     decDivideOp(res, a, b, &aset, DIVIDE, &status); /* into result  */
@@ skipping 1411 matching lines @@
     /* (Rounded, etc.) should be ignored, not accumulated.]  */
 
     /* Calculate initial approximation, and allow for odd exponent  */
     workset.digits=workp;                    /* p for initial calculation  */
     t->bits=0; t->digits=3;
     a->bits=0; a->digits=3;
     if ((exp & 1)==0) {                      /* even exponent  */
       /* Set t=0.259, a=0.819  */
       t->exponent=-3;
       a->exponent=-3;
+      #ifdef __clang__
+      #pragma clang diagnostic push
+      #pragma clang diagnostic ignored "-Warray-bounds"
+      #endif
       #if DECDPUN>=3
         t->lsu[0]=259;
         a->lsu[0]=819;
       #elif DECDPUN==2
         t->lsu[0]=59; t->lsu[1]=2;
         a->lsu[0]=19; a->lsu[1]=8;
       #else
         t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
         a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
       #endif
+      #ifdef __clang__
+      #pragma clang diagnostic pop
+      #endif
       }
      else {                                  /* odd exponent  */
       /* Set t=0.0819, a=2.59  */
       f->exponent--;                         /* f=f/10  */
       exp++;                                 /* e=e+1  */
       t->exponent=-4;
       a->exponent=-2;
+      #ifdef __clang__
+      #pragma clang diagnostic push
+      #pragma clang diagnostic ignored "-Warray-bounds"
+      #endif
       #if DECDPUN>=3
         t->lsu[0]=819;
         a->lsu[0]=259;
       #elif DECDPUN==2
         t->lsu[0]=19; t->lsu[1]=8;
         a->lsu[0]=59; a->lsu[1]=2;
       #else
         t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
         a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
       #endif
+      #ifdef __clang__
+      #pragma clang diagnostic pop
+      #endif
       }
 
     decMultiplyOp(a, a, f, &workset, &ignore);    /* a=a*f  */
     decAddOp(a, a, t, &workset, 0, &ignore);      /* ..+t  */
     /* [a is now the initial approximation for sqrt(f), calculated with  */
     /* currentprecision, which is also a's precision.]  */
 
     /* the main calculation loop  */
     uprv_decNumberZero(&dzero);                   /* make 0  */
     uprv_decNumberZero(t);                        /* set t = 0.5  */
@@ skipping 2656 matching lines @@
     /* Non-zero negatives are bad...  */
     if (decNumberIsNegative(rhs)) {     /* -x -> error  */
       *status|=DEC_Invalid_operation;
       break;}
 
     /* Here, rhs is positive, finite, and in range  */
 
     /* lookaside fastpath code for ln(2) and ln(10) at common lengths  */
     if (rhs->exponent==0 && set->digits<=40) {
       #if DECDPUN==1
+      #ifdef __clang__
+      #pragma clang diagnostic push
+      #pragma clang diagnostic ignored "-Warray-bounds"
+      #endif
       if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { /* ln(10)  */
+      #ifdef __clang__
+      #pragma clang diagnostic pop
+      #endif
       #else
       if (rhs->lsu[0]==10 && rhs->digits==2) {                  /* ln(10)  */
       #endif
         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
         #define LN10 "2.302585092994045684017991454684364207601"
         uprv_decNumberFromString(res, LN10, &aset);
         *status|=(DEC_Inexact | DEC_Rounded); /* is inexact  */
         break;}
       if (rhs->lsu[0]==2 && rhs->digits==1) { /* ln(2)  */
         aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
@@ skipping 2483 matching lines @@
   for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
     printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
            b-b0-8, (LI)b0, (LI)n);
   free(b0);                        /* drop the storage  */
   decAllocBytes-=n;                /* account for storage  */
   /* printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n);  */
   } /* decFree  */
 #define malloc(a) decMalloc(a)
 #define free(a) decFree(a)
 #endif