URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [ken/] [rob2.go] - Blame information for rev 700

Details | Compare with Previous | View Log


// $G $D/$F.go && $L $F.$A && ./$A.out
 
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
package main
 
import "fmt"
 
const nilchar = 0
 
type Atom struct {
        str     string
        integer int
        next    *Slist /* in hash bucket */
}
 
type List struct {
        car *Slist
        cdr *Slist
}
 
type Slist struct {
        isatom   bool
        isstring bool
        //union {
        atom Atom
        list List
        //} u;
 
}
 
func (this *Slist) Car() *Slist {
        return this.list.car
}
 
func (this *Slist) Cdr() *Slist {
        return this.list.cdr
}
 
func (this *Slist) String() string {
        return this.atom.str
}
 
func (this *Slist) Integer() int {
        return this.atom.integer
}
 
func (slist *Slist) Free() {
        if slist == nil {
                return
        }
        if slist.isatom {
                //              free(slist.String());
        } else {
                slist.Car().Free()
                slist.Cdr().Free()
        }
        //      free(slist);
}
 
//Slist* atom(byte *s, int i);
 
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
 
const EOF int = -1
 
func main() {
        var list *Slist
 
        OpenFile()
        for {
                list = Parse()
                if list == nil {
                        break
                }
                r := list.Print()
                list.Free()
                if r != "(defn foo (add 12 34))" {
                        panic(r)
                }
                break
        }
}
 
func (slist *Slist) PrintOne(doparen bool) string {
        if slist == nil {
                return ""
        }
        var r string
        if slist.isatom {
                if slist.isstring {
                        r = slist.String()
                } else {
                        r = fmt.Sprintf("%v", slist.Integer())
                }
        } else {
                if doparen {
                        r += "("
                }
                r += slist.Car().PrintOne(true)
                if slist.Cdr() != nil {
                        r += " "
                        r += slist.Cdr().PrintOne(false)
                }
                if doparen {
                        r += ")"
                }
        }
        return r
}
 
func (slist *Slist) Print() string {
        return slist.PrintOne(true)
}
 
func Get() int {
        var c int
 
        if peekc >= 0 {
                c = peekc
                peekc = -1
        } else {
                c = int(input[inputindex])
                inputindex++
                if c == '\n' {
                        lineno = lineno + 1
                }
                if c == nilchar {
                        inputindex = inputindex - 1
                        c = EOF
                }
        }
        return c
}
 
func WhiteSpace(c int) bool {
        return c == ' ' || c == '\t' || c == '\r' || c == '\n'
}
 
func NextToken() {
        var i, c int
 
        tokenbuf[0] = nilchar // clear previous token
        c = Get()
        for WhiteSpace(c) {
                c = Get()
        }
        switch c {
        case EOF:
                token = EOF
        case '(', ')':
                token = c
                break
        default:
                for i = 0; i < 100-1; { // sizeof tokenbuf - 1
                        tokenbuf[i] = byte(c)
                        i = i + 1
                        c = Get()
                        if c == EOF {
                                break
                        }
                        if WhiteSpace(c) || c == ')' {
                                peekc = c
                                break
                        }
                }
                if i >= 100-1 { // sizeof tokenbuf - 1
                        panic("atom too long\n")
                }
                tokenlen = i
                tokenbuf[i] = nilchar
                if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' {
                        token = '0'
                } else {
                        token = 'A'
                }
        }
}
 
func Expect(c int) {
        if token != c {
                print("parse error: expected ", c, "\n")
                panic("parse")
        }
        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
                }
                slist.list.cdr = new(Slist)
                slist = slist.list.cdr
        }
        return retval
}
 
func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)
        var slist *Slist
 
        slist = new(Slist)
        if token == '0' {
                slist.atom.integer = i
                slist.isstring = false
        } else {
                slist.atom.str = string(tokenbuf[0:tokenlen])
                slist.isstring = true
        }
        slist.isatom = true
        return slist
}
 
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')
        }
        return v
}
 
