test/Golden/Machine/G4.expected.txt

   1 let name
   2   minReads=(Right 4)
   3   mayRaise=[ExceptionFailure]
   4   freeRegs=[]
   5 | catch ExceptionFailure
   6 |   minReads=(Right 4)
   7 |   mayRaise=[ExceptionFailure]
   8 |   freeRegs=[]
   9 | | <ok>
  10 | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))
  11 | | |   minReads=(Right 4)
  12 | | |   mayRaise=[ExceptionFailure]
  13 | | |   freeRegs=[]
  14 | | | read ((GHC.Classes.==) 'a')
  15 | | |   minReads=(Right 4)
  16 | | |   mayRaise=[ExceptionFailure]
  17 | | |   freeRegs=[]
  18 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  19 | | |   minReads=(Right 3)
  20 | | |   mayRaise=[ExceptionFailure]
  21 | | |   freeRegs=[]
  22 | | | read ((GHC.Classes.==) 'b')
  23 | | |   minReads=(Right 3)
  24 | | |   mayRaise=[ExceptionFailure]
  25 | | |   freeRegs=[]
  26 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  27 | | |   minReads=(Right 2)
  28 | | |   mayRaise=[ExceptionFailure]
  29 | | |   freeRegs=[]
  30 | | | read ((GHC.Classes.==) 'c')
  31 | | |   minReads=(Right 2)
  32 | | |   mayRaise=[ExceptionFailure]
  33 | | |   freeRegs=[]
  34 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  35 | | |   minReads=(Right 1)
  36 | | |   mayRaise=[ExceptionFailure]
  37 | | |   freeRegs=[]
  38 | | | read ((GHC.Classes.==) 'd')
  39 | | |   minReads=(Right 1)
  40 | | |   mayRaise=[ExceptionFailure]
  41 | | |   freeRegs=[]
  42 | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  43 | | |   minReads=(Right 0)
  44 | | |   mayRaise=[]
  45 | | |   freeRegs=[]
  46 | | | commit ExceptionFailure
  47 | | |   minReads=(Right 0)
  48 | | |   mayRaise=[]
  49 | | |   freeRegs=[]
  50 | | | ret
  51 | | |   minReads=(Right 0)
  52 | | |   mayRaise=[]
  53 | | |   freeRegs=[]
  54 | | <ko>
  55 | | | loadInput
  56 | | |   minReads=(Left ExceptionFailure)
  57 | | |   mayRaise=[ExceptionFailure]
  58 | | |   freeRegs=[]
  59 | | | fail []
  60 | | |   minReads=(Left ExceptionFailure)
  61 | | |   mayRaise=[ExceptionFailure]
  62 | | |   freeRegs=[]
  63 pushValue (\x_0 -> \x_1 -> GHC.Show.show ((GHC.Types.:) x_0 x_1))
  64   minReads=(Right 4)
  65   mayRaise=[ExceptionFailure]
  66   freeRegs=[]
  67 call name
  68   minReads=(Right 4)
  69   mayRaise=[ExceptionFailure]
  70   freeRegs=[]
  71 lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  72   minReads=(Right 0)
  73   mayRaise=[ExceptionFailure]
  74   freeRegs=[]
  75 pushValue (\x_0 -> x_0)
  76   minReads=(Right 0)
  77   mayRaise=[ExceptionFailure]
  78   freeRegs=[]
  79 newRegister reg
  80   minReads=(Right 0)
  81   mayRaise=[ExceptionFailure]
  82   freeRegs=[]
  83 iter loop
  84   minReads=(Right 0)
  85   mayRaise=[ExceptionFailure]
  86   freeRegs=[reg]
  87 | <ok>
  88 | | pushValue (GHC.Types.:)
  89 | |   minReads=(Right 4)
  90 | |   mayRaise=[ExceptionFailure]
  91 | |   freeRegs=[reg]
  92 | | call name
  93 | |   minReads=(Right 4)
  94 | |   mayRaise=[ExceptionFailure]
  95 | |   freeRegs=[reg]
  96 | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
  97 | |   minReads=(Right 0)
  98 | |   mayRaise=[]
  99 | |   freeRegs=[reg]
 100 | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))
 101 | |   minReads=(Right 0)
 102 | |   mayRaise=[]
 103 | |   freeRegs=[reg]
 104 | | lift2Value (\x_0 -> \x_1 -> x_1 x_0)
 105 | |   minReads=(Right 0)
 106 | |   mayRaise=[]
 107 | |   freeRegs=[reg]
 108 | | readRegister reg
 109 | |   minReads=(Right 0)
 110 | |   mayRaise=[]
 111 | |   freeRegs=[reg]
 112 | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 113 | |   minReads=(Right 0)
 114 | |   mayRaise=[]
 115 | |   freeRegs=[reg]
 116 | | writeRegister reg
 117 | |   minReads=(Right 0)
 118 | |   mayRaise=[]
 119 | |   freeRegs=[reg]
 120 | | jump loop
 121 | |   minReads=(Right 0)
 122 | |   mayRaise=[]
 123 | |   freeRegs=[]
 124 | <ko>
 125 | | pushInput
 126 | |   minReads=(Right 0)
 127 | |   mayRaise=[ExceptionFailure]
 128 | |   freeRegs=[reg]
 129 | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _
 130 | |                                                                j_1
 131 | |                                                                _) -> i_0 GHC.Classes.== j_1)
 132 | |   minReads=(Right 0)
 133 | |   mayRaise=[ExceptionFailure]
 134 | |   freeRegs=[reg]
 135 | | choicesBranch
 136 | |   minReads=(Right 0)
 137 | |   mayRaise=[ExceptionFailure]
 138 | |   freeRegs=[reg]
 139 | | | <branch (\x_0 -> x_0)>
 140 | | | | readRegister reg
 141 | | | |   minReads=(Right 0)
 142 | | | |   mayRaise=[]
 143 | | | |   freeRegs=[reg]
 144 | | | | pushValue GHC.Types.[]
 145 | | | |   minReads=(Right 0)
 146 | | | |   mayRaise=[]
 147 | | | |   freeRegs=[]
 148 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 149 | | | |   minReads=(Right 0)
 150 | | | |   mayRaise=[]
 151 | | | |   freeRegs=[]
 152 | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)
 153 | | | |   minReads=(Right 0)
 154 | | | |   mayRaise=[]
 155 | | | |   freeRegs=[]
 156 | | | | ret
 157 | | | |   minReads=(Right 0)
 158 | | | |   mayRaise=[]
 159 | | | |   freeRegs=[]
 160 | | | <default>
 161 | | | | fail []
 162 | | | |   minReads=(Left ExceptionFailure)
 163 | | | |   mayRaise=[ExceptionFailure]
 164 | | | |   freeRegs=[]