allow slices (open arrays) to be

receivers in methods.
put back original code for hilbert/bignum

R=r
OCL=21910
CL=21920

diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h
index 9dfd0ec75aceb8a94322fda9b2dd4924d6bc9839..ce8dd42e8ab42bba6a4ac710bc5229f89c28b2a5 100644 (file)
--- a/src/cmd/gc/go.h
+++ b/src/cmd/gc/go.h
@@ -41,7 +41,7 @@ enum
        ASTRING,
        APTR,
        AINTER,
-       AARRAY,
+       ASLICE,
        ASTRUCT,
 
        BADWIDTH        = -1000000000

diff --git a/src/cmd/gc/subr.c b/src/cmd/gc/subr.c
index 3a488ece4dece2f65865a82089f822d32aa610c0..9b902838ad97afddd0120d82449a33935cac8918 100644 (file)
--- a/src/cmd/gc/subr.c
+++ b/src/cmd/gc/subr.c
@@ -301,8 +301,8 @@ algtype(Type *t)
        if(isptr[t->etype])
                a = APTR;       // pointer
        else
-       if(t->etype == TARRAY)
-               a = AARRAY;
+       if(t->etype == TARRAY && t->bound < 0)
+               a = ASLICE;
        else
        if(t->etype == TSTRUCT)
                a = ASTRUCT;
@@ -1576,6 +1576,7 @@ out:
        case ASIMP:
        case APTR:
        case ASTRING:
+       case ASLICE:
                break;
        }
 

diff --git a/src/lib/bignum.go b/src/lib/bignum.go
index cc4d4df89a9de879fe9bb64e319e471ff52da2ff..d8f8000b61abf51993a0383ae910d87e75baed6b 100755 (executable)
--- a/src/lib/bignum.go
+++ b/src/lib/bignum.go
@@ -130,18 +130,18 @@ export func Nat(x uint) Natural {
        case 10: return NatTen;
        }
        assert(Digit(x) < B);
-       return *&Natural{Digit(x)};     // TODO(rsc): *&
+       return Natural{Digit(x)};
 }
 
 
 // Predicates
 
