decl MAIN
entry MAIN
 9            call EOF s( 13 )f($ 9 )
 13           error 1 
 15           return
                                       $ 9 = 17 
{begin loop}
 17           call EXPR s( 21 )f($ 17 )
 21           loop s( 17 )
                                       $ 17 = 21 
 23           return
                                       $ 17 = 25 
 25           call EOF s( 29 )f($ 25 )
 29           code 1 
 31           return
                                       $ 25 = 31 
decl EOF
entry EOF
 33           term - s( 37 )f($ 33 )
 37           term * s( 41 )f($ 33 )
 41           return
                                       $ 33 = 41 
decl EXPR
entry EXPR
 43           call COM s( 47 )f($ 43 )
 47           return
                                       $ 43 = 49 
 49           call DEFR s( 53 )f($ 49 )
 53           call DEFE s( 57 )f($ 49 )
 57           call EOL s( 61 )f($ 49 )
 61           return
                                       $ 49 = 61 
decl DEFR
entry DEFR
 63           string f($ 63 )
 65           code 2 
 67           return
                                       $ 63 = 69 
 69           scan s($ 69 )
 71           term : f($ 71 )s( 69 )
$ 71 = 75 
 75           call STOP f($ 75 )s( 69 )
$ 75 = 69 
                                       $ 69 = 79 
                                       {end scan}
 79           return
                                       $ 69 = 79 
decl COM
entry COM
 81           term $ s( 85 )f($ 81 )
 85           scan s($ 85 )
 87           call STOP f($ 87 )s( 85 )
$ 87 = 85 
                                       $ 85 = 91 
                                       {end scan}
 91           call STOP s( 95 )f($ 81 )
 95           return
                                       $ 81 = 95 
decl DEFE
entry DEFE
 97           call EOF s( 101 )f($ 97 )
 101          code 1 
 103          return
                                       $ 97 = 105 
 105          term : s( 109 )f($ 105 )
 109          code 3 
 111          call ALT s( 115 )f($ 105 )
 115          return
                                       $ 105 = 117 
 117          error 3 
 119          scan s($ 119 )
 121          call STOP f($ 121 )s( 119 )
$ 121 = 119 
                                       $ 119 = 125 
                                       {end scan}
 125          return
                                       $ 117 = 125 
decl STOP
entry STOP
 127          term . s( 131 )f($ 127 )
 131          return
                                       $ 127 = 133 
 133          term - s( 137 )f($ 133 )
 137          return
                                       $ 133 = 137 
decl ALT
entry ALT
 139          call TM s( 143 )f($ 139 )
{begin loop}
 143          term ; s( 147 )f($ 143 )
 147          code 4 
 149          call TM s( 153 )f($ 143 )
 153          loop s( 143 )
                                       $ 143 = 153 
 155          return
                                       $ 139 = 157 
 157          error 4 
 159          scan s($ 159 )
 161          call STOP f($ 161 )s( 159 )
$ 161 = 159 
                                       $ 159 = 165 
                                       {end scan}
 165          return
                                       $ 157 = 165 
decl EOL
entry EOL
 167          term . s( 171 )f($ 167 )
 171          code 16 
 173          return
                                       $ 167 = 175 
 175          scan s($ 175 )
 177          call STOP f($ 177 )s( 175 )
$ 177 = 175 
                                       $ 175 = 181 
                                       {end scan}
 181          error 16 
 183          return
                                       $ 175 = 183 
decl TM
entry TM
 185          call ST s( 189 )f($ 185 )
{begin loop}
 189          call ST s( 193 )f($ 189 )
 193          loop s( 189 )
                                       $ 189 = 193 
 195          return
                                       $ 185 = 195 
decl ST
entry ST
 197          call AS s( 201 )f($ 197 )
 201          return
                                       $ 197 = 203 
 203          term [ s( 207 )f($ 203 )
 207          call RS s( 211 )f($ 203 )
 211          term ] s( 215 )f($ 203 )
 215          return
                                       $ 203 = 215 
decl AS
entry AS
 217          term S s( 221 )f($ 217 )
 221          code 5 
 223          return
                                       $ 217 = 225 
 225          term T s( 229 )f($ 225 )
 229          code 6 
 231          return
                                       $ 225 = 233 
 233          term N s( 237 )f($ 233 )
 237          code 7 
 239          return
                                       $ 233 = 241 
 241          term ( s( 245 )f($ 241 )
 245          call LS s( 249 )f($ 241 )
 249          term ) s( 253 )f($ 241 )
 253          return
                                       $ 241 = 255 
 255          call TS s( 259 )f($ 255 )
 259          return
                                       $ 255 = 259 
decl RS
entry RS
 261          integer f($ 261 )
 263          code 8 
 265          return
                                       $ 261 = 267 
 267          code 9 
 269          call AS s( 273 )f($ 267 )
{begin loop}
 273          call AS s( 277 )f($ 273 )
 277          loop s( 273 )
                                       $ 273 = 277 
 279          code 10 
 281          return
                                       $ 267 = 281 
decl LS
entry LS
 283          integer f($ 283 )
 285          code 11 
 287          return
                                       $ 283 = 289 
 289          code 12 
 291          call TS s( 295 )f($ 289 )
{begin loop}
 295          call TS s( 299 )f($ 295 )
 299          loop s( 295 )
                                       $ 295 = 299 
 301          code 13 
 303          return
                                       $ 289 = 303 
decl TS
entry TS
 305          term ' s( 309 )f($ 305 )
 309          call STA s( 313 )f($ 305 )
 313          term ' s( 317 )f($ 305 )
 317          code 14 
 319          return
                                       $ 305 = 321 
 321          string f($ 321 )
 323          code 15 
 325          return
                                       $ 321 = 325 
decl STA
entry STA
 327          string f($ 327 )
 329          return
                                       $ 327 = 331 
 331          teken f($ 331 )
 333          return
                                       $ 331 = 333 
einde code gen.
Lengte term_table 14 
-              1 
*              2 
:              3 
$              4 
.              5 
;              6 
[              7 
]              8 
S              9 
T              10 
N              11 
(              12 
)              13 
'              14 
Lengte name_table 16 
MAIN                                       9             0 
EOF                                        33            3 
EXPR                                       43            1 
COM                                        81            1 
DEFR                                       63            1 
DEFE                                       97            1 
EOL                                        167           1 
STOP                                       127           6 
ALT                                        139           1 
TM                                         185           2 
ST                                         197           2 
AS                                         217           3 
RS                                         261           1 
LS                                         283           1 
TS                                         305           3 
STA                                        327           1 
Lengte code_table 333