1 files changed, 77 insertions, 59 deletions

diff --git a/src/pkg/runtime/string.goc b/src/pkg/runtime/string.goc
index 1a4847322..916559eb2 100644
--- a/src/pkg/runtime/string.goc
+++ b/src/pkg/runtime/string.goc
@@ -6,10 +6,10 @@ package runtime
 #include "runtime.h"
 #include "malloc.h"
 
-String	emptystring;
+String	runtime·emptystring;
 
 int32
-findnull(byte *s)
+runtime·findnull(byte *s)
 {
 	int32 l;
 
@@ -21,7 +21,7 @@ findnull(byte *s)
 }
 
 int32
-findnullw(uint16 *s)
+runtime·findnullw(uint16 *s)
 {
 	int32 l;
 
@@ -32,46 +32,56 @@ findnullw(uint16 *s)
 	return l;
 }
 
-int32 maxstring = 256;
+int32 runtime·maxstring = 256;
 
 String
-gostringsize(int32 l)
+runtime·gostringsize(int32 l)
 {
 	String s;
 
 	if(l == 0)
-		return emptystring;
-	s.str = mal(l+1);	// leave room for NUL for C runtime (e.g., callers of getenv)
+		return runtime·emptystring;
+	s.str = runtime·mal(l+1);	// leave room for NUL for C runtime (e.g., callers of getenv)
 	s.len = l;
-	if(l > maxstring)
-		maxstring = l;
+	if(l > runtime·maxstring)
+		runtime·maxstring = l;
 	return s;
 }
 
 String
-gostring(byte *str)
+runtime·gostring(byte *str)
 {
 	int32 l;
 	String s;
 
-	l = findnull(str);
-	s = gostringsize(l);
-	mcpy(s.str, str, l);
+	l = runtime·findnull(str);
+	s = runtime·gostringsize(l);
+	runtime·mcpy(s.str, str, l);
 	return s;
 }
 
 String
-gostringnocopy(byte *str)
+runtime·gostringn(byte *str, int32 l)
+{
+	String s;
+
+	s = runtime·gostringsize(l);
+	runtime·mcpy(s.str, str, l);
+	return s;
+}
+
+String
+runtime·gostringnocopy(byte *str)
 {
 	String s;
 	
 	s.str = str;
-	s.len = findnull(str);
+	s.len = runtime·findnull(str);
 	return s;
 }
 
 String
-gostringw(uint16 *str)
+runtime·gostringw(uint16 *str)
 {
 	int32 n, i;
 	byte buf[8];
@@ -79,17 +89,17 @@ gostringw(uint16 *str)
 
 	n = 0;
 	for(i=0; str[i]; i++)
-		n += runetochar(buf, str[i]);
-	s = gostringsize(n+4);
+		n += runtime·runetochar(buf, str[i]);
+	s = runtime·gostringsize(n+4);
 	n = 0;
 	for(i=0; str[i]; i++)
-		n += runetochar(s.str+n, str[i]);
+		n += runtime·runetochar(s.str+n, str[i]);
 	s.len = n;
 	return s;
 }
 
 String
-catstring(String s1, String s2)
+runtime·catstring(String s1, String s2)
 {
 	String s3;
 
@@ -98,18 +108,42 @@ catstring(String s1, String s2)
 	if(s2.len == 0)
 		return s1;
 
-	s3 = gostringsize(s1.len + s2.len);
-	mcpy(s3.str, s1.str, s1.len);
-	mcpy(s3.str+s1.len, s2.str, s2.len);
+	s3 = runtime·gostringsize(s1.len + s2.len);
+	runtime·mcpy(s3.str, s1.str, s1.len);
+	runtime·mcpy(s3.str+s1.len, s2.str, s2.len);
 	return s3;
 }
 
+static String
+concatstring(int32 n, String *s)
+{
+	int32 i, l;
+	String out;
+
+	l = 0;
+	for(i=0; i<n; i++) {
+		if(l + s[i].len < l)
+			runtime·throw("string concatenation too long");
+		l += s[i].len;
+	}
+	
+	out = runtime·gostringsize(l);
+	l = 0;
+	for(i=0; i<n; i++) {
+		runtime·mcpy(out.str+l, s[i].str, s[i].len);
+		l += s[i].len;
+	}
+	return out;
+}
 