-func (x *Natural) IsOdd() bool {
+func (x Natural) IsOdd() bool {
        return len(x) > 0 && x[0]&1 != 0;
 }
 
 
-func (x *Natural) IsZero() bool {
+func (x Natural) IsZero() bool {
        return len(x) == 0;
 }
 
@@ -158,11 +158,11 @@ func Normalize(x Natural) Natural {
 }
 
 
-func (x *Natural) Add(y Natural) Natural {
+func (x Natural) Add(y Natural) Natural {
        n := len(x);
        m := len(y);
        if n < m {
-               return y.Add(*x);
+               return y.Add(x);
        }
 
        c := Digit(0);
@@ -187,7 +187,7 @@ func (x *Natural) Add(y Natural) Natural {
 }
 
 
-func (x *Natural) Sub(y Natural) Natural {
+func (x Natural) Sub(y Natural) Natural {
        n := len(x);
        m := len(y);
        if n < m {
@@ -249,7 +249,7 @@ func Mul11(x, y Digit) (Digit, Digit) {
 }
 
 
-func (x *Natural) Mul(y Natural) Natural {
+func (x Natural) Mul(y Natural) Natural {
        n := len(x);
        m := len(y);
 
@@ -440,20 +440,20 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
 }
 
 
-func (x *Natural) Div(y Natural) Natural {
-       q, r := DivMod(Unpack(*x), Unpack(y));
+func (x Natural) Div(y Natural) Natural {
+       q, r := DivMod(Unpack(x), Unpack(y));
        return Pack(q);
 }
 
 
-func (x *Natural) Mod(y Natural) Natural {
-       q, r := DivMod(Unpack(*x), Unpack(y));
+func (x Natural) Mod(y Natural) Natural {
+       q, r := DivMod(Unpack(x), Unpack(y));
        return Pack(r);
 }
 
 
-func (x *Natural) DivMod(y Natural) (Natural, Natural) {
-       q, r := DivMod(Unpack(*x), Unpack(y));
+func (x Natural) DivMod(y Natural) (Natural, Natural) {
+       q, r := DivMod(Unpack(x), Unpack(y));
        return Pack(q), Pack(r);
 }
 
@@ -469,12 +469,12 @@ func Shl(z, x []Digit, s uint) Digit {
 }
 
 
-func (x *Natural) Shl(s uint) Natural {
+func (x Natural) Shl(s uint) Natural {
        n := uint(len(x));
        m := n + s/W;
        z := new(Natural, m+1);
 
-       z[m] = Shl(z[m-n : m], *x, s%W);
+       z[m] = Shl(z[m-n : m], x, s%W);
 
        return Normalize(z);
 }
@@ -491,7 +491,7 @@ func Shr(z, x []Digit, s uint) Digit {
 }
 
 
-func (x *Natural) Shr(s uint) Natural {
+func (x Natural) Shr(s uint) Natural {
        n := uint(len(x));
        m := n - s/W;
        if m > n {  // check for underflow
@@ -499,17 +499,17 @@ func (x *Natural) Shr(s uint) Natural {
        }
        z := new(Natural, m);
 
-       Shr(z, (*x)[n-m : n], s%W);
+       Shr(z, x[n-m : n], s%W);
 
        return Normalize(z);
 }
 
 
-func (x *Natural) And(y Natural) Natural {
+func (x Natural) And(y Natural) Natural {
        n := len(x);
        m := len(y);
        if n < m {
-               return y.And(*x);
+               return y.And(x);
        }
 
        z := new(Natural, m);
@@ -529,41 +529,41 @@ func Copy(z, x []Digit) {
 }
 
 
-func (x *Natural) Or(y Natural) Natural {
+func (x Natural) Or(y Natural) Natural {
        n := len(x);
        m := len(y);
        if n < m {
-               return y.Or(*x);
+               return y.Or(x);
        }
 
        z := new(Natural, n);
        for i := 0; i < m; i++ {
                z[i] = x[i] | y[i];
        }
-       Copy(z[m : n], (*x)[m : n]);
+       Copy(z[m : n], x[m : n]);
 
        return z;
 }
 
 
-func (x *Natural) Xor(y Natural) Natural {
+func (x Natural) Xor(y Natural) Natural {
        n := len(x);
        m := len(y);
        if n < m {
-               return y.Xor(*x);
+               return y.Xor(x);
        }
 
        z := new(Natural, n);
        for i := 0; i < m; i++ {
                z[i] = x[i] ^ y[i];
        }
-       Copy(z[m : n], (*x)[m : n]);
+       Copy(z[m : n], x[m : n]);
 
        return Normalize(z);
 }
 
 
-func (x *Natural) Cmp(y Natural) int {
+func (x Natural) Cmp(y Natural) int {
        n := len(x);
        m := len(y);
 
@@ -595,7 +595,7 @@ func Log2(x Digit) uint {
 }
 
 
-func (x *Natural) Log2() uint {
+func (x Natural) Log2() uint {
        n := len(x);
        if n > 0 {
                return (uint(n) - 1)*W + Log2(x[n - 1]);
@@ -606,7 +606,7 @@ func (x *Natural) Log2() uint {
 
 // Computes x = x div d in place (modifies x) for "small" d's.
 // Returns updated x and x mod d.
-func DivMod1(x *Natural, d Digit) (Natural, Digit) {
+func DivMod1(x Natural, d Digit) (Natural, Digit) {
        assert(0 < d && IsSmall(d - 1));
 
        c := Digit(0);
@@ -615,11 +615,11 @@ func DivMod1(x *Natural, d Digit) (Natural, Digit) {
                c, x[i] = t%d, t/d;
        }
 
-       return Normalize(*x), c;
+       return Normalize(x), c;
 }
 
 
-func (x *Natural) ToString(base uint) string {
+func (x Natural) ToString(base uint) string {
        if len(x) == 0 {
                return "0";
        }
@@ -631,14 +631,14 @@ func (x *Natural) ToString(base uint) string {
 
        // don't destroy x
        t := new(Natural, len(x));
-       Copy(t, *x);
+       Copy(t, x);
 
        // convert
        i := n;
        for !t.IsZero() {
                i--;
                var d Digit;
-               t, d = DivMod1(&t, Digit(base));
+               t, d = DivMod1(t, Digit(base));
                s[i] = "0123456789abcdef"[d];
        };
 
@@ -646,7 +646,7 @@ func (x *Natural) ToString(base uint) string {
 }
 
 
-func (x *Natural) String() string {
+func (x Natural) String() string {
        return x.ToString(10);
 }
 
@@ -661,9 +661,8 @@ func FmtBase(c int) uint {
 }
 
 
-func (x *Natural) Format(h Fmt.Formatter, c int) {
-       t := x.ToString(FmtBase(c));  // BUG in 6g
-       Fmt.fprintf(h, "%s", t);
+func (x Natural) Format(h Fmt.Formatter, c int) {
+       Fmt.fprintf(h, "%s", x.ToString(FmtBase(c)));
 }
 
 
@@ -679,7 +678,7 @@ func HexValue(ch byte) uint {
 
 
 // Computes x = x*d + c for "small" d's.
-func MulAdd1(x *Natural, d, c Digit) Natural {
+func MulAdd1(x Natural, d, c Digit) Natural {
        assert(IsSmall(d-1) && IsSmall(c));
        n := len(x);
        z := new(Natural, n + 1);
@@ -716,7 +715,7 @@ export func NatFromString(s string, base uint, slen *int) (Natural, uint) {
        for ; i < n; i++ {
                d := HexValue(s[i]);
                if d < base {
-                       x = MulAdd1(&x, Digit(base), Digit(d));
+                       x = MulAdd1(x, Digit(base), Digit(d));
                } else {
                        break;
                }
@@ -743,7 +742,7 @@ func Pop1(x Digit) uint {
 }
 
 
-func (x *Natural) Pop() uint {
+func (x Natural) Pop() uint {
        n := uint(0);
        for i := len(x) - 1; i >= 0; i-- {
                n += Pop1(x[i]);
@@ -752,9 +751,9 @@ func (x *Natural) Pop() uint {
 }
 
 
-func (xp *Natural) Pow(n uint) Natural {
+func (xp Natural) Pow(n uint) Natural {
        z := Nat(1);
-       x := *xp;
+       x := xp;
        for n > 0 {
                // z * x^n == x^n0
                if n&1 == 1 {
@@ -770,18 +769,11 @@ export func MulRange(a, b uint) Natural {
        switch {
        case a > b: return Nat(1);
        case a == b: return Nat(a);
-       //BUG case a + 1 == b: return Nat(a).Mul(Nat(b));
-       case a + 1 == b:
-               na := Nat(a);
-               nb := Nat(b);
-               return na.Mul(nb);
+       case a + 1 == b: return Nat(a).Mul(Nat(b));
        }
        m := (a + b)>>1;
        assert(a <= m && m < b);
-       //BUG   return MulRange(a, m).Mul(MulRange(m + 1, b));
-       m1 := MulRange(a, m);
-       m2 := MulRange(m + 1, b);
-       return m1.Mul(m2);
+       return MulRange(a, m).Mul(MulRange(m + 1, b));
 }
 
 
@@ -793,16 +785,13 @@ export func Fact(n uint) Natural {
 
 
 export func Binomial(n, k uint) Natural {
-       //BUG return MulRange(n-k+1, n).Div(MulRange(1, k));
-       x := MulRange(n-k+1, n);
-       y := MulRange(1, k);
-       return x.Div(y);
+       return MulRange(n-k+1, n).Div(MulRange(1, k));
 }
 
 
-func (xp *Natural) Gcd(y Natural) Natural {
+func (xp Natural) Gcd(y Natural) Natural {
        // Euclidean algorithm.
-       x := *xp;
+       x := xp;
        for !y.IsZero() {
                x, y = y, x.Mod(y);
        }
@@ -1107,8 +1096,7 @@ func (x *Integer) String() string {
 
 
 func (x *Integer) Format(h Fmt.Formatter, c int) {
-       t := x.ToString(FmtBase(c));  // BUG in 6g
-       Fmt.fprintf(h, "%s", t);
+       Fmt.fprintf(h, "%s", x.ToString(FmtBase(c)));
 }
 
 
@@ -1238,8 +1226,7 @@ func (x *Rational) String() string {
 
 
 func (x *Rational) Format(h Fmt.Formatter, c int) {
-       t := x.ToString(FmtBase(c));  // BUG in 6g
-       Fmt.fprintf(h, "%s", t);
+       Fmt.fprintf(h, "%s", x.ToString(FmtBase(c)));
 }
 
 
@@ -1261,12 +1248,8 @@ export func RatFromString(s string, base uint, slen *int) (*Rational, uint) {
                        alen++;
                        b, base = NatFromString(s[alen : len(s)], abase, &blen);
                        assert(base == abase);
-                       //BUG f := Nat(base).Pow(uint(blen));
-                       na := Nat(base);
-                       f := na.Pow(uint(blen));
-                       //BUG a = MakeInt(a.sign, a.mant.Mul(f).Add(b));
-                       nb := a.mant.Mul(f);
-                       a = MakeInt(a.sign, nb.Add(b));
+                       f := Nat(base).Pow(uint(blen));
+                       a = MakeInt(a.sign, a.mant.Mul(f).Add(b));
                        b = f;
                }
        }

diff --git a/test/hilbert.go b/test/hilbert.go
index 15d4ae2972392350e1e398eb5c40d7c99ea2009c..a807c3ccac97be90137efda57b78c690e7b66e88 100644 (file)
--- a/test/hilbert.go
+++ b/test/hilbert.go
@@ -100,12 +100,7 @@ func NewInverseHilbert(n int) *Matrix {
                        x3 := MakeRat(Big.Binomial(uint(n+j), uint(n-i-1)));
                        x4 := MakeRat(Big.Binomial(uint(i+j), uint(i)));
                        x4 = x4.Mul(x4);
-                       // BUG a.set(i, j, x0.Mul(x1).Mul(x2).Mul(x3).Mul(x4));
-                       y1 := x0.Mul(x1);
-                       y2 := y1.Mul(x2);
-                       y3 := y2.Mul(x3);
-                       y4 := y3.Mul(x4);
-                       a.set(i, j, y4);
+                       a.set(i, j, x0.Mul(x1).Mul(x2).Mul(x3).Mul(x4));
                }
        }
        return a;
@@ -119,11 +114,7 @@ func (a *Matrix) Mul(b *Matrix) *Matrix {
                for j := 0; j < c.m; j++ {
                        x := Zero;
                        for k := 0; k < a.m; k++ {
-                               //BUG x = x.Add(a.at(i, k).Mul(b.at(k, j)));
-                               a1 := a.at(i, k);
-                               b1 := b.at(k, j);
-                               a2 := a1.Mul(b1);
-                               x = x.Add(a2);
+                               x = x.Add(a.at(i, k).Mul(b.at(k, j)));
                        }
                        c.set(i, j, x);
                }
@@ -138,10 +129,7 @@ func (a *Matrix) Eql(b *Matrix) bool {
        }
        for i := 0; i < a.n; i++ {
                for j := 0; j < a.m; j++ {
-                       // BUG if a.at(i, j).Cmp(b.at(i,j)) != 0 {
-                       a1 := a.at(i, j);
-                       b1 := b.at(i,j);
-                       if a1.Cmp(b1) != 0 {
+                       if a.at(i, j).Cmp(b.at(i,j)) != 0 {
                                return false;
                        }
                }
@@ -154,8 +142,7 @@ func (a *Matrix) String() string {
        s := "";
        for i := 0; i < a.n; i++ {
                for j := 0; j < a.m; j++ {
-                       x := a.at(i, j);  // BUG 6g bug
-                       s += Fmt.sprintf("\t%s", x);
+                       s += Fmt.sprintf("\t%s", a.at(i, j));
                }
                s += "\n";
        }