tools/misc/bugfix3.output

   1 Functor encoding for literals:
   2 literal 0       =       5
   3 literal 1       =       6
   4 literal 2       =       7
   5
   6 Functor encoding for constructors:
   7 datatype EXP:
   8         num     =       0
   9         add     =       1
  10         sub     =       2
  11         mul     =       3
  12         div     =       4
  13
  14 Index compression is enabled
  15 Algorithm is TreeGen
  16 Canonical grammar:
  17 [0]     1 : add(num(0), _)
  18 [1]     1 : add(_, num(0))
  19 [2]     1 : sub(_, num(0))
  20 [3]     1 : mul(_, num(0))
  21 [4]     1 : mul(num(0), _)
  22 [5]     1 : mul(_, num(1))
  23 [6]     1 : mul(num(1), _)
  24 [7]     1 : mul(_, num(2))
  25 [8]     1 : mul(num(2), _)
  26 [9]     1 : div(_, num(1))
  27 [10]    1 : add(num(_), num(_))
  28 [11]    1 : sub(num(_), num(_))
  29 [12]    1 : mul(num(_), num(_))
  30 [13]    1 : div(num(_), num(_))
  31
  32
  33 Statistics of the tree automaton:
  34    Number of functors      = 8
  35    Number of non-terminals = 2
  36    Number of states        = 42
  37    Memory used             = 24 k-bytes
  38
  39 Index compression statistics:
  40    Uncompressed index entries = 378
  41    Non-empty index entries    = 70
  42    Compressed table entries   = 149
  43    Compression rate           = 154%
  44
  45 Items:
  46 {0}     _
  47 {1}     _
  48 {2}     num(_)
  49 {3}     div(num(_), num(_))
  50 {4}     mul(num(_), num(_))
  51 {5}     sub(num(_), num(_))
  52 {6}     add(num(_), num(_))
  53 {7}     1
  54 {8}     num(1)
  55 {9}     div(_, num(1))
  56 {10}    2
  57 {11}    num(2)
  58 {12}    mul(num(2), _)
  59 {13}    mul(_, num(2))
  60 {14}    mul(num(1), _)
  61 {15}    mul(_, num(1))
  62 {16}    0
  63 {17}    num(0)
  64 {18}    mul(num(0), _)
  65 {19}    mul(_, num(0))
  66 {20}    sub(_, num(0))
  67 {21}    add(_, num(0))
  68 {22}    add(num(0), _)
  69
  70 States:
  71 <0>     _
  72 <1>     0
  73         _
  74 <2>     1
  75         _
  76 <3>     2
  77         _
  78 <4>     num(_)
  79         _
  80 <5>     num(0)
  81         num(_)
  82         _
  83 <6>     num(1)
  84         num(_)
  85         _
  86 <7>     num(2)
  87         num(_)
  88         _
  89 <8>     add(num(_), num(_))
  90         _
  91         [accept 10]
  92 <9>     sub(num(_), num(_))
  93         _
  94         [accept 11]
  95 <10>    mul(num(_), num(_))
  96         _
  97         [accept 12]
  98 <11>    div(num(_), num(_))
  99         _
 100         [accept 13]
 101 <12>    add(_, num(0))
 102         _
 103         [accept 1]
 104 <13>    add(num(0), _)
 105         add(_, num(0))
 106         add(num(_), num(_))
 107         _
 108         [accept 0]
 109 <14>    add(_, num(0))
 110         add(num(_), num(_))
 111         _
 112         [accept 1]
 113 <15>    add(num(0), _)
 114         _
 115         [accept 0]
 116 <16>    add(num(0), _)
 117         add(num(_), num(_))
 118         _
 119         [accept 0]
 120 <17>    sub(_, num(0))
 121         _
 122         [accept 2]
 123 <18>    sub(_, num(0))
 124         sub(num(_), num(_))
 125         _
 126         [accept 2]
 127 <19>    mul(_, num(0))
 128         _
 129         [accept 3]
 130 <20>    mul(_, num(0))
 131         mul(num(0), _)
 132         mul(num(_), num(_))
 133         _
 134         [accept 3]
 135 <21>    mul(_, num(0))
 136         mul(num(_), num(_))
 137         _
 138         [accept 3]
 139 <22>    mul(num(0), _)
 140         _
 141         [accept 4]
 142 <23>    mul(num(0), _)
 143         mul(num(_), num(_))
 144         _
 145         [accept 4]
 146 <24>    mul(_, num(1))
 147         _
 148         [accept 5]
 149 <25>    mul(_, num(1))
 150         mul(num(1), _)
 151         mul(num(_), num(_))
 152         _
 153         [accept 5]
 154 <26>    mul(num(0), _)
 155         mul(_, num(1))
 156         mul(num(_), num(_))
 157         _
 158         [accept 4]
 159 <27>    mul(_, num(1))
 160         mul(num(_), num(_))
 161         _
 162         [accept 5]
 163 <28>    mul(num(1), _)
 164         _
 165         [accept 6]
 166 <29>    mul(_, num(0))
 167         mul(num(1), _)
 168         mul(num(_), num(_))
 169         _
 170         [accept 3]
 171 <30>    mul(num(1), _)
 172         mul(num(_), num(_))
 173         _
 174         [accept 6]
 175 <31>    div(_, num(1))
 176         _
 177         [accept 9]
 178 <32>    div(_, num(1))
 179         div(num(_), num(_))
 180         _
 181         [accept 9]
 182 <33>    mul(_, num(2))
 183         _
 184         [accept 7]
 185 <34>    mul(_, num(2))
 186         mul(num(2), _)
 187         mul(num(_), num(_))
 188         _
 189         [accept 7]
 190 <35>    mul(num(1), _)
 191         mul(_, num(2))
 192         mul(num(_), num(_))
 193         _
 194         [accept 6]
 195 <36>    mul(num(0), _)
 196         mul(_, num(2))
 197         mul(num(_), num(_))
 198         _
 199         [accept 4]
 200 <37>    mul(_, num(2))
 201         mul(num(_), num(_))
 202         _
 203         [accept 7]
 204 <38>    mul(num(2), _)
 205         _
 206         [accept 8]
 207 <39>    mul(_, num(1))
 208         mul(num(2), _)
 209         mul(num(_), num(_))
 210         _
 211         [accept 5]
 212 <40>    mul(_, num(0))
 213         mul(num(2), _)
 214         mul(num(_), num(_))
 215         _
 216         [accept 3]
 217 <41>    mul(num(2), _)
 218         mul(num(_), num(_))
 219         _
 220         [accept 8]
 221 Functor encoding for literals:
 222
 223 Functor encoding for constructors:
 224 datatype EXP:
 225         num     =       2
 226         add     =       3
 227         sub     =       4
 228         mul     =       5
 229         div     =       6
 230 datatype NAT:
 231         zero    =       0
 232         succ    =       1
 233
 234 Index compression is disabled
 235 Algorithm is TreeGen
 236 Canonical grammar:
 237 [0]     1 : zero
 238 [1]     1 : succ(zero)
 239 [2]     1 : succ(succ(_))
 240 [3]     1 : succ(succ(zero))
 241 [4]     1 : succ(succ(succ(succ(_))))
 242 [5]     1 : add(num(_), num(_))
 243 [6]     1 : sub(num(_), num(_))
 244 [7]     1 : mul(num(_), num(_))
 245 [8]     1 : div(num(_), num(_))
 246
 247
 248 Statistics of the tree automaton:
 249    Number of functors      = 7
 250    Number of non-terminals = 2
 251    Number of states        = 13
 252    Memory used             = 24 k-bytes
 253
 254 Index compression statistics:
 255    Uncompressed index entries = 130
 256    Non-empty index entries    = 25
 257    Compressed table entries   = 60
 258    Compression rate           = 117%
 259
 260 Items:
 261 {0}     _
 262 {1}     _
 263 {2}     num(_)
 264 {3}     div(num(_), num(_))
 265 {4}     mul(num(_), num(_))
 266 {5}     sub(num(_), num(_))
 267 {6}     add(num(_), num(_))
 268 {7}     succ(_)
 269 {8}     succ(succ(_))
 270 {9}     succ(succ(succ(_)))
 271 {10}    succ(succ(succ(succ(_))))
 272 {11}    zero
 273 {12}    succ(zero)
 274 {13}    succ(succ(zero))
 275
 276 States:
 277 <0>     _
 278 <1>     zero
 279         _
 280         [accept 0]
 281 <2>     succ(_)
 282         _
 283 <3>     num(_)
 284         _
 285 <4>     succ(zero)
 286         succ(_)
 287         _
 288         [accept 1]
 289 <5>     succ(succ(_))
 290         succ(_)
 291         _
 292         [accept 2]
 293 <6>     add(num(_), num(_))
 294         _
 295         [accept 5]
 296 <7>     sub(num(_), num(_))
 297         _
 298         [accept 6]
 299 <8>     mul(num(_), num(_))
 300         _
 301         [accept 7]
 302 <9>     div(num(_), num(_))
 303         _
 304         [accept 8]
 305 <10>    succ(succ(zero))
 306         succ(succ(_))
 307         succ(_)
 308         _
 309         [accept 2]
 310 <11>    succ(succ(succ(_)))
 311         succ(succ(_))
 312         succ(_)
 313         _
 314         [accept 2]
 315 <12>    succ(succ(succ(succ(_))))
 316         succ(succ(succ(_)))
 317         succ(succ(_))
 318         succ(_)
 319         _
 320         [accept 2]