source: rtems/contrib/crossrpms/patches/newlib-1.15.0-rtems4.8-20070110.diff @ 3d62598

4.104.114.84.9
Last change on this file since 3d62598 was 3d62598, checked in by Ralf Corsepius <ralf.corsepius@…>, on Jan 10, 2007 at 6:05:01 AM

Add ECANCELED.

  • Property mode set to 100644
File size: 23.7 KB
  • newlib/libc/include/machine/setjmp.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/include/machine/setjmp.h newlib-1.15.0/newlib/libc/include/machine/setjmp.h
    old new  
    2727
    2828/* necv70 was 9 as well. */
    2929
    30 #ifdef __mc68000__
     30#if defined(__m68k__) || defined(__mc68000__)
    3131/*
    3232 * onsstack,sigmask,sp,pc,psl,d2-d7,a2-a6,
    3333 * fp2-fp7      for 68881.
  • newlib/libc/include/sys/errno.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/include/sys/errno.h newlib-1.15.0/newlib/libc/include/sys/errno.h
    old new  
    148148#define ECASECLASH 137  /* Filename exists with different case */
    149149#define EILSEQ 138
    150150#define EOVERFLOW 139   /* Value too large for defined data type */
     151#define ECANCELED 140   /* Operation canceled. */
    151152
    152153/* From cygwin32.  */
    153154#define EWOULDBLOCK EAGAIN      /* Operation would block */
  • newlib/libc/include/sys/_types.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/include/sys/_types.h newlib-1.15.0/newlib/libc/include/sys/_types.h
    old new  
    3939/* Iconv descriptor type */
    4040typedef void *_iconv_t;
    4141
     42typedef long * __intptr_t;
     43typedef unsigned long* __uintptr_t;
     44
    4245#endif  /* _SYS__TYPES_H */
  • newlib/libc/machine/arm/machine/endian.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/machine/arm/machine/endian.h newlib-1.15.0/newlib/libc/machine/arm/machine/endian.h
    old new  
    1 /* ARM configuration file */
    2 
    3 #ifndef _MACHINE_ENDIAN_H
    4 # define _MACHINE_ENDIAN_H
    5 
    6 #ifdef __ARMEB__
    7 #define BYTE_ORDER BIG_ENDIAN
    8 #else
    9 #define BYTE_ORDER LITTLE_ENDIAN
    10 #endif
    11 
    12 #endif
  • newlib/libc/search/db_local.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/db_local.h newlib-1.15.0/newlib/libc/search/db_local.h
    old new  
    5050#define MAX_PAGE_NUMBER 0xffffffff      /* >= # of pages in a file */
    5151typedef __uint32_t      pgno_t;
    5252#define MAX_PAGE_OFFSET 65535           /* >= # of bytes in a page */
    53 typedef __uint16_t      indx_t;
     53typedef __uint_least16_t        indx_t;
    5454#define MAX_REC_NUMBER  0xffffffff      /* >= # of records in a tree */
    5555typedef __uint32_t      recno_t;
    5656
     
    191191 *      P_16_COPY       swap from one location to another
    192192 */
    193193#define M_16_SWAP(a) {                                                  \
    194         __uint16_t _tmp = a;                                            \
     194        __uint_least16_t _tmp = a;                                              \
    195195        ((char *)&a)[0] = ((char *)&_tmp)[1];                           \
    196196        ((char *)&a)[1] = ((char *)&_tmp)[0];                           \
    197197}
    198198#define P_16_SWAP(a) {                                                  \
    199         __uint16_t _tmp = *(__uint16_t *)a;                             \
     199        __uint_least16_t _tmp = *(__uint_least16_t *)a;                         \
    200200        ((char *)a)[0] = ((char *)&_tmp)[1];                            \
    201201        ((char *)a)[1] = ((char *)&_tmp)[0];                            \
    202202}
  • newlib/libc/search/extern.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/extern.h newlib-1.15.0/newlib/libc/search/extern.h
    old new  
    4848int      __delpair(HTAB *, BUFHEAD *, int);
    4949int      __expand_table(HTAB *);
    5050int      __find_bigpair(HTAB *, BUFHEAD *, int, char *, int);
    51 __uint16_t       __find_last_page(HTAB *, BUFHEAD **);
     51__uint_least16_t         __find_last_page(HTAB *, BUFHEAD **);
    5252void     __free_ovflpage(HTAB *, BUFHEAD *);
    5353BUFHEAD *__get_buf(HTAB *, __uint32_t, BUFHEAD *, int);
    5454int      __get_page(HTAB *, char *, __uint32_t, int, int, int);
  • newlib/libc/search/hash_bigkey.c

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/hash_bigkey.c newlib-1.15.0/newlib/libc/search/hash_bigkey.c
    old new  
    9292        BUFHEAD *bufp;
    9393        const DBT *key, *val;
    9494{
    95         __uint16_t *p;
     95        __uint_least16_t *p;
    9696        int key_size, n, val_size;
    97         __uint16_t space, move_bytes, off;
     97        __uint_least16_t space, move_bytes, off;
    9898        char *cp, *key_data, *val_data;
    9999
    100100        cp = bufp->page;                /* Character pointer of p. */
    101         p = (__uint16_t *)cp;
     101        p = (__uint_least16_t *)cp;
    102102
    103103        key_data = (char *)key->data;
    104104        key_size = key->size;
     
    136136                                OFFSET(p) = off;
    137137                        } else
    138138                                p[n - 2] = FULL_KEY;
    139                 p = (__uint16_t *)bufp->page;
     139                p = (__uint_least16_t *)bufp->page;
    140140                cp = bufp->page;
    141141                bufp->flags |= BUF_MOD;
    142142        }
     
    166166                        if (!bufp)
    167167                                return (-1);
    168168                        cp = bufp->page;
    169                         p = (__uint16_t *)cp;
     169                        p = (__uint_least16_t *)cp;
    170170                } else
    171171                        p[n] = FULL_KEY_DATA;
    172172                bufp->flags |= BUF_MOD;
     
    191191        BUFHEAD *bufp;
    192192{
    193193        BUFHEAD *last_bfp, *rbufp;
    194         __uint16_t *bp, pageno;
     194        __uint_least16_t *bp, pageno;
    195195        int key_done, n;
    196196
    197197        rbufp = bufp;
    198198        last_bfp = NULL;
    199         bp = (__uint16_t *)bufp->page;
     199        bp = (__uint_least16_t *)bufp->page;
    200200        pageno = 0;
    201201        key_done = 0;
    202202
     
    219219                last_bfp = rbufp;
    220220                if (!rbufp)
    221221                        return (-1);            /* Error. */
    222                 bp = (__uint16_t *)rbufp->page;
     222                bp = (__uint_least16_t *)rbufp->page;
    223223        }
    224224
    225225        /*
     
    234234        pageno = bp[n - 1];
    235235
    236236        /* Now, bp is the first page of the pair. */
    237         bp = (__uint16_t *)bufp->page;
     237        bp = (__uint_least16_t *)bufp->page;
    238238        if (n > 2) {
    239239                /* There is an overflow page. */
    240240                bp[1] = pageno;
     
    272272        char *key;
    273273        int size;
    274274{
    275         __uint16_t *bp;
     275        __uint_least16_t *bp;
    276276        char *p;
    277277        int ksize;
    278         __uint16_t bytes;
     278        __uint_least16_t bytes;
    279279        char *kkey;
    280280
    281         bp = (__uint16_t *)bufp->page;
     281        bp = (__uint_least16_t *)bufp->page;
    282282        p = bufp->page;
    283283        ksize = size;
    284284        kkey = key;
     
    294294                if (!bufp)
    295295                        return (-3);
    296296                p = bufp->page;
    297                 bp = (__uint16_t *)p;
     297                bp = (__uint_least16_t *)p;
    298298                ndx = 1;
    299299        }
    300300
     
    316316 * of the pair; 0 if there isn't any (i.e. big pair is the last key in the
    317317 * bucket)
    318318 */
    319 extern __uint16_t
     319extern __uint_least16_t
    320320__find_last_page(hashp, bpp)
    321321        HTAB *hashp;
    322322        BUFHEAD **bpp;
    323323{
    324324        BUFHEAD *bufp;
    325         __uint16_t *bp, pageno;
     325        __uint_least16_t *bp, pageno;
    326326        int n;
    327327
    328328        bufp = *bpp;
    329         bp = (__uint16_t *)bufp->page;
     329        bp = (__uint_least16_t *)bufp->page;
    330330        for (;;) {
    331331                n = bp[0];
    332332
     
    343343                bufp = __get_buf(hashp, pageno, bufp, 0);
    344344                if (!bufp)
    345345                        return (0);     /* Need to indicate an error! */
    346                 bp = (__uint16_t *)bufp->page;
     346                bp = (__uint_least16_t *)bufp->page;
    347347        }
    348348
    349349        *bpp = bufp;
     
    366366        int set_current;
    367367{
    368368        BUFHEAD *save_p;
    369         __uint16_t *bp, len, off, save_addr;
     369        __uint_least16_t *bp, len, off, save_addr;
    370370        char *tp;
    371371
    372         bp = (__uint16_t *)bufp->page;
     372        bp = (__uint_least16_t *)bufp->page;
    373373        while (bp[ndx + 1] == PARTIAL_KEY) {
    374374                bufp = __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    375375                if (!bufp)
    376376                        return (-1);
    377                 bp = (__uint16_t *)bufp->page;
     377                bp = (__uint_least16_t *)bufp->page;
    378378                ndx = 1;
    379379        }
    380380
     
    382382                bufp = __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    383383                if (!bufp)
    384384                        return (-1);
    385                 bp = (__uint16_t *)bufp->page;
     385                bp = (__uint_least16_t *)bufp->page;
    386386                save_p = bufp;
    387387                save_addr = save_p->addr;
    388388                off = bp[1];
     
    403403                        bufp = __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    404404                        if (!bufp)
    405405                                return (-1);
    406                         bp = (__uint16_t *)bufp->page;
     406                        bp = (__uint_least16_t *)bufp->page;
    407407                } else {
    408408                        /* The data is all on one page. */
    409409                        tp = (char *)bp;
     
    422422                                        if (!hashp->cpage)
    423423                                                return (-1);
    424424                                        hashp->cndx = 1;
    425                                         if (!((__uint16_t *)
     425                                        if (!((__uint_least16_t *)
    426426                                            hashp->cpage->page)[0]) {
    427427                                                hashp->cbucket++;
    428428                                                hashp->cpage = NULL;
     
    454454        BUFHEAD *bufp;
    455455        int len, set;
    456456{
    457         __uint16_t *bp;
     457        __uint_least16_t *bp;
    458458        char *p;
    459459        BUFHEAD *xbp;
    460         __uint16_t save_addr;
     460        __uint_least16_t save_addr;
    461461        int mylen, totlen;
    462462
    463463        p = bufp->page;
    464         bp = (__uint16_t *)p;
     464        bp = (__uint_least16_t *)p;
    465465        mylen = hashp->BSIZE - bp[1];
    466466        save_addr = bufp->addr;
    467467
     
    481481                                    __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    482482                                if (!hashp->cpage)
    483483                                        return (-1);
    484                                 else if (!((__uint16_t *)hashp->cpage->page)[0]) {
     484                                else if (!((__uint_least16_t *)hashp->cpage->page)[0]) {
    485485                                        hashp->cbucket++;
    486486                                        hashp->cpage = NULL;
    487487                                }
     
    533533        BUFHEAD *xbp;
    534534        char *p;
    535535        int mylen, totlen;
    536         __uint16_t *bp, save_addr;
     536        __uint_least16_t *bp, save_addr;
    537537
    538538        p = bufp->page;
    539         bp = (__uint16_t *)p;
     539        bp = (__uint_least16_t *)p;
    540540        mylen = hashp->BSIZE - bp[1];
    541541
    542542        save_addr = bufp->addr;
     
    579579        SPLIT_RETURN *ret;
    580580{
    581581        BUFHEAD *tmpp;
    582         __uint16_t *tp;
     582        __uint_least16_t *tp;
    583583        BUFHEAD *bp;
    584584        DBT key, val;
    585585        __uint32_t change;
    586         __uint16_t free_space, n, off;
     586        __uint_least16_t free_space, n, off;
    587587
    588588        bp = big_keyp;
    589589
     
    615615            (tmpp->ovfl ? tmpp->ovfl->addr : 0), (bp ? bp->addr : 0));
    616616#endif
    617617        tmpp->ovfl = bp;        /* one of op/np point to big_keyp */
    618         tp = (__uint16_t *)tmpp->page;
     618        tp = (__uint_least16_t *)tmpp->page;
    619619#ifdef DEBUG
    620620        assert(FREESPACE(tp) >= OVFLSIZE);
    621621#endif
    622622        n = tp[0];
    623623        off = OFFSET(tp);
    624624        free_space = FREESPACE(tp);
    625         tp[++n] = (__uint16_t)addr;
     625        tp[++n] = (__uint_least16_t)addr;
    626626        tp[++n] = OVFLPAGE;
    627627        tp[0] = n;
    628628        OFFSET(tp) = off;
     
    638638        ret->newp = np;
    639639        ret->oldp = op;
    640640
    641         tp = (__uint16_t *)big_keyp->page;
     641        tp = (__uint_least16_t *)big_keyp->page;
    642642        big_keyp->flags |= BUF_MOD;
    643643        if (tp[0] > 2) {
    644644                /*
  • newlib/libc/search/hash_buf.c

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/hash_buf.c newlib-1.15.0/newlib/libc/search/hash_buf.c
    old new  
    176176        BUFHEAD *next_xbp;
    177177        SEGMENT segp;
    178178        int segment_ndx;
    179         __uint16_t oaddr, *shortp;
     179        __uint_least16_t oaddr, *shortp;
    180180
    181181        oaddr = 0;
    182182        bp = LRU;
     
    212212                         * Set oaddr before __put_page so that you get it
    213213                         * before bytes are swapped.
    214214                         */
    215                         shortp = (__uint16_t *)bp->page;
     215                        shortp = (__uint_least16_t *)bp->page;
    216216                        if (shortp[0])
    217217                                oaddr = shortp[shortp[0] - 1];
    218218                        if ((bp->flags & BUF_MOD) && __put_page(hashp, bp->page,
     
    255255                                    (oaddr != xbp->addr))
    256256                                        break;
    257257
    258                                 shortp = (__uint16_t *)xbp->page;
     258                                shortp = (__uint_least16_t *)xbp->page;
    259259                                if (shortp[0])
    260260                                        /* set before __put_page */
    261261                                        oaddr = shortp[shortp[0] - 1];
  • newlib/libc/search/hash.c

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/hash.c newlib-1.15.0/newlib/libc/search/hash.c
    old new  
    628628{
    629629        BUFHEAD *rbufp;
    630630        BUFHEAD *bufp, *save_bufp;
    631         __uint16_t *bp;
     631        __uint_least16_t *bp;
    632632        int n, ndx, off, size;
    633633        char *kp;
    634         __uint16_t pageno;
     634        __uint_least16_t pageno;
    635635
    636636#ifdef HASH_STATISTICS
    637637        hash_accesses++;
     
    647647
    648648        /* Pin the bucket chain */
    649649        rbufp->flags |= BUF_PIN;
    650         for (bp = (__uint16_t *)rbufp->page, n = *bp++, ndx = 1; ndx < n;)
     650        for (bp = (__uint_least16_t *)rbufp->page, n = *bp++, ndx = 1; ndx < n;)
    651651                if (bp[1] >= REAL_KEY) {
    652652                        /* Real key/data pair */
    653653                        if (size == off - *bp &&
     
    666666                                return (ERROR);
    667667                        }
    668668                        /* FOR LOOP INIT */
    669                         bp = (__uint16_t *)rbufp->page;
     669                        bp = (__uint_least16_t *)rbufp->page;
    670670                        n = *bp++;
    671671                        ndx = 1;
    672672                        off = hashp->BSIZE;
     
    688688                                        return (ERROR);
    689689                                }
    690690                                /* FOR LOOP INIT */
    691                                 bp = (__uint16_t *)rbufp->page;
     691                                bp = (__uint_least16_t *)rbufp->page;
    692692                                n = *bp++;
    693693                                ndx = 1;
    694694                                off = hashp->BSIZE;
     
    722722                save_bufp->flags &= ~BUF_PIN;
    723723                return (ABNORMAL);
    724724        case HASH_GET:
    725                 bp = (__uint16_t *)rbufp->page;
     725                bp = (__uint_least16_t *)rbufp->page;
    726726                if (bp[ndx + 1] < REAL_KEY) {
    727727                        if (__big_return(hashp, rbufp, ndx, val, 0))
    728728                                return (ERROR);
     
    758758        __uint32_t bucket;
    759759        BUFHEAD *bufp;
    760760        HTAB *hashp;
    761         __uint16_t *bp, ndx;
     761        __uint_least16_t *bp, ndx;
    762762
    763763        hashp = (HTAB *)dbp->internal;
    764764        if (flag && flag != R_FIRST && flag != R_NEXT) {
     
    783783                                if (!bufp)
    784784                                        return (ERROR);
    785785                                hashp->cpage = bufp;
    786                                 bp = (__uint16_t *)bufp->page;
     786                                bp = (__uint_least16_t *)bufp->page;
    787787                                if (bp[0])
    788788                                        break;
    789789                        }
     
    793793                                return (ABNORMAL);
    794794                        }
    795795                } else
    796                         bp = (__uint16_t *)hashp->cpage->page;
     796                        bp = (__uint_least16_t *)hashp->cpage->page;
    797797
    798798#ifdef DEBUG
    799799                assert(bp);
     
    804804                            __get_buf(hashp, bp[hashp->cndx], bufp, 0);
    805805                        if (!bufp)
    806806                                return (ERROR);
    807                         bp = (__uint16_t *)(bufp->page);
     807                        bp = (__uint_least16_t *)(bufp->page);
    808808                        hashp->cndx = 1;
    809809                }
    810810                if (!bp[0]) {
  • newlib/libc/search/hash.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/hash.h newlib-1.15.0/newlib/libc/search/hash.h
    old new  
    102102#define NCACHED 32                      /* number of bit maps and spare
    103103                                         * points */
    104104        int             spares[NCACHED];/* spare pages for overflow */
    105         __uint16_t      bitmaps[NCACHED];       /* address of overflow page
     105        __uint_least16_t        bitmaps[NCACHED];       /* address of overflow page
    106106                                                 * bitmaps */
    107107} HASHHDR;
    108108
  • newlib/libc/search/hash_page.c

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/hash_page.c newlib-1.15.0/newlib/libc/search/hash_page.c
    old new  
    7777static __uint32_t       *fetch_bitmap(HTAB *, int);
    7878static __uint32_t        first_free(__uint32_t);
    7979static int       open_temp(HTAB *);
    80 static __uint16_t        overflow_page(HTAB *);
     80static __uint_least16_t  overflow_page(HTAB *);
    8181static void      putpair(char *, const DBT *, const DBT *);
    82 static void      squeeze_key(__uint16_t *, const DBT *, const DBT *);
     82static void      squeeze_key(__uint_least16_t *, const DBT *, const DBT *);
    8383static int       ugly_split
    8484(HTAB *, __uint32_t, BUFHEAD *, BUFHEAD *, int, int);
    8585
    8686#define PAGE_INIT(P) { \
    87         ((__uint16_t *)(P))[0] = 0; \
    88         ((__uint16_t *)(P))[1] = hashp->BSIZE - 3 * sizeof(__uint16_t); \
    89         ((__uint16_t *)(P))[2] = hashp->BSIZE; \
     87        ((__uint_least16_t *)(P))[0] = 0; \
     88        ((__uint_least16_t *)(P))[1] = hashp->BSIZE - 3 * sizeof(__uint_least16_t); \
     89        ((__uint_least16_t *)(P))[2] = hashp->BSIZE; \
    9090}
    9191
    9292/*
     
    9999        char *p;
    100100        const DBT *key, *val;
    101101{
    102         __uint16_t *bp, n, off;
     102        __uint_least16_t *bp, n, off;
    103103
    104         bp = (__uint16_t *)p;
     104        bp = (__uint_least16_t *)p;
    105105
    106106        /* Enter the key first. */
    107107        n = bp[0];
     
    117117
    118118        /* Adjust page info. */
    119119        bp[0] = n;
    120         bp[n + 1] = off - ((n + 3) * sizeof(__uint16_t));
     120        bp[n + 1] = off - ((n + 3) * sizeof(__uint_least16_t));
    121121        bp[n + 2] = off;
    122122}
    123123
     
    132132        BUFHEAD *bufp;
    133133        int ndx;
    134134{
    135         __uint16_t *bp, newoff;
     135        __uint_least16_t *bp, newoff;
    136136        int n;
    137         __uint16_t pairlen;
     137        __uint_least16_t pairlen;
    138138
    139         bp = (__uint16_t *)bufp->page;
     139        bp = (__uint_least16_t *)bufp->page;
    140140        n = bp[0];
    141141
    142142        if (bp[ndx + 1] < REAL_KEY)
     
    167167        }
    168168        /* Finally adjust the page data */
    169169        bp[n] = OFFSET(bp) + pairlen;
    170         bp[n - 1] = bp[n + 1] + pairlen + 2 * sizeof(__uint16_t);
     170        bp[n - 1] = bp[n + 1] + pairlen + 2 * sizeof(__uint_least16_t);
    171171        bp[0] = n - 2;
    172172        hashp->NKEYS--;
    173173
     
    185185        __uint32_t obucket, nbucket;
    186186{
    187187        BUFHEAD *new_bufp, *old_bufp;
    188         __uint16_t *ino;
     188        __uint_least16_t *ino;
    189189        char *np;
    190190        DBT key, val;
    191191        int n, ndx, retval;
    192         __uint16_t copyto, diff, off, moved;
     192        __uint_least16_t copyto, diff, off, moved;
    193193        char *op;
    194194
    195         copyto = (__uint16_t)hashp->BSIZE;
    196         off = (__uint16_t)hashp->BSIZE;
     195        copyto = (__uint_least16_t)hashp->BSIZE;
     196        off = (__uint_least16_t)hashp->BSIZE;
    197197        old_bufp = __get_buf(hashp, obucket, NULL, 0);
    198198        if (old_bufp == NULL)
    199199                return (-1);
     
    204204        old_bufp->flags |= (BUF_MOD | BUF_PIN);
    205205        new_bufp->flags |= (BUF_MOD | BUF_PIN);
    206206
    207         ino = (__uint16_t *)(op = old_bufp->page);
     207        ino = (__uint_least16_t *)(op = old_bufp->page);
    208208        np = new_bufp->page;
    209209
    210210        moved = 0;
     
    246246
    247247        /* Now clean up the page */
    248248        ino[0] -= moved;
    249         FREESPACE(ino) = copyto - sizeof(__uint16_t) * (ino[0] + 3);
     249        FREESPACE(ino) = copyto - sizeof(__uint_least16_t) * (ino[0] + 3);
    250250        OFFSET(ino) = copyto;
    251251
    252252#ifdef DEBUG3
    253253        (void)fprintf(stderr, "split %d/%d\n",
    254             ((__uint16_t *)np)[0] / 2,
    255             ((__uint16_t *)op)[0] / 2);
     254            ((__uint_least16_t *)np)[0] / 2,
     255            ((__uint_least16_t *)op)[0] / 2);
    256256#endif
    257257        /* unpin both pages */
    258258        old_bufp->flags &= ~BUF_PIN;
     
    284284        int moved;              /* Number of pairs moved to new page. */
    285285{
    286286        BUFHEAD *bufp;          /* Buffer header for ino */
    287         __uint16_t *ino;                /* Page keys come off of */
    288         __uint16_t *np;         /* New page */
    289         __uint16_t *op;         /* Page keys go on to if they aren't moving */
     287        __uint_least16_t *ino;          /* Page keys come off of */
     288        __uint_least16_t *np;           /* New page */
     289        __uint_least16_t *op;           /* Page keys go on to if they aren't moving */
    290290
    291291        BUFHEAD *last_bfp;      /* Last buf header OVFL needing to be freed */
    292292        DBT key, val;
    293293        SPLIT_RETURN ret;
    294         __uint16_t n, off, ov_addr, scopyto;
     294        __uint_least16_t n, off, ov_addr, scopyto;
    295295        char *cino;             /* Character value of ino */
    296296
    297297        bufp = old_bufp;
    298         ino = (__uint16_t *)old_bufp->page;
    299         np = (__uint16_t *)new_bufp->page;
    300         op = (__uint16_t *)old_bufp->page;
     298        ino = (__uint_least16_t *)old_bufp->page;
     299        np = (__uint_least16_t *)new_bufp->page;
     300        op = (__uint_least16_t *)old_bufp->page;
    301301        last_bfp = NULL;
    302         scopyto = (__uint16_t)copyto;   /* ANSI */
     302        scopyto = (__uint_least16_t)copyto;     /* ANSI */
    303303
    304304        n = ino[0] - 1;
    305305        while (n < ino[0]) {
     
    310310                        old_bufp = ret.oldp;
    311311                        if (!old_bufp)
    312312                                return (-1);
    313                         op = (__uint16_t *)old_bufp->page;
     313                        op = (__uint_least16_t *)old_bufp->page;
    314314                        new_bufp = ret.newp;
    315315                        if (!new_bufp)
    316316                                return (-1);
    317                         np = (__uint16_t *)new_bufp->page;
     317                        np = (__uint_least16_t *)new_bufp->page;
    318318                        bufp = ret.nextp;
    319319                        if (!bufp)
    320320                                return (0);
    321321                        cino = (char *)bufp->page;
    322                         ino = (__uint16_t *)cino;
     322                        ino = (__uint_least16_t *)cino;
    323323                        last_bfp = ret.nextp;
    324324                } else if (ino[n + 1] == OVFLPAGE) {
    325325                        ov_addr = ino[n];
     
    329329                         */
    330330                        ino[0] -= (moved + 2);
    331331                        FREESPACE(ino) =
    332                             scopyto - sizeof(__uint16_t) * (ino[0] + 3);
     332                            scopyto - sizeof(__uint_least16_t) * (ino[0] + 3);
    333333                        OFFSET(ino) = scopyto;
    334334
    335335                        bufp = __get_buf(hashp, ov_addr, bufp, 0);
    336336                        if (!bufp)
    337337                                return (-1);
    338338
    339                         ino = (__uint16_t *)bufp->page;
     339                        ino = (__uint_least16_t *)bufp->page;
    340340                        n = 1;
    341341                        scopyto = hashp->BSIZE;
    342342                        moved = 0;
     
    364364                                            __add_ovflpage(hashp, old_bufp);
    365365                                        if (!old_bufp)
    366366                                                return (-1);
    367                                         op = (__uint16_t *)old_bufp->page;
     367                                        op = (__uint_least16_t *)old_bufp->page;
    368368                                        putpair((char *)op, &key, &val);
    369369                                }
    370370                                old_bufp->flags |= BUF_MOD;
     
    377377                                            __add_ovflpage(hashp, new_bufp);
    378378                                        if (!new_bufp)
    379379                                                return (-1);
    380                                         np = (__uint16_t *)new_bufp->page;
     380                                        np = (__uint_least16_t *)new_bufp->page;
    381381                                        putpair((char *)np, &key, &val);
    382382                                }
    383383                                new_bufp->flags |= BUF_MOD;
     
    402402        BUFHEAD *bufp;
    403403        const DBT *key, *val;
    404404{
    405         __uint16_t *bp, *sop;
     405        __uint_least16_t *bp, *sop;
    406406        int do_expand;
    407407
    408         bp = (__uint16_t *)bufp->page;
     408        bp = (__uint_least16_t *)bufp->page;
    409409        do_expand = 0;
    410410        while (bp[0] && (bp[2] < REAL_KEY || bp[bp[0]] < REAL_KEY))
    411411                /* Exception case */
     
    417417                        bufp = __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    418418                        if (!bufp)
    419419                                return (-1);
    420                         bp = (__uint16_t *)bufp->page;
     420                        bp = (__uint_least16_t *)bufp->page;
    421421                } else
    422422                        /* Try to squeeze key on this page */
    423423                        if (FREESPACE(bp) > PAIRSIZE(key, val)) {
     
    427427                                bufp = __get_buf(hashp, bp[bp[0] - 1], bufp, 0);
    428428                                if (!bufp)
    429429                                        return (-1);
    430                                 bp = (__uint16_t *)bufp->page;
     430                                bp = (__uint_least16_t *)bufp->page;
    431431                        }
    432432
    433433        if (PAIRFITS(bp, key, val))
     
    437437                bufp = __add_ovflpage(hashp, bufp);
    438438                if (!bufp)
    439439                        return (-1);
    440                 sop = (__uint16_t *)bufp->page;
     440                sop = (__uint_least16_t *)bufp->page;
    441441
    442442                if (PAIRFITS(sop, key, val))
    443443                        putpair((char *)sop, key, val);
     
    468468        HTAB *hashp;
    469469        BUFHEAD *bufp;
    470470{
    471         __uint16_t *sp;
    472         __uint16_t ndx, ovfl_num;
     471        __uint_least16_t *sp;
     472        __uint_least16_t ndx, ovfl_num;
    473473#ifdef DEBUG1
    474474        int tmp1, tmp2;
    475475#endif
    476         sp = (__uint16_t *)bufp->page;
     476        sp = (__uint_least16_t *)bufp->page;
    477477
    478478        /* Check if we are dynamically determining the fill factor */
    479479        if (hashp->FFACTOR == DEF_FFACTOR) {
     
    525525{
    526526        int fd, page, size;
    527527        int rsize;
    528         __uint16_t *bp;
     528        __uint_least16_t *bp;
    529529
    530530        fd = hashp->fp;
    531531        size = hashp->BSIZE;
     
    541541        if ((lseek(fd, (off_t)page << hashp->BSHIFT, SEEK_SET) == -1) ||
    542542            ((rsize = read(fd, p, size)) == -1))
    543543                return (-1);
    544         bp = (__uint16_t *)p;
     544        bp = (__uint_least16_t *)p;
    545545        if (!rsize)
    546546                bp[0] = 0;      /* We hit the EOF, so initialize a new page */
    547547        else
     
    600600                        for (i = 0; i < max; i++)
    601601                                M_32_SWAP(((int *)p)[i]);
    602602                } else {
    603                         max = ((__uint16_t *)p)[0] + 2;
     603                        max = ((__uint_least16_t *)p)[0] + 2;
    604604                        for (i = 0; i <= max; i++)
    605                                 M_16_SWAP(((__uint16_t *)p)[i]);
     605                                M_16_SWAP(((__uint_least16_t *)p)[i]);
    606606                }
    607607        }
    608608        if (is_bucket)
     
    643643            hashp->BSIZE - clearbytes);
    644644        ip[clearints - 1] = ALL_SET << (nbits & BYTE_MASK);
    645645        SETBIT(ip, 0);
    646         hashp->BITMAPS[ndx] = (__uint16_t)pnum;
     646        hashp->BITMAPS[ndx] = (__uint_least16_t)pnum;
    647647        hashp->mapp[ndx] = ip;
    648648        return (0);
    649649}
     
    663663        return (i);
    664664}
    665665
    666 static __uint16_t
     666static __uint_least16_t
    667667overflow_page(hashp)
    668668        HTAB *hashp;
    669669{
    670670        __uint32_t *freep;
    671671        int max_free, offset, splitnum;
    672         __uint16_t addr;
     672        __uint_least16_t addr;
    673673        int bit, first_page, free_bit, free_page, i, in_use_bits, j;
    674674#ifdef DEBUG2
    675675        int tmp1, tmp2;
     
    816816        HTAB *hashp;
    817817        BUFHEAD *obufp;
    818818{
    819         __uint16_t addr;
     819        __uint_least16_t addr;
    820820        __uint32_t *freep;
    821821        int bit_address, free_page, free_bit;
    822         __uint16_t ndx;
     822        __uint_least16_t ndx;
    823823
    824824        addr = obufp->addr;
    825825#ifdef DEBUG1
    826826        (void)fprintf(stderr, "Freeing %d\n", addr);
    827827#endif
    828         ndx = (((__uint16_t)addr) >> SPLITSHIFT);
     828        ndx = (((__uint_least16_t)addr) >> SPLITSHIFT);
    829829        bit_address =
    830830            (ndx ? hashp->SPARES[ndx - 1] : 0) + (addr & SPLITMASK) - 1;
    831831         if (bit_address < hashp->LAST_FREED)
     
    883883 */
    884884static void
    885885squeeze_key(sp, key, val)
    886         __uint16_t *sp;
     886        __uint_least16_t *sp;
    887887        const DBT *key, *val;
    888888{
    889889        char *p;
    890         __uint16_t free_space, n, off, pageno;
     890        __uint_least16_t free_space, n, off, pageno;
    891891
    892892        p = (char *)sp;
    893893        n = sp[0];
  • newlib/libc/search/page.h

    diff -uNr newlib-1.15.0.orig/newlib/libc/search/page.h newlib-1.15.0/newlib/libc/search/page.h
    old new  
    7474 * You might as well do this up front.
    7575 */
    7676
    77 #define PAIRSIZE(K,D)   (2*sizeof(__uint16_t) + (K)->size + (D)->size)
    78 #define BIGOVERHEAD     (4*sizeof(__uint16_t))
    79 #define KEYSIZE(K)      (4*sizeof(__uint16_t) + (K)->size);
    80 #define OVFLSIZE        (2*sizeof(__uint16_t))
     77#define PAIRSIZE(K,D)   (2*sizeof(__uint_least16_t) + (K)->size + (D)->size)
     78#define BIGOVERHEAD     (4*sizeof(__uint_least16_t))
     79#define KEYSIZE(K)      (4*sizeof(__uint_least16_t) + (K)->size);
     80#define OVFLSIZE        (2*sizeof(__uint_least16_t))
    8181#define FREESPACE(P)    ((P)[(P)[0]+1])
    8282#define OFFSET(P)       ((P)[(P)[0]+2])
    8383#define PAIRFITS(P,K,D) \
    8484        (((P)[2] >= REAL_KEY) && \
    8585            (PAIRSIZE((K),(D)) + OVFLSIZE) <= FREESPACE((P)))
    86 #define PAGE_META(N)    (((N)+3) * sizeof(__uint16_t))
     86#define PAGE_META(N)    (((N)+3) * sizeof(__uint_least16_t))
    8787
    8888typedef struct {
    8989        BUFHEAD *newp;
    9090        BUFHEAD *oldp;
    9191        BUFHEAD *nextp;
    92         __uint16_t next_addr;
     92        __uint_least16_t next_addr;
    9393}       SPLIT_RETURN;
Note: See TracBrowser for help on using the repository browser.