func Parse() *Slist {
        var slist *Slist
 
        if token == EOF || token == ')' {
                return nil
        }
        if token == '(' {
                NextToken()
                slist = ParseList()
                Expect(')')
                return slist
        } else {
                // Atom
                switch token {
                case EOF:
                        return nil
                case '0':
                        slist = atom(atoi())
                case '"', 'A':
                        slist = atom(0)
                default:
                        slist = nil
                        print("unknown token: ", token, "\n")
                }
                NextToken()
                return slist
        }
        return nil
}
 
func OpenFile() {
        input = "(defn foo (add 12 34))\n\x00"
        inputindex = 0
        peekc = -1 // BUG
        NextToken()
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [ken/] [rob2.go] - Blame information for rev 700

Line No.	Rev	Author	Line
1	700	jeremybenn	`// $G $D/$F.go && $L $F.$A && ./$A.out`
2
3			`// Copyright 2009 The Go Authors. All rights reserved.`
4			`// Use of this source code is governed by a BSD-style`
5			`// license that can be found in the LICENSE file.`
6
7			`package main`
8
9			`import "fmt"`
10
11			`const nilchar = 0`
12
13			`type Atom struct {`
14			`str string`
15			`integer int`
16			`next Slist / in hash bucket */`
17			`}`
18
19			`type List struct {`
20			`car *Slist`
21			`cdr *Slist`
22			`}`
23
24			`type Slist struct {`
25			`isatom bool`
26			`isstring bool`
27			`//union {`
28			`atom Atom`
29			`list List`
30			`//} u;`
31
32			`}`
33
34			`func (this Slist) Car() Slist {`
35			`return this.list.car`
36			`}`
37
38			`func (this Slist) Cdr() Slist {`
39			`return this.list.cdr`
40			`}`
41
42			`func (this *Slist) String() string {`
43			`return this.atom.str`
44			`}`
45
46			`func (this *Slist) Integer() int {`
47			`return this.atom.integer`
48			`}`
49
50			`func (slist *Slist) Free() {`
51			`if slist == nil {`
52			`return`
53			`}`
54			`if slist.isatom {`
55			`// free(slist.String());`
56			`} else {`
57			`slist.Car().Free()`
58			`slist.Cdr().Free()`
59			`}`
60			`// free(slist);`
61			`}`
62
63			`//Slist* atom(byte *s, int i);`
64
65			`var token int`
66			`var peekc int = -1`
67			`var lineno int32 = 1`
68
69			`var input string`
70			`var inputindex int = 0`
71			`var tokenbuf [100]byte`
72			`var tokenlen int = 0`
73
74			`const EOF int = -1`
75
76			`func main() {`
77			`var list *Slist`
78
79			`OpenFile()`
80			`for {`
81			`list = Parse()`
82			`if list == nil {`
83			`break`
84			`}`
85			`r := list.Print()`
86			`list.Free()`
87			`if r != "(defn foo (add 12 34))" {`
88			`panic(r)`
89			`}`
90			`break`
91			`}`
92			`}`
93
94			`func (slist *Slist) PrintOne(doparen bool) string {`
95			`if slist == nil {`
96			`return ""`
97			`}`
98			`var r string`
99			`if slist.isatom {`
100			`if slist.isstring {`
101			`r = slist.String()`
102			`} else {`
103			`r = fmt.Sprintf("%v", slist.Integer())`
104			`}`
105			`} else {`
106			`if doparen {`
107			`r += "("`
108			`}`
109			`r += slist.Car().PrintOne(true)`
110			`if slist.Cdr() != nil {`
111			`r += " "`
112			`r += slist.Cdr().PrintOne(false)`
113			`}`
114			`if doparen {`
115			`r += ")"`
116			`}`
117			`}`
118			`return r`
119			`}`
120
121			`func (slist *Slist) Print() string {`
122			`return slist.PrintOne(true)`
123			`}`
124
125			`func Get() int {`
126			`var c int`
127
128			`if peekc >= 0 {`
129			`c = peekc`
130			`peekc = -1`
131			`} else {`
132			`c = int(input[inputindex])`
133			`inputindex++`
134			`if c == '\n' {`
135			`lineno = lineno + 1`
136			`}`
137			`if c == nilchar {`
138			`inputindex = inputindex - 1`
139			`c = EOF`
140			`}`
141			`}`
142			`return c`
143			`}`
144
145			`func WhiteSpace(c int) bool {`
146			`return c == ' ' \|\| c == '\t' \|\| c == '\r' \|\| c == '\n'`
147			`}`
148
149			`func NextToken() {`
150			`var i, c int`
151
152			`tokenbuf[0] = nilchar // clear previous token`
153			`c = Get()`
154			`for WhiteSpace(c) {`
155			`c = Get()`
156			`}`
157			`switch c {`
158			`case EOF:`
159			`token = EOF`
160			`case '(', ')':`
161			`token = c`
162			`break`
163			`default:`
164			`for i = 0; i < 100-1; { // sizeof tokenbuf - 1`
165			`tokenbuf[i] = byte(c)`
166			`i = i + 1`
167			`c = Get()`
168			`if c == EOF {`
169			`break`
170			`}`
171			`if WhiteSpace(c) \|\| c == ')' {`
172			`peekc = c`
173			`break`
174			`}`
175			`}`
176			`if i >= 100-1 { // sizeof tokenbuf - 1`
177			`panic("atom too long\n")`
178			`}`
179			`tokenlen = i`
180			`tokenbuf[i] = nilchar`
181			`if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' {`
182			`token = '0'`
183			`} else {`
184			`token = 'A'`
185			`}`
186			`}`
187			`}`
188
189			`func Expect(c int) {`
190			`if token != c {`
191			`print("parse error: expected ", c, "\n")`
192			`panic("parse")`
193			`}`
194			`NextToken()`
195			`}`
196
197			`// Parse a non-parenthesized list up to a closing paren or EOF`
198			`func ParseList() *Slist {`
199			`var slist, retval *Slist`
200
201			`slist = new(Slist)`
202			`slist.list.car = nil`
203			`slist.list.cdr = nil`
204			`slist.isatom = false`
205			`slist.isstring = false`
206
207			`retval = slist`
208			`for {`
209			`slist.list.car = Parse()`
210			`if token == ')' \|\| token == EOF { // empty cdr`
211			`break`
212			`}`
213			`slist.list.cdr = new(Slist)`
214			`slist = slist.list.cdr`
215			`}`
216			`return retval`
217			`}`
218
219			`func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)`
220			`var slist *Slist`
221
222			`slist = new(Slist)`
223			`if token == '0' {`
224			`slist.atom.integer = i`
225			`slist.isstring = false`
226			`} else {`
227			`slist.atom.str = string(tokenbuf[0:tokenlen])`
228			`slist.isstring = true`
229			`}`
230			`slist.isatom = true`
231			`return slist`
232			`}`
233
234			`func atoi() int { // BUG: uses tokenbuf; should take argument)`
235			`var v int = 0`
236			`for i := 0; i < tokenlen && '0' <= tokenbuf[i] && tokenbuf[i] <= '9'; i = i + 1 {`
237			`v = 10*v + int(tokenbuf[i]-'0')`
238			`}`
239			`return v`
240			`}`
241
242			`func Parse() *Slist {`
243			`var slist *Slist`
244
245			`if token == EOF \|\| token == ')' {`
246			`return nil`
247			`}`
248			`if token == '(' {`
249			`NextToken()`
250			`slist = ParseList()`
251			`Expect(')')`
252			`return slist`
253			`} else {`
254			`// Atom`
255			`switch token {`
256			`case EOF:`
257			`return nil`
258			`case '0':`
259			`slist = atom(atoi())`
260			`case '"', 'A':`
261			`slist = atom(0)`
262			`default:`
263			`slist = nil`
264			`print("unknown token: ", token, "\n")`
265			`}`
266			`NextToken()`
267			`return slist`
268			`}`
269			`return nil`
270			`}`
271
272			`func OpenFile() {`
273			`input = "(defn foo (add 12 34))\n\x00"`
274			`inputindex = 0`
275			`peekc = -1 // BUG`
276			`NextToken()`
277			`}`