{-
    Copyright 2012-2019 Vidar Holen

    This file is part of ShellCheck.
    https://www.shellcheck.net

    ShellCheck is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    ShellCheck is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-}
{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}
module ShellCheck.AST where

import GHC.Generics (Generic)
import Control.Monad.Identity
import Control.DeepSeq
import Text.Parsec
import qualified ShellCheck.Regex as Re
import Prelude hiding (id)

newtype Id = Id Int deriving (Int -> Id -> ShowS
[Id] -> ShowS
Id -> String
(Int -> Id -> ShowS)
-> (Id -> String) -> ([Id] -> ShowS) -> Show Id
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Id] -> ShowS
$cshowList :: [Id] -> ShowS
show :: Id -> String
$cshow :: Id -> String
showsPrec :: Int -> Id -> ShowS
$cshowsPrec :: Int -> Id -> ShowS
Show, Id -> Id -> Bool
(Id -> Id -> Bool) -> (Id -> Id -> Bool) -> Eq Id
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Id -> Id -> Bool
$c/= :: Id -> Id -> Bool
== :: Id -> Id -> Bool
$c== :: Id -> Id -> Bool
Eq, Eq Id
Eq Id
-> (Id -> Id -> Ordering)
-> (Id -> Id -> Bool)
-> (Id -> Id -> Bool)
-> (Id -> Id -> Bool)
-> (Id -> Id -> Bool)
-> (Id -> Id -> Id)
-> (Id -> Id -> Id)
-> Ord Id
Id -> Id -> Bool
Id -> Id -> Ordering
Id -> Id -> Id
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Id -> Id -> Id
$cmin :: Id -> Id -> Id
max :: Id -> Id -> Id
$cmax :: Id -> Id -> Id
>= :: Id -> Id -> Bool
$c>= :: Id -> Id -> Bool
> :: Id -> Id -> Bool
$c> :: Id -> Id -> Bool
<= :: Id -> Id -> Bool
$c<= :: Id -> Id -> Bool
< :: Id -> Id -> Bool
$c< :: Id -> Id -> Bool
compare :: Id -> Id -> Ordering
$ccompare :: Id -> Id -> Ordering
$cp1Ord :: Eq Id
Ord, (forall x. Id -> Rep Id x)
-> (forall x. Rep Id x -> Id) -> Generic Id
forall x. Rep Id x -> Id
forall x. Id -> Rep Id x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Id x -> Id
$cfrom :: forall x. Id -> Rep Id x
Generic, Id -> ()
(Id -> ()) -> NFData Id
forall a. (a -> ()) -> NFData a
rnf :: Id -> ()
$crnf :: Id -> ()
NFData)

