Changeset 531 for trunk/src/gmake/variable.c

Timestamp:

Sep 18, 2006, 1:49:49 AM (19 years ago)

Author:

bird

Message:

skip some unnecessary copies and allocations.

File:

• trunk/src/gmake/variable.c (modified) (12 diffs)

trunk/src/gmake/variable.c

@@ -314 +314 @@
    that it should be recursively re-expanded.  */
 
+#ifdef CONFIG_WITH_VALUE_LENGTH
 struct variable *
 define_variable_in_set (const char *name, unsigned int length,
-                        char *value, enum variable_origin origin,
-                        int recursive, struct variable_set *set,
+                        char *value, unsigned int value_length, int duplicate_value,
+                        enum variable_origin origin, int recursive, 
+                        struct variable_set *set, const struct floc *flocp)
+#else
+struct variable *
+define_variable_in_set (const char *name, unsigned int length,
+                        char *value, enum variable_origin origin, 
+                        int recursive, struct variable_set *set, 
                         const struct floc *flocp)
+#endif 
 {
   struct variable *v;
@@ -352 +360 @@
         {
 #ifdef CONFIG_WITH_VALUE_LENGTH
-          v->value_length = strlen (value);
-          v->value = xrealloc (v->value, v->value_length + 1);
-          bcopy (value, v->value, v->value_length + 1);
+          if (value_length == ~0U)
+            value_length = strlen (value);
+          else
+            assert (value_length == strlen (value));
+          v->value_length = value_length;
+          if (!duplicate_value)
+            {
+              if (v->value != 0)
+                free (v->value);
+              v->value = value;
+            }
+          else
+            {
+              v->value = xrealloc (v->value, v->value_length + 1);
+              bcopy (value, v->value, v->value_length + 1);
+            }
 #else
           if (v->value != 0)
@@ -381 +402 @@
   hash_insert_at (&set->table, v, var_slot);
 #ifdef CONFIG_WITH_VALUE_LENGTH
-  v->value_length = strlen (value);
-  v->value = xmalloc (v->value_length + 1);
-  bcopy (value, v->value, v->value_length + 1);
+  if (value_length == ~0U)
+    value_length = strlen (value);
+  else
+    assert (value_length == strlen (value));
+  v->value_length = value_length;
+  if (!duplicate_value)
+    v->value = value;
+  else
+    {
+      v->value = xmalloc (v->value_length + 1);
+      bcopy (value, v->value, v->value_length + 1);
+    }
 #else
   v->value = xstrdup (value);
@@ -1044 +1074 @@
       v->value = xstrdup (default_shell);
 #ifdef CONFIG_WITH_VALUE_LENGTH
-      v->value_length = -1;
+      v->value_length = strlen (v->value);
 #endif 
     }
@@ -1244 +1274 @@
   int conditional = 0;
   const size_t varname_len = strlen (varname); /* bird */
+# ifdef CONFIG_WITH_VALUE_LENGTH
+  unsigned int value_len = ~0U;
+# endif 
 
   /* Calculate the variable's new value in VALUE.  */
@@ -1308 +1341 @@
 
             val = value;
+#ifdef CONFIG_WITH_VALUE_LENGTH
+            if (v->recursive)
+              {
+                /* The previous definition of the variable was recursive.
+                   The new value is the unexpanded old and new values. */
+                flavor = f_recursive;
+                oldlen = v->value_length; assert (oldlen == strlen (v->value));
+                vallen = strlen (val);
+
+                value_len = oldlen + 1 + vallen;
+                p = alloc_value = xmalloc (value_len + 1);
+                memcpy (p, v->value, oldlen);
+                p[oldlen] = ' ';
+                memcpy (&p[oldlen + 1], val, vallen + 1);
+              }
+            else 
+              {
+                /* The previous definition of the variable was simple.
+                   The new value comes from the old value, which was expanded
+                   when it was set; and from the expanded new value.  Allocate
+                   memory for the expansion as we may still need the rest of the
+                   buffer if we're looking at a target-specific variable.  */
+                char *buf;
+                unsigned int len;
+                install_variable_buffer (&buf, &len);
+
+                p = variable_buffer;
+                if ( v->value && *v->value )
+                  {
+                    p = variable_buffer_output (p, v->value, v->value_length);
+                    p = variable_buffer_output (p, " ", 1);
+                  }
+                p = variable_expand_string (p, val, (long)-1);
+
+                p = strchr (p, '\0'); /* returns adjusted start, not end. */
+                alloc_value = variable_buffer;
+                value_len = p - alloc_value;
+                p = alloc_value;
+
+                variable_buffer = NULL; /* hackish */
+                restore_variable_buffer (buf, len);
+              }
+#else /* !CONFIG_WITH_VALUE_LENGTH */
             if (v->recursive)
               /* The previous definition of the variable was recursive.
@@ -1320 +1396 @@
               val = alloc_value = allocated_variable_expand (val);
 
-#ifdef CONFIG_WITH_VALUE_LENGTH
-            oldlen = v->value_length;
-            assert(oldlen == strlen (v->value));
-#endif 
+            oldlen = strlen (v->value);
             vallen = strlen (val);
             p = (char *) alloca (oldlen + 1 + vallen + 1);
@@ -1329 +1402 @@
             p[oldlen] = ' ';
             bcopy (val, &p[oldlen + 1], vallen + 1);
+#endif /* !CONFIG_WITH_VALUE_LENGTH */
           }
       }
@@ -1430 +1504 @@
         {
           v = define_variable_in_set (varname, varname_len, default_shell,
+# ifdef CONFIG_WITH_VALUE_LENGTH
+                                      ~0U, 1 /* duplicate_value */,
+# endif 
                                       origin, flavor == f_recursive,
                                       (target_var
@@ -1439 +1516 @@
       else
         v = lookup_variable (varname, varname_len);
+# ifdef CONFIG_WITH_VALUE_LENGTH
+      if (alloc_value)
+        free (alloc_value);
+# endif 
     }
   else
@@ -1450 +1531 @@
 
   v = define_variable_in_set (varname, varname_len, p,
+#ifdef CONFIG_WITH_VALUE_LENGTH
+                              value_len, !alloc_value,
+#endif
                               origin, flavor == f_recursive,
                               (target_var
@@ -1457 +1541 @@
   v->conditional = conditional;
 
+#ifndef CONFIG_WITH_VALUE_LENGTH
   if (alloc_value)
     free (alloc_value);
+#endif 
 
   return v;