test/Golden/Splice/G4.expected.txt

   1 test/Golden/Splice/G4.hs:0:0:: Splicing expression
   2     P.runParser @Text Grammar.g4
   3   ======>
   4     \ (input :: inp)
   5       -> let
   6            !(# init, readMore, readNext #)
   7              = let _ = "cursorOf" in
   8                let
   9                  next t@(Data.Text.Internal.Text arr off unconsumed)
  10                    = let !(Data.Text.Unsafe.Iter c d) = (Data.Text.Unsafe.iter t) 0
  11                      in
  12                        (# c, ((Data.Text.Internal.Text arr) (off + d)) (unconsumed - d) #)
  13                  more (Data.Text.Internal.Text _ _ unconsumed) = (unconsumed > 0)
  14                in (# input, more, next #) in
  15          let finalRet = \ _farInp _farExp v _inp -> Right v in
  16          let
  17            finalRaise :: forall b. P.Catcher inp b
  18              = \ _failInp !farInp !farExp
  19                  -> Left
  20                       P.ParsingErrorStandard
  21                         {P.parsingErrorOffset = P.offset farInp,
  22                          P.parsingErrorUnexpected = if readMore farInp then
  23                                                         Just (let (# c, _ #) = readNext farInp in c)
  24                                                     else
  25                                                         Nothing,
  26                          P.parsingErrorExpecting = Data.Set.Internal.fromList farExp} in
  27          let
  28            name
  29              = \ !ok !inp !koByLabel
  30                  -> let _ = "catchException lbl=fail" in
  31                     let
  32                       readFail
  33                         = \ !failInp !farInp !farExp
  34                             -> let
  35                                  (# farInp, farExp #)
  36                                    = case ((compare `Data.Function.on` P.offset) farInp) inp of
  37                                        LT -> (# inp, [] #)
  38                                        EQ -> (# farInp, (farExp <> []) #)
  39                                        GT -> (# farInp, farExp #)
  40                                in
  41                                  (((((Data.Map.Strict.Internal.findWithDefault finalRaise) "fail")
  42                                       koByLabel)
  43                                      inp)
  44                                     farInp)
  45                                    farExp
  46                     in
  47                       if readMore ((P.shiftRightText 3) inp) then
  48                           let !(# c, cs #) = readNext inp
  49                           in
  50                             if ('a' ==) c then
  51                                 let readFail = readFail in
  52                                 let !(# c, cs #) = readNext cs
  53                                 in
  54                                   if ('b' ==) c then
  55                                       let readFail = readFail in
  56                                       let !(# c, cs #) = readNext cs
  57                                       in
  58                                         if ('c' ==) c then
  59                                             let readFail = readFail in
  60                                             let !(# c, cs #) = readNext cs
  61                                             in
  62                                               if ('d' ==) c then
  63                                                   let _ = "resume"
  64                                                   in
  65                                                     (((ok init) [])
  66                                                        (let _ = "resume.genCode"
  67                                                         in
  68                                                           ((\ x -> \ x -> x x)
  69                                                              (((\ x -> \ x -> x x)
  70                                                                  (((\ x -> \ x -> x x)
  71                                                                      (((\ x -> \ x -> x x)
  72                                                                          (\ x
  73                                                                             -> \ x
  74                                                                                  -> \ x
  75                                                                                       -> \ x
  76                                                                                            -> ('a'
  77                                                                                                  : ('b'
  78                                                                                                       : ('c'
  79                                                                                                            : ('d'
  80                                                                                                                 : []))))))
  81                                                                         c))
  82                                                                     c))
  83                                                                 c))
  84                                                             c))
  85                                                       cs
  86                                               else
  87                                                   let _ = "checkToken.else" in
  88                                                   let
  89                                                     (# farInp, farExp #)
  90                                                       = case
  91                                                             ((compare `Data.Function.on` P.offset)
  92                                                                init)
  93                                                               cs
  94                                                         of
  95                                                           LT -> (# cs, [P.ErrorItemToken 'd'] #)
  96                                                           EQ
  97                                                             -> (# init,
  98                                                                   ([] <> [P.ErrorItemToken 'd']) #)
  99                                                           GT -> (# init, [] #)
 100                                                   in ((readFail cs) farInp) farExp
 101                                         else
 102                                             let _ = "checkToken.else" in
 103                                             let
 104                                               (# farInp, farExp #)
 105                                                 = case
 106                                                       ((compare `Data.Function.on` P.offset) init)
 107                                                         cs
 108                                                   of
 109                                                     LT -> (# cs, [P.ErrorItemToken 'c'] #)
 110                                                     EQ -> (# init, ([] <> [P.ErrorItemToken 'c']) #)
 111                                                     GT -> (# init, [] #)
 112                                             in ((readFail cs) farInp) farExp
 113                                   else
 114                                       let _ = "checkToken.else" in
 115                                       let
 116                                         (# farInp, farExp #)
 117                                           = case ((compare `Data.Function.on` P.offset) init) cs of
 118                                               LT -> (# cs, [P.ErrorItemToken 'b'] #)
 119                                               EQ -> (# init, ([] <> [P.ErrorItemToken 'b']) #)
 120                                               GT -> (# init, [] #)
 121                                       in ((readFail cs) farInp) farExp
 122                             else
 123                                 let _ = "checkToken.else" in
 124                                 let
 125                                   (# farInp, farExp #)
 126                                     = case ((compare `Data.Function.on` P.offset) init) inp of
 127                                         LT -> (# inp, [P.ErrorItemToken 'a'] #)
 128                                         EQ -> (# init, ([] <> [P.ErrorItemToken 'a']) #)
 129                                         GT -> (# init, [] #)
 130                                 in ((readFail inp) farInp) farExp
 131                       else
 132                           let _ = "checkHorizon.else" in
 133                           let
 134                             (# farInp, farExp #)
 135                               = case ((compare `Data.Function.on` P.offset) init) inp of
 136                                   LT -> (# inp, [P.ErrorItemHorizon 4] #)
 137                                   EQ -> (# init, ([] <> [P.ErrorItemHorizon 4]) #)
 138                                   GT -> (# init, [] #)
 139                           in ((readFail inp) farInp) farExp in
 140          let
 141            _ = "call exceptionsByName(name_1)=["fail"] catchStackByLabel(ctx)=[]"
 142          in
 143            ((name
 144                (let
 145                   _ = "suspend raiseException=fromList [(name_1,fromList [("fail",())])]"
 146                 in
 147                   \ farInp farExp v !inp
 148                     -> let
 149                          name
 150                            = \ !ok !inp !koByLabel
 151                                -> let _ = "catchException lbl=fail" in
 152                                   let
 153                                     _ = "call exceptionsByName(name_1)=["fail"] catchStackByLabel(ctx)=["fail"]"
 154                                   in
 155                                     ((name
 156                                         (let
 157                                            _ = "suspend raiseException=fromList [(name_1,fromList [("fail",())]),(name_2,fromList [])]"
 158                                          in
 159                                            \ farInp farExp v !inp
 160                                              -> let
 161                                                   _ = "call exceptionsByName(name_2)=[] catchStackByLabel(ctx)=["fail"]"
 162                                                 in
 163                                                   ((name
 164                                                       (let
 165                                                          _ = "suspend raiseException=fromList [(name_1,fromList [("fail",())]),(name_2,fromList [])]"
 166                                                        in
 167                                                          \ farInp farExp v !inp
 168                                                            -> let _ = "resume"
 169                                                               in
 170                                                                 (((ok farInp) farExp)
 171                                                                    (let _ = "resume.genCode"
 172                                                                     in
 173                                                                       ((\ x -> \ x -> x x)
 174                                                                          (((\ x -> \ x -> x x)
 175                                                                              (\ x
 176                                                                                 -> \ x
 177                                                                                      -> \ x
 178                                                                                           -> (x : x x)))
 179                                                                             v))
 180                                                                         v))
 181                                                                   inp))
 182                                                      inp)
 183                                                     (((((Data.Map.Internal.Bin 1) "fail")
 184                                                          (\ !failInp !farInp !farExp
 185                                                             -> if (\ x -> x)
 186                                                                     (((\ (Data.Text.Internal.Text _
 187                                                                                                   i
 188                                                                                                   _)
 189                                                                          (Data.Text.Internal.Text _
 190                                                                                                   j
 191                                                                                                   _)
 192                                                                          -> (i == j))
 193                                                                         inp)
 194                                                                        failInp) then
 195                                                                    let _ = "resume"
 196                                                                    in
 197                                                                      (((ok farInp) farExp)
 198                                                                         (let _ = "resume.genCode"
 199                                                                          in \ x -> x))
 200                                                                        failInp
 201                                                                else
 202                                                                    let
 203                                                                      (# farInp, farExp #)
 204                                                                        = case
 205                                                                              ((compare
 206                                                                                  `Data.Function.on`
 207                                                                                    P.offset)
 208                                                                                 farInp)
 209                                                                                failInp
 210                                                                          of
 211                                                                            LT -> (# failInp, [] #)
 212                                                                            EQ
 213                                                                              -> (# farInp,
 214                                                                                    (farExp <> []) #)
 215                                                                            GT
 216                                                                              -> (# farInp, farExp #)
 217                                                                    in
 218                                                                      (((((Data.Map.Strict.Internal.findWithDefault
 219                                                                             finalRaise)
 220                                                                            "fail")
 221                                                                           koByLabel)
 222                                                                          failInp)
 223                                                                         farInp)
 224                                                                        farExp))
 225                                                         Data.Map.Internal.Tip)
 226                                                        Data.Map.Internal.Tip)))
 227                                        inp)
 228                                       (((((Data.Map.Internal.Bin 1) "fail")
 229                                            (\ !failInp !farInp !farExp
 230                                               -> if (\ x -> x)
 231                                                       (((\ (Data.Text.Internal.Text _ i _)
 232                                                            (Data.Text.Internal.Text _ j _)
 233                                                            -> (i == j))
 234                                                           inp)
 235                                                          failInp) then
 236                                                      let _ = "resume"
 237                                                      in
 238                                                        (((ok farInp) farExp)
 239                                                           (let _ = "resume.genCode" in \ x -> x))
 240                                                          failInp
 241                                                  else
 242                                                      let
 243                                                        (# farInp, farExp #)
 244                                                          = case
 245                                                                ((compare
 246                                                                    `Data.Function.on` P.offset)
 247                                                                   farInp)
 248                                                                  failInp
 249                                                            of
 250                                                              LT -> (# failInp, [] #)
 251                                                              EQ -> (# farInp, (farExp <> []) #)
 252                                                              GT -> (# farInp, farExp #)
 253                                                      in
 254                                                        (((((Data.Map.Strict.Internal.findWithDefault
 255                                                               finalRaise)
 256                                                              "fail")
 257                                                             koByLabel)
 258                                                            failInp)
 259                                                           farInp)
 260                                                          farExp))
 261                                           Data.Map.Internal.Tip)
 262                                          Data.Map.Internal.Tip) in
 263                        let
 264                          _ = "call exceptionsByName(name_2)=["fail"] catchStackByLabel(ctx)=[]"
 265                        in
 266                          ((name
 267                              (let
 268                                 _ = "suspend raiseException=fromList [(name_1,fromList [("fail",())]),(name_2,fromList [("fail",())])]"
 269                               in
 270                                 \ farInp farExp v !inp
 271                                   -> let _ = "resume"
 272                                      in
 273                                        (((finalRet farInp) farExp)
 274                                           (let _ = "resume.genCode"
 275                                            in
 276                                              ((\ x -> \ x -> x x)
 277                                                 (((\ x -> \ x -> x x) (\ x -> \ x -> (x : x [])))
 278                                                    v))
 279                                                v))
 280                                          inp))
 281                             inp)
 282                            Data.Map.Internal.Tip))
 283               init)
 284              Data.Map.Internal.Tip