data Quoted = Quoted | Unquoted deriving (Int -> Quoted -> ShowS
[Quoted] -> ShowS
Quoted -> String
(Int -> Quoted -> ShowS)
-> (Quoted -> String) -> ([Quoted] -> ShowS) -> Show Quoted
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Quoted] -> ShowS
$cshowList :: [Quoted] -> ShowS
show :: Quoted -> String
$cshow :: Quoted -> String
showsPrec :: Int -> Quoted -> ShowS
$cshowsPrec :: Int -> Quoted -> ShowS
Show, Quoted -> Quoted -> Bool
(Quoted -> Quoted -> Bool)
-> (Quoted -> Quoted -> Bool) -> Eq Quoted
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Quoted -> Quoted -> Bool
$c/= :: Quoted -> Quoted -> Bool
== :: Quoted -> Quoted -> Bool
$c== :: Quoted -> Quoted -> Bool
Eq)
data Dashed = Dashed | Undashed deriving (Int -> Dashed -> ShowS
[Dashed] -> ShowS
Dashed -> String
(Int -> Dashed -> ShowS)
-> (Dashed -> String) -> ([Dashed] -> ShowS) -> Show Dashed
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Dashed] -> ShowS
$cshowList :: [Dashed] -> ShowS
show :: Dashed -> String
$cshow :: Dashed -> String
showsPrec :: Int -> Dashed -> ShowS
$cshowsPrec :: Int -> Dashed -> ShowS
Show, Dashed -> Dashed -> Bool
(Dashed -> Dashed -> Bool)
-> (Dashed -> Dashed -> Bool) -> Eq Dashed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Dashed -> Dashed -> Bool
$c/= :: Dashed -> Dashed -> Bool
== :: Dashed -> Dashed -> Bool
$c== :: Dashed -> Dashed -> Bool
Eq)
data AssignmentMode = Assign | Append deriving (Int -> AssignmentMode -> ShowS
[AssignmentMode] -> ShowS
AssignmentMode -> String
(Int -> AssignmentMode -> ShowS)
-> (AssignmentMode -> String)
-> ([AssignmentMode] -> ShowS)
-> Show AssignmentMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssignmentMode] -> ShowS
$cshowList :: [AssignmentMode] -> ShowS
show :: AssignmentMode -> String
$cshow :: AssignmentMode -> String
showsPrec :: Int -> AssignmentMode -> ShowS
$cshowsPrec :: Int -> AssignmentMode -> ShowS
Show, AssignmentMode -> AssignmentMode -> Bool
(AssignmentMode -> AssignmentMode -> Bool)
-> (AssignmentMode -> AssignmentMode -> Bool) -> Eq AssignmentMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssignmentMode -> AssignmentMode -> Bool
$c/= :: AssignmentMode -> AssignmentMode -> Bool
== :: AssignmentMode -> AssignmentMode -> Bool
$c== :: AssignmentMode -> AssignmentMode -> Bool
Eq)
newtype FunctionKeyword = FunctionKeyword Bool deriving (Int -> FunctionKeyword -> ShowS
[FunctionKeyword] -> ShowS
FunctionKeyword -> String
(Int -> FunctionKeyword -> ShowS)
-> (FunctionKeyword -> String)
-> ([FunctionKeyword] -> ShowS)
-> Show FunctionKeyword
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionKeyword] -> ShowS
$cshowList :: [FunctionKeyword] -> ShowS
show :: FunctionKeyword -> String
$cshow :: FunctionKeyword -> String
showsPrec :: Int -> FunctionKeyword -> ShowS
$cshowsPrec :: Int -> FunctionKeyword -> ShowS
Show, FunctionKeyword -> FunctionKeyword -> Bool
(FunctionKeyword -> FunctionKeyword -> Bool)
-> (FunctionKeyword -> FunctionKeyword -> Bool)
-> Eq FunctionKeyword
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionKeyword -> FunctionKeyword -> Bool
$c/= :: FunctionKeyword -> FunctionKeyword -> Bool
== :: FunctionKeyword -> FunctionKeyword -> Bool
$c== :: FunctionKeyword -> FunctionKeyword -> Bool
Eq)
newtype FunctionParentheses = FunctionParentheses Bool deriving (Int -> FunctionParentheses -> ShowS
[FunctionParentheses] -> ShowS
FunctionParentheses -> String
(Int -> FunctionParentheses -> ShowS)
-> (FunctionParentheses -> String)
-> ([FunctionParentheses] -> ShowS)
-> Show FunctionParentheses
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FunctionParentheses] -> ShowS
$cshowList :: [FunctionParentheses] -> ShowS
show :: FunctionParentheses -> String
$cshow :: FunctionParentheses -> String
showsPrec :: Int -> FunctionParentheses -> ShowS
$cshowsPrec :: Int -> FunctionParentheses -> ShowS
Show, FunctionParentheses -> FunctionParentheses -> Bool
(FunctionParentheses -> FunctionParentheses -> Bool)
-> (FunctionParentheses -> FunctionParentheses -> Bool)
-> Eq FunctionParentheses
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FunctionParentheses -> FunctionParentheses -> Bool
$c/= :: FunctionParentheses -> FunctionParentheses -> Bool
== :: FunctionParentheses -> FunctionParentheses -> Bool
$c== :: FunctionParentheses -> FunctionParentheses -> Bool
Eq)
data CaseType = CaseBreak | CaseFallThrough | CaseContinue deriving (Int -> CaseType -> ShowS
[CaseType] -> ShowS
CaseType -> String
(Int -> CaseType -> ShowS)
-> (CaseType -> String) -> ([CaseType] -> ShowS) -> Show CaseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CaseType] -> ShowS
$cshowList :: [CaseType] -> ShowS
show :: CaseType -> String
$cshow :: CaseType -> String
showsPrec :: Int -> CaseType -> ShowS
$cshowsPrec :: Int -> CaseType -> ShowS
Show, CaseType -> CaseType -> Bool
(CaseType -> CaseType -> Bool)
-> (CaseType -> CaseType -> Bool) -> Eq CaseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CaseType -> CaseType -> Bool
$c/= :: CaseType -> CaseType -> Bool
== :: CaseType -> CaseType -> Bool
$c== :: CaseType -> CaseType -> Bool
Eq)

