{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TupleSections #-}

-- | This is an internal module that provides the core parsing engine
-- functionality for the Demangler.

module Demangler.Engine
where

import           Control.Applicative
import           Control.Lens ( Lens, Lens', (&), (^.), (.~), _1, _2, _3 )
import           Data.Char
import           Data.List.NonEmpty ( NonEmpty((:|)) )
import           Data.Maybe ( fromMaybe )
import qualified Data.Sequence as Seq
import           Data.Text ( Text )
import qualified Data.Text as T

import           Demangler.Context
import           Demangler.Structure

#ifdef MIN_VERSION_panic
-- The debug flag is enabled in the cabal file
import           Debug.Trace
import           Panic

instance PanicComponent Demangler where
  panicComponentName _ = "Demangler"
  panicComponentIssues = const "https://github.com/GaloisInc/demangler/issues"
  panicComponentRevision _ = ("main", "-")

cannot :: PanicComponent a => a -> String -> [String] -> b
cannot = panic
#else
cannot :: a -> String -> [String] -> Maybe b
cannot :: forall a b. a -> String -> [String] -> Maybe b
cannot a
_ String
_ [String]
_ = Maybe b
forall a. Maybe a
Nothing  -- signals a parsing failure, ultimately resulting in Original
#endif

data Demangler = Demangler


type Result = (Demangled, Context)

--------------------
-- Mangled name parsing basis types

-- | Next encodes a parsing step: provided with the current string and the
-- context, it may succeed with the remainder of the string after the portion
-- consumed by this parser and the updated context.

type Next a b = NextArg a -> Maybe (NextArg b)

type NextArg a = (Text, (a, (Context, ( Seq.Seq SubsCandidate
                                      , (Seq.Seq TemplateArg, Bool, Bool)))))

type AnyNext b = forall a . Next a b


nInp :: Lens' (NextArg a) Text
nInp :: forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp = (Text -> f Text) -> NextArg a -> f (NextArg a)
forall s t a b. Field1 s t a b => Lens s t a b
Lens (NextArg a) (NextArg a) Text Text
_1

nVal :: Lens (NextArg a) (NextArg b) a b
nVal :: forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (b,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg b)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg b)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (b,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg b))
-> ((a -> f b)
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (b,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (a -> f b)
-> NextArg a
-> f (NextArg b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b)
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (b,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  a
  b
_1

nContext :: Lens' (NextArg a) Context
nContext :: forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg a)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg a)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg a))
-> ((Context -> f Context)
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (a,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (Context -> f Context)
-> NextArg a
-> f (NextArg a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
_2 (((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> (a,
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> ((Context -> f Context)
    -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
    -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (Context -> f Context)
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Context -> f Context)
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  Context
  Context
_1

nSubs :: Lens' (NextArg a) (Seq.Seq SubsCandidate)
nSubs :: forall a (f :: * -> *).
Functor f =>
(Seq SubsCandidate -> f (Seq SubsCandidate))
-> NextArg a -> f (NextArg a)
nSubs = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg a)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg a)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg a))
-> ((Seq SubsCandidate -> f (Seq SubsCandidate))
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (a,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (Seq SubsCandidate -> f (Seq SubsCandidate))
-> NextArg a
-> f (NextArg a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
_2 (((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> (a,
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> ((Seq SubsCandidate -> f (Seq SubsCandidate))
    -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
    -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (Seq SubsCandidate -> f (Seq SubsCandidate))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
_2 (((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> ((Seq SubsCandidate -> f (Seq SubsCandidate))
    -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
    -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Seq SubsCandidate -> f (Seq SubsCandidate))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Seq SubsCandidate -> f (Seq SubsCandidate))
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate)
  (Seq SubsCandidate)
_1

nTmplSubs :: Lens' (NextArg a) (Seq.Seq TemplateArg)
nTmplSubs :: forall a (f :: * -> *).
Functor f =>
(Seq TemplateArg -> f (Seq TemplateArg))
-> NextArg a -> f (NextArg a)
nTmplSubs = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg a)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg a)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg a))
-> ((Seq TemplateArg -> f (Seq TemplateArg))
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (a,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (Seq TemplateArg -> f (Seq TemplateArg))
-> NextArg a
-> f (NextArg a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
_2 (((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> (a,
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> ((Seq TemplateArg -> f (Seq TemplateArg))
    -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
    -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (Seq TemplateArg -> f (Seq TemplateArg))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
_2 (((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> ((Seq TemplateArg -> f (Seq TemplateArg))
    -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
    -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Seq TemplateArg -> f (Seq TemplateArg))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
_2 (((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
 -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> ((Seq TemplateArg -> f (Seq TemplateArg))
    -> (Seq TemplateArg, Bool, Bool)
    -> f (Seq TemplateArg, Bool, Bool))
-> (Seq TemplateArg -> f (Seq TemplateArg))
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Seq TemplateArg -> f (Seq TemplateArg))
-> (Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool)
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg)
  (Seq TemplateArg)
_1

nTmplSubsLatch :: Lens' (NextArg a) Bool
nTmplSubsLatch :: forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLatch = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg a)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg a)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg a))
-> ((Bool -> f Bool)
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (a,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (Bool -> f Bool)
-> NextArg a
-> f (NextArg a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
_2 (((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> (a,
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> ((Bool -> f Bool)
    -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
    -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (Bool -> f Bool)
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
_2 (((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> ((Bool -> f Bool)
    -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
    -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Bool -> f Bool)
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
_2 (((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
 -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> ((Bool -> f Bool)
    -> (Seq TemplateArg, Bool, Bool)
    -> f (Seq TemplateArg, Bool, Bool))
-> (Bool -> f Bool)
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> f Bool)
-> (Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
  Bool
  Bool
_2

nTmplSubsLock :: Lens' (NextArg a) Bool
nTmplSubsLock :: forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock = ((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> f (NextArg a)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg a)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> f (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> f (NextArg a))
-> ((Bool -> f Bool)
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> f (a,
          (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (Bool -> f Bool)
-> NextArg a
-> f (NextArg a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
_2 (((Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> (a,
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> f (a,
       (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> ((Bool -> f Bool)
    -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
    -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> (Bool -> f Bool)
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> f (a,
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
_2 (((Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
 -> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> ((Bool -> f Bool)
    -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
    -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> (Bool -> f Bool)
-> (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> f (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
_2 (((Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool))
 -> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
 -> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))
-> ((Bool -> f Bool)
    -> (Seq TemplateArg, Bool, Bool)
    -> f (Seq TemplateArg, Bool, Bool))
-> (Bool -> f Bool)
-> (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
-> f (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> f Bool)
-> (Seq TemplateArg, Bool, Bool) -> f (Seq TemplateArg, Bool, Bool)
forall s t a b. Field3 s t a b => Lens s t a b
Lens
  (Seq TemplateArg, Bool, Bool)
  (Seq TemplateArg, Bool, Bool)
  Bool
  Bool
_3

ret :: Applicative f => NextArg a -> b -> f (NextArg b)
ret :: forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg a
i b
v = NextArg b -> f (NextArg b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (((a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
 -> Identity
      (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> NextArg a -> Identity (NextArg b)
forall s t a b. Field2 s t a b => Lens s t a b
Lens
  (NextArg a)
  (NextArg b)
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
_2 (((a,
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  -> Identity
       (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> NextArg a -> Identity (NextArg b))
-> ((a -> Identity b)
    -> (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
    -> Identity
         (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> (a -> Identity b)
-> NextArg a
-> Identity (NextArg b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Identity b)
-> (a,
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
-> Identity
     (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
forall s t a b. Field1 s t a b => Lens s t a b
Lens
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  (b, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))
  a
  b
_1 ((a -> Identity b) -> NextArg a -> Identity (NextArg b))
-> b -> NextArg a -> NextArg b
forall s t a b. ASetter s t a b -> b -> s -> t
.~ b
v (NextArg a -> NextArg b) -> NextArg a -> NextArg b
forall a b. (a -> b) -> a -> b
$ NextArg a
i)

ret' :: Applicative f => b -> NextArg a -> f (NextArg b)
ret' :: forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' b
a NextArg a
b = NextArg a -> b -> f (NextArg b)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg a
b b
a

rmap :: Applicative f => (a -> b) -> NextArg a -> f (NextArg b)
rmap :: forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap a -> b
f NextArg a
i = NextArg a -> b -> f (NextArg b)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg a
i (b -> f (NextArg b)) -> b -> f (NextArg b)
forall a b. (a -> b) -> a -> b
$ a -> b
f (NextArg a
i NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)

rapply :: Applicative f => NextArg (a -> b, a) -> f (NextArg b)
rapply :: forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply = ((a -> b, a) -> b) -> NextArg (a -> b, a) -> f (NextArg b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (((a -> b, a) -> b) -> NextArg (a -> b, a) -> f (NextArg b))
-> ((a -> b, a) -> b) -> NextArg (a -> b, a) -> f (NextArg b)
forall a b. (a -> b) -> a -> b
$ ((a -> b) -> a -> b) -> (a -> b, a) -> b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
($)


--------------------
-- Helpers

match :: Text -> Next a a
match :: forall a. Text -> Next a a
match Text
n NextArg a
i =
  let (Text
mp, Text
rp) = Int -> Text -> (Text, Text)
T.splitAt (Text -> Int
T.length Text
n) (NextArg a
i NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp)
  in do Bool -> Maybe ()
require (Text
mp Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
n)
        NextArg a -> Maybe (NextArg a)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NextArg a -> Maybe (NextArg a)) -> NextArg a -> Maybe (NextArg a)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg a -> Identity (NextArg a))
-> Text -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
rp

single_digit_num :: AnyNext Int
single_digit_num :: AnyNext Int
single_digit_num NextArg a
i =
  let txt :: Text
txt = NextArg a
i NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp
      d :: Char
d = HasCallStack => Text -> Char
Text -> Char
T.head Text
txt
  in if Bool -> Bool
not (Text -> Bool
T.null Text
txt) Bool -> Bool -> Bool
&& Char -> Bool
isDigit Char
d
     then NextArg Int -> Maybe (NextArg Int)
forall a. a -> Maybe a
Just (NextArg Int -> Maybe (NextArg Int))
-> NextArg Int -> Maybe (NextArg Int)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg a -> Identity (NextArg a))
-> Text -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Int -> Text -> Text
T.drop Int
1 Text
txt NextArg a -> (NextArg a -> NextArg Int) -> NextArg Int
forall a b. a -> (a -> b) -> b
& (a -> Identity Int) -> NextArg a -> Identity (NextArg Int)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity Int) -> NextArg a -> Identity (NextArg Int))
-> Int -> NextArg a -> NextArg Int
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Char -> Int
ord Char
d Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord Char
'0'
     else Maybe (NextArg Int)
forall a. Maybe a
Nothing

digits_num :: AnyNext Int
digits_num :: AnyNext Int
digits_num NextArg a
i =
  let (Text
d,Text
r) = (Char -> Bool) -> Text -> (Text, Text)
T.span Char -> Bool
isDigit (Text -> (Text, Text)) -> Text -> (Text, Text)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp
  in if Text -> Bool
T.null Text
d
     then Maybe (NextArg Int)
forall a. Maybe a
Nothing
     else NextArg Int -> Maybe (NextArg Int)
forall a. a -> Maybe a
Just (NextArg Int -> Maybe (NextArg Int))
-> NextArg Int -> Maybe (NextArg Int)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg a -> Identity (NextArg a))
-> Text -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
r NextArg a -> (NextArg a -> NextArg Int) -> NextArg Int
forall a b. a -> (a -> b) -> b
& (a -> Identity Int) -> NextArg a -> Identity (NextArg Int)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity Int) -> NextArg a -> Identity (NextArg Int))
-> Int -> NextArg a -> NextArg Int
forall s t a b. ASetter s t a b -> b -> s -> t
.~ String -> Int
forall a. Read a => String -> a
read (Text -> String
T.unpack Text
d)

base36_num :: AnyNext Int
base36_num :: AnyNext Int
base36_num NextArg a
i =
  let isB36char :: Char -> Bool
isB36char Char
c = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or [ Char -> Bool
isDigit Char
c, Char -> Bool
isAsciiUpper Char
c ]
      nextB36Digit :: Int -> Char -> Int
nextB36Digit Int
a Char
x = (Int
a Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
36)
                         Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Char -> Int
ord Char
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- if Char -> Bool
isDigit Char
x then Char -> Int
ord Char
'0' else Char -> Int
ord Char
'A' Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
10)
      (Text
d,Text
r) = (Char -> Bool) -> Text -> (Text, Text)
T.span Char -> Bool
isB36char (Text -> (Text, Text)) -> Text -> (Text, Text)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp
  in if Text -> Bool
T.null Text
d
     then Maybe (NextArg Int)
forall a. Maybe a
Nothing
     else NextArg Int -> Maybe (NextArg Int)
forall a. a -> Maybe a
Just (NextArg Int -> Maybe (NextArg Int))
-> NextArg Int -> Maybe (NextArg Int)
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg a -> Identity (NextArg a))
-> Text -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
r NextArg a -> (NextArg a -> NextArg Int) -> NextArg Int
forall a b. a -> (a -> b) -> b
& (a -> Identity Int) -> NextArg a -> Identity (NextArg Int)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity Int) -> NextArg a -> Identity (NextArg Int))
-> Int -> NextArg a -> NextArg Int
forall s t a b. ASetter s t a b -> b -> s -> t
.~ (Int -> Char -> Int) -> Int -> Text -> Int
forall a. (a -> Char -> a) -> a -> Text -> a
T.foldl Int -> Char -> Int
nextB36Digit Int
0 Text
d

require :: Bool -> Maybe ()
require :: Bool -> Maybe ()
require Bool
t = if Bool
t then () -> Maybe ()
forall a. a -> Maybe a
Just () else Maybe ()
forall a. Maybe a
Nothing

rdiscard :: NextArg a -> NextArg ()
rdiscard :: forall a. NextArg a -> NextArg ()
rdiscard = (a -> Identity ()) -> NextArg a -> Identity (NextArg ())
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity ()) -> NextArg a -> Identity (NextArg ()))
-> () -> NextArg a -> NextArg ()
forall s t a b. ASetter s t a b -> b -> s -> t
.~ ()

#if MIN_VERSION_base(4,16,0)
#else
asum :: (Foldable t, Alternative f) => t (f a) -> f a
asum = foldr (<|>) empty
#endif

asum' :: (Foldable t, Functor t, Alternative f) => t (a -> f b) -> a -> f b
asum' :: forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' t (a -> f b)
opts a
i = t (f b) -> f b
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum (t (f b) -> f b) -> t (f b) -> f b
forall a b. (a -> b) -> a -> b
$ ((a -> f b) -> a -> f b
forall a b. (a -> b) -> a -> b
$ a
i) ((a -> f b) -> f b) -> t (a -> f b) -> t (f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> t (a -> f b)
opts

tbd :: String -> Next a b
#ifdef MIN_VERSION_panic
tbd why i = trace ("TBD: " <> why <> " @ " <> (T.unpack $ i ^. nInp)) Nothing
#else
tbd :: forall a b. String -> Next a b
tbd String
_why = Maybe (NextArg b) -> NextArg a -> Maybe (NextArg b)
forall a b. a -> b -> a
const Maybe (NextArg b)
forall a. Maybe a
Nothing
#endif

some' :: AnyNext a -> Next b (NonEmpty a)
some' :: forall a b. AnyNext a -> Next b (NonEmpty a)
some' AnyNext a
p NextArg b
i = do NextArg a
e1 <- Next b a
AnyNext a
p NextArg b
i
               (NextArg a -> Maybe (NextArg a))
-> NextArg a -> Maybe (NextArg [a])
forall {f :: * -> *} {a}.
Monad f =>
((Text,
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> Maybe
      (Text,
       (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> (Text,
    (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> f (NextArg [a])
go NextArg a -> Maybe (NextArg a)
AnyNext a
p NextArg a
e1 Maybe (NextArg [a])
-> (NextArg [a] -> Maybe (NextArg (NonEmpty a)))
-> Maybe (NextArg (NonEmpty a))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([a] -> NonEmpty a) -> NextArg [a] -> Maybe (NextArg (NonEmpty a))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (NextArg a
e1 NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:|)
  where go :: ((Text,
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> Maybe
      (Text,
       (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> (Text,
    (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> f (NextArg [a])
go (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe
     (Text,
      (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
p' (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
i' = case (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe
     (Text,
      (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
p' (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
i' of
                     Maybe
  (Text,
   (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
Nothing -> (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> [a] -> f (NextArg [a])
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
i' []
                     Just (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
e -> ((Text,
  (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> Maybe
      (Text,
       (a,
        (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> (Text,
    (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> f (NextArg [a])
go (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe
     (Text,
      (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
p' (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
e f (NextArg [a])
-> (NextArg [a] -> f (NextArg [a])) -> f (NextArg [a])
forall a b. f a -> (a -> f b) -> f b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([a] -> [a]) -> NextArg [a] -> f (NextArg [a])
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
e (Text,
 (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Getting
     a
     (Text,
      (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
     a
-> a
forall s a. s -> Getting a s a -> a
^. Getting
  a
  (Text,
   (a, (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
  a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal a -> [a] -> [a]
forall a. a -> [a] -> [a]
:)

many' :: Next () a -> Next () [a]
many' :: forall a. Next () a -> Next () [a]
many' Next () a
p NextArg ()
i = case Next () a
p NextArg ()
i of
              Maybe (NextArg a)
Nothing -> NextArg () -> [a] -> Maybe (NextArg [a])
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg ()
i []
              Just NextArg a
e -> Next () a -> Next () [a]
forall a. Next () a -> Next () [a]
many' Next () a
p (NextArg a -> NextArg ()
forall a. NextArg a -> NextArg ()
rdiscard NextArg a
e) Maybe (NextArg [a])
-> (NextArg [a] -> Maybe (NextArg [a])) -> Maybe (NextArg [a])
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([a] -> [a]) -> NextArg [a] -> Maybe (NextArg [a])
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (NextArg a
e NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal a -> [a] -> [a]
forall a. a -> [a] -> [a]
:)

optional' :: Next a b -> Next a (a, Maybe b)
optional' :: forall a b. Next a b -> Next a (a, Maybe b)
optional' Next a b
o NextArg a
i = (Next a b
o NextArg a
i Maybe (NextArg b)
-> (NextArg b -> Maybe (NextArg (a, Maybe b)))
-> Maybe (NextArg (a, Maybe b))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (b -> (a, Maybe b)) -> NextArg b -> Maybe (NextArg (a, Maybe b))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((NextArg a
i NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal,) (Maybe b -> (a, Maybe b)) -> (b -> Maybe b) -> b -> (a, Maybe b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Maybe b
forall a. a -> Maybe a
Just)) Maybe (NextArg (a, Maybe b))
-> Maybe (NextArg (a, Maybe b)) -> Maybe (NextArg (a, Maybe b))
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (a -> (a, Maybe b)) -> NextArg a -> Maybe (NextArg (a, Maybe b))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (,Maybe b
forall a. Maybe a
Nothing) NextArg a
i

(>&=>) :: Next a b -> Next b c -> Next a (b,c)
Next a b
a >&=> :: forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next b c
b = \NextArg a
i -> do NextArg b
x <- Next a b
a NextArg a
i
                    NextArg c
y <- Next b c
b NextArg b
x
                    (c -> (b, c)) -> NextArg c -> Maybe (NextArg (b, c))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((NextArg b
x NextArg b -> Getting b (NextArg b) b -> b
forall s a. s -> Getting a s a -> a
^. Getting b (NextArg b) b
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal,)) NextArg c
y
infixl 2 >&=>

insert :: b -> Next a b
insert :: forall b a. b -> Next a b
insert b
v = NextArg b -> Maybe (NextArg b)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NextArg b -> Maybe (NextArg b))
-> (NextArg a -> NextArg b) -> NextArg a -> Maybe (NextArg b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> Identity b) -> NextArg a -> Identity (NextArg b)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity b) -> NextArg a -> Identity (NextArg b))
-> b -> NextArg a -> NextArg b
forall s t a b. ASetter s t a b -> b -> s -> t
.~ b
v)

noop :: Next a a
noop :: forall a. Next a a
noop = NextArg a -> Maybe (NextArg a)
forall a. a -> Maybe a
Just

end_of_input :: Next a a
end_of_input :: forall a. Next a a
end_of_input NextArg a
i = if Text -> Bool
T.null (NextArg a
i NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp) then NextArg a -> Maybe (NextArg a)
forall a. a -> Maybe a
Just NextArg a
i else Maybe (NextArg a)
forall a. Maybe a
Nothing

#ifdef MIN_VERSION_panic
traceP :: String -> Next a a
traceP at i = trace (at <> " @ " <> (T.unpack $ i ^. nInp) <> " #subs=" <> show (Seq.length (i ^. nSubs)) <> " #tmplSubs=" <> show (Seq.length (i ^. nTmplSubs))) $ Just i
#endif

----------------------------------------------------------------------

-- | Add an additional PrefixR entry to the end of a Prefix.

extendPrefix :: Prefix -> PrefixR -> Prefix
extendPrefix :: Prefix -> PrefixR -> Prefix
extendPrefix = \case
      PrefixTemplateParam TemplateArg
tp PrefixR
PrefixEnd -> TemplateArg -> PrefixR -> Prefix
PrefixTemplateParam TemplateArg
tp
      PrefixDeclType DeclType
dt PrefixR
PrefixEnd -> DeclType -> PrefixR -> Prefix
PrefixDeclType DeclType
dt
      Prefix PrefixR
PrefixEnd -> PrefixR -> Prefix
Prefix
      PrefixTemplateParam TemplateArg
tp PrefixR
sp -> TemplateArg -> PrefixR -> Prefix
PrefixTemplateParam TemplateArg
tp (PrefixR -> Prefix) -> (PrefixR -> PrefixR) -> PrefixR -> Prefix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixR -> PrefixR -> PrefixR
extPfx2 PrefixR
sp
      PrefixDeclType DeclType
dt PrefixR
sp -> DeclType -> PrefixR -> Prefix
PrefixDeclType DeclType
dt (PrefixR -> Prefix) -> (PrefixR -> PrefixR) -> PrefixR -> Prefix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixR -> PrefixR -> PrefixR
extPfx2 PrefixR
sp
      Prefix PrefixR
sp -> PrefixR -> Prefix
Prefix (PrefixR -> Prefix) -> (PrefixR -> PrefixR) -> PrefixR -> Prefix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixR -> PrefixR -> PrefixR
extPfx2 PrefixR
sp
      Prefix
o -> (PrefixR -> Prefix)
-> Maybe (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a. a -> Maybe a -> a
fromMaybe (Prefix -> PrefixR -> Prefix
forall a b. a -> b -> a
const Prefix
o) (Maybe (PrefixR -> Prefix) -> PrefixR -> Prefix)
-> Maybe (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ Demangler -> String -> [String] -> Maybe (PrefixR -> Prefix)
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"extendPrefix"
           [ String
"What prefix to extend? " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Prefix -> String
forall a. Show a => a -> String
show Prefix
o ]
extPfx2 :: PrefixR -> (PrefixR -> PrefixR)
extPfx2 :: PrefixR -> PrefixR -> PrefixR
extPfx2 = \case
      PrefixR
PrefixEnd -> PrefixR -> PrefixR
forall a. a -> a
id
      PrefixUQName UnqualifiedName
uqn PrefixR
sp -> UnqualifiedName -> PrefixR -> PrefixR
PrefixUQName UnqualifiedName
uqn (PrefixR -> PrefixR) -> (PrefixR -> PrefixR) -> PrefixR -> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixR -> PrefixR -> PrefixR
extPfx2 PrefixR
sp
      PrefixTemplateArgs TemplateArgs
ta PrefixR
sp -> TemplateArgs -> PrefixR -> PrefixR
PrefixTemplateArgs TemplateArgs
ta (PrefixR -> PrefixR) -> (PrefixR -> PrefixR) -> PrefixR -> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrefixR -> PrefixR -> PrefixR
extPfx2 PrefixR
sp

-- | Split a prefix into the last element and the initial portion without that
-- last element (if possible).

prefixInitLast :: Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast :: Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast = \case
  PrefixTemplateParam TemplateArg
tp PrefixR
p2 -> (PrefixR -> Prefix)
-> PrefixR -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
descend (TemplateArg -> PrefixR -> Prefix
PrefixTemplateParam TemplateArg
tp) PrefixR
p2
  PrefixDeclType DeclType
dt PrefixR
sp -> (PrefixR -> Prefix)
-> PrefixR -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
descend (DeclType -> PrefixR -> Prefix
PrefixDeclType DeclType
dt) PrefixR
sp
  Prefix PrefixR
p2 -> (PrefixR -> Prefix)
-> PrefixR -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
descend PrefixR -> Prefix
Prefix PrefixR
p2
  Prefix
o -> Demangler
-> String
-> [String]
-> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"prefixInitLast"
       [ String
"Not a valid prefix for this need"
       , Prefix -> String
forall a. Show a => a -> String
show Prefix
o
       ]
  where
    descend :: (PrefixR -> Prefix) -> PrefixR
            -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
    descend :: (PrefixR -> Prefix)
-> PrefixR -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
descend PrefixR -> Prefix
mkPfx PrefixR
pfxR = let (PrefixR -> PrefixR
rf, Maybe (Either UnqualifiedName TemplateArgs)
mb'le) = (PrefixR -> PrefixR, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR
-> (PrefixR -> PrefixR,
    Maybe (Either UnqualifiedName TemplateArgs))
forall {c}.
(PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR
-> (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
go (PrefixR -> PrefixR
forall a. a -> a
id, Maybe (Either UnqualifiedName TemplateArgs)
forall a. Maybe a
Nothing) PrefixR
pfxR
                         in case Maybe (Either UnqualifiedName TemplateArgs)
mb'le of
                              Maybe (Either UnqualifiedName TemplateArgs)
Nothing -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
forall a. Maybe a
Nothing
                              Just Either UnqualifiedName TemplateArgs
le -> (Prefix, Either UnqualifiedName TemplateArgs)
-> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
forall a. a -> Maybe a
Just (PrefixR -> Prefix
mkPfx (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ PrefixR -> PrefixR
rf PrefixR
PrefixEnd, Either UnqualifiedName TemplateArgs
le)
    go :: (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR
-> (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
go (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen = \case
      PrefixUQName UnqualifiedName
uqn PrefixR
PrefixEnd -> ((PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR -> c
forall a b. (a, b) -> a
fst (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen, Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a. a -> Maybe a
Just (Either UnqualifiedName TemplateArgs
 -> Maybe (Either UnqualifiedName TemplateArgs))
-> Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a b. (a -> b) -> a -> b
$ UnqualifiedName -> Either UnqualifiedName TemplateArgs
forall a b. a -> Either a b
Left UnqualifiedName
uqn)
      PrefixUQName UnqualifiedName
uqn PrefixR
subpfx ->
        (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR
-> (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
go ((PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR -> c
forall a b. (a, b) -> a
fst (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen (PrefixR -> c) -> (PrefixR -> PrefixR) -> PrefixR -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnqualifiedName -> PrefixR -> PrefixR
PrefixUQName UnqualifiedName
uqn, Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a. a -> Maybe a
Just (Either UnqualifiedName TemplateArgs
 -> Maybe (Either UnqualifiedName TemplateArgs))
-> Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a b. (a -> b) -> a -> b
$ UnqualifiedName -> Either UnqualifiedName TemplateArgs
forall a b. a -> Either a b
Left UnqualifiedName
uqn) PrefixR
subpfx
      PrefixTemplateArgs TemplateArgs
ta PrefixR
PrefixEnd -> ((PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR -> c
forall a b. (a, b) -> a
fst (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen, Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a. a -> Maybe a
Just (Either UnqualifiedName TemplateArgs
 -> Maybe (Either UnqualifiedName TemplateArgs))
-> Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a b. (a -> b) -> a -> b
$ TemplateArgs -> Either UnqualifiedName TemplateArgs
forall a b. b -> Either a b
Right TemplateArgs
ta)
      PrefixTemplateArgs TemplateArgs
ta PrefixR
subpfx ->
        (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR
-> (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
go ((PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
-> PrefixR -> c
forall a b. (a, b) -> a
fst (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen (PrefixR -> c) -> (PrefixR -> PrefixR) -> PrefixR -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TemplateArgs -> PrefixR -> PrefixR
PrefixTemplateArgs TemplateArgs
ta, Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a. a -> Maybe a
Just (Either UnqualifiedName TemplateArgs
 -> Maybe (Either UnqualifiedName TemplateArgs))
-> Either UnqualifiedName TemplateArgs
-> Maybe (Either UnqualifiedName TemplateArgs)
forall a b. (a -> b) -> a -> b
$ TemplateArgs -> Either UnqualifiedName TemplateArgs
forall a b. b -> Either a b
Right TemplateArgs
ta) PrefixR
subpfx
      PrefixR
PrefixEnd -> (PrefixR -> c, Maybe (Either UnqualifiedName TemplateArgs))
seen