Changeset 903 for trunk/src/gmakenew/function.c

Timestamp:

May 23, 2007, 7:31:19 AM (18 years ago)

Author:

bird

Message:

Merged with the 2007-05-23 CVS. Added rsort and fixed a couple of windows build issues.

File:

• trunk/src/gmakenew/function.c (modified) (79 diffs)

trunk/src/gmakenew/function.c

@@ -53 +53 @@
     unsigned char maximum_args;
     char expand_args;
-    char *(*func_ptr) PARAMS ((char *output, char **argv, const char *fname));
+    char *(*func_ptr) (char *output, char **argv, const char *fname);
   };
 
@@ -59 +59 @@
 function_table_entry_hash_1 (const void *keyv)
 {
-  struct function_table_entry const *key = (struct function_table_entry const *) keyv;
+  const struct function_table_entry *key = keyv;
   return_STRING_N_HASH_1 (key->name, key->len);
 }
@@ -66 +66 @@
 function_table_entry_hash_2 (const void *keyv)
 {
-  struct function_table_entry const *key = (struct function_table_entry const *) keyv;
+  const struct function_table_entry *key = keyv;
   return_STRING_N_HASH_2 (key->name, key->len);
 }
@@ -73 +73 @@
 function_table_entry_hash_cmp (const void *xv, const void *yv)
 {
-  struct function_table_entry const *x = (struct function_table_entry const *) xv;
-  struct function_table_entry const *y = (struct function_table_entry const *) yv;
+  const struct function_table_entry *x = xv;
+  const struct function_table_entry *y = yv;
   int result = x->len - y->len;
   if (result)
@@ -92 +92 @@
 
 char *
-subst_expand (char *o, char *text, char *subst, char *replace,
+subst_expand (char *o, const char *text, const char *subst, const char *replace,
               unsigned int slen, unsigned int rlen, int by_word)
 {
-  char *t = text;
-  char *p;
+  const char *t = text;
+  const char *p;
 
   if (slen == 0 && !by_word)
@@ -141 +141 @@
 
       /* Advance T past the string to be replaced.  */
-      {
-        char *nt = p + slen;
-        t = nt;
-      }
+      t = p + slen;
     } while (*t != '\0');
 
@@ -163 +160 @@
 
 char *
-patsubst_expand (char *o, char *text, char *pattern, char *replace,
-                 char *pattern_percent, char *replace_percent)
+patsubst_expand_pat (char *o, const char *text,
+                     const char *pattern, const char *replace,
+                     const char *pattern_percent, const char *replace_percent)
 {
   unsigned int pattern_prepercent_len, pattern_postpercent_len;
   unsigned int replace_prepercent_len, replace_postpercent_len;
-  char *t;
+  const char *t;
   unsigned int len;
   int doneany = 0;
-
-  /* We call find_percent on REPLACE before checking PATTERN so that REPLACE
-     will be collapsed before we call subst_expand if PATTERN has no %.  */
-  if (!replace_percent)
-    {
-      replace_percent = find_percent (replace);
-      if (replace_percent)
-        ++replace_percent;
-    }
 
   /* Record the length of REPLACE before and after the % so we don't have to
@@ -194 +183 @@
     }
 
-  if (!pattern_percent)
-    {
-      pattern_percent = find_percent (pattern);
-      if (pattern_percent)
-        ++pattern_percent;
-    }
   if (!pattern_percent)
     /* With no % in the pattern, this is just a simple substitution.  */
@@ -271 +254 @@
 }
 
+/* Store into VARIABLE_BUFFER at O the result of scanning TEXT
+   and replacing strings matching PATTERN with REPLACE.
+   If PATTERN_PERCENT is not nil, PATTERN has already been
+   run through find_percent, and PATTERN_PERCENT is the result.
+   If REPLACE_PERCENT is not nil, REPLACE has already been
+   run through find_percent, and REPLACE_PERCENT is the result.
+   Note that we expect PATTERN_PERCENT and REPLACE_PERCENT to point to the
+   character _AFTER_ the %, not to the % itself.
+*/
+
+char *
+patsubst_expand (char *o, const char *text, char *pattern, char *replace)
+{
+  const char *pattern_percent = find_percent (pattern);
+  const char *replace_percent = find_percent (replace);
+
+  /* If there's a percent in the pattern or replacement skip it.  */
+  if (replace_percent)
+    ++replace_percent;
+  if (pattern_percent)
+    ++pattern_percent;
+
+  return patsubst_expand_pat (o, text, pattern, replace,
+                              pattern_percent, replace_percent);
+}
+
 
 #ifdef CONFIG_WITH_OPTIMIZATION_HACKS
@@ -276 +285 @@
    it can't be function and we can skip the hash lookup drop out. */
 
-#ifdef KMK
-# define MAX_FUNCTION_LENGTH 12
-#else
-# define MAX_FUNCTION_LENGTH 10
-#endif
+# ifdef KMK
+#  define MAX_FUNCTION_LENGTH 12
+# else
+#  define MAX_FUNCTION_LENGTH 10
+# endif
+#endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
 
 /* Look up a function by name.  */
+
+#ifdef CONFIG_WITH_OPTIMIZATION_HACKS
 __inline
 #endif /* CONFIG_WITH_OPTIMIZATION_HACKS */
@@ -318 +330 @@
 
 int
-pattern_matches (char *pattern, char *percent, char *str)
+pattern_matches (const char *pattern, const char *percent, const char *str)
 {
   unsigned int sfxlen, strlength;
@@ -325 +337 @@
     {
       unsigned int len = strlen (pattern) + 1;
-      char *new_chars = (char *) alloca (len);
-      bcopy (pattern, new_chars, len);
+      char *new_chars = alloca (len);
+      memcpy (new_chars, pattern, len);
+      percent = find_percent (new_chars);
+      if (percent == 0)
+        return streq (new_chars, str);
       pattern = new_chars;
-      percent = find_percent (pattern);
-      if (percent == 0)
-        return streq (pattern, str);
     }
 
@@ -386 +398 @@
   static char *result = 0;
   static unsigned int length;
-  register struct nameseq *chain;
-  register unsigned int idx;
+  struct nameseq *chain;
+  unsigned int idx;
 
   chain = multi_glob (parse_file_seq
@@ -400 +412 @@
     {
       length = 100;
-      result = (char *) xmalloc (100);
+      result = xmalloc (100);
     }
 
@@ -406 +418 @@
   while (chain != 0)
     {
-      register char *name = chain->name;
+      const char *name = chain->name;
       unsigned int len = strlen (name);
 
       struct nameseq *next = chain->next;
-      free ((char *) chain);
+      free (chain);
       chain = next;
 
@@ -420 +432 @@
             {
               length += (len + 1) * 2;
-              result = (char *) xrealloc (result, length);
+              result = xrealloc (result, length);
             }
-          bcopy (name, &result[idx], len);
+          memcpy (&result[idx], name, len);
           idx += len;
           result[idx++] = ' ';
         }
-
-      free (name);
     }
 
@@ -447 +457 @@
 func_patsubst (char *o, char **argv, const char *funcname UNUSED)
 {
-  o = patsubst_expand (o, argv[2], argv[0], argv[1], (char *) 0, (char *) 0);
+  o = patsubst_expand (o, argv[2], argv[0], argv[1]);
   return o;
 }
@@ -461 +471 @@
      If the two arguments have a different number of words,
      the excess words are just output separated by blanks.  */
-  register char *tp;
-  register char *pp;
-  char *list1_iterator = argv[0];
-  char *list2_iterator = argv[1];
+  const char *tp;
+  const char *pp;
+  const char *list1_iterator = argv[0];
+  const char *list2_iterator = argv[1];
   do
     {
@@ -496 +506 @@
 {
   /* Expand the argument.  */
-  register struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
+  struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
   if (v == 0)
     o = variable_buffer_output (o, "undefined", 9);
@@ -535 +545 @@
 func_flavor (char *o, char **argv, const char *funcname UNUSED)
 {
-  register struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
+  struct variable *v = lookup_variable (argv[0], strlen (argv[0]));
 
   if (v == 0)
@@ -563 +573 @@
 {
   /* Expand the argument.  */
-  char *list_iterator = argv[0];
-  char *p2 =0;
+  const char *list_iterator = argv[0];
+  const char *p2;
   int doneany =0;
   unsigned int len=0;
@@ -572 +582 @@
   while ((p2 = find_next_token (&list_iterator, &len)) != 0)
     {
-      char *p = p2 + len;
+      const char *p = p2 + len;
 
 
@@ -607 +617 @@
         }
     }
+
   if (doneany)
     /* Kill last space.  */
     --o;
 
-
-  return o;
-
+  return o;
 }
 
@@ -621 +630 @@
 {
   /* Expand the argument.  */
-  char *p3 = argv[0];
-  char *p2=0;
+  const char *p3 = argv[0];
+  const char *p2;
   int doneany=0;
   unsigned int len=0;
-  char *p=0;
+
   int is_basename= streq (funcname, "basename");
   int is_dir= !is_basename;
 
   while ((p2 = find_next_token (&p3, &len)) != 0)
-        {
-          p = p2 + len;
-          while (p >= p2 && (!is_basename  || *p != '.'))
-            {
-              if (IS_PATHSEP (*p))
-                break;
-                    --p;
-            }
-
-          if (p >= p2 && (is_dir))
-            o = variable_buffer_output (o, p2, ++p - p2);
-          else if (p >= p2 && (*p == '.'))
-            o = variable_buffer_output (o, p2, p - p2);
+    {
+      const char *p = p2 + len;
+      while (p >= p2 && (!is_basename  || *p != '.'))
+        {
+          if (IS_PATHSEP (*p))
+            break;
+          --p;
+        }
+
+      if (p >= p2 && (is_dir))
+        o = variable_buffer_output (o, p2, ++p - p2);
+      else if (p >= p2 && (*p == '.'))
+        o = variable_buffer_output (o, p2, p - p2);
 #ifdef HAVE_DOS_PATHS
-        /* Handle the "d:foobar" case */
-          else if (p2[0] && p2[1] == ':' && is_dir)
-            o = variable_buffer_output (o, p2, 2);
-#endif
-          else if (is_dir)
+      /* Handle the "d:foobar" case */
+      else if (p2[0] && p2[1] == ':' && is_dir)
+        o = variable_buffer_output (o, p2, 2);
+#endif
+      else if (is_dir)
 #ifdef VMS
-            o = variable_buffer_output (o, "[]", 2);
+        o = variable_buffer_output (o, "[]", 2);
 #else
 #ifndef _AMIGA
-            o = variable_buffer_output (o, "./", 2);
+      o = variable_buffer_output (o, "./", 2);
 #else
-            ; /* Just a nop...  */
+      ; /* Just a nop...  */
 #endif /* AMIGA */
 #endif /* !VMS */
-          else
-            /* The entire name is the basename.  */
-            o = variable_buffer_output (o, p2, len);
-
-          o = variable_buffer_output (o, " ", 1);
-          doneany = 1;
-        }
-      if (doneany)
-        /* Kill last space.  */
-        --o;
-
-
- return o;
+      else
+        /* The entire name is the basename.  */
+        o = variable_buffer_output (o, p2, len);
+
+      o = variable_buffer_output (o, " ", 1);
+      doneany = 1;
+    }
+
+  if (doneany)
+    /* Kill last space.  */
+    --o;
+
+  return o;
 }
 
@@ -677 +686 @@
 {
   int fixlen = strlen (argv[0]);
-  char *list_iterator = argv[1];
+  const char *list_iterator = argv[1];
   int is_addprefix = streq (funcname, "addprefix");
   int is_addsuffix = !is_addprefix;
 
   int doneany = 0;
-  char *p;
+  const char *p;
   unsigned int len;
 
@@ -717 +726 @@
 {
   unsigned int i;
-  char *words = argv[0];    /* Use a temp variable for find_next_token */
-  char *p = find_next_token (&words, &i);
+  const char *words = argv[0];    /* Use a temp variable for find_next_token */
+  const char *p = find_next_token (&words, &i);
 
   if (p != 0)
@@ -730 +739 @@
 {
   unsigned int i;
-  char *words = argv[0];    /* Use a temp variable for find_next_token */
-  char *p = 0;
-  char *t;
+  const char *words = argv[0];    /* Use a temp variable for find_next_token */
+  const char *p = NULL;
+  const char *t;
 
   while ((t = find_next_token (&words, &i)))
@@ -747 +756 @@
 {
   int i = 0;
-  char *word_iterator = argv[0];
+  const char *word_iterator = argv[0];
   char buf[20];
 
@@ -755 +764 @@
   sprintf (buf, "%d", i);
   o = variable_buffer_output (o, buf, strlen (buf));
-
 
   return o;
@@ -776 +784 @@
 
 static void
-check_numeric (const char *s, const char *message)
+check_numeric (const char *s, const char *msg)
 {
   const char *end = s + strlen (s) - 1;
@@ -787 +795 @@
 
   if (s <= end || end - beg < 0)
-    fatal (*expanding_var, "%s: '%s'", message, beg);
+    fatal (*expanding_var, "%s: '%s'", msg, beg);
 }
 
@@ -795 +803 @@
 func_word (char *o, char **argv, const char *funcname UNUSED)
 {
-  char *end_p=0;
-  int i=0;
-  char *p=0;
+  const char *end_p;
+  const char *p;
+  int i;
 
   /* Check the first argument.  */
   check_numeric (argv[0], _("non-numeric first argument to `word' function"));
-  i =  atoi (argv[0]);
+  i = atoi (argv[0]);
 
   if (i == 0)
     fatal (*expanding_var,
            _("first argument to `word' function must be greater than 0"));
-
 
   end_p = argv[1];
@@ -839 +846 @@
   if (count > 0)
     {
-      char *p;
-      char *end_p = argv[2];
+      const char *p;
+      const char *end_p = argv[2];
 
       /* Find the beginning of the "start"th word.  */
@@ -860 +867 @@
 }
 
-static char*
+static char *
 func_findstring (char *o, char **argv, const char *funcname UNUSED)
 {
@@ -876 +883 @@
   char *varname = expand_argument (argv[0], NULL);
   char *list = expand_argument (argv[1], NULL);
-  char *body = argv[2];
+  const char *body = argv[2];
 
   int doneany = 0;
-  char *list_iterator = list;
-  char *p;
+  const char *list_iterator = list;
+  const char *p;
   unsigned int len;
-  register struct variable *var;
+  struct variable *var;
 
   push_new_variable_scope ();
@@ -902 +909 @@
       var->value_length = len;
 #else
-      {
-        char save = p[len];
-
-        p[len] = '\0';
-        free (var->value);
-        var->value = (char *) xstrdup ((char*) p);
-        p[len] = save;
-      }
+      free (var->value);
+      var->value = savestring (p, len);
 #endif
 
@@ -983 +984 @@
   struct hash_table a_word_table;
   int is_filter = streq (funcname, "filter");
-  char *pat_iterator = argv[0];
-  char *word_iterator = argv[1];
+  const char *pat_iterator = argv[0];
+  const char *word_iterator = argv[1];
   int literals = 0;
   int words = 0;
@@ -996 +997 @@
   while ((p = find_next_token (&pat_iterator, &len)) != 0)
     {
-      struct a_pattern *pat = (struct a_pattern *) alloca (sizeof (struct a_pattern));
+      struct a_pattern *pat = alloca (sizeof (struct a_pattern));
 
       *pattail = pat;
@@ -1019 +1020 @@
   while ((p = find_next_token (&word_iterator, &len)) != 0)
     {
-      struct a_word *word = (struct a_word *) alloca (sizeof (struct a_word));
+      struct a_word *word = alloca (sizeof (struct a_word));
 
       *wordtail = word;
@@ -1040 +1041 @@
   if (hashing)
     {
-      hash_init (&a_word_table, words, a_word_hash_1, a_word_hash_2, a_word_hash_cmp);
+      hash_init (&a_word_table, words, a_word_hash_1, a_word_hash_2,
+                 a_word_hash_cmp);
       for (wp = wordhead; wp != 0; wp = wp->next)
         {
@@ -1064 +1066 @@
               a_word_key.str = pp->str;
               a_word_key.length = pp->length;
-              wp = (struct a_word *) hash_find_item (&a_word_table, &a_word_key);
+              wp = hash_find_item (&a_word_table, &a_word_key);
               while (wp)
                 {
@@ -1104 +1106 @@
 func_strip (char *o, char **argv, const char *funcname UNUSED)
 {
-  char *p = argv[0];
-  int doneany =0;
+  const char *p = argv[0];
+  int doneany = 0;
 
   while (*p != '\0')
     {
       int i=0;
-      char *word_start=0;
+      const char *word_start;
 
       while (isspace ((unsigned char)*p))
@@ -1127 +1129 @@
     /* Kill the last space.  */
     --o;
+
   return o;
 }
@@ -1146 +1149 @@
     len += strlen (*argvp) + 2;
 
-  p = msg = (char *) alloca (len + 1);
+  p = msg = alloca (len + 1);
 
   for (argvp=argv; argvp[1] != 0; ++argvp)
@@ -1185 +1188 @@
 func_sort (char *o, char **argv, const char *funcname UNUSED)
 {
-  char **words = 0;
-  int nwords = 0;
-  register int wordi = 0;
-
-  /* Chop ARGV[0] into words and put them in WORDS.  */
-  char *t = argv[0];
+  const char *t;
+  char **words;
+  int wordi;
   char *p;
   unsigned int len;
   int i;
 
+  /* Find the maximum number of words we'll have.  */
+  t = argv[0];
+  wordi = 1;
+  while (*t != '\0')
+    {
+      char c = *(t++);
+
+      if (! isspace ((unsigned char)c))
+        continue;
+
+      ++wordi;
+
+      while (isspace ((unsigned char)*t))
+        ++t;
+    }
+
+  words = xmalloc (wordi * sizeof (char *));
+
+  /* Now assign pointers to each string in the array.  */
+  t = argv[0];
+  wordi = 0;
   while ((p = find_next_token (&t, &len)) != 0)
     {
-      if (wordi >= nwords - 1)
-        {
-          nwords = (2 * nwords) + 5;
-          words = (char **) xrealloc ((char *) words,
-                                      nwords * sizeof (char *));
-        }
-      words[wordi++] = savestring (p, len);
-    }
-
-  if (!wordi)
-    return o;
-
-  /* Now sort the list of words.  */
-  qsort ((char *) words, wordi, sizeof (char *), alpha_compare);
-
-  /* Now write the sorted list.  */
-  for (i = 0; i < wordi; ++i)
-    {
-      len = strlen (words[i]);
-      if (i == wordi - 1 || strlen (words[i + 1]) != len
-          || strcmp (words[i], words[i + 1]))
+      ++t;
+      p[len] = '\0';
+      words[wordi++] = p;
+    }
+
+  if (wordi)
+    {
+      /* Now sort the list of words.  */
+      qsort (words, wordi, sizeof (char *), alpha_compare);
+
+      /* Now write the sorted list, uniquified.  */
+#ifdef CONFIG_WITH_RSORT
+      if (strcmp (funcname, "rsort"))
         {
-          o = variable_buffer_output (o, words[i], len);
-          o = variable_buffer_output (o, " ", 1);
+          /* sort */
+#endif
+          for (i = 0; i < wordi; ++i)
+            {
+              len = strlen (words[i]);
+              if (i == wordi - 1 || strlen (words[i + 1]) != len
+                  || strcmp (words[i], words[i + 1]))
+                {
+                  o = variable_buffer_output (o, words[i], len);
+                  o = variable_buffer_output (o, " ", 1);
+                }
+            }
+#ifdef CONFIG_WITH_RSORT
         }
-      free (words[i]);
-    }
-  /* Kill the last space.  */
-  --o;
+      else
+        {
+          /* rsort - reverse the result */
+          i = wordi;
+          while (i-- > 0)
+            {
+              len = strlen (words[i]);
+              if (i == 0 || strlen (words[i + 1]) != len
+                  || strcmp (words[i], words[i + 1]))
+                {
+                  o = variable_buffer_output (o, words[i], len);
+                  o = variable_buffer_output (o, " ", 1);
+                }
+            }
+        }
+#endif
+
+      /* Kill the last space.  */
+      --o;
+    }
 
   free (words);
@@ -1271 +1311 @@
   argv += 1 + !result;
 
-  if (argv[0])
-    {
-      char *expansion;
-
-      expansion = expand_argument (argv[0], NULL);
+  if (*argv)
+    {
+      char *expansion = expand_argument (*argv, NULL);
 
       o = variable_buffer_output (o, expansion, strlen (expansion));
@@ -1392 +1430 @@
 func_wildcard (char *o, char **argv, const char *funcname UNUSED)
 {
-
 #ifdef _AMIGA
    o = wildcard_expansion (argv[0], o);
@@ -1637 +1674 @@
 func_shell (char *o, char **argv, const char *funcname UNUSED)
 {
-  char* batch_filename = NULL;
+  char *batch_filename = NULL;
 
 #ifdef __MSDOS__
@@ -1643 +1680 @@
 #endif
   char **command_argv;
-  char *error_prefix;
+  const char *error_prefix;
   char **envp;
   int pipedes[2];
@@ -1650 +1687 @@
 #ifndef __MSDOS__
   /* Construct the argument list.  */
-  command_argv = construct_command_argv (argv[0],
-                                         (char **) NULL, (struct file *) 0,
-                                         &batch_filename);
+  command_argv = construct_command_argv (argv[0], NULL, NULL, &batch_filename);
   if (command_argv == 0)
     return o;
@@ -1664 +1699 @@
      calling environment.
 
+     See Savannah bug #10593.
+
   envp = target_environment (NILF);
   */
@@ -1672 +1709 @@
   if (reading_file && reading_file->filenm)
     {
-      error_prefix = (char *) alloca (strlen (reading_file->filenm)+11+4);
-      sprintf (error_prefix,
-               "%s:%lu: ", reading_file->filenm, reading_file->lineno);
+      char *p = alloca (strlen (reading_file->filenm)+11+4);
+      sprintf (p, "%s:%lu: ", reading_file->filenm, reading_file->lineno);
+      error_prefix = p;
     }
   else
     error_prefix = "";
 
-#ifdef WINDOWS32
-
-  windows32_openpipe (pipedes, &pid, command_argv, envp);
-
-  if (pipedes[0] < 0) {
-        /* open of the pipe failed, mark as failed execution */
-    shell_function_completed = -1;
-
-        return o;
-  } else
-
-#elif defined(__MSDOS__)
-
+#if defined(__MSDOS__)
   fpipe = msdos_openpipe (pipedes, &pid, argv[0]);
   if (pipedes[0] < 0)
@@ -1698 +1723 @@
       return o;
     }
-
+#elif defined(WINDOWS32)
+  windows32_openpipe (pipedes, &pid, command_argv, envp);
+  if (pipedes[0] < 0)
+    {
+      /* open of the pipe failed, mark as failed execution */
+      shell_function_completed = -1;
+
+      return o;
+    }
+  else
 #else
-
   if (pipe (pipedes) < 0)
     {
@@ -1708 +1741 @@
 
 # ifdef __EMX__
-
   /* close some handles that are unnecessary for the child process */
   CLOSE_ON_EXEC(pipedes[1]);
@@ -1716 +1748 @@
   if (pid < 0)
     perror_with_name (error_prefix, "spawn");
-
 # else /* ! __EMX__ */
-
   pid = vfork ();
   if (pid < 0)
@@ -1725 +1755 @@
     child_execute_job (0, pipedes[1], command_argv, envp);
   else
-
 # endif
-
 #endif
     {
@@ -1742 +1770 @@
       /* Free the storage only the child needed.  */
       free (command_argv[0]);
-      free ((char *) command_argv);
+      free (command_argv);
 
       /* Close the write side of the pipe.  */
-# ifdef _MSC_VER /* crap. */
+# ifdef _MSC_VER /* Avoid annoying msvcrt when debugging. (bird) */
       if (pipedes[1] != -1)
-# endif 
-      (void) close (pipedes[1]);
+# endif
+      close (pipedes[1]);
 #endif
 
@@ -1754 +1782 @@
 
       maxlen = 200;
-      buffer = (char *) xmalloc (maxlen + 1);
+      buffer = xmalloc (maxlen + 1);
 
       /* Read from the pipe until it gets EOF.  */
@@ -1762 +1790 @@
             {
               maxlen += 512;
-              buffer = (char *) xrealloc (buffer, maxlen + 1);
+              buffer = xrealloc (buffer, maxlen + 1);
             }
 
@@ -1776 +1804 @@
         (void) pclose (fpipe);
 #else
-# ifdef _MSC_VER /* crap. */
+# ifdef _MSC_VER /* Avoid annoying msvcrt when debugging. (bird) */
       if (pipedes[0] != -1)
-# endif 
+# endif
       (void) close (pipedes[0]);
 #endif
@@ -1892 +1920 @@
         {
           maxlen += 512;
-          buffer = (char *) xrealloc (buffer, maxlen + 1);
+          buffer = xrealloc (buffer, maxlen + 1);
         }
 
@@ -1930 +1958 @@
 func_not (char *o, char **argv, const char *funcname)
 {
-  char *s = argv[0];
+  const char *s = argv[0];
   int result = 0;
   while (isspace ((unsigned char)*s))
@@ -2063 +2091 @@
 {
   /* Expand the argument.  */
-  char *p = argv[0];
-  char *path = 0;
+  const char *p = argv[0];
+  const char *path = 0;
   int doneany = 0;
   unsigned int len = 0;
@@ -2077 +2105 @@
           in[len] = '\0';
 
-          if
-          (
+          if (
 #ifdef HAVE_REALPATH
-            realpath (in, out)
+              realpath (in, out)
 #else
-            abspath (in, out)
-#endif
-          )
+              abspath (in, out)
+#endif
+             )
             {
               o = variable_buffer_output (o, out, strlen (out));
@@ -2097 +2124 @@
     --o;
 
- return o;
+  return o;
 }
 
@@ -2104 +2131 @@
 {
   /* Expand the argument.  */
-  char *p = argv[0];
-  char *path = 0;
+  const char *p = argv[0];
+  const char *path = 0;
   int doneany = 0;
   unsigned int len = 0;
@@ -2131 +2158 @@
     --o;
 
- return o;
+  return o;
 }
 
@@ -2141 +2168 @@
   /* Expand the argument.  */
   char *p = argv[0];
-  PATH_VAR (current_directory);
   char *cwd = argv[1];
   unsigned int cwd_len = ~0U;
@@ -2974 +3000 @@
 }
 
-
 #endif /* CONFIG_WITH_MATH */
+
 
 /* Lookup table for builtin functions.
@@ -2989 +3015 @@
    Functions that do namespace tricks (foreach) don't automatically expand.  */
 
-static char *func_call PARAMS ((char *o, char **argv, const char *funcname));
+static char *func_call (char *o, char **argv, const char *funcname);
 
 
@@ -3012 +3038 @@
   { STRING_SIZE_TUPLE("patsubst"),      3,  3,  1,  func_patsubst},
   { STRING_SIZE_TUPLE("realpath"),      0,  1,  1,  func_realpath},
+#ifdef CONFIG_WITH_RSORT
+  { STRING_SIZE_TUPLE("rsort"),         0,  1,  1,  func_sort},
+#endif
   { STRING_SIZE_TUPLE("shell"),         0,  1,  1,  func_shell},
   { STRING_SIZE_TUPLE("sort"),          0,  1,  1,  func_sort},
@@ -3115 +3144 @@
 
 static int
-handle_function2 (const struct function_table_entry *entry_p, char **op, char **stringp) /* bird split it up. */
+handle_function2 (const struct function_table_entry *entry_p, char **op, const char **stringp) /* bird split it up. */
 {
   char openparen = (*stringp)[0];
   char closeparen = openparen == '(' ? ')' : '}';
-  char *beg;
-  char *end;
+  const char *beg;
+  const char *end;
   int count = 0;
-  register char *p;
+  char *abeg = NULL;
   char **argv, **argvp;
   int nargs;
@@ -3154 +3183 @@
 
   /* Get some memory to store the arg pointers.  */
-  argvp = argv = (char **) alloca (sizeof (char *) * (nargs + 2));
+  argvp = argv = alloca (sizeof (char *) * (nargs + 2));
 
   /* Chop the string into arguments, then a nul.  As soon as we hit
@@ -3164 +3193 @@
      each argument.  */
 
-  if (!entry_p->expand_args)
+  if (entry_p->expand_args)
+    {
+      const char *p;
+      for (p=beg, nargs=0; p <= end; ++argvp)
+        {
+          const char *next;
+
+          ++nargs;
+
+          if (nargs == entry_p->maximum_args
+              || (! (next = find_next_argument (openparen, closeparen, p, end))))
+            next = end;
+
+          *argvp = expand_argument (p, next);
+          p = next + 1;
+        }
+    }
+  else
     {
       int len = end - beg;
-
-      p = xmalloc (len+1);
-      memcpy (p, beg, len);
-      p[len] = '\0';
-      beg = p;
-      end = beg + len;
-    }
-
-  for (p=beg, nargs=0; p <= end; ++argvp)
-    {
-      char *next;
-
-      ++nargs;
-
-      if (nargs == entry_p->maximum_args
-          || (! (next = find_next_argument (openparen, closeparen, p, end))))
-        next = end;
-
-      if (entry_p->expand_args)
-        *argvp = expand_argument (p, next);
-      else
+      char *p, *aend;
+
+      abeg = xmalloc (len+1);
+      memcpy (abeg, beg, len);
+      abeg[len] = '\0';
+      aend = abeg + len;
+
+      for (p=abeg, nargs=0; p <= aend; ++argvp)
         {
+          char *next;
+
+          ++nargs;
+
+          if (nargs == entry_p->maximum_args
+              || (! (next = find_next_argument (openparen, closeparen, p, aend))))
+            next = aend;
+
           *argvp = p;
           *next = '\0';
+          p = next + 1;
         }
-
-      p = next + 1;
     }
   *argvp = NULL;
@@ -3204 +3244 @@
     for (argvp=argv; *argvp != 0; ++argvp)
       free (*argvp);
-  else
-    free (beg);
+  if (abeg)
+    free (abeg);
 
   return 1;
@@ -3211 +3251 @@
 
 int
-handle_function (char **op, char **stringp) /* bird split it up */
+handle_function (char **op, const char **stringp) /* bird split it up */
 {
   const struct function_table_entry *entry_p = lookup_function (*stringp + 1);
@@ -3256 +3296 @@
 
   entry_p = lookup_function (fname);
-
   if (entry_p)
     {
       /* How many arguments do we have?  */
       for (i=0; argv[i+1]; ++i)
-        ;
-
+        ;
       return expand_builtin_function (o, i, argv+1, entry_p);
     }
@@ -3278 +3316 @@
     return o;
 
-  body = (char *) alloca (flen + 4);
+  body = alloca (flen + 4);
   body[0] = '$';
   body[1] = '(';
@@ -3339 +3377 @@
     unsigned i;
     for (i = 0; i < FUNCTION_TABLE_ENTRIES; i++)
-        assert(function_table_init[i].len <= MAX_FUNCTION_LENGTH);
+        assert (function_table_init[i].len <= MAX_FUNCTION_LENGTH);
   }
 #endif