newtype Root = Root Token
data Token =
    TA_Binary Id String Token Token
    | TA_Assignment Id String Token Token
    | TA_Variable Id String [Token]
    | TA_Expansion Id [Token]
    | TA_Sequence Id [Token]
    | TA_Trinary Id Token Token Token
    | TA_Unary Id String Token
    | TC_And Id ConditionType String Token Token
    | TC_Binary Id ConditionType String Token Token
    | TC_Group Id ConditionType Token
    | TC_Nullary Id ConditionType Token
    | TC_Or Id ConditionType String Token Token
    | TC_Unary Id ConditionType String Token
    | TC_Empty Id ConditionType
    | T_AND_IF Id
    | T_AndIf Id Token Token
    | T_Arithmetic Id Token
    | T_Array Id [Token]
    | T_IndexedElement Id [Token] Token
    -- Store the index as string, and parse as arithmetic or string later
    | T_UnparsedIndex Id SourcePos String
    | T_Assignment Id AssignmentMode String [Token] Token
    | T_Backgrounded Id Token
    | T_Backticked Id [Token]
    | T_Bang Id
    | T_Banged Id Token
    | T_BraceExpansion Id [Token]
    | T_BraceGroup Id [Token]
    | T_CLOBBER Id
    | T_Case Id
    | T_CaseExpression Id Token [(CaseType, [Token], [Token])]
    | T_Condition Id ConditionType Token
    | T_DGREAT Id
    | T_DLESS Id
    | T_DLESSDASH Id
    | T_DSEMI Id
    | T_Do Id
    | T_DollarArithmetic Id Token
    | T_DollarBraced Id Bool Token
    | T_DollarBracket Id Token
    | T_DollarDoubleQuoted Id [Token]
    | T_DollarExpansion Id [Token]
    | T_DollarSingleQuoted Id String
    | T_DollarBraceCommandExpansion Id [Token]
    | T_Done Id
    | T_DoubleQuoted Id [Token]
    | T_EOF Id
    | T_Elif Id
    | T_Else Id
    | T_Esac Id
    | T_Extglob Id String [Token]
    | T_FdRedirect Id String Token
    | T_Fi Id
    | T_For Id
    | T_ForArithmetic Id Token Token Token [Token]
    | T_ForIn Id String [Token] [Token]
    | T_Function Id FunctionKeyword FunctionParentheses String Token
    | T_GREATAND Id
    | T_Glob Id String
    | T_Greater Id
    | T_HereDoc Id Dashed Quoted String [Token]
    | T_HereString Id Token
    | T_If Id
    | T_IfExpression Id [([Token],[Token])] [Token]
    | T_In  Id
    | T_IoFile Id Token Token
    | T_IoDuplicate Id Token String
    | T_LESSAND Id
    | T_LESSGREAT Id
    | T_Lbrace Id
    | T_Less Id
    | T_Literal Id String
    | T_Lparen Id
    | T_NEWLINE Id
    | T_NormalWord Id [Token]
    | T_OR_IF Id
    | T_OrIf Id Token Token
    | T_ParamSubSpecialChar Id String -- e.g. '%' in ${foo%bar}  or '/' in ${foo/bar/baz}
    | T_Pipeline Id [Token] [Token] -- [Pipe separators] [Commands]
    | T_ProcSub Id String [Token]
    | T_Rbrace Id
    | T_Redirecting Id [Token] Token
    | T_Rparen Id
    | T_Script Id Token [Token] -- Shebang T_Literal, followed by script.
    | T_Select Id
    | T_SelectIn Id String [Token] [Token]
    | T_Semi Id
    | T_SimpleCommand Id [Token] [Token]
    | T_SingleQuoted Id String
    | T_Subshell Id [Token]
    | T_Then Id
    | T_Until Id
    | T_UntilExpression Id [Token] [Token]
    | T_While Id
    | T_WhileExpression Id [Token] [Token]
    | T_Annotation Id [Annotation] Token
    | T_Pipe Id String
    | T_CoProc Id (Maybe String) Token
    | T_CoProcBody Id Token
    | T_Include Id Token
    | T_SourceCommand Id Token Token
    | T_BatsTest Id Token Token
    deriving (Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Token] -> ShowS
$cshowList :: [Token] -> ShowS
show :: Token -> String
$cshow :: Token -> String
showsPrec :: Int -> Token -> ShowS
$cshowsPrec :: Int -> Token -> ShowS
Show)

data Annotation =
    DisableComment Integer
    | EnableComment String
    | SourceOverride String
    | ShellOverride String
    | SourcePath String
    deriving (Int -> Annotation -> ShowS
[Annotation] -> ShowS
Annotation -> String
(Int -> Annotation -> ShowS)
-> (Annotation -> String)
-> ([Annotation] -> ShowS)
-> Show Annotation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotation] -> ShowS
$cshowList :: [Annotation] -> ShowS
show :: Annotation -> String
$cshow :: Annotation -> String
showsPrec :: Int -> Annotation -> ShowS
$cshowsPrec :: Int -> Annotation -> ShowS
Show, Annotation -> Annotation -> Bool
(Annotation -> Annotation -> Bool)
-> (Annotation -> Annotation -> Bool) -> Eq Annotation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotation -> Annotation -> Bool
$c/= :: Annotation -> Annotation -> Bool
== :: Annotation -> Annotation -> Bool
$c== :: Annotation -> Annotation -> Bool
Eq)
data ConditionType = DoubleBracket | SingleBracket deriving (Int -> ConditionType -> ShowS
[ConditionType] -> ShowS
ConditionType -> String
(Int -> ConditionType -> ShowS)
-> (ConditionType -> String)
-> ([ConditionType] -> ShowS)
-> Show ConditionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConditionType] -> ShowS
$cshowList :: [ConditionType] -> ShowS
show :: ConditionType -> String
$cshow :: ConditionType -> String
showsPrec :: Int -> ConditionType -> ShowS
$cshowsPrec :: Int -> ConditionType -> ShowS
Show, ConditionType -> ConditionType -> Bool
(ConditionType -> ConditionType -> Bool)
-> (ConditionType -> ConditionType -> Bool) -> Eq ConditionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConditionType -> ConditionType -> Bool
$c/= :: ConditionType -> ConditionType -> Bool
== :: ConditionType -> ConditionType -> Bool
$c== :: ConditionType -> ConditionType -> Bool
Eq)

