casify, cleanup sys

R=r
OCL=22978
CL=22984

19 files changed, 66 insertions, 60 deletions

diff --git a/src/lib/flag.go b/src/lib/flag.go
index 3274a854e5..90784e7116 100644
--- a/src/lib/flag.go
+++ b/src/lib/flag.go
@@ -239,13 +239,13 @@ export func PrintDefaults() {
 }
 
 export func Usage() {
-	if sys.argc() > 0 {
-		print("Usage of ", sys.argv(0), ": \n");
+	if len(sys.Args) > 0 {
+		print("Usage of ", sys.Args[0], ": \n");
 	} else {
 		print("Usage: \n");
 	}
 	PrintDefaults();
-	sys.exit(1);
+	sys.Exit(1);
 }
 
 export func NFlag() int {
@@ -254,14 +254,14 @@ export func NFlag() int {
 
 export func Arg(i int) string {
 	i += flags.first_arg;
-	if i < 0 || i >= sys.argc() {
+	if i < 0 || i >= len(sys.Args) {
 		return "";
 	}
-	return sys.argv(i)
+	return sys.Args[i]
 }
 
 export func NArg() int {
-	return sys.argc() - flags.first_arg
+	return len(sys.Args) - flags.first_arg
 }
 
 func add(name string, value _Value, usage string) {
@@ -339,7 +339,7 @@ export func StringVar(p *string, name, value string, usage string) {
 
 func (f *allFlags) ParseOne(index int) (ok bool, next int)
 {
-	s := sys.argv(index);
+	s := sys.Args[index];
 	f.first_arg = index;  // until proven otherwise
 	if len(s) == 0 {
 		return false, -1
@@ -398,11 +398,11 @@ func (f *allFlags) ParseOne(index int) (ok bool, next int)
 		}
 	} else {
 		// It must have a value, which might be the next argument.
-		if !has_value && index < sys.argc()-1 {
+		if !has_value && index < len(sys.Args)-1 {
 			// value is the next arg
 			has_value = true;
 			index++;
-			value = sys.argv(index);
+			value = sys.Args[index];
 		}
 		if !has_value {
 			print("flag needs an argument: -", name, "\n");
@@ -433,7 +433,7 @@ func (f *allFlags) ParseOne(index int) (ok bool, next int)
 }
 
 export func Parse() {
-	for i := 1; i < sys.argc(); {
+	for i := 1; i < len(sys.Args); {
 		ok, next := flags.ParseOne(i);
 		if next > 0 {
 			flags.first_arg = next;
diff --git a/src/lib/fmt/print.go b/src/lib/fmt/print.go
index 67d56e1c18..0e75697313 100644
--- a/src/lib/fmt/print.go
+++ b/src/lib/fmt/print.go
@@ -14,6 +14,7 @@ import (
 	"io";
 	"reflect";
 	"os";
+	"utf8";
 )
 
 // Representation of printer state passed to custom formatters.
@@ -438,7 +439,7 @@ func (p *pp) doprintf(format string, v reflect.StructValue) {
 	end := len(format) - 1;
 	fieldnum := 0;	// we process one field per non-trivial format
 	for i := 0; i <= end;  {
-		c, w := sys.stringtorune(format, i);
+		c, w := utf8.DecodeRuneInString(format, i);
 		if c != '%' || i == end {
 			p.add(c);
 			i += w;
@@ -469,7 +470,7 @@ func (p *pp) doprintf(format string, v reflect.StructValue) {
 		if i < end && format[i] == '.' {
 			p.fmt.prec, p.fmt.prec_present, i = parsenum(format, i+1, end);
 		}
-		c, w = sys.stringtorune(format, i);
+		c, w = utf8.DecodeRuneInString(format, i);
 		i += w;
 		// percent is special - absorbs no operand
 		if c == '%' {
diff --git a/src/lib/math/exp.go b/src/lib/math/exp.go
index efc17aec03..b2697195e7 100644
--- a/src/lib/math/exp.go
+++ b/src/lib/math/exp.go
@@ -101,9 +101,9 @@ export func Exp(x float64) float64 {
 
 	// special cases
 	switch {
-	case sys.isNaN(x) || sys.isInf(x, 1):
+	case sys.IsNaN(x) || sys.IsInf(x, 1):
 		return x;
-	case sys.isInf(x, -1):
+	case sys.IsInf(x, -1):
 		return 0;
 	case x > Overflow:
 		return sys.Inf(1);
@@ -129,6 +129,6 @@ export func Exp(x float64) float64 {
 	t := r * r;
 	c := r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))));
 	y := 1 - ((lo - (r*c)/(2-c)) - hi);
-	// TODO(rsc): make sure sys.ldexp can handle boundary k
-	return sys.ldexp(y, k);
+	// TODO(rsc): make sure sys.Ldexp can handle boundary k
+	return sys.Ldexp(y, k);
 }
diff --git a/src/lib/math/floor.go b/src/lib/math/floor.go
index 421c29299b..14b3908415 100644
--- a/src/lib/math/floor.go
+++ b/src/lib/math/floor.go
@@ -11,13 +11,13 @@ package math
 
 export func Floor(arg float64) float64 {
 	if arg < 0 {
-		d, fract := sys.modf(-arg);
+		d, fract := sys.Modf(-arg);
 		if fract != 0.0 {
 			d = d+1;
 		}
 		return -d;
 	}
-	d, fract := sys.modf(arg);
+	d, fract := sys.Modf(arg);
 	return d;
 }
 
diff --git a/src/lib/math/fmod.go b/src/lib/math/fmod.go
index 488ee4321f..ae35e719fa 100644
--- a/src/lib/math/fmod.go
+++ b/src/lib/math/fmod.go
@@ -16,7 +16,7 @@ export func Fmod(x, y float64) float64 {
 		y = -y;
 	}
 
-	yfr, yexp := sys.frexp(y);
+	yfr, yexp := sys.Frexp(y);
 	sign := false;
 	r := x;
 	if x < 0 {
@@ -25,11 +25,11 @@ export func Fmod(x, y float64) float64 {
 	}
 
 	for r >= y {
-		rfr, rexp := sys.frexp(r);
+		rfr, rexp := sys.Frexp(r);
 		if rfr < yfr {
 			rexp = rexp - 1;
 		}
-		r = r - sys.ldexp(y, rexp-yexp);
+		r = r - sys.Ldexp(y, rexp-yexp);
 	}
 	if sign {
 		r = -r;
diff --git a/src/lib/math/log.go b/src/lib/math/log.go
index 5eee5daec5..259ecd2023 100644
--- a/src/lib/math/log.go
+++ b/src/lib/math/log.go
@@ -85,7 +85,7 @@ export func Log(x float64) float64 {
 
 	// special cases
 	switch {
-	case sys.isNaN(x) || sys.isInf(x, 1):
+	case sys.IsNaN(x) || sys.IsInf(x, 1):
 		return x;
 	case x < 0:
 		return sys.NaN();
@@ -94,7 +94,7 @@ export func Log(x float64) float64 {
 	}
 
 	// reduce
-	f1, ki := sys.frexp(x);
+	f1, ki := sys.Frexp(x);
 	if f1 < Sqrt2/2 {
 		f1 *= 2;
 		ki--;
diff --git a/src/lib/math/pow.go b/src/lib/math/pow.go
index 22f2aa9968..b5c67d88c0 100644
--- a/src/lib/math/pow.go
+++ b/src/lib/math/pow.go
@@ -30,7 +30,7 @@ export func Pow(x, y float64) float64 {
 		absy = -absy;
 		flip = true;
 	}
-	yi, yf := sys.modf(absy);
+	yi, yf := sys.Modf(absy);
 	if yf != 0 && x < 0 {
 		return sys.NaN();
 	}
@@ -55,7 +55,7 @@ export func Pow(x, y float64) float64 {
 	// by multiplying in successive squarings
 	// of x according to bits of yi.
 	// accumulate powers of two into exp.
-	x1, xe := sys.frexp(x);
+	x1, xe := sys.Frexp(x);
 	for i := int64(yi); i != 0; i >>= 1 {
 		if i&1 == 1 {
 			a1 *= x1;
@@ -76,5 +76,5 @@ export func Pow(x, y float64) float64 {
 		a1 = 1 / a1;
 		ae = -ae;
 	}
-	return sys.ldexp(a1, ae);
+	return sys.Ldexp(a1, ae);
 }
diff --git a/src/lib/math/sin.go b/src/lib/math/sin.go
index 6e3fbb28f7..b6a074242e 100644
--- a/src/lib/math/sin.go
+++ b/src/lib/math/sin.go
@@ -29,9 +29,9 @@ func sinus(arg float64, quad int) float64 {
 	var y float64;
 	if x > 32764 {
 		var e float64;
-		e, y = sys.modf(x);
+		e, y = sys.Modf(x);
 		e = e + float64(quad);
-		temp1, f := sys.modf(0.25*e);
+		temp1, f := sys.Modf(0.25*e);
 		quad = int(e - 4*f);
 	} else {
 		k := int32(x);
diff --git a/src/lib/math/sqrt.go b/src/lib/math/sqrt.go
index 6459b31acd..698639781f 100644
--- a/src/lib/math/sqrt.go
+++ b/src/lib/math/sqrt.go
@@ -12,7 +12,7 @@ package math
  */
 
 export func Sqrt(arg float64) float64 {
-	if sys.isInf(arg, 1) {
+	if sys.IsInf(arg, 1) {
 		return arg;
 	}
 
@@ -23,7 +23,7 @@ export func Sqrt(arg float64) float64 {
 		return 0;
 	}
 
-	x,exp := sys.frexp(arg);
+	x,exp := sys.Frexp(arg);
 	for x < 0.5 {
 		x = x*2;
 		exp = exp-1;
diff --git a/src/lib/math/tan.go b/src/lib/math/tan.go
index ddfe80d0f5..bae194bcbe 100644
--- a/src/lib/math/tan.go
+++ b/src/lib/math/tan.go
@@ -33,7 +33,7 @@ export func Tan(arg float64) float64 {
 	}
 	x = x * (4/Pi);   /* overflow? */
 	var e float64;
-	e, x = sys.modf(x);
+	e, x = sys.Modf(x);
 	i := int32(e);
 
 	switch i & 3 {
diff --git a/src/lib/os/os_env.go b/src/lib/os/os_env.go
index 8559373ac1..26cb11a476 100644
--- a/src/lib/os/os_env.go
+++ b/src/lib/os/os_env.go
@@ -18,10 +18,9 @@ export func Getenv(s string) (v string, err *Error) {
 	if n == 0 {
 		return "", EINVAL
 	}
-	for i := 0; i < sys.envc(); i++ {
-		e := sys.envv(i);
-		if len(e) > n && e[n] == '=' && e[0 : n] == s {
-			return e[n+1 : len(e)], nil
+	for i, e := range sys.Envs {
+		if len(e) > n && e[n] == '=' && e[0:n] == s {
+			return e[n+1:len(e)], nil
 		}
 	}
 	return "", ENOENV
diff --git a/src/lib/reflect/type.go b/src/lib/reflect/type.go
index 87751547e4..a7e8f7f317 100644
--- a/src/lib/reflect/type.go
+++ b/src/lib/reflect/type.go
@@ -7,13 +7,16 @@
 
 package reflect
 
-import "sync"
+import (
+	"utf8";
+	"sync";
+)
 
 export type Type interface
 
 export func ExpandType(name string) Type
 
-export func typestrings() string	// implemented in C; declared here
+func typestrings() string	// implemented in C; declared here
 
 export const (
 	MissingKind = iota;
@@ -577,7 +580,7 @@ func (p *typeParser) Next() {
 		return;
 	}
 	start := p.index;
-	c, w := sys.stringtorune(p.str, p.index);
+	c, w := utf8.DecodeRuneInString(p.str, p.index);
 	p.index += w;
 	switch {
 	case c == '<':
diff --git a/src/lib/reflect/value.go b/src/lib/reflect/value.go
index 63752d84de..ebd3c5f4ad 100644
--- a/src/lib/reflect/value.go
+++ b/src/lib/reflect/value.go
@@ -48,12 +48,12 @@ func (c *commonValue) Addr() Addr {
 func (c *commonValue) Interface() interface {} {
 	var i interface {};
 	if c.typ.Size() > 8 {	// TODO(rsc): how do we know it is 8?
-		i = sys.unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true);
+		i = sys.Unreflect(c.addr.(uintptr).(uint64), c.typ.String(), true);
 	} else {
 		if uintptr(c.addr) == 0 {
 			panicln("reflect: address 0 for", c.typ.String());
 		}
-		i = sys.unreflect(uint64(uintptr(*c.addr.(*Addr))), c.typ.String(), false);
+		i = sys.Unreflect(uint64(uintptr(*c.addr.(*Addr))), c.typ.String(), false);
 	}
 	return i;
 }
@@ -876,7 +876,7 @@ export func CopyArray(dst ArrayValue, src ArrayValue, n int) {
 
 
 export func NewValue(e interface {}) Value {
-	value, typestring, indir := sys.reflect(e);
+	value, typestring, indir := sys.Reflect(e);
 	typ, ok := typecache[typestring];
 	if !ok {
 		typ = ParseTypeString("", typestring);
diff --git a/src/lib/regexp/regexp.go b/src/lib/regexp/regexp.go
index 4162f9f38f..e838603146 100644
--- a/src/lib/regexp/regexp.go
+++ b/src/lib/regexp/regexp.go
@@ -7,8 +7,9 @@
 package regexp
 
 import (
-	"os";
 	"array";
+	"os";
+	"utf8";
 )
 
 var debug = false;
@@ -215,7 +216,7 @@ func (nop *_Nop) Print() { print("nop") }
 func (re *_RE) Error(err *os.Error) {
 	re.error = err;
 	re.ch <- re;
-	sys.goexit();
+	sys.Goexit();
 }
 
 func (re *_RE) Add(i instr) instr {
@@ -241,7 +242,7 @@ func (p *parser) nextc() int {
 	if p.pos >= len(p.re.expr) {
 		p.ch = endOfFile
 	} else {
-		c, w := sys.stringtorune(p.re.expr, p.pos);
+		c, w := utf8.DecodeRuneInString(p.re.expr, p.pos);
 		p.ch = c;
 		p.pos += w;
 	}
@@ -653,7 +654,7 @@ func (re *_RE) DoExecute(str string, pos int) []int {
 		charwidth := 1;
 		c := endOfFile;
 		if pos < len(str) {
-			c, charwidth = sys.stringtorune(str, pos);
+			c, charwidth = utf8.DecodeRuneInString(str, pos);
 		}
 		for i := 0; i < len(s[in]); i++ {
 			st := s[in][i];
diff --git a/src/lib/strconv/atof.go b/src/lib/strconv/atof.go
index cb034f088e..147b7955b2 100644
--- a/src/lib/strconv/atof.go
+++ b/src/lib/strconv/atof.go
@@ -329,7 +329,7 @@ export func Atof64(s string) (f float64, err *os.Error) {
 		}
 	}
 	b, ovf := decimalToFloatBits(neg, d, trunc, &float64info);
-	f = sys.float64frombits(b);
+	f = sys.Float64frombits(b);
 	if ovf {
 		err = os.ERANGE;
 	}
@@ -347,7 +347,7 @@ export func Atof32(s string) (f float32, err *os.Error) {
 		}
 	}
 	b, ovf := decimalToFloatBits(neg, d, trunc, &float32info);
-	f = sys.float32frombits(uint32(b));
+	f = sys.Float32frombits(uint32(b));
 	if ovf {
 		err = os.ERANGE;
 	}
diff --git a/src/lib/strconv/ftoa.go b/src/lib/strconv/ftoa.go
index f826d944c0..355680fb7b 100644
--- a/src/lib/strconv/ftoa.go
+++ b/src/lib/strconv/ftoa.go
@@ -41,11 +41,11 @@ func floatsize() int {
 export var FloatSize = floatsize()
 
 export func Ftoa32(f float32, fmt byte, prec int) string {
-	return genericFtoa(uint64(sys.float32bits(f)), fmt, prec, &float32info);
+	return genericFtoa(uint64(sys.Float32bits(f)), fmt, prec, &float32info);
 }
 
 export func Ftoa64(f float64, fmt byte, prec int) string {
-	return genericFtoa(sys.float64bits(f), fmt, prec, &float64info);
+	return genericFtoa(sys.Float64bits(f), fmt, prec, &float64info);
 }
 
 export func Ftoa(f float, fmt byte, prec int) string {
diff --git a/src/lib/sync/mutex.go b/src/lib/sync/mutex.go
index accf55a76a..68db0b697a 100644
--- a/src/lib/sync/mutex.go
+++ b/src/lib/sync/mutex.go
@@ -4,7 +4,9 @@
 
 package sync
 
-package func cas(val *int32, old, new int32) bool
+func cas(val *int32, old, new int32) bool
+func semacquire(*int32)
+func semrelease(*int32)
 
 export type Mutex struct {
 	key int32;
@@ -26,7 +28,7 @@ func (m *Mutex) Lock() {
 		// changed from 0 to 1; we hold lock
 		return;
 	}
-	sys.semacquire(&m.sema);
+	semacquire(&m.sema);
 }
 
 func (m *Mutex) Unlock() {
@@ -34,6 +36,6 @@ func (m *Mutex) Unlock() {
 		// changed from 1 to 0; no contention
 		return;
 	}
-	sys.semrelease(&m.sema);
+	semrelease(&m.sema);
 }
 
diff --git a/src/lib/sync/mutex_test.go b/src/lib/sync/mutex_test.go
index 1c4e73056d..b9c063dbc0 100644
--- a/src/lib/sync/mutex_test.go
+++ b/src/lib/sync/mutex_test.go
@@ -11,10 +11,10 @@ import (
 	"testing"
 )
 
-func hammerSemaphore(s *int32, cdone chan bool) {
+export func HammerSemaphore(s *int32, cdone chan bool) {
 	for i := 0; i < 1000; i++ {
-		sys.semacquire(s);
-		sys.semrelease(s);
+		semacquire(s);
+		semrelease(s);
 	}
 	cdone <- true;
 }
@@ -24,7 +24,7 @@ export func TestSemaphore(t *testing.T) {
 	*s = 1;
 	c := make(chan bool);
 	for i := 0; i < 10; i++ {
-		go hammerSemaphore(s, c);
+		go HammerSemaphore(s, c);
 	}
 	for i := 0; i < 10; i++ {
 		<-c;
@@ -32,7 +32,7 @@ export func TestSemaphore(t *testing.T) {
 }
 
 
-func hammerMutex(m *Mutex, cdone chan bool) {
+export func HammerMutex(m *Mutex, cdone chan bool) {
 	for i := 0; i < 1000; i++ {
 		m.Lock();
 		m.Unlock();
@@ -44,7 +44,7 @@ export func TestMutex(t *testing.T) {
 	m := new(Mutex);
 	c := make(chan bool);
 	for i := 0; i < 10; i++ {
-		go hammerMutex(m, c);
+		go HammerMutex(m, c);
 	}
 	for i := 0; i < 10; i++ {
 		<-c;
diff --git a/src/lib/testing.go b/src/lib/testing.go
index 2ef05afbcd..6199aa6ee4 100644
--- a/src/lib/testing.go
+++ b/src/lib/testing.go
@@ -34,7 +34,7 @@ func (t *T) Fail() {
 func (t *T) FailNow() {
 	t.Fail();
 	t.ch <- t;
-	sys.goexit();
+	sys.Goexit();
 }
 
 func (t *T) Log(args ...) {
@@ -104,7 +104,7 @@ export func Main(tests []Test) {
 	}
 	if !ok {
 		println("FAIL");
-		sys.exit(1);
+		sys.Exit(1);
 	}
 	println("PASS");
 }