Fix issues with variable expansion.

expand.go

@@ -10,18 +10,24 @@ import (
 
 
 // Expand a word. This includes substituting variables and handling quotes.
-func expand(input string, vars map[string][]string, expandBackticks bool) string {
-	expanded := make([]byte, 0)
+func expand(input string, vars map[string][]string, expandBackticks bool) []string {
+    parts := make([]string, 0)
+    expanded := ""
 	var i, j int
 	for i = 0; i < len(input); {
 		j = i + strings.IndexAny(input[i:], "\"'`$\\")
 
 		if j < 0 {
-			expanded = append(expanded, input[i:]...)
+            expanded += input[i:]
 			break
 		}
 
-		expanded = append(expanded, input[i:j]...)
+        println("-------------------")
+        println(len(input))
+        println(i)
+        println(j)
+
+        expanded += input[i:j]
 		c, w := utf8.DecodeRuneInString(input[j:])
 		i = j + w
 
@@ -30,12 +36,15 @@ func expand(input string, vars map[string][]string, expandBackticks bool) string
 		switch c {
 		case '\\':
 			out, off = expandEscape(input[i:])
+            expanded += out
 
 		case '"':
 			out, off = expandDoubleQuoted(input[i:], vars, expandBackticks)
+            expanded += out
 
 		case '\'':
 			out, off = expandSingleQuoted(input[i:])
+            expanded += out
 
 		case '`':
             if expandBackticks {
@@ -44,16 +53,26 @@ func expand(input string, vars map[string][]string, expandBackticks bool) string
                 out = input
                 off = len(input)
             }
+            expanded += out
 
 		case '$':
-            out, off = expandSigil(input[i:], vars)
+            var outparts []string
+            outparts, off = expandSigil(input[i:], vars)
+            if len(outparts) > 0 {
+                outparts[0] = expanded + outparts[0]
+                expanded = outparts[len(outparts)-1]
+                parts = append(parts, outparts[:len(outparts)-1]...)
+            }
 		}
 
-		expanded = append(expanded, out...)
 		i += off
 	}
 
-	return string(expanded)
+    if len(expanded) > 0 {
+        parts = append(parts, expanded)
+    }
+
+	return parts
 }
 
 // Expand following a '\\'
@@ -79,7 +98,7 @@ func expandDoubleQuoted(input string, vars map[string][]string, expandBackticks
 		j += w
 
 		if c == '"' {
-			return expand(input[:j], vars, expandBackticks), (j + w)
+			return strings.Join(expand(input[:j], vars, expandBackticks), " "), (j + w)
 		}
 
 		if c == '\\' {
@@ -106,21 +125,21 @@ func expandSingleQuoted(input string) (string, int) {
 }
 
 // Expand something starting with at '$'.
-func expandSigil(input string, vars map[string][]string) (string, int) {
+func expandSigil(input string, vars map[string][]string) ([]string, int) {
     c, w := utf8.DecodeRuneInString(input)
     var offset int
     var varname string
     if c == '{' {
         j := strings.IndexRune(input[w:], '}')
         if j < 0 {
-            return input, len(input)
+            return []string{"$" + input}, len(input)
         }
 
         varname = input[w:j]
         offset = j + 1
     } else {
         // try to match a variable name
-        i := w
+        i := 0
         j := i
         for j < len(input) {
             c, w = utf8.DecodeRuneInString(input)
@@ -132,38 +151,48 @@ func expandSigil(input string, vars map[string][]string) (string, int) {
 
         if j > i {
             varname = input[i:j]
+            offset = j
         } else {
-            return input, len(input)
+            return []string{"$" + input}, len(input)
         }
     }
 
     if isValidVarName(varname) {
         varvals, ok := vars[varname]
         if ok {
-            return strings.Join(varvals, " "), offset
+            return varvals, offset
         }
     }
 
-    return input, len(input)
+    return []string{"$" + input}, len(input)
 }
 
 
 // Find and expand all sigils.
-func expandSigils(input string, vars map[string][]string) string {
-    expanded := make([]byte, 0)
+func expandSigils(input string, vars map[string][]string) []string {
+    parts := make([]string, 0)
+    expanded := ""
     for i := 0; i < len(input); {
         j := strings.IndexRune(input[i:], '$')
         if j < 0 {
-            expanded = append(expanded, input[i:]...)
+            expanded += input[i:]
             break
         }
 
         ex, k := expandSigil(input[j+1:], vars)
-        expanded = append(expanded, ex...)
+        if len(ex) > 0 {
+            ex[0] = expanded + ex[0]
+            expanded = ex[len(ex)-1]
+            parts = append(parts, ex[:len(ex)-1]...)
+        }
         i = k
     }
 
-    return string(expanded)
+    if len(expanded) > 0 {
+        parts = append(parts, expanded)
+    }
+
+    return parts
 }
 
 
@@ -212,3 +241,39 @@ func expandBackQuoted(input string, vars map[string][]string) (string, int) {
 }
 
 
+// Split a string on whitespace taking into account escaping and quoting.
+//func splitQuoted(input string) []string {
+    //parts := make([]string, 0)
+    //var i, j int
+    //i = 0
+    //for {
+        //// skip all unescaped whitespace
+        //for i < len(input) {
+            //c, w := utf8.DecodeRuneInString(input[i:])
+            //if strings.IndexRune(" \t", c) < 0 {
+                //break
+            //}
+            //i += w
+        //}
+
+        //if i >= len(input) {
+            //break
+        //}
+
+        //// Ugh. Will this take into account quoting in variables?
+
+        //switch c {
+        //case '"':
+        //case '\'':
+        //default:
+
+        //}
+    //}
+
+    //return parts
+//}
+
+
+
+
+