}
type Vector struct {
- nelem int;
- elem []Element;
+ nelem int
+ elem []Element
}
func New() *Vector {
- v := new(Vector);
- v.nelem = 0;
- v.elem = make([]Element, 10);
- return v;
+ v := new(Vector)
+ v.nelem = 0
+ v.elem = make([]Element, 10)
+ return v
}
func (v *Vector) At(i int) Element {
- return v.elem[i];
+ return v.elem[i]
}
func (v *Vector) Insert(e Element) {
- v.elem[v.nelem] = e;
- v.nelem++;
+ v.elem[v.nelem] = e
+ v.nelem++
}
func main() {
- type I struct { val int; };
- i0 := new(I); i0.val = 0;
- i1 := new(I); i1.val = 11;
- i2 := new(I); i2.val = 222;
- i3 := new(I); i3.val = 3333;
- i4 := new(I); i4.val = 44444;
- v := New();
- print("hi\n");
- v.Insert(i4);
- v.Insert(i3);
- v.Insert(i2);
- v.Insert(i1);
- v.Insert(i0);
+ type I struct{ val int }
+ i0 := new(I)
+ i0.val = 0
+ i1 := new(I)
+ i1.val = 11
+ i2 := new(I)
+ i2.val = 222
+ i3 := new(I)
+ i3.val = 3333
+ i4 := new(I)
+ i4.val = 44444
+ v := New()
+ print("hi\n")
+ v.Insert(i4)
+ v.Insert(i3)
+ v.Insert(i2)
+ v.Insert(i1)
+ v.Insert(i0)
for i := 0; i < v.nelem; i++ {
- var x *I;
- x = v.At(i).(*I);
- print(i, " ", x.val, "\n"); // prints correct list
+ var x *I
+ x = v.At(i).(*I)
+ print(i, " ", x.val, "\n") // prints correct list
}
for i := 0; i < v.nelem; i++ {
- print(i, " ", v.At(i).(*I).val, "\n");
+ print(i, " ", v.At(i).(*I).val, "\n")
}
}
+
/*
bug027.go:50: illegal types for operand
(<Element>I{}) CONV (<I>{})
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-
package main
-const nilchar = 0;
+const nilchar = 0
type Atom struct {
- str string;
- integer int;
- next *Slist; /* in hash bucket */
+ str string
+ integer int
+ next *Slist /* in hash bucket */
}
type List struct {
- car *Slist;
- cdr*Slist;
+ car *Slist
+ cdr *Slist
}
type Slist struct {
- isatom bool;
- isstring bool;
+ isatom bool
+ isstring bool
//union {
- atom Atom;
- list List;
+ atom Atom
+ list List
//} u;
}
func (this *Slist) Car() *Slist {
- return this.list.car;
+ return this.list.car
}
func (this *Slist) Cdr() *Slist {
- return this.list.cdr;
+ return this.list.cdr
}
func (this *Slist) String() string {
- return this.atom.str;
+ return this.atom.str
}
func (this *Slist) Integer() int {
- return this.atom.integer;
+ return this.atom.integer
}
func (slist *Slist) Free() {
if slist == nil {
- return;
+ return
}
if slist.isatom {
-// free(slist.String());
+ // free(slist.String());
} else {
- slist.Car().Free();
- slist.Cdr().Free();
+ slist.Car().Free()
+ slist.Cdr().Free()
}
-// free(slist);
+ // free(slist);
}
//Slist* atom(byte *s, int i);
-var token int;
-var peekc int = -1;
-var lineno int32 = 1;
+var token int
+var peekc int = -1
+var lineno int32 = 1
-var input string;
-var inputindex int = 0;
-var tokenbuf [100]byte;
-var tokenlen int = 0;
+var input string
+var inputindex int = 0
+var tokenbuf [100]byte
+var tokenlen int = 0
-const EOF int = -1;
+const EOF int = -1
func main() {
- var list *Slist;
+ var list *Slist
- OpenFile();
- for ;; {
- list = Parse();
+ OpenFile()
+ for {
+ list = Parse()
if list == nil {
- break;
+ break
}
- list.Print();
- list.Free();
- break;
+ list.Print()
+ list.Free()
+ break
}
}
func (slist *Slist) PrintOne(doparen bool) {
if slist == nil {
- return;
+ return
}
if slist.isatom {
if slist.isstring {
- print(slist.String());
+ print(slist.String())
} else {
- print(slist.Integer());
+ print(slist.Integer())
}
} else {
if doparen {
- print("(" );
+ print("(")
}
- slist.Car().PrintOne(true);
+ slist.Car().PrintOne(true)
if slist.Cdr() != nil {
- print(" ");
- slist.Cdr().PrintOne(false);
+ print(" ")
+ slist.Cdr().PrintOne(false)
}
if doparen {
- print(")");
+ print(")")
}
}
}
func (slist *Slist) Print() {
- slist.PrintOne(true);
- print("\n");
+ slist.PrintOne(true)
+ print("\n")
}
func Get() int {
- var c int;
+ var c int
if peekc >= 0 {
- c = peekc;
- peekc = -1;
+ c = peekc
+ peekc = -1
} else {
- c = int(input[inputindex]);
- inputindex++;
+ c = int(input[inputindex])
+ inputindex++
if c == '\n' {
- lineno = lineno + 1;
+ lineno = lineno + 1
}
if c == nilchar {
- inputindex = inputindex - 1;
- c = EOF;
+ inputindex = inputindex - 1
+ c = EOF
}
}
- return c;
+ return c
}
func WhiteSpace(c int) bool {
- return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+ return c == ' ' || c == '\t' || c == '\r' || c == '\n'
}
func NextToken() {
- var i, c int;
+ var i, c int
- tokenbuf[0] = nilchar; // clear previous token
- c = Get();
+ tokenbuf[0] = nilchar // clear previous token
+ c = Get()
for WhiteSpace(c) {
- c = Get();
+ c = Get()
}
switch c {
case EOF:
- token = EOF;
+ token = EOF
case '(', ')':
- token = c;
- break;
+ token = c
+ break
default:
- for i = 0; i < 100 - 1; { // sizeof tokenbuf - 1
- tokenbuf[i] = byte(c);
- i = i + 1;
- c = Get();
+ for i = 0; i < 100-1; { // sizeof tokenbuf - 1
+ tokenbuf[i] = byte(c)
+ i = i + 1
+ c = Get()
if c == EOF {
- break;
+ break
}
if WhiteSpace(c) || c == ')' {
- peekc = c;
- break;
+ peekc = c
+ break
}
}
- if i >= 100 - 1 { // sizeof tokenbuf - 1
- panic("atom too long\n");
+ if i >= 100-1 { // sizeof tokenbuf - 1
+ panic("atom too long\n")
}
- tokenlen = i;
- tokenbuf[i] = nilchar;
+ tokenlen = i
+ tokenbuf[i] = nilchar
if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' {
- token = '0';
+ token = '0'
} else {
- token = 'A';
+ token = 'A'
}
}
}
func Expect(c int) {
if token != c {
- print("parse error: expected ", c, "\n");
- panic("parse");
+ print("parse error: expected ", c, "\n")
+ panic("parse")
}
- NextToken();
+ NextToken()
}
// Parse a non-parenthesized list up to a closing paren or EOF
func ParseList() *Slist {
- var slist, retval *Slist;
-
- slist = new(Slist);
- slist.list.car = nil;
- slist.list.cdr = nil;
- slist.isatom = false;
- slist.isstring = false;
-
- retval = slist;
- for ;; {
- slist.list.car = Parse();
- if token == ')' || token == EOF { // empty cdr
- break;
+ var slist, retval *Slist
+
+ slist = new(Slist)
+ slist.list.car = nil
+ slist.list.cdr = nil
+ slist.isatom = false
+ slist.isstring = false
+
+ retval = slist
+ for {
+ slist.list.car = Parse()
+ if token == ')' || token == EOF { // empty cdr
+ break
}
- slist.list.cdr = new(Slist);
- slist = slist.list.cdr;
+ slist.list.cdr = new(Slist)
+ slist = slist.list.cdr
}
- return retval;
+ return retval
}
-func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)
- var slist *Slist;
+func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)
+ var slist *Slist
- slist = new(Slist);
+ slist = new(Slist)
if token == '0' {
- slist.atom.integer = i;
- slist.isstring = false;
+ slist.atom.integer = i
+ slist.isstring = false
} else {
- slist.atom.str = string(tokenbuf[0:tokenlen]);
- slist.isstring = true;
+ slist.atom.str = string(tokenbuf[0:tokenlen])
+ slist.isstring = true
}
- slist.isatom = true;
- return slist;
+ slist.isatom = true
+ return slist
}
-func atoi() int { // BUG: uses tokenbuf; should take argument)
- var v int = 0;
+func atoi() int { // BUG: uses tokenbuf; should take argument)
+ var v int = 0
for i := 0; i < tokenlen && '0' <= tokenbuf[i] && tokenbuf[i] <= '9'; i = i + 1 {
- v = 10 * v + int(tokenbuf[i] - '0');
+ v = 10*v + int(tokenbuf[i]-'0')
}
- return v;
+ return v
}
func Parse() *Slist {
- var slist *Slist;
+ var slist *Slist
if token == EOF || token == ')' {
- return nil;
+ return nil
}
if token == '(' {
- NextToken();
- slist = ParseList();
- Expect(')');
- return slist;
+ NextToken()
+ slist = ParseList()
+ Expect(')')
+ return slist
} else {
// Atom
switch token {
case EOF:
- return nil;
+ return nil
case '0':
- slist = atom(atoi());
+ slist = atom(atoi())
case '"', 'A':
- slist = atom(0);
+ slist = atom(0)
default:
- slist = nil;
- print("unknown token: ", token, "\n");
+ slist = nil
+ print("unknown token: ", token, "\n")
}
- NextToken();
- return slist;
+ NextToken()
+ return slist
}
- return nil;
+ return nil
}
func OpenFile() {
- input = "(defn foo (add 12 34))\n\x00";
- inputindex = 0;
- peekc = -1; // BUG
- NextToken();
+ input = "(defn foo (add 12 34))\n\x00"
+ inputindex = 0
+ peekc = -1 // BUG
+ NextToken()
}
type Number *Number
-
// -------------------------------------
// Peano primitives
return nil
}
-
func is_zero(x *Number) bool {
return x == nil
}
-
func add1(x *Number) *Number {
e := new(Number)
*e = x
return e
}
-
func sub1(x *Number) *Number {
return *x
}
-
func add(x, y *Number) *Number {
if is_zero(y) {
return x
return add(add1(x), sub1(y))
}
-
func mul(x, y *Number) *Number {
if is_zero(x) || is_zero(y) {
return zero()
return add(mul(x, sub1(y)), x)
}
-
func fact(n *Number) *Number {
if is_zero(n) {
return add1(zero())
return mul(fact(sub1(n)), n)
}
-
// -------------------------------------
// Helpers to generate/count Peano integers
return zero()
}
-
func count(x *Number) int {
if is_zero(x) {
return 0
return count(sub1(x)) + 1
}
-
func check(x *Number, expected int) {
var c = count(x)
if c != expected {
}
}
-
// -------------------------------------
// Test basic functionality
check(fact(gen(5)), 120)
}
-
// -------------------------------------
// Factorial