-- This is an abomination.
tokenEquals :: Token -> Token -> Bool
tokenEquals :: Token -> Token -> Bool
tokenEquals Token
a Token
b = Token -> String
forall a. Show a => a -> String
kludge Token
a String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== Token -> String
forall a. Show a => a -> String
kludge Token
b
    where kludge :: a -> String
kludge a
s = Regex -> String -> ShowS
Re.subRegex (String -> Regex
Re.mkRegex String
"\\(Id [0-9]+\\)") (a -> String
forall a. Show a => a -> String
show a
s) String
"(Id 0)"

instance Eq Token where
    == :: Token -> Token -> Bool
(==) = Token -> Token -> Bool
tokenEquals

analyze :: Monad m => (Token -> m ()) -> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze :: (Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
f Token -> m ()
g Token -> m Token
i =
    Token -> m Token
round
  where
    round :: Token -> m Token
round Token
t = do
        Token -> m ()
f Token
t
        Token
newT <- Token -> m Token
delve Token
t
        Token -> m ()
g Token
t
        Token -> m Token
i Token
newT
    roundAll :: [Token] -> m [Token]
roundAll = (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round

    dl :: [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l [Token] -> Token
v = do
        [Token]
x <- [Token] -> m [Token]
roundAll [Token]
l
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ [Token] -> Token
v [Token]
x
    dll :: [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
l [Token]
m [Token] -> [Token] -> Token
v = do
        [Token]
x <- [Token] -> m [Token]
roundAll [Token]
l
        [Token]
y <- [Token] -> m [Token]
roundAll [Token]
m
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ [Token] -> [Token] -> Token
v [Token]
x [Token]
y
    d1 :: Token -> (Token -> Token) -> m Token
d1 Token
t Token -> Token
v = do
        Token
x <- Token -> m Token
round Token
t
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Token -> Token
v Token
x
    d2 :: Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t1 Token
t2 Token -> Token -> Token
v = do
        Token
x <- Token -> m Token
round Token
t1
        Token
y <- Token -> m Token
round Token
t2
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Token -> Token -> Token
v Token
x Token
y

    delve :: Token -> m Token
delve (T_NormalWord Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_NormalWord Id
id
    delve (T_DoubleQuoted Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_DoubleQuoted Id
id
    delve (T_DollarDoubleQuoted Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_DollarDoubleQuoted Id
id
    delve (T_DollarExpansion Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_DollarExpansion Id
id
    delve (T_DollarBraceCommandExpansion Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_DollarBraceCommandExpansion Id
id
    delve (T_BraceExpansion Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_BraceExpansion Id
id
    delve (T_Backticked Id
id [Token]
list) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
list (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_Backticked Id
id
    delve (T_DollarArithmetic Id
id Token
c) = Token -> (Token -> Token) -> m Token
d1 Token
c ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_DollarArithmetic Id
id
    delve (T_DollarBracket Id
id Token
c) = Token -> (Token -> Token) -> m Token
d1 Token
c ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_DollarBracket Id
id
    delve (T_IoFile Id
id Token
op Token
file) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
op Token
file ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token
T_IoFile Id
id
    delve (T_IoDuplicate Id
id Token
op String
num) = Token -> (Token -> Token) -> m Token
d1 Token
op ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ \Token
x -> Id -> Token -> String -> Token
T_IoDuplicate Id
id Token
x String
num
    delve (T_HereString Id
id Token
word) = Token -> (Token -> Token) -> m Token
d1 Token
word ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_HereString Id
id
    delve (T_FdRedirect Id
id String
v Token
t) = Token -> (Token -> Token) -> m Token
d1 Token
t ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> Token -> Token
T_FdRedirect Id
id String
v
    delve (T_Assignment Id
id AssignmentMode
mode String
var [Token]
indices Token
value) = do
        [Token]
a <- [Token] -> m [Token]
roundAll [Token]
indices
        Token
b <- Token -> m Token
round Token
value
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> AssignmentMode -> String -> [Token] -> Token -> Token
T_Assignment Id
id AssignmentMode
mode String
var [Token]
a Token
b
    delve (T_Array Id
id [Token]
t) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
t (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_Array Id
id
    delve (T_IndexedElement Id
id [Token]
indices Token
t) = do
        [Token]
a <- [Token] -> m [Token]
roundAll [Token]
indices
        Token
b <- Token -> m Token
round Token
t
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token -> Token
T_IndexedElement Id
id [Token]
a Token
b
    delve (T_Redirecting Id
id [Token]
redirs Token
cmd) = do
        [Token]
a <- [Token] -> m [Token]
roundAll [Token]
redirs
        Token
b <- Token -> m Token
round Token
cmd
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token -> Token
T_Redirecting Id
id [Token]
a Token
b
    delve (T_SimpleCommand Id
id [Token]
vars [Token]
cmds) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
vars [Token]
cmds (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> [Token] -> Token
T_SimpleCommand Id
id
    delve (T_Pipeline Id
id [Token]
l1 [Token]
l2) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
l1 [Token]
l2 (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> [Token] -> Token
T_Pipeline Id
id
    delve (T_Banged Id
id Token
l) = Token -> (Token -> Token) -> m Token
d1 Token
l ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_Banged Id
id
    delve (T_AndIf Id
id Token
t Token
u) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t Token
u ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token
T_AndIf Id
id
    delve (T_OrIf Id
id Token
t Token
u) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t Token
u ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token
T_OrIf Id
id
    delve (T_Backgrounded Id
id Token
l) = Token -> (Token -> Token) -> m Token
d1 Token
l ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_Backgrounded Id
id
    delve (T_Subshell Id
id [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_Subshell Id
id
    delve (T_ProcSub Id
id String
typ [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> [Token] -> Token
T_ProcSub Id
id String
typ
    delve (T_Arithmetic Id
id Token
c) = Token -> (Token -> Token) -> m Token
d1 Token
c ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_Arithmetic Id
id
    delve (T_IfExpression Id
id [([Token], [Token])]
conditions [Token]
elses) = do
        [([Token], [Token])]
newConds <- (([Token], [Token]) -> m ([Token], [Token]))
-> [([Token], [Token])] -> m [([Token], [Token])]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\([Token]
c, [Token]
t) -> do
                            [Token]
x <- (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round [Token]
c
                            [Token]
y <- (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round [Token]
t
                            ([Token], [Token]) -> m ([Token], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return ([Token]
x,[Token]
y)
                    ) [([Token], [Token])]
conditions
        [Token]
newElses <- [Token] -> m [Token]
roundAll [Token]
elses
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [([Token], [Token])] -> [Token] -> Token
T_IfExpression Id
id [([Token], [Token])]
newConds [Token]
newElses
    delve (T_BraceGroup Id
id [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
T_BraceGroup Id
id
    delve (T_WhileExpression Id
id [Token]
c [Token]
l) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
c [Token]
l (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> [Token] -> Token
T_WhileExpression Id
id
    delve (T_UntilExpression Id
id [Token]
c [Token]
l) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
c [Token]
l (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> [Token] -> Token
T_UntilExpression Id
id
    delve (T_ForIn Id
id String
v [Token]
w [Token]
l) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
w [Token]
l (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> [Token] -> [Token] -> Token
T_ForIn Id
id String
v
    delve (T_SelectIn Id
id String
v [Token]
w [Token]
l) = [Token] -> [Token] -> ([Token] -> [Token] -> Token) -> m Token
dll [Token]
w [Token]
l (([Token] -> [Token] -> Token) -> m Token)
-> ([Token] -> [Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> [Token] -> [Token] -> Token
T_SelectIn Id
id String
v
    delve (T_CaseExpression Id
id Token
word [(CaseType, [Token], [Token])]
cases) = do
        Token
newWord <- Token -> m Token
round Token
word
        [(CaseType, [Token], [Token])]
newCases <- ((CaseType, [Token], [Token]) -> m (CaseType, [Token], [Token]))
-> [(CaseType, [Token], [Token])]
-> m [(CaseType, [Token], [Token])]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(CaseType
o, [Token]
c, [Token]
t) -> do
                            [Token]
x <- (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round [Token]
c
                            [Token]
y <- (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round [Token]
t
                            (CaseType, [Token], [Token]) -> m (CaseType, [Token], [Token])
forall (m :: * -> *) a. Monad m => a -> m a
return (CaseType
o, [Token]
x,[Token]
y)
                        ) [(CaseType, [Token], [Token])]
cases
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> [(CaseType, [Token], [Token])] -> Token
T_CaseExpression Id
id Token
newWord [(CaseType, [Token], [Token])]
newCases

    delve (T_ForArithmetic Id
id Token
a Token
b Token
c [Token]
group) = do
        Token
x <- Token -> m Token
round Token
a
        Token
y <- Token -> m Token
round Token
b
        Token
z <- Token -> m Token
round Token
c
        [Token]
list <- (Token -> m Token) -> [Token] -> m [Token]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Token -> m Token
round [Token]
group
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token -> [Token] -> Token
T_ForArithmetic Id
id Token
x Token
y Token
z [Token]
list

    delve (T_Script Id
id Token
s [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> [Token] -> Token
T_Script Id
id Token
s
    delve (T_Function Id
id FunctionKeyword
a FunctionParentheses
b String
name Token
body) = Token -> (Token -> Token) -> m Token
d1 Token
body ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id
-> FunctionKeyword
-> FunctionParentheses
-> String
-> Token
-> Token
T_Function Id
id FunctionKeyword
a FunctionParentheses
b String
name
    delve (T_Condition Id
id ConditionType
typ Token
token) = Token -> (Token -> Token) -> m Token
d1 Token
token ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> Token -> Token
T_Condition Id
id ConditionType
typ
    delve (T_Extglob Id
id String
str [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> [Token] -> Token
T_Extglob Id
id String
str
    delve (T_DollarBraced Id
id Bool
braced Token
op) = Token -> (Token -> Token) -> m Token
d1 Token
op ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Bool -> Token -> Token
T_DollarBraced Id
id Bool
braced
    delve (T_HereDoc Id
id Dashed
d Quoted
q String
str [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Dashed -> Quoted -> String -> [Token] -> Token
T_HereDoc Id
id Dashed
d Quoted
q String
str

    delve (TC_And Id
id ConditionType
typ String
str Token
t1 Token
t2) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t1 Token
t2 ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> String -> Token -> Token -> Token
TC_And Id
id ConditionType
typ String
str
    delve (TC_Or Id
id ConditionType
typ String
str Token
t1 Token
t2) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t1 Token
t2 ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> String -> Token -> Token -> Token
TC_Or Id
id ConditionType
typ String
str
    delve (TC_Group Id
id ConditionType
typ Token
token) = Token -> (Token -> Token) -> m Token
d1 Token
token ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> Token -> Token
TC_Group Id
id ConditionType
typ
    delve (TC_Binary Id
id ConditionType
typ String
op Token
lhs Token
rhs) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
lhs Token
rhs ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> String -> Token -> Token -> Token
TC_Binary Id
id ConditionType
typ String
op
    delve (TC_Unary Id
id ConditionType
typ String
op Token
token) = Token -> (Token -> Token) -> m Token
d1 Token
token ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> String -> Token -> Token
TC_Unary Id
id ConditionType
typ String
op
    delve (TC_Nullary Id
id ConditionType
typ Token
token) = Token -> (Token -> Token) -> m Token
d1 Token
token ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> ConditionType -> Token -> Token
TC_Nullary Id
id ConditionType
typ

    delve (TA_Binary Id
id String
op Token
t1 Token
t2) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t1 Token
t2 ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> Token -> Token -> Token
TA_Binary Id
id String
op
    delve (TA_Assignment Id
id String
op Token
t1 Token
t2) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
t1 Token
t2 ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> Token -> Token -> Token
TA_Assignment Id
id String
op
    delve (TA_Unary Id
id String
op Token
t1) = Token -> (Token -> Token) -> m Token
d1 Token
t1 ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> Token -> Token
TA_Unary Id
id String
op
    delve (TA_Sequence Id
id [Token]
l) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
l (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
TA_Sequence Id
id
    delve (TA_Trinary Id
id Token
t1 Token
t2 Token
t3) = do
        Token
a <- Token -> m Token
round Token
t1
        Token
b <- Token -> m Token
round Token
t2
        Token
c <- Token -> m Token
round Token
t3
        Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> m Token) -> Token -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token -> Token
TA_Trinary Id
id Token
a Token
b Token
c
    delve (TA_Expansion Id
id [Token]
t) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
t (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Token] -> Token
TA_Expansion Id
id
    delve (TA_Variable Id
id String
str [Token]
t) = [Token] -> ([Token] -> Token) -> m Token
dl [Token]
t (([Token] -> Token) -> m Token) -> ([Token] -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> String -> [Token] -> Token
TA_Variable Id
id String
str
    delve (T_Annotation Id
id [Annotation]
anns Token
t) = Token -> (Token -> Token) -> m Token
d1 Token
t ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> [Annotation] -> Token -> Token
T_Annotation Id
id [Annotation]
anns
    delve (T_CoProc Id
id Maybe String
var Token
body) = Token -> (Token -> Token) -> m Token
d1 Token
body ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Maybe String -> Token -> Token
T_CoProc Id
id Maybe String
var
    delve (T_CoProcBody Id
id Token
t) = Token -> (Token -> Token) -> m Token
d1 Token
t ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_CoProcBody Id
id
    delve (T_Include Id
id Token
script) = Token -> (Token -> Token) -> m Token
d1 Token
script ((Token -> Token) -> m Token) -> (Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token
T_Include Id
id
    delve (T_SourceCommand Id
id Token
includer Token
t_include) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
includer Token
t_include ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token
T_SourceCommand Id
id
    delve (T_BatsTest Id
id Token
name Token
t) = Token -> Token -> (Token -> Token -> Token) -> m Token
d2 Token
name Token
t ((Token -> Token -> Token) -> m Token)
-> (Token -> Token -> Token) -> m Token
forall a b. (a -> b) -> a -> b
$ Id -> Token -> Token -> Token
T_BatsTest Id
id
    delve Token
t = Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return Token
t

getId :: Token -> Id
getId :: Token -> Id
getId Token
t = case Token
t of
        T_AND_IF Id
id  -> Id
id
        T_OR_IF Id
id  -> Id
id
        T_DSEMI Id
id  -> Id
id
        T_Semi Id
id  -> Id
id
        T_DLESS Id
id  -> Id
id
        T_DGREAT Id
id  -> Id
id
        T_LESSAND Id
id  -> Id
id
        T_GREATAND Id
id  -> Id
id
        T_LESSGREAT Id
id  -> Id
id
        T_DLESSDASH Id
id  -> Id
id
        T_CLOBBER Id
id  -> Id
id
        T_If Id
id  -> Id
id
        T_Then Id
id  -> Id
id
        T_Else Id
id  -> Id
id
        T_Elif Id
id  -> Id
id
        T_Fi Id
id  -> Id
id
        T_Do Id
id  -> Id
id
        T_Done Id
id  -> Id
id
        T_Case Id
id  -> Id
id
        T_Esac Id
id  -> Id
id
        T_While Id
id  -> Id
id
        T_Until Id
id  -> Id
id
        T_For Id
id  -> Id
id
        T_Select Id
id  -> Id
id
        T_Lbrace Id
id  -> Id
id
        T_Rbrace Id
id  -> Id
id
        T_Lparen Id
id  -> Id
id
        T_Rparen Id
id  -> Id
id
        T_Bang Id
id  -> Id
id
        T_In  Id
id  -> Id
id
        T_NEWLINE Id
id  -> Id
id
        T_EOF Id
id  -> Id
id
        T_Less Id
id  -> Id
id
        T_Greater Id
id  -> Id
id
        T_SingleQuoted Id
id String
_  -> Id
id
        T_Literal Id
id String
_  -> Id
id
        T_NormalWord Id
id [Token]
_  -> Id
id
        T_DoubleQuoted Id
id [Token]
_  -> Id
id
        T_DollarExpansion Id
id [Token]
_  -> Id
id
        T_DollarBraced Id
id Bool
_ Token
_ -> Id
id
        T_DollarArithmetic Id
id Token
_  -> Id
id
        T_BraceExpansion Id
id [Token]
_  -> Id
id
        T_ParamSubSpecialChar Id
id String
_ -> Id
id
        T_DollarBraceCommandExpansion Id
id [Token]
_  -> Id
id
        T_IoFile Id
id Token
_ Token
_  -> Id
id
        T_IoDuplicate Id
id Token
_ String
_  -> Id
id
        T_HereDoc Id
id Dashed
_ Quoted
_ String
_ [Token]
_ -> Id
id
        T_HereString Id
id Token
_  -> Id
id
        T_FdRedirect Id
id String
_ Token
_  -> Id
id
        T_Assignment Id
id AssignmentMode
_ String
_ [Token]
_ Token
_  -> Id
id
        T_Array Id
id [Token]
_  -> Id
id
        T_IndexedElement Id
id [Token]
_ Token
_  -> Id
id
        T_Redirecting Id
id [Token]
_ Token
_  -> Id
id
        T_SimpleCommand Id
id [Token]
_ [Token]
_  -> Id
id
        T_Pipeline Id
id [Token]
_ [Token]
_  -> Id
id
        T_Banged Id
id Token
_  -> Id
id
        T_AndIf Id
id Token
_ Token
_ -> Id
id
        T_OrIf Id
id Token
_ Token
_ -> Id
id
        T_Backgrounded Id
id Token
_  -> Id
id
        T_IfExpression Id
id [([Token], [Token])]
_ [Token]
_  -> Id
id
        T_Subshell Id
id [Token]
_  -> Id
id
        T_BraceGroup Id
id [Token]
_  -> Id
id
        T_WhileExpression Id
id [Token]
_ [Token]
_  -> Id
id
        T_UntilExpression Id
id [Token]
_ [Token]
_  -> Id
id
        T_ForIn Id
id String
_ [Token]
_ [Token]
_  -> Id
id
        T_SelectIn Id
id String
_ [Token]
_ [Token]
_  -> Id
id
        T_CaseExpression Id
id Token
_ [(CaseType, [Token], [Token])]
_ -> Id
id
        T_Function Id
id FunctionKeyword
_ FunctionParentheses
_ String
_ Token
_  -> Id
id
        T_Arithmetic Id
id Token
_  -> Id
id
        T_Script Id
id Token
_ [Token]
_  -> Id
id
        T_Condition Id
id ConditionType
_ Token
_  -> Id
id
        T_Extglob Id
id String
_ [Token]
_ -> Id
id
        T_Backticked Id
id [Token]
_ -> Id
id
        TC_And Id
id ConditionType
_ String
_ Token
_ Token
_  -> Id
id
        TC_Or Id
id ConditionType
_ String
_ Token
_ Token
_  -> Id
id
        TC_Group Id
id ConditionType
_ Token
_  -> Id
id
        TC_Binary Id
id ConditionType
_ String
_ Token
_ Token
_  -> Id
id
        TC_Unary Id
id ConditionType
_ String
_ Token
_  -> Id
id
        TC_Nullary Id
id ConditionType
_ Token
_  -> Id
id
        TA_Binary Id
id String
_ Token
_ Token
_  -> Id
id
        TA_Assignment Id
id String
_ Token
_ Token
_  -> Id
id
        TA_Unary Id
id String
_ Token
_  -> Id
id
        TA_Sequence Id
id [Token]
_  -> Id
id
        TA_Trinary Id
id Token
_ Token
_ Token
_  -> Id
id
        TA_Expansion Id
id [Token]
_  -> Id
id
        T_ProcSub Id
id String
_ [Token]
_ -> Id
id
        T_Glob Id
id String
_ -> Id
id
        T_ForArithmetic Id
id Token
_ Token
_ Token
_ [Token]
_ -> Id
id
        T_DollarSingleQuoted Id
id String
_ -> Id
id
        T_DollarDoubleQuoted Id
id [Token]
_ -> Id
id
        T_DollarBracket Id
id Token
_ -> Id
id
        T_Annotation Id
id [Annotation]
_ Token
_ -> Id
id
        T_Pipe Id
id String
_ -> Id
id
        T_CoProc Id
id Maybe String
_ Token
_ -> Id
id
        T_CoProcBody Id
id Token
_ -> Id
id
        T_Include Id
id Token
_ -> Id
id
        T_SourceCommand Id
id Token
_ Token
_ -> Id
id
        T_UnparsedIndex Id
id SourcePos
_ String
_ -> Id
id
        TC_Empty Id
id ConditionType
_ -> Id
id
        TA_Variable Id
id String
_ [Token]
_ -> Id
id
        T_BatsTest Id
id Token
_ Token
_ -> Id
id

blank :: Monad m => Token -> m ()
blank :: Token -> m ()
blank = m () -> Token -> m ()
forall a b. a -> b -> a
const (m () -> Token -> m ()) -> m () -> Token -> m ()
forall a b. (a -> b) -> a -> b
$ () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
doAnalysis :: Monad m => (Token -> m ()) -> Token -> m Token
doAnalysis :: (Token -> m ()) -> Token -> m Token
doAnalysis Token -> m ()
f = (Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
f Token -> m ()
forall (m :: * -> *). Monad m => Token -> m ()
blank Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return
doStackAnalysis :: Monad m => (Token -> m ()) -> (Token -> m ()) -> Token -> m Token
doStackAnalysis :: (Token -> m ()) -> (Token -> m ()) -> Token -> m Token
doStackAnalysis Token -> m ()
startToken Token -> m ()
endToken = (Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> m ()
startToken Token -> m ()
endToken Token -> m Token
forall (m :: * -> *) a. Monad m => a -> m a
return
doTransform :: (Token -> Token) -> Token -> Token
doTransform :: (Token -> Token) -> Token -> Token
doTransform Token -> Token
i = Identity Token -> Token
forall a. Identity a -> a
runIdentity (Identity Token -> Token)
-> (Token -> Identity Token) -> Token -> Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Token -> Identity ())
-> (Token -> Identity ())
-> (Token -> Identity Token)
-> Token
-> Identity Token
forall (m :: * -> *).
Monad m =>
(Token -> m ())
-> (Token -> m ()) -> (Token -> m Token) -> Token -> m Token
analyze Token -> Identity ()
forall (m :: * -> *). Monad m => Token -> m ()
blank Token -> Identity ()
forall (m :: * -> *). Monad m => Token -> m ()
blank (Token -> Identity Token
forall (m :: * -> *) a. Monad m => a -> m a
return (Token -> Identity Token)
-> (Token -> Token) -> Token -> Identity Token
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Token -> Token
i)