gcc/testsuite/go.test/test/ken/rob2.go

   1 // $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 }