}
var f []string;
- if f = strings.split(s, " "); len(f) != 3 {
+ if f = strings.Split(s, " "); len(f) != 3 {
return nil, BadRequest
}
req.method, req.rawurl, req.proto = f[0], f[1], f[2];
}
// If there's no @, split's default is wrong. Check explicitly.
- if strings.index(url.authority, "@") < 0 {
+ if strings.Index(url.authority, "@") < 0 {
url.host = url.authority;
} else {
url.userinfo, url.host = split(url.authority, '@', true);
// Convert something that implements Read into something
// whose Reads are always Readn
-type FullRead struct {
+type _FullRead struct {
fd Read;
}
-func (fd *FullRead) Read(p []byte) (n int, err *os.Error) {
+func (fd *_FullRead) Read(p []byte) (n int, err *os.Error) {
n, err = Readn(fd.fd, p);
return n, err
}
-export func MakeFullReader(fd Read) Read {
- if fr, ok := fd.(*FullRead); ok {
- // already a FullRead
+export func Make_FullReader(fd Read) Read {
+ if fr, ok := fd.(*_FullRead); ok {
+ // already a _FullRead
return fd
}
- return &FullRead{fd}
+ return &_FullRead{fd}
}
// Copies n bytes (or until EOF is reached) from src to dst.
export func Walk(j Json, path string) Json {
for len(path) > 0 {
var elem string;
- if i := strings.index(path, "/"); i >= 0 {
+ if i := strings.Index(path, "/"); i >= 0 {
elem = path[0:i];
path = path[i+1:len(path)];
} else {
package malloc
-type Stats struct {
+export type Stats struct {
alloc uint64;
sys uint64;
};
// If name is rooted (trailing dot) or has enough dots,
// try it by itself first.
rooted := len(name) > 0 && name[len(name)-1] == '.';
- if rooted || strings.count(name, ".") >= cfg.ndots {
+ if rooted || strings.Count(name, ".") >= cfg.ndots {
rname := name;
if !rooted {
rname += ".";
package once
-type Job struct {
+type _Job struct {
done bool;
doit chan bool; // buffer of 1
}
-type Request struct {
+type _Request struct {
f *();
- reply chan *Job
+ reply chan *_Job
}
-// TODO: Would like to use chan Request but 6g rejects it.
-var service = make(chan *Request)
-var jobmap = make(map[*()]*Job)
+var service = make(chan _Request)
+var jobmap = make(map[*()]*_Job)
// Moderate access to the jobmap.
// Even if accesses were thread-safe (they should be but are not)
// something needs to serialize creation of new jobs.
// That's what the Server does.
-func Server() {
+func server() {
for {
req := <-service;
job, present := jobmap[req.f];
if !present {
- job = new(Job);
+ job = new(_Job);
job.doit = make(chan bool, 1);
job.doit <- true;
jobmap[req.f] = job
// If not there, ask map server to make one.
// TODO: Uncomment use of jobmap[f] once
// maps are thread-safe.
- var job *Job;
+ var job *_Job;
var present bool;
// job, present = jobmap[f]
if !present {
- c := make(chan *Job);
- req := Request{f, c};
- service <- &req;
+ c := make(chan *_Job);
+ service <- _Request{f, c};
job = <-c
}
}
func init() {
- go Server()
+ go server()
}
)
var ncall int;
-func Call() {
+func call() {
ncall++
}
export func TestOnce(t *testing.T) {
ncall = 0;
- once.Do(&Call);
+ once.Do(&call);
if ncall != 1 {
- t.Fatalf("once.Do(&Call) didn't Call(): ncall=%d", ncall);
+ t.Fatalf("once.Do(&call) didn't call(): ncall=%d", ncall);
}
- once.Do(&Call);
+ once.Do(&call);
if ncall != 1 {
- t.Fatalf("second once.Do(&Call) did Call(): ncall=%d", ncall);
+ t.Fatalf("second once.Do(&call) did call(): ncall=%d", ncall);
}
- once.Do(&Call);
+ once.Do(&call);
if ncall != 1 {
- t.Fatalf("third once.Do(&Call) did Call(): ncall=%d", ncall);
+ t.Fatalf("third once.Do(&call) did call(): ncall=%d", ncall);
}
}
package rand
-// rand, rand31, rand63 - return non-negative random int, int32, int64
+// rand, rand31, Int63 - return non-negative random int, int32, int64
// urand32 - return random uint32
-// nrand, nrand31, nrand63 - return 0 <= random < n
+// nrand, nrand31, Int63n - return 0 <= random < n
// frand, frand64, frand32 - return 0 <= random float, float64, float32 < 1
// perm gives a random permutation []int
-const
-(
- LEN = 607;
- TAP = 273;
- MASK = (1<<63)-1;
- A = 48271;
- M = 2147483647;
- Q = 44488;
- R = 3399;
+const (
+ _LEN = 607;
+ _TAP = 273;
+ _MASK = (1<<63)-1;
+ _A = 48271;
+ _M = 2147483647;
+ _Q = 44488;
+ _R = 3399;
)
-var
-(
- rng_cooked [LEN]int64; // cooked random numbers
- rng_vec [LEN]int64; // current feedback register
+var (
+ rng_cooked [_LEN]int64; // cooked random numbers
+ rng_vec [_LEN]int64; // current feedback register
rng_tap int; // index into vector
rng_feed int; // index into vector
)
-func
-seedrand(x int32) int32
-{
+func seedrand(x int32) int32 {
// seed rng x[n+1] = 48271 * x[n] mod (2**31 - 1)
- hi := x / Q;
- lo := x % Q;
- x = A*lo - R*hi;
+ hi := x / _Q;
+ lo := x % _Q;
+ x = _A*lo - _R*hi;
if x < 0 {
- x += M;
+ x += _M;
}
return x;
}
-export func
-srand(seed int32)
-{
+export func Seed(seed int32) {
rng_tap = 0;
- rng_feed = LEN-TAP;
+ rng_feed = _LEN-_TAP;
- seed = seed%M;
+ seed = seed%_M;
if seed < 0 {
- seed += M;
+ seed += _M;
}
if seed == 0 {
seed = 89482311;
}
x := seed;
- for i := -20; i < LEN; i++ {
+ for i := -20; i < _LEN; i++ {
x = seedrand(x);
if i >= 0 {
var u int64;
x = seedrand(x);
u ^= int64(x);
u ^= rng_cooked[i];
- rng_vec[i] = u & MASK;
+ rng_vec[i] = u & _MASK;
}
}
}
-export func
-rand63() int64
-{
+export func Int63() int64 {
rng_tap--;
if rng_tap < 0 {
- rng_tap += LEN;
+ rng_tap += _LEN;
}
rng_feed--;
if rng_feed < 0 {
- rng_feed += LEN;
+ rng_feed += _LEN;
}
- x := (rng_vec[rng_feed] + rng_vec[rng_tap]) & MASK;
+ x := (rng_vec[rng_feed] + rng_vec[rng_tap]) & _MASK;
rng_vec[rng_feed] = x;
return x;
}
-export func
-urand32() uint32
-{
- return uint32(rand63() >> 31);
+export func Uint32() uint32 {
+ return uint32(Int63() >> 31);
}
-export func
-rand31() int32
-{
- return int32(rand63() >> 32);
+export func Int31() int32 {
+ return int32(Int63() >> 32);
}
-export func
-rand() int
-{
- u := uint(rand63());
+export func Int() int {
+ u := uint(Int63());
return int(u << 1 >> 1); // clear sign bit if int == int32
}
-export func
-nrand63(n int64) int64
-{
+export func Int63n(n int64) int64 {
if n <= 0 {
return 0
}
max := int64((1<<63)-1 - (1<<63) % uint64(n));
- v := rand63();
+ v := Int63();
for v > max {
- v = rand63()
+ v = Int63()
}
return v % n
}
-export func
-nrand31(n int32) int32
-{
- return int32(nrand63(int64(n)))
+export func Int31n(n int32) int32 {
+ return int32(Int63n(int64(n)))
}
-export func
-nrand(n int) int
-{
- return int(nrand63(int64(n)))
+export func Intn(n int) int {
+ return int(Int63n(int64(n)))
}
-export func
-frand64() float64
-{
- x := float64(rand63()) / float64(MASK);
+export func Float64() float64 {
+ x := float64(Int63()) / float64(_MASK);
for x >= 1 {
- x = float64(rand63()) / float64(MASK);
+ x = float64(Int63()) / float64(_MASK);
}
return x;
}
-export func
-frand32() float32
-{
- return float32(frand64())
+export func Float32() float32 {
+ return float32(Float64())
}
-export func
-frand() float
+export func Float() float
{
- return float(frand64())
+ return float(Float64())
}
-export func
-perm(n int) []int
-{
+export func Perm(n int) []int {
m := make([]int, n);
for i:=0; i<n; i++ {
m[i] = i;
}
for i:=0; i<n; i++ {
- j := nrand(n);
+ j := Intn(n);
t := m[i];
m[i] = m[j];
m[j] = t;
return m;
}
-func
-init()
-{
+func init() {
// the state of the rng
// after 780e10 iterations
rng_cooked[605] = 9103922860780351547;
rng_cooked[606] = 4152330101494654406;
- srand(1);
+ Seed(1);
}
export func TestSortLarge_Random(t *testing.T) {
data := make([]int, 1000000);
for i := 0; i < len(data); i++ {
- data[i] = rand.rand() % 100;
+ data[i] = rand.Intn(100);
}
if sort.IntsAreSorted(data) {
t.Fatalf("terrible rand.rand");
case _Sawtooth:
data[i] = i % m;
case _Rand:
- data[i] = rand.rand() % m;
+ data[i] = rand.Intn(m);
case _Stagger:
data[i] = (i*m + i) % n;
case _Plateau:
data[i] = min(i, m);
case _Shuffle:
- if rand.rand() % m != 0 {
+ if rand.Intn(m) != 0 {
j += 2;
data[i] = j;
} else {
import "utf8"
// Split string into array of UTF-8 sequences (still strings)
-export func explode(s string) []string {
+export func Explode(s string) []string {
a := make([]string, utf8.RuneCountInString(s, 0, len(s)));
j := 0;
var size, rune int;
}
// Count non-overlapping instances of sep in s.
-export func count(s, sep string) int {
+export func Count(s, sep string) int {
if sep == "" {
return utf8.RuneCountInString(s, 0, len(s))+1
}
}
// Return index of first instance of sep in s.
-export func index(s, sep string) int {
+export func Index(s, sep string) int {
if sep == "" {
return 0
}
}
// Split string into list of strings at separators
-export func split(s, sep string) []string {
+export func Split(s, sep string) []string {
if sep == "" {
- return explode(s)
+ return Explode(s)
}
c := sep[0];
start := 0;
- n := count(s, sep)+1;
+ n := Count(s, sep)+1;
a := make([]string, n);
na := 0;
for i := 0; i+len(sep) <= len(s); i++ {
}
// Join list of strings with separators between them.
-export func join(a []string, sep string) string {
+export func Join(a []string, sep string) string {
if len(a) == 0 {
return ""
}
var commas = "1,2,3,4";
var dots = "1....2....3....4";
-type ExplodeTest struct {
+export type ExplodeTest struct {
s string;
a []string;
}
export func TestExplode(t *testing.T) {
for i := 0; i < len(explodetests); i++ {
tt := explodetests[i];
- a := explode(tt.s);
+ a := Explode(tt.s);
if !eq(a, tt.a) {
t.Errorf("Explode(%q) = %v; want %v", tt.s, a, tt.a);
continue;
}
- s := join(a, "");
+ s := Join(a, "");
if s != tt.s {
t.Errorf(`Join(Explode(%q), "") = %q`, tt.s, s);
}
}
}
-type SplitTest struct {
+export type SplitTest struct {
s string;
sep string;
a []string;
export func TestSplit(t *testing.T) {
for i := 0; i < len(splittests); i++ {
tt := splittests[i];
- a := split(tt.s, tt.sep);
+ a := Split(tt.s, tt.sep);
if !eq(a, tt.a) {
t.Errorf("Split(%q, %q) = %v; want %v", tt.s, tt.sep, a, tt.a);
continue;
}
- s := join(a, tt.sep);
+ s := Join(a, tt.sep);
if s != tt.s {
t.Errorf("Join(Split(%q, %q), %q) = %q", tt.s, tt.sep, tt.sep, s);
}
)
const (
- T1 = 0x00; // 0000 0000
- Tx = 0x80; // 1000 0000
- T2 = 0xC0; // 1100 0000
- T3 = 0xE0; // 1110 0000
- T4 = 0xF0; // 1111 0000
- T5 = 0xF8; // 1111 1000
-
- Maskx = 0x3F; // 0011 1111
- Mask2 = 0x1F; // 0001 1111
- Mask3 = 0x0F; // 0000 1111
- Mask4 = 0x07; // 0000 0111
-
- Rune1Max = 1<<7 - 1;
- Rune2Max = 1<<11 - 1;
- Rune3Max = 1<<16 - 1;
- Rune4Max = 1<<21 - 1;
+ _T1 = 0x00; // 0000 0000
+ _Tx = 0x80; // 1000 0000
+ _T2 = 0xC0; // 1100 0000
+ _T3 = 0xE0; // 1110 0000
+ _T4 = 0xF0; // 1111 0000
+ _T5 = 0xF8; // 1111 1000
+
+ _Maskx = 0x3F; // 0011 1111
+ _Mask2 = 0x1F; // 0001 1111
+ _Mask3 = 0x0F; // 0000 1111
+ _Mask4 = 0x07; // 0000 0111
+
+ _Rune1Max = 1<<7 - 1;
+ _Rune2Max = 1<<11 - 1;
+ _Rune3Max = 1<<16 - 1;
+ _Rune4Max = 1<<21 - 1;
)
-func DecodeRuneInternal(p []byte) (rune, size int, short bool) {
+func decodeRuneInternal(p []byte) (rune, size int, short bool) {
n := len(p);
if n < 1 {
return RuneError, 0, true;
c0 := p[0];
// 1-byte, 7-bit sequence?
- if c0 < Tx {
+ if c0 < _Tx {
return int(c0), 1, false
}
// unexpected continuation byte?
- if c0 < T2 {
+ if c0 < _T2 {
return RuneError, 1, false
}
return RuneError, 1, true
}
c1 := p[1];
- if c1 < Tx || T2 <= c1 {
+ if c1 < _Tx || _T2 <= c1 {
return RuneError, 1, false
}
// 2-byte, 11-bit sequence?
- if c0 < T3 {
- rune = int(c0&Mask2)<<6 | int(c1&Maskx);
- if rune <= Rune1Max {
+ if c0 < _T3 {
+ rune = int(c0&_Mask2)<<6 | int(c1&_Maskx);
+ if rune <= _Rune1Max {
return RuneError, 1, false
}
return rune, 2, false
return RuneError, 1, true
}
c2 := p[2];
- if c2 < Tx || T2 <= c2 {
+ if c2 < _Tx || _T2 <= c2 {
return RuneError, 1, false
}
// 3-byte, 16-bit sequence?
- if c0 < T4 {
- rune = int(c0&Mask3)<<12 | int(c1&Maskx)<<6 | int(c2&Maskx);
- if rune <= Rune2Max {
+ if c0 < _T4 {
+ rune = int(c0&_Mask3)<<12 | int(c1&_Maskx)<<6 | int(c2&_Maskx);
+ if rune <= _Rune2Max {
return RuneError, 1, false
}
return rune, 3, false
return RuneError, 1, true
}
c3 := p[3];
- if c3 < Tx || T2 <= c3 {
+ if c3 < _Tx || _T2 <= c3 {
return RuneError, 1, false
}
// 4-byte, 21-bit sequence?
- if c0 < T5 {
- rune = int(c0&Mask4)<<18 | int(c1&Maskx)<<12 | int(c2&Maskx)<<6 | int(c3&Maskx);
- if rune <= Rune3Max {
+ if c0 < _T5 {
+ rune = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx);
+ if rune <= _Rune3Max {
return RuneError, 1, false
}
return rune, 4, false
return RuneError, 1, false
}
-func DecodeRuneInStringInternal(s string, i int, n int) (rune, size int, short bool) {
+func decodeRuneInStringInternal(s string, i int, n int) (rune, size int, short bool) {
if n < 1 {
return RuneError, 0, true;
}
c0 := s[i];
// 1-byte, 7-bit sequence?
- if c0 < Tx {
+ if c0 < _Tx {
return int(c0), 1, false
}
// unexpected continuation byte?
- if c0 < T2 {
+ if c0 < _T2 {
return RuneError, 1, false
}
return RuneError, 1, true
}
c1 := s[i+1];
- if c1 < Tx || T2 <= c1 {
+ if c1 < _Tx || _T2 <= c1 {
return RuneError, 1, false
}
// 2-byte, 11-bit sequence?
- if c0 < T3 {
- rune = int(c0&Mask2)<<6 | int(c1&Maskx);
- if rune <= Rune1Max {
+ if c0 < _T3 {
+ rune = int(c0&_Mask2)<<6 | int(c1&_Maskx);
+ if rune <= _Rune1Max {
return RuneError, 1, false
}
return rune, 2, false
return RuneError, 1, true
}
c2 := s[i+2];
- if c2 < Tx || T2 <= c2 {
+ if c2 < _Tx || _T2 <= c2 {
return RuneError, 1, false
}
// 3-byte, 16-bit sequence?
- if c0 < T4 {
- rune = int(c0&Mask3)<<12 | int(c1&Maskx)<<6 | int(c2&Maskx);
- if rune <= Rune2Max {
+ if c0 < _T4 {
+ rune = int(c0&_Mask3)<<12 | int(c1&_Maskx)<<6 | int(c2&_Maskx);
+ if rune <= _Rune2Max {
return RuneError, 1, false
}
return rune, 3, false
return RuneError, 1, true
}
c3 := s[i+3];
- if c3 < Tx || T2 <= c3 {
+ if c3 < _Tx || _T2 <= c3 {
return RuneError, 1, false
}
// 4-byte, 21-bit sequence?
- if c0 < T5 {
- rune = int(c0&Mask4)<<18 | int(c1&Maskx)<<12 | int(c2&Maskx)<<6 | int(c3&Maskx);
- if rune <= Rune3Max {
+ if c0 < _T5 {
+ rune = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx);
+ if rune <= _Rune3Max {
return RuneError, 1, false
}
return rune, 4, false
}
export func FullRune(p []byte) bool {
- rune, size, short := DecodeRuneInternal(p);
+ rune, size, short := decodeRuneInternal(p);
return !short
}
export func FullRuneInString(s string, i int) bool {
- rune, size, short := DecodeRuneInStringInternal(s, i, len(s) - i);
+ rune, size, short := decodeRuneInStringInternal(s, i, len(s) - i);
return !short
}
export func DecodeRune(p []byte) (rune, size int) {
var short bool;
- rune, size, short = DecodeRuneInternal(p);
+ rune, size, short = decodeRuneInternal(p);
return;
}
export func DecodeRuneInString(s string, i int) (rune, size int) {
var short bool;
- rune, size, short = DecodeRuneInStringInternal(s, i, len(s) - i);
+ rune, size, short = decodeRuneInStringInternal(s, i, len(s) - i);
return;
}
export func RuneLen(rune int) int {
switch {
- case rune <= Rune1Max:
+ case rune <= _Rune1Max:
return 1;
- case rune <= Rune2Max:
+ case rune <= _Rune2Max:
return 2;
- case rune <= Rune3Max:
+ case rune <= _Rune3Max:
return 3;
- case rune <= Rune4Max:
+ case rune <= _Rune4Max:
return 4;
}
return -1;
}
export func EncodeRune(rune int, p []byte) int {
- if rune <= Rune1Max {
+ if rune <= _Rune1Max {
p[0] = byte(rune);
return 1;
}
- if rune <= Rune2Max {
- p[0] = T2 | byte(rune>>6);
- p[1] = Tx | byte(rune)&Maskx;
+ if rune <= _Rune2Max {
+ p[0] = _T2 | byte(rune>>6);
+ p[1] = _Tx | byte(rune)&_Maskx;
return 2;
}
rune = RuneError
}
- if rune <= Rune3Max {
- p[0] = T3 | byte(rune>>12);
- p[1] = Tx | byte(rune>>6)&Maskx;
- p[2] = Tx | byte(rune)&Maskx;
+ if rune <= _Rune3Max {
+ p[0] = _T3 | byte(rune>>12);
+ p[1] = _Tx | byte(rune>>6)&_Maskx;
+ p[2] = _Tx | byte(rune)&_Maskx;
return 3;
}
- p[0] = T4 | byte(rune>>18);
- p[1] = Tx | byte(rune>>12)&Maskx;
- p[2] = Tx | byte(rune>>6)&Maskx;
- p[3] = Tx | byte(rune)&Maskx;
+ p[0] = _T4 | byte(rune>>18);
+ p[1] = _Tx | byte(rune>>12)&_Maskx;
+ p[2] = _Tx | byte(rune>>6)&_Maskx;
+ p[3] = _Tx | byte(rune)&_Maskx;
return 4;
}
if s[i] < RuneSelf {
i++;
} else {
- rune, size, short := DecodeRuneInStringInternal(s, i, ei - i);
+ rune, size, short := decodeRuneInStringInternal(s, i, ei - i);
i += size;
}
}
"utf8";
)
-type Utf8Map struct {
+export type Utf8Map struct {
rune int;
str string;
}
Utf8Map{ 0x10ffff, "\xf4\x8f\xbf\xbf" },
}
-func Bytes(s string) []byte {
+// like io.StringBytes but leaves one extra byte at end
+func bytes(s string) []byte {
b := make([]byte, len(s)+1);
if !syscall.StringToBytes(b, s) {
- panic("StringToBytes failed");
+ panic("StringTobytes failed");
}
return b[0:len(s)];
}
export func TestFullRune(t *testing.T) {
for i := 0; i < len(utf8map); i++ {
m := utf8map[i];
- b := Bytes(m.str);
+ b := bytes(m.str);
if !utf8.FullRune(b) {
t.Errorf("FullRune(%q) (rune %04x) = false, want true", b, m.rune);
}
}
}
-func EqualBytes(a, b []byte) bool {
+func equalBytes(a, b []byte) bool {
if len(a) != len(b) {
return false;
}
export func TestEncodeRune(t *testing.T) {
for i := 0; i < len(utf8map); i++ {
m := utf8map[i];
- b := Bytes(m.str);
+ b := bytes(m.str);
var buf [10]byte;
n := utf8.EncodeRune(m.rune, buf);
b1 := buf[0:n];
- if !EqualBytes(b, b1) {
+ if !equalBytes(b, b1) {
t.Errorf("EncodeRune(0x%04x) = %q want %q", m.rune, b1, b);
}
}
export func TestDecodeRune(t *testing.T) {
for i := 0; i < len(utf8map); i++ {
m := utf8map[i];
- b := Bytes(m.str);
+ b := bytes(m.str);
rune, size := utf8.DecodeRune(b);
if rune != m.rune || size != len(b) {
t.Errorf("DecodeRune(%q) = 0x%04x, %d want 0x%04x, %d", b, rune, size, m.rune, len(b));
t.Errorf("DecodeRune(%q, 2) = 0x%04x, %d want 0x%04x, %d", s, rune, size, m.rune, len(b));
}
- // there's an extra byte that Bytes left behind - make sure trailing byte works
+ // there's an extra byte that bytes left behind - make sure trailing byte works
rune, size = utf8.DecodeRune(b[0:cap(b)]);
if rune != m.rune || size != len(b) {
t.Errorf("DecodeRune(%q) = 0x%04x, %d want 0x%04x, %d", b, rune, size, m.rune, len(b));
}
}
-type RuneCountTest struct {
+export type RuneCountTest struct {
in string;
out int;
}
if out := utf8.RuneCountInString(tt.in, 0, len(tt.in)); out != tt.out {
t.Errorf("RuneCountInString(%q) = %d, want %d", tt.in, out, tt.out);
}
- if out := utf8.RuneCount(Bytes(tt.in)); out != tt.out {
+ if out := utf8.RuneCount(bytes(tt.in)); out != tt.out {
t.Errorf("RuneCount(%q) = %d, want %d", tt.in, out, tt.out);
}
}