-func catstring(s1 String, s2 String) (s3 String) {
-	s3 = catstring(s1, s2);
+#pragma textflag 7
+// s1 is the first of n strings.
+// the output string follows.
+func concatstring(n int32, s1 String) {
+	(&s1)[n] = concatstring(n, &s1);
 }
 
-uint32
+static int32
 cmpstring(String s1, String s2)
 {
 	uint32 i, l;
@@ -138,7 +172,7 @@ func cmpstring(s1 String, s2 String) (v int32) {
 }
 
 int32
-strcmp(byte *s1, byte *s2)
+runtime·strcmp(byte *s1, byte *s2)
 {
 	uint32 i;
 	byte c1, c2;
@@ -160,57 +194,41 @@ func slicestring(si String, lindex int32, hindex int32) (so String) {
 
 	if(lindex < 0 || lindex > si.len ||
 	   hindex < lindex || hindex > si.len) {
-	   	·panicslice();
+	   	runtime·panicslice();
 	}
 
 	l = hindex-lindex;
 	so.str = si.str + lindex;
 	so.len = l;
-
-//	alternate to create a new string
-//	so = gostringsize(l);
-//	mcpy(so.str, si.str+lindex, l);
 }
 
 func slicestring1(si String, lindex int32) (so String) {
 	int32 l;
 
 	if(lindex < 0 || lindex > si.len) {
-		·panicslice();
+		runtime·panicslice();
 	}
 
 	l = si.len-lindex;
 	so.str = si.str + lindex;
 	so.len = l;
-
-//	alternate to create a new string
-//	so = gostringsize(l);
-//	mcpy(so.str, si.str+lindex, l);
-}
-
-func indexstring(s String, i int32) (b byte) {
-	if(i < 0 || i >= s.len) {
-		·panicindex();
-	}
-
-	b = s.str[i];
 }
 
 func intstring(v int64) (s String) {
-	s = gostringsize(8);
-	s.len = runetochar(s.str, v);
+	s = runtime·gostringsize(8);
+	s.len = runtime·runetochar(s.str, v);
 }
 
 func slicebytetostring(b Slice) (s String) {
-	s = gostringsize(b.len);
-	mcpy(s.str, b.array, s.len);
+	s = runtime·gostringsize(b.len);
+	runtime·mcpy(s.str, b.array, s.len);
 }
 
 func stringtoslicebyte(s String) (b Slice) {
-	b.array = mallocgc(s.len, RefNoPointers, 1, 1);
+	b.array = runtime·mallocgc(s.len, RefNoPointers, 1, 1);
 	b.len = s.len;
 	b.cap = s.len;
-	mcpy(b.array, s.str, s.len);
+	runtime·mcpy(b.array, s.str, s.len);
 }
 
 func sliceinttostring(b Slice) (s String) {
@@ -221,16 +239,16 @@ func sliceinttostring(b Slice) (s String) {
 	a = (int32*)b.array;
 	siz1 = 0;
 	for(i=0; i<b.len; i++) {
-		siz1 += runetochar(dum, a[i]);
+		siz1 += runtime·runetochar(dum, a[i]);
 	}
 
-	s = gostringsize(siz1+4);
+	s = runtime·gostringsize(siz1+4);
 	siz2 = 0;
 	for(i=0; i<b.len; i++) {
 		// check for race
 		if(siz2 >= siz1)
 			break;
-		siz2 += runetochar(s.str+siz2, a[i]);
+		siz2 += runtime·runetochar(s.str+siz2, a[i]);
 	}
 	s.len = siz2;
 }
@@ -246,17 +264,17 @@ func stringtosliceint(s String) (b Slice) {
 	ep = s.str+s.len;
 	n = 0;
 	while(p < ep) {
-		p += charntorune(&dum, p, ep-p);
+		p += runtime·charntorune(&dum, p, ep-p);
 		n++;
 	}
 
-	b.array = mallocgc(n*sizeof(r[0]), RefNoPointers, 1, 1);
+	b.array = runtime·mallocgc(n*sizeof(r[0]), RefNoPointers, 1, 1);
 	b.len = n;
 	b.cap = n;
 	p = s.str;
 	r = (int32*)b.array;
 	while(p < ep)
-		p += charntorune(r++, p, ep-p);
+		p += runtime·charntorune(r++, p, ep-p);
 }
 
 enum
@@ -280,7 +298,7 @@ func stringiter(s String, k int32) (retk int32) {
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&l, s.str+k, s.len-k);
+	retk = k + runtime·charntorune(&l, s.str+k, s.len-k);
 
 out:
 }
@@ -300,7 +318,7 @@ func stringiter2(s String, k int32) (retk int32, retv int32) {
 	}
 
 	// multi-char rune
-	retk = k + charntorune(&retv, s.str+k, s.len-k);
+	retk = k + runtime·charntorune(&retv, s.str+k, s.len-k);
 
 out:
 }