Changeset 32623 in project


Ignore:
Timestamp:
07/29/15 02:22:21 (5 years ago)
Author:
Alexej Magura
Message:

uhhhh...

Location:
release/4/readline/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • release/4/readline/trunk/readline-egg.c

    r32340 r32623  
    4343     } while(0);
    4444
    45 /* *** BEGIN ***
    46  * Conditional Macros *
    47  */
    48 #ifndef INLINE
    49 #if defined __GNUC__
    50 #define INLINE __inline__
    51 #else
    52 #define INLINE inline
    53 #endif
    54 #endif
    55 
    56 #ifndef __GNUC__
    57 #ifndef __attribute__
    58 #define __attribute__(x)
    59 #endif
    60 #endif
    61 
    6245#ifndef DEBUG
    6346#define DEBUG 0
     
    117100 */
    118101
    119 char *memsafe_concat(const char *s1, ...) __attribute__ ((__sentinel__));
    120 
    121 char *memsafe_concat(const char *s1, ...)
    122 {
    123   va_list args;
    124   const char *s;
    125   char *p, *result;
    126   unsigned long l, m, n;
    127 
    128   m = n = strlen(s1);
    129   va_start(args, s1);
    130   while ((s = va_arg(args, char *))) {
    131     l = strlen(s);
    132     if ((m += l) < l) break;
    133   }
    134   va_end(args);
    135   if (s || m >= INT_MAX) return NULL;
    136 
    137   result = (char *)malloc(m + 1);
    138   if (!result) return NULL;
    139 
    140   memcpy(p = result, s1, n);
    141   p += n;
    142   va_start(args, s1);
    143   while ((s = va_arg(args, char *))) {
    144     l = strlen(s);
    145     if ((n += l) < l || n > m) break;
    146     memcpy(p, s, l);
    147     p += l;
    148   }
    149   va_end(args);
    150   if (s || m != n || p != result + n) {
    151     free(result);
    152     return NULL;
    153   }
    154 
    155   *p = 0;
    156   return result;
    157 }
    158 
    159 char *concat (const char *s1, ...)
    160 {
    161      va_list ap;
    162      size_t allocated = 8;
    163      char *result = (char *) malloc (allocated);
    164 
    165      if (result != NULL) {
    166           char *newp;
    167           char *tmp;
    168           const char *s;
    169 
    170           va_start (ap, s1);
    171 
    172           tmp = result;
    173           for (s = s1; s != NULL; s = va_arg (ap, const char *)) {
    174                size_t len = strlen (s);
    175 
    176                /* `s' is too big to fit into `result', resize `result' */
    177                if (tmp + len + 1 > result + allocated) {
    178                     allocated = (allocated + len) * 2;
    179                     newp = (char *) realloc (result, allocated);
    180                     if (newp == NULL) {
    181                          free (result);
    182                          return NULL;
    183                     }
    184                     tmp = newp + (tmp - result);
    185                     result = tmp;
    186                }
    187                tmp = mempcpy (tmp, s, len);
    188           }
    189 
    190           *tmp++ = '\0';
    191 
    192           newp = realloc (result, tmp - result);
    193           if (newp != NULL)
    194                result = newp;
    195 
    196           va_end (ap);
     102static size_t concatl(char *buf, size_t bufsiz, const char *s1, ...)
     103{
     104     va_list args;
     105     const char *s = NULL;
     106     char *p, *tmp;
     107     unsigned long ldx, mdx, ndx;
     108     size_t used = 0;
     109
     110     mdx = ndx = strlen(s1);
     111     va_start(args, s1);
     112     while ((s = va_arg(args, char *))) {
     113          ldx = strlen(s);
     114          if ((mdx += ldx) < ldx) break;
    197115     }
    198      return result;
    199 }
    200 
     116     va_end(args);
     117     if (s || mdx >= INT_MAX) return bufsiz;
     118
     119#if defined(__cplusplus)
     120     tmp = (char *)malloc(mdx + 1);
     121#else
     122     tmp = malloc(mdx + 1);
     123#endif
     124     if (!tmp) return bufsiz;
     125     bzero(tmp, mdx + 1);
     126     bzero(buf, mdx + 1);
     127
     128     p = tmp;
     129     p = mempcpy(p, (char *)s1, ndx);
     130
     131     used += ndx;
     132
     133     va_start(args, s1);
     134     while ((s = va_arg(args, char *))) {
     135          ldx = strlen(s);
     136          if ((ndx += ldx) < ldx || ndx > mdx) break;
     137          p = mempcpy(p, (char *)s, ldx);
     138          used += ldx;
     139     }
     140     va_end(args);
     141     if (s || mdx != ndx || p != tmp + ndx) {
     142          free(tmp);
     143          return bufsiz;
     144     }
     145
     146     *p = '\0';
     147     /* NOTE it's so easy to forget, but in C, arrays start at 0.
     148      * I know it may sound silly to say that I forget this, but I do.
     149      * Because of this, a pointer at position 255 is really at position
     150      * 256, because the pointer's start position is 0; not 1.
     151      * This is why, if you were to assign `*p' like so:
     152      * *++p = '\0'; it would result in an error: because position 256 is
     153      * outside of the malloc'd memory address. */
     154     ++used;
     155
     156     memcpy(buf, tmp, (used > bufsiz ? bufsiz : used));
     157     free(tmp);
     158     return bufsiz - used;
     159}
     160#undef catl
     161#define catl(...) (concatl(__VA_ARGS__, (void *)NULL));
     162
     163static char cpeek(char *wp, char *str, short fwd)
    201164INLINE char peek_chr(char *cp, char *stringp, bool direct)
    202165{
  • release/4/readline/trunk/readline.setup

    r32340 r32623  
    8585    'readline
    8686    '("readline.so" "readline.import.so" "readline-static.o")
    87     `((version           "3.1.1")
     87    `((version           "4.0.0")
    8888      (static            "readline-static.o")
    8989      (static-options    ,rl-extralib)))
Note: See TracChangeset for help on using the changeset viewer.