Changeset 32660 in project


Ignore:
Timestamp:
08/08/15 01:51:51 (5 years ago)
Author:
Alexej Magura
Message:

updates for chicken 4.10

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

Legend:

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

    r32623 r32660  
    5555  } while(0)
    5656
     57#  define RKG_DBG(format, ...)                                  \
     58     do {                                                       \
     59          fprintf(stderr, "## (%s)(%s)%d\n",                    \
     60                  COM_PROGNAME, __FILE__, __LINE__);            \
     61          fprintf(stderr, "#  `%s'\n", __FUNCTION__);           \
     62          fprintf(stderr, (format), ##__VA_ARGS__);             \
     63          fprintf(stderr, "\n");                                \
     64     } while(0)
     65
    5766#define RL_EGG_BEGIN_TRACE fprintf(stderr, "++ %s{%d}:\n\n", __FILE__, __LINE__)
    5867#define RL_EGG_END_TRACE fprintf(stderr, "\n-- %s %s `%s'\n\n", "In", "function", __FUNCTION__)
     
    6473  } while(0)
    6574#else
     75#define RKG_DBG(format, ...)
    6676#define RL_EGG_STACK(format, ...)
    6777#define RL_EGG_BEGIN_TRACE
     
    100110 */
    101111
    102 static size_t concatl(char *buf, size_t bufsiz, const char *s1, ...)
     112static char *concat(const char *s1, ...)
     113{
     114        va_list args;
     115        const char *s;
     116        char *p, *result;
     117        unsigned long l, m, n;
     118
     119        m = n = strlen(s1);
     120        va_start(args, s1);
     121        while ((s = va_arg(args, char *))) {
     122                l = strlen(s);
     123                if ((m += l) < l) break;
     124        }
     125        va_end(args);
     126        if (s || m >= INT_MAX) return NULL;
     127
     128#if defined(__cplusplus)
     129        result = (char *)malloc(m + 1);
     130#else
     131        result = malloc(m + 1);
     132#endif
     133        if (!result) return NULL;
     134
     135        memcpy(p = result, s1, n);
     136        p += n;
     137        va_start(args, s1);
     138        while ((s = va_arg(args, char *))) {
     139                l = strlen(s);
     140                if ((n += l) < l || n > m) break;
     141                memcpy(p, s, l);
     142                p += l;
     143        }
     144        va_end(args);
     145        if (s || m != n || p != result + n) {
     146                free(result);
     147                return NULL;
     148        }
     149
     150        *p = '\0';
     151        return result;
     152}
     153
     154/* unlike `concat', which returns a
     155 * new pointer that must then be copied
     156 * or acted upon in some meaningfully meaningless
     157 * manner, `catl' returns the number of bytes belonging
     158 * to `buf', which could _NOT_ be filled, always copying
     159 * no more than `bufsiz` of data into `buf'
     160 *
     161 * If the return value is an integral value, which
     162 * we'll call `y', that is less than 0,
     163 * then the resulting catenation has been truncated by `!y'
     164 * many bytes.  Similarlly, if a positive value is returned:
     165 * `y' many bytes is how much of `buf', which was _NOT_ used.
     166 *
     167 * XXX A failure is indicated by a return value _equal to
     168 * the destination buffers size_, which may make errors somewhat
     169 * harder to spot! */
     170static size_t concatl(char *dst, size_t sz, const char *s1, ...)
    103171{
    104172     va_list args;
     
    111179     va_start(args, s1);
    112180     while ((s = va_arg(args, char *))) {
    113           ldx = strlen(s);
    114           if ((mdx += ldx) < ldx) break;
     181          ldx = strlen(s);
     182          if ((mdx += ldx) < ldx) break;
    115183     }
    116184     va_end(args);
    117      if (s || mdx >= INT_MAX) return bufsiz;
     185     if (s || mdx >= INT_MAX) return sz;
    118186
    119187#if defined(__cplusplus)
     
    122190     tmp = malloc(mdx + 1);
    123191#endif
    124      if (!tmp) return bufsiz;
     192     if (!tmp) return sz;
    125193     bzero(tmp, mdx + 1);
    126      bzero(buf, mdx + 1);
     194     bzero(dst, mdx + 1);
    127195
    128196     p = tmp;
     
    130198
    131199     used += ndx;
     200     RKG_DBG("p: `%s`\n", p);
     201     RKG_DBG("used: %lu\n", used - 0);
    132202
    133203     va_start(args, s1);
    134204     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;
     205          ldx = strlen(s);
     206          if ((ndx += ldx) < ldx || ndx > mdx) break;
     207          p = mempcpy(p, (char *)s, ldx);
     208          used += ldx;
    139209     }
    140210     va_end(args);
    141211     if (s || mdx != ndx || p != tmp + ndx) {
    142           free(tmp);
    143           return bufsiz;
    144      }
    145 
     212          free(tmp);
     213          return sz;
     214     }
     215
     216     RKG_DBG("tmp: `%s'\n", tmp);
     217     p = mempcpy(dst, tmp, (used > sz ? sz : used));
     218     free(tmp);
    146219     *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. */
    154220     ++used;
    155221
    156      memcpy(buf, tmp, (used > bufsiz ? bufsiz : used));
     222     RKG_DBG("dst: `%s'\n", dst);
     223     RKG_DBG("*p: `%c'\n", *p);
     224     RKG_DBG("*--p: `%c'\n", cpeek(p, dst, 0));
     225     RKG_DBG("strlen(dst): %lu\n", strlen(dst));
     226     RKG_DBG("used#2: %lu\n", used - 0);
     227
     228     return (used > sz ? 0 : sz - used);
     229}
     230
     231/* concatm is a little different:
     232 * unlike `concatl' or `concat', concatm _moves_ memory: that is, the destination
     233 * pointer can be passed as an argument. */
     234static size_t concatm(char *dst, size_t sz, const char *s1, ...)
     235{
     236     va_list args;
     237     const char *s = NULL;
     238     char *p, *tmp;
     239     unsigned long ldx, mdx, ndx;
     240     size_t used = 0;
     241
     242     mdx = ndx = strlen(s1);
     243     va_start(args, s1);
     244     while ((s = va_arg(args, char *))) {
     245          ldx = strlen(s);
     246          if ((mdx += ldx) < ldx) break;
     247     }
     248     va_end(args);
     249     if (s || mdx >= INT_MAX) return sz;
     250
     251#if defined(__cplusplus)
     252     tmp = (char *)malloc(mdx + 1);
     253#else
     254     tmp = malloc(mdx + 1);
     255#endif
     256     if (!tmp) return sz;
     257     bzero(tmp, mdx + 1);
     258
     259     p = tmp;
     260     p = mempcpy(p, (char *)s1, ndx);
     261
     262     used += ndx;
     263     RKG_DBG("p: `%s`\n", p);
     264     RKG_DBG("used: %lu\n", used - 0);
     265
     266     va_start(args, s1);
     267     while ((s = va_arg(args, char *))) {
     268          ldx = strlen(s);
     269          if ((ndx += ldx) < ldx || ndx > mdx) break;
     270          p = mempcpy(p, (char *)s, ldx);
     271          used += ldx;
     272     }
     273     va_end(args);
     274     if (s || mdx != ndx || p != tmp + ndx) {
     275          free(tmp);
     276          return sz;
     277     }
     278     RKG_DBG("tmp: `%s'\n", tmp);
     279#if defined(mempmove) && 0
     280     p = mempmove(dst, tmp, (used > sz ? sz : used));
     281#else
     282     memmove(dst, tmp, (used > sz ? sz : used));
     283     p = &dst[(used > sz ? sz : used)];
     284#endif
    157285     free(tmp);
    158      return bufsiz - used;
    159 }
    160 #undef catl
    161 #define catl(...) (concatl(__VA_ARGS__, (void *)NULL));
    162 
    163 static char cpeek(char *wp, char *str, short fwd)
    164 INLINE char peek_chr(char *cp, char *stringp, bool direct)
    165 {
    166     if (direct) {
    167     char next = '\0';
    168     if (cp != &stringp[strlen(stringp) - 1]) {
    169       next = *(++cp);
    170       --cp;
    171     } else {
    172       next = *cp;
    173     }
    174     return next;
    175   } else {
    176     char prev = '\0';
    177     if (cp != stringp) {
    178       prev = *(--cp);
    179       ++cp;
    180     } else {
    181       prev = *cp;
    182     }
    183     return prev;
    184   }
    185 }
    186 
    187 INLINE int strnof_delim(char *str, char odelim, char cdelim, int count[2])
     286     *p = '\0';
     287     ++used;
     288
     289     RKG_DBG("dst: `%s'\n", dst);
     290     RKG_DBG("*p: `%c'\n", *p);
     291     RKG_DBG("*--p: `%c'\n", cpeek(p, dst, 0));
     292     RKG_DBG("strlen(dst): %lu\n", strlen(dst));
     293     RKG_DBG("used#2: %lu\n", used - 0);
     294
     295     return (used > sz ? 0 : sz - used);
     296}
     297
     298# define cat(...) (concat(__VA_ARGS__, (void *)NULL))
     299# define catl(...) (concatl(__VA_ARGS__, (void *)NULL))
     300# define catm(...) (concatm(__VA_ARGS__, (void *)NULL))
     301
     302
     303static char cpeek(const char *c, const char *s, const short fwd)
     304{
     305     if (fwd > 0) {
     306          if (*c == '\0'
     307# if defined(_GNU_SOURCE)
     308              || c == strchr(s, '\0') - 1
     309# else
     310              || c == &s[strlen(s)]
     311# endif
     312               )
     313               return *c;
     314          else
     315               return *(c + 1);
     316     }
     317     return (c == s) ? *c : *(c - 1);
     318}
     319
     320# if 0
     321static int strnof_delim(char *str, char odelim, char cdelim, int count[2])
    188322{
    189323  memset(count, 0, sizeof(*count)*2);
     
    197331
    198332  do {
    199     if (cp != str && peek_chr(cp, str, false) == '\\')
     333    if (cp != str && cpeek(cp, str, false) == '\\')
    200334      continue;
    201335
     
    221355  return 0;
    222356}
    223 
    224 INLINE char *str_unquotd(char *str)
    225 {
    226   //RL_EGG_BEGIN_TRACE;
    227   //RL_EGG_DEBUG("str: `%s'\n", str);
    228   //RL_EGG_END_TRACE;
    229 
    230   char *buf = "";
    231   char *nbuf = "";
    232   int count[2];
    233   strnof_delim(str, '"', '"', count);
    234   //RL_EGG_DEBUG("idx[0]: %d\n", count[0]);
    235   //RL_EGG_DEBUG("idx[1]: %d\n", count[1]);
    236 
    237   if (count[0] == 0)
    238     return str;
    239   int even = count[0] - abs(count[0] - count[1]);
    240   char *token, *tmp, *rest;
    241   bool need_free = true;
    242   token = NULL;
    243   rest = NULL;
    244   tmp = strdupa(str);
    245 
    246   if (tmp == NULL) {
    247 #if DEBUG
    248     perror(__FUNCTION__);
    249 #endif
    250     return NULL;
    251   }
    252 
    253   token = strtok_r(tmp, "\"", &rest);
    254   if (token == NULL)
    255     return str;
    256   //RL_EGG_DEBUG("token: %s\n", token);
    257   buf = memsafe_concat(buf, token, NULL);
    258 
    259   while ((token = strtok_r(NULL, "\"", &rest)) != NULL) {
    260     //RL_EGG_DEBUG("token (while): %s\n", token);
    261     //RL_EGG_DEBUG("even (while): %d\n", even);
    262     if (even % 2 == 1) {
    263       if (need_free) {
    264         nbuf = memsafe_concat(buf, token, NULL);
    265         free(buf);
    266         need_free = false;
    267       } else {
    268         buf = memsafe_concat(nbuf, token, NULL);
    269         free(nbuf);
    270         need_free = true;
    271       }
    272       --even;
    273     } else {
    274       ++even;
    275     }
    276   }
    277   return buf;
    278 }
    279 
    280 INLINE void clear_parbar(char token)
     357# endif
     358
     359static int *strndelim(const char *s, const char od, const char cd, int count[2])
     360{
     361     memset(count, 0, sizeof(*count)*2);
     362     char *c = strchr(s, '\0');
     363
     364     if (c == s)
     365          return NULL;
     366
     367     do {
     368          if (c != s && cpeek(c, s, 0) == '\\')
     369               continue;
     370          if (*c == cd)
     371               ++count[1];
     372          else if (*c == od)
     373               ++count[0];
     374     } while (c-- != s);
     375
     376     if (od == cd && count[1] > 0) {
     377          if (count[1] % 2 == 1)
     378               while (count[0]++ < --count[1]);
     379          else {
     380               count[0] = count[1] * 0.5;
     381               count[1] *= 0.5;
     382          }
     383     }
     384
     385     return count;
     386}
     387static char *strwodqp(const char *src)
     388{
     389     size_t n = strlen(src) + 1;
     390     int c[2] = {0, 0}, even = 0;
     391     char *tmp, *token, *rest, *newp;
     392     tmp = token = rest = newp = NULL;
     393
     394     if (!strndelim(src, '"', '"', c))
     395          return NULL;
     396
     397     if (c[0] == 0)
     398          return NULL;
     399
     400     tmp = strdup(src);
     401     newp = malloc(n);
     402     even = c[0] - abs(c[0] - c[1]);
     403
     404     token = strtok_r(tmp, "\"", &rest);
     405
     406     if (token == NULL) {
     407          free(newp);
     408          return NULL;
     409     }
     410
     411     catl(newp, n, token);
     412     while ((token = strtok_r(NULL, "\"", &rest)) != NULL) {
     413          if (even % 2 == 1) {
     414               catm(newp, n, newp, token);
     415               --even;
     416          } else {
     417               ++even;
     418          }
     419     }
     420
     421     free(tmp);
     422     return newp;
     423}
     424
     425static void clear_parbar(char token)
    281426{
    282427  int idx = 0;
     
    289434}
    290435
    291 INLINE int parbar_in_string(char *str, char add_token)
     436static int parbar_in_string(char *str, char add_token)
    292437{
    293438  int *idxp = NULL;
     
    307452
    308453  do {
    309     if (cp != str && peek_chr(cp, str, false) == '\\')
     454    if (cp != str && cpeek(cp, str, false) == '\\')
    310455      continue;
    311456
     
    326471}
    327472
    328 INLINE int quote_in_string(char *str)
     473static int quote_in_string(char *str)
    329474{
    330475  if (str == NULL)
     
    337482
    338483  do {
    339     if (cp != str && peek_chr(cp, str, false) == '\\')
     484    if (cp != str && cpeek(cp, str, false) == '\\')
    340485      continue;
    341486
     
    661806{
    662807     char *text = (add_eol
    663                    ? memsafe_concat(last_history_line(del_current, script), "\n", NULL)
     808                   ? cat(last_history_line(del_current, script), "\n", NULL)
    664809                   : last_history_line(del_current, script));
    665810     if (text != NULL) {
     
    708853  if (hist_list == NULL)
    709854    return NULL;
    710   list_0 = memsafe_concat("", hist_list[0]->line, "\n", NULL);
     855  list_0 = cat("", hist_list[0]->line, "\n", NULL);
    711856  RL_EGG_DEBUG("buf@%d: %s\n", __LINE__, list_0);
    712857
    713858  for (idx = 1; idx < history_length; ++idx) {
    714859    if (need_free) {
    715       list_1 = memsafe_concat(list_0, hist_list[idx]->line, "\n", NULL);
     860      list_1 = concat(list_0, hist_list[idx]->line, "\n", NULL);
    716861      free(list_0);
    717862      need_free = false;
    718863    } else {
    719       list_0 = memsafe_concat(list_1, hist_list[idx]->line, "\n", NULL);
     864      list_0 = concat(list_1, hist_list[idx]->line, "\n", NULL);
    720865      free(list_1);
    721866      need_free = true;
  • release/4/readline/trunk/readline.scm

    r32340 r32660  
    122122#>
    123123#include "readline-egg.c"
     124
     125C_regparm C_word C_enumerate_symbols(C_SYMBOL_TABLE *stable, C_word pos)
     126{
     127  int i;
     128  C_word
     129    sym,
     130    bucket = C_u_i_car(pos);
     131
     132  if(!C_truep(bucket)) return C_SCHEME_FALSE; /* end already reached */
     133  else i = C_unfix(bucket);
     134
     135  bucket = C_u_i_cdr(pos);
     136
     137  while(bucket == C_SCHEME_END_OF_LIST) {
     138    if(++i >= stable->size) {
     139      C_set_block_item(pos, 0, C_SCHEME_FALSE);        /* no more buckets */
     140      return C_SCHEME_FALSE;
     141    }
     142    else bucket = stable->table[ i ];
     143  }
     144
     145  sym = C_block_item(bucket, 0);
     146  C_set_block_item(pos, 0, C_fix(i));
     147  C_mutate2(&C_u_i_cdr(pos), C_block_item(bucket, 1));
     148  return sym;
     149}
     150
    124151<#
    125152
     
    162189                  #:record-history #t
    163190                  #:verify-history-expansions #f))
    164 (define version "3.1")
     191(define version "4.1.0")
    165192#|/////////////////////////////////|#
    166193;;;; Private Variables
     
    636663(toplevel-command 'rl-emacs (lambda ()
    637664                              (readline#parse-and-bind "set editing-mode emacs")))
    638 
    639665; TODO add rl-history-grep
    640666;(toplevel-command 'rl-hgrp
  • release/4/readline/trunk/readline.setup

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