{-
    Copyright 2022 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 TemplateHaskell #-}
{-# LANGUAGE DeriveAnyClass, DeriveGeneric #-}

-- Constructs a Control Flow Graph from an AST
module ShellCheck.CFG (
    CFNode (..),
    CFEdge (..),
    CFEffect (..),
    CFStringPart (..),
    CFVariableProp (..),
    CFGResult (..),
    CFValue (..),
    CFGraph,
    CFGParameters (..),
    IdTagged (..),
    Scope (..),
    buildGraph
    , ShellCheck.CFG.runTests -- STRIP
    )
  where

import GHC.Generics (Generic)
import ShellCheck.AST
import ShellCheck.ASTLib
import ShellCheck.Data
import ShellCheck.Interface
import ShellCheck.Prelude
import ShellCheck.Regex
import Control.DeepSeq
import Control.Monad
import Control.Monad.Identity
import Data.Array.Unboxed
import Data.Array.ST
import Data.List hiding (map)
import qualified Data.List.NonEmpty as NE
import Data.Maybe
import qualified Data.Map as M
import qualified Data.Set as S
import Control.Monad.RWS.Lazy
import Data.Graph.Inductive.Graph
import Data.Graph.Inductive.Query.DFS
import Data.Graph.Inductive.Basic
import Data.Graph.Inductive.Query.Dominators
import Data.Graph.Inductive.PatriciaTree as G
import Debug.Trace -- STRIP

import Test.QuickCheck.All (forAllProperties)
import Test.QuickCheck.Test (quickCheckWithResult, stdArgs, maxSuccess)


-- Our basic Graph type
type CFGraph = G.Gr CFNode CFEdge

-- Node labels in a Control Flow Graph
data CFNode =
    -- A no-op node for structural purposes
    CFStructuralNode
    -- A no-op for graph inspection purposes
    | CFEntryPoint String
    -- Drop current prefix assignments
    | CFDropPrefixAssignments
    -- A node with a certain effect on program state
    | CFApplyEffects [IdTagged CFEffect]
    -- The execution of a command or function by literal string if possible
    | CFExecuteCommand (Maybe String)
    -- Execute a subshell. These are represented by disjoint graphs just like
    -- functions, but they don't require any form of name resolution
    | CFExecuteSubshell String Node Node
    -- Assignment of $?
    | CFSetExitCode Id
    -- The virtual 'exit' at the natural end of a subshell
    | CFImpliedExit
    -- An exit statement resolvable at CFG build time
    | CFResolvedExit
    -- An exit statement only resolvable at DFA time
    | CFUnresolvedExit
    -- An unreachable node, serving as the unconnected end point of a range
    | CFUnreachable
    -- Assignment of $!
    | CFSetBackgroundPid Id
  deriving (CFNode -> CFNode -> Bool
(CFNode -> CFNode -> Bool)
-> (CFNode -> CFNode -> Bool) -> Eq CFNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFNode -> CFNode -> Bool
== :: CFNode -> CFNode -> Bool
$c/= :: CFNode -> CFNode -> Bool
/= :: CFNode -> CFNode -> Bool
Eq, Eq CFNode
Eq CFNode =>
(CFNode -> CFNode -> Ordering)
-> (CFNode -> CFNode -> Bool)
-> (CFNode -> CFNode -> Bool)
-> (CFNode -> CFNode -> Bool)
-> (CFNode -> CFNode -> Bool)
-> (CFNode -> CFNode -> CFNode)
-> (CFNode -> CFNode -> CFNode)
-> Ord CFNode
CFNode -> CFNode -> Bool
CFNode -> CFNode -> Ordering
CFNode -> CFNode -> CFNode
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
$ccompare :: CFNode -> CFNode -> Ordering
compare :: CFNode -> CFNode -> Ordering
$c< :: CFNode -> CFNode -> Bool
< :: CFNode -> CFNode -> Bool
$c<= :: CFNode -> CFNode -> Bool
<= :: CFNode -> CFNode -> Bool
$c> :: CFNode -> CFNode -> Bool
> :: CFNode -> CFNode -> Bool
$c>= :: CFNode -> CFNode -> Bool
>= :: CFNode -> CFNode -> Bool
$cmax :: CFNode -> CFNode -> CFNode
max :: CFNode -> CFNode -> CFNode
$cmin :: CFNode -> CFNode -> CFNode
min :: CFNode -> CFNode -> CFNode
Ord, Int -> CFNode -> ShowS
[CFNode] -> ShowS
CFNode -> [Char]
(Int -> CFNode -> ShowS)
-> (CFNode -> [Char]) -> ([CFNode] -> ShowS) -> Show CFNode
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFNode -> ShowS
showsPrec :: Int -> CFNode -> ShowS
$cshow :: CFNode -> [Char]
show :: CFNode -> [Char]
$cshowList :: [CFNode] -> ShowS
showList :: [CFNode] -> ShowS
Show, (forall x. CFNode -> Rep CFNode x)
-> (forall x. Rep CFNode x -> CFNode) -> Generic CFNode
forall x. Rep CFNode x -> CFNode
forall x. CFNode -> Rep CFNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFNode -> Rep CFNode x
from :: forall x. CFNode -> Rep CFNode x
$cto :: forall x. Rep CFNode x -> CFNode
to :: forall x. Rep CFNode x -> CFNode
Generic, CFNode -> ()
(CFNode -> ()) -> NFData CFNode
forall a. (a -> ()) -> NFData a
$crnf :: CFNode -> ()
rnf :: CFNode -> ()
NFData)

-- Edge labels in a Control Flow Graph
data CFEdge =
    CFEErrExit
    -- Regular control flow edge
    | CFEFlow
    -- An edge that a human might think exists (e.g. from a backgrounded process to its parent)
    | CFEFalseFlow
    -- An edge followed on exit
    | CFEExit
  deriving (CFEdge -> CFEdge -> Bool
(CFEdge -> CFEdge -> Bool)
-> (CFEdge -> CFEdge -> Bool) -> Eq CFEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFEdge -> CFEdge -> Bool
== :: CFEdge -> CFEdge -> Bool
$c/= :: CFEdge -> CFEdge -> Bool
/= :: CFEdge -> CFEdge -> Bool
Eq, Eq CFEdge
Eq CFEdge =>
(CFEdge -> CFEdge -> Ordering)
-> (CFEdge -> CFEdge -> Bool)
-> (CFEdge -> CFEdge -> Bool)
-> (CFEdge -> CFEdge -> Bool)
-> (CFEdge -> CFEdge -> Bool)
-> (CFEdge -> CFEdge -> CFEdge)
-> (CFEdge -> CFEdge -> CFEdge)
-> Ord CFEdge
CFEdge -> CFEdge -> Bool
CFEdge -> CFEdge -> Ordering
CFEdge -> CFEdge -> CFEdge
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
$ccompare :: CFEdge -> CFEdge -> Ordering
compare :: CFEdge -> CFEdge -> Ordering
$c< :: CFEdge -> CFEdge -> Bool
< :: CFEdge -> CFEdge -> Bool
$c<= :: CFEdge -> CFEdge -> Bool
<= :: CFEdge -> CFEdge -> Bool
$c> :: CFEdge -> CFEdge -> Bool
> :: CFEdge -> CFEdge -> Bool
$c>= :: CFEdge -> CFEdge -> Bool
>= :: CFEdge -> CFEdge -> Bool
$cmax :: CFEdge -> CFEdge -> CFEdge
max :: CFEdge -> CFEdge -> CFEdge
$cmin :: CFEdge -> CFEdge -> CFEdge
min :: CFEdge -> CFEdge -> CFEdge
Ord, Int -> CFEdge -> ShowS
[CFEdge] -> ShowS
CFEdge -> [Char]
(Int -> CFEdge -> ShowS)
-> (CFEdge -> [Char]) -> ([CFEdge] -> ShowS) -> Show CFEdge
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFEdge -> ShowS
showsPrec :: Int -> CFEdge -> ShowS
$cshow :: CFEdge -> [Char]
show :: CFEdge -> [Char]
$cshowList :: [CFEdge] -> ShowS
showList :: [CFEdge] -> ShowS
Show, (forall x. CFEdge -> Rep CFEdge x)
-> (forall x. Rep CFEdge x -> CFEdge) -> Generic CFEdge
forall x. Rep CFEdge x -> CFEdge
forall x. CFEdge -> Rep CFEdge x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFEdge -> Rep CFEdge x
from :: forall x. CFEdge -> Rep CFEdge x
$cto :: forall x. Rep CFEdge x -> CFEdge
to :: forall x. Rep CFEdge x -> CFEdge
Generic, CFEdge -> ()
(CFEdge -> ()) -> NFData CFEdge
forall a. (a -> ()) -> NFData a
$crnf :: CFEdge -> ()
rnf :: CFEdge -> ()
NFData)

-- Actions we track
data CFEffect =
    CFSetProps (Maybe Scope) String (S.Set CFVariableProp)
    | CFUnsetProps (Maybe Scope) String (S.Set CFVariableProp)
    | CFReadVariable String
    | CFWriteVariable String CFValue
    | CFWriteGlobal String CFValue
    | CFWriteLocal String CFValue
    | CFWritePrefix String CFValue
    | CFDefineFunction String Id Node Node
    | CFUndefine String
    | CFUndefineVariable String
    | CFUndefineFunction String
    | CFUndefineNameref String
    -- Usage implies that this is an array (e.g. it's expanded with index)
    | CFHintArray String
    -- Operation implies that the variable will be defined (e.g. [ -z "$var" ])
    | CFHintDefined String
  deriving (CFEffect -> CFEffect -> Bool
(CFEffect -> CFEffect -> Bool)
-> (CFEffect -> CFEffect -> Bool) -> Eq CFEffect
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFEffect -> CFEffect -> Bool
== :: CFEffect -> CFEffect -> Bool
$c/= :: CFEffect -> CFEffect -> Bool
/= :: CFEffect -> CFEffect -> Bool
Eq, Eq CFEffect
Eq CFEffect =>
(CFEffect -> CFEffect -> Ordering)
-> (CFEffect -> CFEffect -> Bool)
-> (CFEffect -> CFEffect -> Bool)
-> (CFEffect -> CFEffect -> Bool)
-> (CFEffect -> CFEffect -> Bool)
-> (CFEffect -> CFEffect -> CFEffect)
-> (CFEffect -> CFEffect -> CFEffect)
-> Ord CFEffect
CFEffect -> CFEffect -> Bool
CFEffect -> CFEffect -> Ordering
CFEffect -> CFEffect -> CFEffect
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
$ccompare :: CFEffect -> CFEffect -> Ordering
compare :: CFEffect -> CFEffect -> Ordering
$c< :: CFEffect -> CFEffect -> Bool
< :: CFEffect -> CFEffect -> Bool
$c<= :: CFEffect -> CFEffect -> Bool
<= :: CFEffect -> CFEffect -> Bool
$c> :: CFEffect -> CFEffect -> Bool
> :: CFEffect -> CFEffect -> Bool
$c>= :: CFEffect -> CFEffect -> Bool
>= :: CFEffect -> CFEffect -> Bool
$cmax :: CFEffect -> CFEffect -> CFEffect
max :: CFEffect -> CFEffect -> CFEffect
$cmin :: CFEffect -> CFEffect -> CFEffect
min :: CFEffect -> CFEffect -> CFEffect
Ord, Int -> CFEffect -> ShowS
[CFEffect] -> ShowS
CFEffect -> [Char]
(Int -> CFEffect -> ShowS)
-> (CFEffect -> [Char]) -> ([CFEffect] -> ShowS) -> Show CFEffect
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFEffect -> ShowS
showsPrec :: Int -> CFEffect -> ShowS
$cshow :: CFEffect -> [Char]
show :: CFEffect -> [Char]
$cshowList :: [CFEffect] -> ShowS
showList :: [CFEffect] -> ShowS
Show, (forall x. CFEffect -> Rep CFEffect x)
-> (forall x. Rep CFEffect x -> CFEffect) -> Generic CFEffect
forall x. Rep CFEffect x -> CFEffect
forall x. CFEffect -> Rep CFEffect x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFEffect -> Rep CFEffect x
from :: forall x. CFEffect -> Rep CFEffect x
$cto :: forall x. Rep CFEffect x -> CFEffect
to :: forall x. Rep CFEffect x -> CFEffect
Generic, CFEffect -> ()
(CFEffect -> ()) -> NFData CFEffect
forall a. (a -> ()) -> NFData a
$crnf :: CFEffect -> ()
rnf :: CFEffect -> ()
NFData)

data IdTagged a = IdTagged Id a
  deriving (IdTagged a -> IdTagged a -> Bool
(IdTagged a -> IdTagged a -> Bool)
-> (IdTagged a -> IdTagged a -> Bool) -> Eq (IdTagged a)
forall a. Eq a => IdTagged a -> IdTagged a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => IdTagged a -> IdTagged a -> Bool
== :: IdTagged a -> IdTagged a -> Bool
$c/= :: forall a. Eq a => IdTagged a -> IdTagged a -> Bool
/= :: IdTagged a -> IdTagged a -> Bool
Eq, Eq (IdTagged a)
Eq (IdTagged a) =>
(IdTagged a -> IdTagged a -> Ordering)
-> (IdTagged a -> IdTagged a -> Bool)
-> (IdTagged a -> IdTagged a -> Bool)
-> (IdTagged a -> IdTagged a -> Bool)
-> (IdTagged a -> IdTagged a -> Bool)
-> (IdTagged a -> IdTagged a -> IdTagged a)
-> (IdTagged a -> IdTagged a -> IdTagged a)
-> Ord (IdTagged a)
IdTagged a -> IdTagged a -> Bool
IdTagged a -> IdTagged a -> Ordering
IdTagged a -> IdTagged a -> IdTagged a
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
forall a. Ord a => Eq (IdTagged a)
forall a. Ord a => IdTagged a -> IdTagged a -> Bool
forall a. Ord a => IdTagged a -> IdTagged a -> Ordering
forall a. Ord a => IdTagged a -> IdTagged a -> IdTagged a
$ccompare :: forall a. Ord a => IdTagged a -> IdTagged a -> Ordering
compare :: IdTagged a -> IdTagged a -> Ordering
$c< :: forall a. Ord a => IdTagged a -> IdTagged a -> Bool
< :: IdTagged a -> IdTagged a -> Bool
$c<= :: forall a. Ord a => IdTagged a -> IdTagged a -> Bool
<= :: IdTagged a -> IdTagged a -> Bool
$c> :: forall a. Ord a => IdTagged a -> IdTagged a -> Bool
> :: IdTagged a -> IdTagged a -> Bool
$c>= :: forall a. Ord a => IdTagged a -> IdTagged a -> Bool
>= :: IdTagged a -> IdTagged a -> Bool
$cmax :: forall a. Ord a => IdTagged a -> IdTagged a -> IdTagged a
max :: IdTagged a -> IdTagged a -> IdTagged a
$cmin :: forall a. Ord a => IdTagged a -> IdTagged a -> IdTagged a
min :: IdTagged a -> IdTagged a -> IdTagged a
Ord, Int -> IdTagged a -> ShowS
[IdTagged a] -> ShowS
IdTagged a -> [Char]
(Int -> IdTagged a -> ShowS)
-> (IdTagged a -> [Char])
-> ([IdTagged a] -> ShowS)
-> Show (IdTagged a)
forall a. Show a => Int -> IdTagged a -> ShowS
forall a. Show a => [IdTagged a] -> ShowS
forall a. Show a => IdTagged a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> IdTagged a -> ShowS
showsPrec :: Int -> IdTagged a -> ShowS
$cshow :: forall a. Show a => IdTagged a -> [Char]
show :: IdTagged a -> [Char]
$cshowList :: forall a. Show a => [IdTagged a] -> ShowS
showList :: [IdTagged a] -> ShowS
Show, (forall x. IdTagged a -> Rep (IdTagged a) x)
-> (forall x. Rep (IdTagged a) x -> IdTagged a)
-> Generic (IdTagged a)
forall x. Rep (IdTagged a) x -> IdTagged a
forall x. IdTagged a -> Rep (IdTagged a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (IdTagged a) x -> IdTagged a
forall a x. IdTagged a -> Rep (IdTagged a) x
$cfrom :: forall a x. IdTagged a -> Rep (IdTagged a) x
from :: forall x. IdTagged a -> Rep (IdTagged a) x
$cto :: forall a x. Rep (IdTagged a) x -> IdTagged a
to :: forall x. Rep (IdTagged a) x -> IdTagged a
Generic, IdTagged a -> ()
(IdTagged a -> ()) -> NFData (IdTagged a)
forall a. NFData a => IdTagged a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => IdTagged a -> ()
rnf :: IdTagged a -> ()
NFData)

-- Where a variable's value comes from
data CFValue =
    -- The special 'uninitialized' value
    CFValueUninitialized
    -- An arbitrary array value
    | CFValueArray
    -- An arbitrary string value
    | CFValueString
    -- An arbitrary integer
    | CFValueInteger
    -- Token 'Id' concatenates and assigns the given parts
    | CFValueComputed Id [CFStringPart]
  deriving (CFValue -> CFValue -> Bool
(CFValue -> CFValue -> Bool)
-> (CFValue -> CFValue -> Bool) -> Eq CFValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFValue -> CFValue -> Bool
== :: CFValue -> CFValue -> Bool
$c/= :: CFValue -> CFValue -> Bool
/= :: CFValue -> CFValue -> Bool
Eq, Eq CFValue
Eq CFValue =>
(CFValue -> CFValue -> Ordering)
-> (CFValue -> CFValue -> Bool)
-> (CFValue -> CFValue -> Bool)
-> (CFValue -> CFValue -> Bool)
-> (CFValue -> CFValue -> Bool)
-> (CFValue -> CFValue -> CFValue)
-> (CFValue -> CFValue -> CFValue)
-> Ord CFValue
CFValue -> CFValue -> Bool
CFValue -> CFValue -> Ordering
CFValue -> CFValue -> CFValue
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
$ccompare :: CFValue -> CFValue -> Ordering
compare :: CFValue -> CFValue -> Ordering
$c< :: CFValue -> CFValue -> Bool
< :: CFValue -> CFValue -> Bool
$c<= :: CFValue -> CFValue -> Bool
<= :: CFValue -> CFValue -> Bool
$c> :: CFValue -> CFValue -> Bool
> :: CFValue -> CFValue -> Bool
$c>= :: CFValue -> CFValue -> Bool
>= :: CFValue -> CFValue -> Bool
$cmax :: CFValue -> CFValue -> CFValue
max :: CFValue -> CFValue -> CFValue
$cmin :: CFValue -> CFValue -> CFValue
min :: CFValue -> CFValue -> CFValue
Ord, Int -> CFValue -> ShowS
[CFValue] -> ShowS
CFValue -> [Char]
(Int -> CFValue -> ShowS)
-> (CFValue -> [Char]) -> ([CFValue] -> ShowS) -> Show CFValue
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFValue -> ShowS
showsPrec :: Int -> CFValue -> ShowS
$cshow :: CFValue -> [Char]
show :: CFValue -> [Char]
$cshowList :: [CFValue] -> ShowS
showList :: [CFValue] -> ShowS
Show, (forall x. CFValue -> Rep CFValue x)
-> (forall x. Rep CFValue x -> CFValue) -> Generic CFValue
forall x. Rep CFValue x -> CFValue
forall x. CFValue -> Rep CFValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFValue -> Rep CFValue x
from :: forall x. CFValue -> Rep CFValue x
$cto :: forall x. Rep CFValue x -> CFValue
to :: forall x. Rep CFValue x -> CFValue
Generic, CFValue -> ()
(CFValue -> ()) -> NFData CFValue
forall a. (a -> ()) -> NFData a
$crnf :: CFValue -> ()
rnf :: CFValue -> ()
NFData)

-- Simplified computed strings
data CFStringPart =
    -- A known literal string value, like 'foo'
    CFStringLiteral String
    -- The contents of a variable, like $foo (may not be a string)
    | CFStringVariable String
    -- An value that is unknown but an integer
    | CFStringInteger
    -- An unknown string value, for things we can't handle
    | CFStringUnknown
  deriving (CFStringPart -> CFStringPart -> Bool
(CFStringPart -> CFStringPart -> Bool)
-> (CFStringPart -> CFStringPart -> Bool) -> Eq CFStringPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFStringPart -> CFStringPart -> Bool
== :: CFStringPart -> CFStringPart -> Bool
$c/= :: CFStringPart -> CFStringPart -> Bool
/= :: CFStringPart -> CFStringPart -> Bool
Eq, Eq CFStringPart
Eq CFStringPart =>
(CFStringPart -> CFStringPart -> Ordering)
-> (CFStringPart -> CFStringPart -> Bool)
-> (CFStringPart -> CFStringPart -> Bool)
-> (CFStringPart -> CFStringPart -> Bool)
-> (CFStringPart -> CFStringPart -> Bool)
-> (CFStringPart -> CFStringPart -> CFStringPart)
-> (CFStringPart -> CFStringPart -> CFStringPart)
-> Ord CFStringPart
CFStringPart -> CFStringPart -> Bool
CFStringPart -> CFStringPart -> Ordering
CFStringPart -> CFStringPart -> CFStringPart
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
$ccompare :: CFStringPart -> CFStringPart -> Ordering
compare :: CFStringPart -> CFStringPart -> Ordering
$c< :: CFStringPart -> CFStringPart -> Bool
< :: CFStringPart -> CFStringPart -> Bool
$c<= :: CFStringPart -> CFStringPart -> Bool
<= :: CFStringPart -> CFStringPart -> Bool
$c> :: CFStringPart -> CFStringPart -> Bool
> :: CFStringPart -> CFStringPart -> Bool
$c>= :: CFStringPart -> CFStringPart -> Bool
>= :: CFStringPart -> CFStringPart -> Bool
$cmax :: CFStringPart -> CFStringPart -> CFStringPart
max :: CFStringPart -> CFStringPart -> CFStringPart
$cmin :: CFStringPart -> CFStringPart -> CFStringPart
min :: CFStringPart -> CFStringPart -> CFStringPart
Ord, Int -> CFStringPart -> ShowS
[CFStringPart] -> ShowS
CFStringPart -> [Char]
(Int -> CFStringPart -> ShowS)
-> (CFStringPart -> [Char])
-> ([CFStringPart] -> ShowS)
-> Show CFStringPart
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFStringPart -> ShowS
showsPrec :: Int -> CFStringPart -> ShowS
$cshow :: CFStringPart -> [Char]
show :: CFStringPart -> [Char]
$cshowList :: [CFStringPart] -> ShowS
showList :: [CFStringPart] -> ShowS
Show, (forall x. CFStringPart -> Rep CFStringPart x)
-> (forall x. Rep CFStringPart x -> CFStringPart)
-> Generic CFStringPart
forall x. Rep CFStringPart x -> CFStringPart
forall x. CFStringPart -> Rep CFStringPart x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFStringPart -> Rep CFStringPart x
from :: forall x. CFStringPart -> Rep CFStringPart x
$cto :: forall x. Rep CFStringPart x -> CFStringPart
to :: forall x. Rep CFStringPart x -> CFStringPart
Generic, CFStringPart -> ()
(CFStringPart -> ()) -> NFData CFStringPart
forall a. (a -> ()) -> NFData a
$crnf :: CFStringPart -> ()
rnf :: CFStringPart -> ()
NFData)

-- The properties of a variable
data CFVariableProp = CFVPExport | CFVPArray | CFVPAssociative | CFVPInteger
  deriving (CFVariableProp -> CFVariableProp -> Bool
(CFVariableProp -> CFVariableProp -> Bool)
-> (CFVariableProp -> CFVariableProp -> Bool) -> Eq CFVariableProp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CFVariableProp -> CFVariableProp -> Bool
== :: CFVariableProp -> CFVariableProp -> Bool
$c/= :: CFVariableProp -> CFVariableProp -> Bool
/= :: CFVariableProp -> CFVariableProp -> Bool
Eq, Eq CFVariableProp
Eq CFVariableProp =>
(CFVariableProp -> CFVariableProp -> Ordering)
-> (CFVariableProp -> CFVariableProp -> Bool)
-> (CFVariableProp -> CFVariableProp -> Bool)
-> (CFVariableProp -> CFVariableProp -> Bool)
-> (CFVariableProp -> CFVariableProp -> Bool)
-> (CFVariableProp -> CFVariableProp -> CFVariableProp)
-> (CFVariableProp -> CFVariableProp -> CFVariableProp)
-> Ord CFVariableProp
CFVariableProp -> CFVariableProp -> Bool
CFVariableProp -> CFVariableProp -> Ordering
CFVariableProp -> CFVariableProp -> CFVariableProp
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
$ccompare :: CFVariableProp -> CFVariableProp -> Ordering
compare :: CFVariableProp -> CFVariableProp -> Ordering
$c< :: CFVariableProp -> CFVariableProp -> Bool
< :: CFVariableProp -> CFVariableProp -> Bool
$c<= :: CFVariableProp -> CFVariableProp -> Bool
<= :: CFVariableProp -> CFVariableProp -> Bool
$c> :: CFVariableProp -> CFVariableProp -> Bool
> :: CFVariableProp -> CFVariableProp -> Bool
$c>= :: CFVariableProp -> CFVariableProp -> Bool
>= :: CFVariableProp -> CFVariableProp -> Bool
$cmax :: CFVariableProp -> CFVariableProp -> CFVariableProp
max :: CFVariableProp -> CFVariableProp -> CFVariableProp
$cmin :: CFVariableProp -> CFVariableProp -> CFVariableProp
min :: CFVariableProp -> CFVariableProp -> CFVariableProp
Ord, Int -> CFVariableProp -> ShowS
[CFVariableProp] -> ShowS
CFVariableProp -> [Char]
(Int -> CFVariableProp -> ShowS)
-> (CFVariableProp -> [Char])
-> ([CFVariableProp] -> ShowS)
-> Show CFVariableProp
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFVariableProp -> ShowS
showsPrec :: Int -> CFVariableProp -> ShowS
$cshow :: CFVariableProp -> [Char]
show :: CFVariableProp -> [Char]
$cshowList :: [CFVariableProp] -> ShowS
showList :: [CFVariableProp] -> ShowS
Show, (forall x. CFVariableProp -> Rep CFVariableProp x)
-> (forall x. Rep CFVariableProp x -> CFVariableProp)
-> Generic CFVariableProp
forall x. Rep CFVariableProp x -> CFVariableProp
forall x. CFVariableProp -> Rep CFVariableProp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CFVariableProp -> Rep CFVariableProp x
from :: forall x. CFVariableProp -> Rep CFVariableProp x
$cto :: forall x. Rep CFVariableProp x -> CFVariableProp
to :: forall x. Rep CFVariableProp x -> CFVariableProp
Generic, CFVariableProp -> ()
(CFVariableProp -> ()) -> NFData CFVariableProp
forall a. (a -> ()) -> NFData a
$crnf :: CFVariableProp -> ()
rnf :: CFVariableProp -> ()
NFData)

-- Options when generating CFG
data CFGParameters = CFGParameters {
    -- Whether the last element in a pipeline runs in the current shell
    CFGParameters -> Bool
cfLastpipe :: Bool,
    -- Whether all elements in a pipeline count towards the exit status
    CFGParameters -> Bool
cfPipefail :: Bool
}

data CFGResult = CFGResult {
    -- The graph itself
    CFGResult -> CFGraph
cfGraph :: CFGraph,
    -- Map from Id to nominal start&end node (i.e. assuming normal execution without exits)
    CFGResult -> Map Id (Int, Int)
cfIdToRange :: M.Map Id (Node, Node),
    -- A set of all nodes belonging to an Id, recursively
    CFGResult -> Map Id (Set Int)
cfIdToNodes :: M.Map Id (S.Set Node),
    -- An array (from,to) saying whether 'from' postdominates 'to'
    CFGResult -> Array Int [Int]
cfPostDominators :: Array Node [Node]
}
  deriving (Int -> CFGResult -> ShowS
[CFGResult] -> ShowS
CFGResult -> [Char]
(Int -> CFGResult -> ShowS)
-> (CFGResult -> [Char])
-> ([CFGResult] -> ShowS)
-> Show CFGResult
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CFGResult -> ShowS
showsPrec :: Int -> CFGResult -> ShowS
$cshow :: CFGResult -> [Char]
show :: CFGResult -> [Char]
$cshowList :: [CFGResult] -> ShowS
showList :: [CFGResult] -> ShowS
Show)

buildGraph :: CFGParameters -> Token -> CFGResult
buildGraph :: CFGParameters -> Token -> CFGResult
buildGraph CFGParameters
params Token
root =
    let
        (Int
nextNode, ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
base) = RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
-> CFContext
-> Int
-> (Int,
    ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)]))
forall r w s a. RWS r w s a -> r -> s -> (s, w)
execRWS (Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildRoot Token
root) (CFGParameters -> CFContext
newCFContext CFGParameters
params) Int
0
        ([LNode CFNode]
nodes, [LEdge CFEdge]
edges, [(Id, (Int, Int))]
mapping, [(Id, Int)]
association) =
--            renumberTopologically $
                ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
removeUnnecessaryStructuralNodes
                    ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
base

        idToRange :: Map Id (Int, Int)
idToRange = [(Id, (Int, Int))] -> Map Id (Int, Int)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(Id, (Int, Int))]
mapping
        isRealEdge :: (a, b, CFEdge) -> Bool
isRealEdge (a
from, b
to, CFEdge
edge) = case CFEdge
edge of CFEdge
CFEFlow -> Bool
True; CFEdge
CFEExit -> Bool
True; CFEdge
_ -> Bool
False
        onlyRealEdges :: [LEdge CFEdge]
onlyRealEdges = (LEdge CFEdge -> Bool) -> [LEdge CFEdge] -> [LEdge CFEdge]
forall a. (a -> Bool) -> [a] -> [a]
filter LEdge CFEdge -> Bool
forall {a} {b}. (a, b, CFEdge) -> Bool
isRealEdge [LEdge CFEdge]
edges
        (Int
_, Int
mainExit) = Maybe (Int, Int) -> (Int, Int)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Int, Int) -> (Int, Int)) -> Maybe (Int, Int) -> (Int, Int)
forall a b. (a -> b) -> a -> b
$ Id -> Map Id (Int, Int) -> Maybe (Int, Int)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup (Token -> Id
getId Token
root) Map Id (Int, Int)
idToRange

        result :: CFGResult
result = CFGResult {
            cfGraph :: CFGraph
cfGraph = [LNode CFNode] -> [LEdge CFEdge] -> CFGraph
forall a b. [LNode a] -> [LEdge b] -> Gr a b
forall (gr :: * -> * -> *) a b.
Graph gr =>
[LNode a] -> [LEdge b] -> gr a b
mkGraph [LNode CFNode]
nodes [LEdge CFEdge]
edges,
            cfIdToRange :: Map Id (Int, Int)
cfIdToRange = Map Id (Int, Int)
idToRange,
            cfIdToNodes :: Map Id (Set Int)
cfIdToNodes = (Set Int -> Set Int -> Set Int)
-> [(Id, Set Int)] -> Map Id (Set Int)
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
M.fromListWith Set Int -> Set Int -> Set Int
forall a. Ord a => Set a -> Set a -> Set a
S.union ([(Id, Set Int)] -> Map Id (Set Int))
-> [(Id, Set Int)] -> Map Id (Set Int)
forall a b. (a -> b) -> a -> b
$ ((Id, Int) -> (Id, Set Int)) -> [(Id, Int)] -> [(Id, Set Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Id
id, Int
n) -> (Id
id, Int -> Set Int
forall a. a -> Set a
S.singleton Int
n)) [(Id, Int)]
association,
            cfPostDominators :: Array Int [Int]
cfPostDominators = Int -> CFGraph -> Array Int [Int]
findPostDominators Int
mainExit (CFGraph -> Array Int [Int]) -> CFGraph -> Array Int [Int]
forall a b. (a -> b) -> a -> b
$ [LNode CFNode] -> [LEdge CFEdge] -> CFGraph
forall a b. [LNode a] -> [LEdge b] -> Gr a b
forall (gr :: * -> * -> *) a b.
Graph gr =>
[LNode a] -> [LEdge b] -> gr a b
mkGraph [LNode CFNode]
nodes [LEdge CFEdge]
onlyRealEdges
        }
    in
        CFGResult
result

remapGraph :: M.Map Node Node -> CFW -> CFW
remapGraph :: Map Int Int
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
remapGraph Map Int Int
remap ([LNode CFNode]
nodes, [LEdge CFEdge]
edges, [(Id, (Int, Int))]
mapping, [(Id, Int)]
assoc) =
    (
        (LNode CFNode -> LNode CFNode) -> [LNode CFNode] -> [LNode CFNode]
forall a b. (a -> b) -> [a] -> [b]
map (Map Int Int -> LNode CFNode -> LNode CFNode
remapNode Map Int Int
remap) [LNode CFNode]
nodes,
        (LEdge CFEdge -> LEdge CFEdge) -> [LEdge CFEdge] -> [LEdge CFEdge]
forall a b. (a -> b) -> [a] -> [b]
map (Map Int Int -> LEdge CFEdge -> LEdge CFEdge
remapEdge Map Int Int
remap) [LEdge CFEdge]
edges,
        ((Id, (Int, Int)) -> (Id, (Int, Int)))
-> [(Id, (Int, Int))] -> [(Id, (Int, Int))]
forall a b. (a -> b) -> [a] -> [b]
map (\(Id
id, (Int
a,Int
b)) -> (Id
id, (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
remap Int
a, Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
remap Int
b))) [(Id, (Int, Int))]
mapping,
        ((Id, Int) -> (Id, Int)) -> [(Id, Int)] -> [(Id, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Id
id, Int
n) -> (Id
id, Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
remap Int
n)) [(Id, Int)]
assoc
    )

prop_testRenumbering :: Bool
prop_testRenumbering =
    let
        s :: CFNode
s = CFNode
CFStructuralNode
        before :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
before = (
            [(Int
1,CFNode
s), (Int
3,CFNode
s), (Int
4, CFNode
s), (Int
8,CFNode
s)],
            [(Int
1,Int
3,CFEdge
CFEFlow), (Int
3,Int
4, CFEdge
CFEFlow), (Int
4,Int
8,CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
3,Int
4))],
            [(Int -> Id
Id Int
1, Int
3), (Int -> Id
Id Int
2, Int
4)]
            )
        after :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
after = (
            [(Int
0,CFNode
s), (Int
1,CFNode
s), (Int
2,CFNode
s), (Int
3,CFNode
s)],
            [(Int
0,Int
1,CFEdge
CFEFlow), (Int
1,Int
2, CFEdge
CFEFlow), (Int
2,Int
3,CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
1,Int
2))],
            [(Int -> Id
Id Int
1, Int
1), (Int -> Id
Id Int
2, Int
2)]
            )
    in ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
after ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> Bool
forall a. Eq a => a -> a -> Bool
== ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
renumberGraph ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
before

-- Renumber the graph for prettiness, so there are no gaps in node numbers
renumberGraph :: CFW -> CFW
renumberGraph :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
renumberGraph g :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
g@([LNode CFNode]
nodes, [LEdge CFEdge]
edges, [(Id, (Int, Int))]
mapping, [(Id, Int)]
assoc) =
    let renumbering :: Map Int Int
renumbering = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList (([Int] -> [Int] -> [(Int, Int)]) -> [Int] -> [Int] -> [(Int, Int)]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Int] -> [Int] -> [(Int, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Int] -> [(Int, Int)]) -> [Int] -> [(Int, Int)]
forall a b. (a -> b) -> a -> b
$ [Int] -> [Int]
forall a. Ord a => [a] -> [a]
sort ([Int] -> [Int]) -> [Int] -> [Int]
forall a b. (a -> b) -> a -> b
$ (LNode CFNode -> Int) -> [LNode CFNode] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map LNode CFNode -> Int
forall a b. (a, b) -> a
fst [LNode CFNode]
nodes)
    in Map Int Int
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
remapGraph Map Int Int
renumbering ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
g

prop_testRenumberTopologically :: Bool
prop_testRenumberTopologically =
    let
        s :: CFNode
s = CFNode
CFStructuralNode
        before :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [a])
before = (
            [(Int
4,CFNode
s), (Int
2,CFNode
s), (Int
3, CFNode
s)],
            [(Int
4,Int
2,CFEdge
CFEFlow), (Int
2,Int
3, CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
4,Int
2))],
            []
            )
        after :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [a])
after = (
            [(Int
0,CFNode
s), (Int
1,CFNode
s), (Int
2,CFNode
s)],
            [(Int
0,Int
1,CFEdge
CFEFlow), (Int
1,Int
2, CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
0,Int
1))],
            []
            )
    in ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
forall {a}.
([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [a])
after ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> Bool
forall a. Eq a => a -> a -> Bool
== ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
renumberTopologically ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
forall {a}.
([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [a])
before

-- Renumber the graph in topological order
renumberTopologically :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
renumberTopologically g :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
g@([LNode CFNode]
nodes, [LEdge CFEdge]
edges, [(Id, (Int, Int))]
mapping, [(Id, Int)]
assoc) =
    let renumbering :: Map Int Int
renumbering = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList (([Int] -> [Int] -> [(Int, Int)]) -> [Int] -> [Int] -> [(Int, Int)]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Int] -> [Int] -> [(Int, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0..] ([Int] -> [(Int, Int)]) -> [Int] -> [(Int, Int)]
forall a b. (a -> b) -> a -> b
$ CFGraph -> [Int]
forall (gr :: * -> * -> *) a b. Graph gr => gr a b -> [Int]
topsort ([LNode CFNode] -> [LEdge CFEdge] -> CFGraph
forall a b. [LNode a] -> [LEdge b] -> Gr a b
forall (gr :: * -> * -> *) a b.
Graph gr =>
[LNode a] -> [LEdge b] -> gr a b
mkGraph [LNode CFNode]
nodes [LEdge CFEdge]
edges :: CFGraph))
    in Map Int Int
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
remapGraph Map Int Int
renumbering ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
g

prop_testRemoveStructural :: Bool
prop_testRemoveStructural =
    let
        s :: CFNode
s = CFNode
CFStructuralNode
        before :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
before = (
            [(Int
1,CFNode
s), (Int
2,CFNode
s), (Int
3, CFNode
s), (Int
4,CFNode
s)],
            [(Int
1,Int
2,CFEdge
CFEFlow), (Int
2,Int
3, CFEdge
CFEFlow), (Int
3,Int
4,CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
2,Int
3))],
            [(Int -> Id
Id Int
0, Int
3)]
            )
        after :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
after = (
            [(Int
1,CFNode
s), (Int
2,CFNode
s), (Int
4,CFNode
s)],
            [(Int
1,Int
2,CFEdge
CFEFlow), (Int
2,Int
4,CFEdge
CFEFlow)],
            [(Int -> Id
Id Int
0, (Int
2,Int
2))],
            [(Int -> Id
Id Int
0, Int
2)]
            )
    in ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
after ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> Bool
forall a. Eq a => a -> a -> Bool
== ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
removeUnnecessaryStructuralNodes ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
before

-- Collapse structural nodes that just form long chains like x->x->x.
-- This way we can generate them with abandon, without making DFA slower.
--
-- Note in particular that we can't remove a structural node x in
-- foo -> x -> bar , because then the pre/post-condition for tokens
-- previously pointing to x would be wrong.
removeUnnecessaryStructuralNodes :: ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
removeUnnecessaryStructuralNodes ([LNode CFNode]
nodes, [LEdge CFEdge]
edges, [(Id, (Int, Int))]
mapping, [(Id, Int)]
association) =
    Map Int Int
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
-> ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))],
    [(Id, Int)])
remapGraph Map Int Int
recursiveRemapping
        (
            (LNode CFNode -> Bool) -> [LNode CFNode] -> [LNode CFNode]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(Int
n, CFNode
_) -> Int
n Int -> Map Int Int -> Bool
forall k a. Ord k => k -> Map k a -> Bool
`M.notMember` Map Int Int
recursiveRemapping) [LNode CFNode]
nodes,
            (LEdge CFEdge -> Bool) -> [LEdge CFEdge] -> [LEdge CFEdge]
forall a. (a -> Bool) -> [a] -> [a]
filter (LEdge CFEdge -> Set (LEdge CFEdge) -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.notMember` Set (LEdge CFEdge)
edgesToCollapse) [LEdge CFEdge]
edges,
            [(Id, (Int, Int))]
mapping,
            [(Id, Int)]
association
        )
  where
    regularEdges :: [LEdge CFEdge]
regularEdges = (LEdge CFEdge -> Bool) -> [LEdge CFEdge] -> [LEdge CFEdge]
forall a. (a -> Bool) -> [a] -> [a]
filter LEdge CFEdge -> Bool
forall {a} {b}. (a, b, CFEdge) -> Bool
isRegularEdge [LEdge CFEdge]
edges
    inDegree :: Map Int Integer
inDegree = [Int] -> Map Int Integer
counter ([Int] -> Map Int Integer) -> [Int] -> Map Int Integer
forall a b. (a -> b) -> a -> b
$ (LEdge CFEdge -> Int) -> [LEdge CFEdge] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
from,Int
to,CFEdge
_) -> Int
from) [LEdge CFEdge]
regularEdges
    outDegree :: Map Int Integer
outDegree = [Int] -> Map Int Integer
counter ([Int] -> Map Int Integer) -> [Int] -> Map Int Integer
forall a b. (a -> b) -> a -> b
$ (LEdge CFEdge -> Int) -> [LEdge CFEdge] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
from,Int
to,CFEdge
_) -> Int
to) [LEdge CFEdge]
regularEdges
    structuralNodes :: Set Int
structuralNodes = [Int] -> Set Int
forall a. Ord a => [a] -> Set a
S.fromList [Int
node | (Int
node, CFNode
CFStructuralNode) <- [LNode CFNode]
nodes]
    candidateNodes :: Set Int
candidateNodes = (Int -> Bool) -> Set Int -> Set Int
forall a. (a -> Bool) -> Set a -> Set a
S.filter Int -> Bool
isLinear Set Int
structuralNodes
    edgesToCollapse :: Set (LEdge CFEdge)
edgesToCollapse = [LEdge CFEdge] -> Set (LEdge CFEdge)
forall a. Ord a => [a] -> Set a
S.fromList ([LEdge CFEdge] -> Set (LEdge CFEdge))
-> [LEdge CFEdge] -> Set (LEdge CFEdge)
forall a b. (a -> b) -> a -> b
$ (LEdge CFEdge -> Bool) -> [LEdge CFEdge] -> [LEdge CFEdge]
forall a. (a -> Bool) -> [a] -> [a]
filter LEdge CFEdge -> Bool
forall {c}. (Int, Int, c) -> Bool
filterEdges [LEdge CFEdge]
regularEdges

    remapping :: M.Map Node Node
    remapping :: Map Int Int
remapping = [(Int, Int)] -> Map Int Int
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Int, Int)] -> Map Int Int) -> [(Int, Int)] -> Map Int Int
forall a b. (a -> b) -> a -> b
$ (LEdge CFEdge -> (Int, Int)) -> [LEdge CFEdge] -> [(Int, Int)]
forall a b. (a -> b) -> [a] -> [b]
map LEdge CFEdge -> (Int, Int)
forall {b} {c}. Ord b => (b, b, c) -> (b, b)
orderEdge ([LEdge CFEdge] -> [(Int, Int)]) -> [LEdge CFEdge] -> [(Int, Int)]
forall a b. (a -> b) -> a -> b
$ Set (LEdge CFEdge) -> [LEdge CFEdge]
forall a. Set a -> [a]
S.toList Set (LEdge CFEdge)
edgesToCollapse
    recursiveRemapping :: Map Int Int
recursiveRemapping = (Int -> Int -> Int) -> Map Int Int -> Map Int Int
forall k a b. (k -> a -> b) -> Map k a -> Map k b
M.mapWithKey (\Int
c Int
_ -> Map Int Int -> Int -> Int
recursiveLookup Map Int Int
remapping Int
c) Map Int Int
remapping

    filterEdges :: (Int, Int, c) -> Bool
filterEdges (Int
a,Int
b,c
_) =
        Int
a Int -> Set Int -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Int
candidateNodes Bool -> Bool -> Bool
&& Int
b Int -> Set Int -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set Int
candidateNodes

    orderEdge :: (b, b, c) -> (b, b)
orderEdge (b
a,b
b,c
_) = if b
a b -> b -> Bool
forall a. Ord a => a -> a -> Bool
< b
b then (b
b,b
a) else (b
a,b
b)
    counter :: [Int] -> Map Int Integer
counter = (Integer -> Integer -> Integer)
-> [(Int, Integer)] -> Map Int Integer
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
M.fromListWith Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
(+) ([(Int, Integer)] -> Map Int Integer)
-> ([Int] -> [(Int, Integer)]) -> [Int] -> Map Int Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Int, Integer)) -> [Int] -> [(Int, Integer)]
forall a b. (a -> b) -> [a] -> [b]
map (\Int
key -> (Int
key, Integer
1))
    isRegularEdge :: (a, b, CFEdge) -> Bool
isRegularEdge (a
_, b
_, CFEdge
CFEFlow) = Bool
True
    isRegularEdge (a, b, CFEdge)
_ = Bool
False

    recursiveLookup :: M.Map Node Node -> Node -> Node
    recursiveLookup :: Map Int Int -> Int -> Int
recursiveLookup Map Int Int
map Int
node =
        case Int -> Map Int Int -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Int
node Map Int Int
map of
            Maybe Int
Nothing -> Int
node
            Just Int
x -> Map Int Int -> Int -> Int
recursiveLookup Map Int Int
map Int
x

    isLinear :: Int -> Bool
isLinear Int
node =
        Integer -> Int -> Map Int Integer -> Integer
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault Integer
0 Int
node Map Int Integer
inDegree Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1
        Bool -> Bool -> Bool
&& Integer -> Int -> Map Int Integer -> Integer
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault Integer
0 Int
node Map Int Integer
outDegree Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
1


remapNode :: M.Map Node Node -> LNode CFNode -> LNode CFNode
remapNode :: Map Int Int -> LNode CFNode -> LNode CFNode
remapNode Map Int Int
m (Int
node, CFNode
label) =
    (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
m Int
node, CFNode
newLabel)
  where
    newLabel :: CFNode
newLabel = case CFNode
label of
        CFApplyEffects [IdTagged CFEffect]
effects -> [IdTagged CFEffect] -> CFNode
CFApplyEffects ((IdTagged CFEffect -> IdTagged CFEffect)
-> [IdTagged CFEffect] -> [IdTagged CFEffect]
forall a b. (a -> b) -> [a] -> [b]
map (Map Int Int -> IdTagged CFEffect -> IdTagged CFEffect
remapEffect Map Int Int
m) [IdTagged CFEffect]
effects)
        CFExecuteSubshell [Char]
s Int
a Int
b -> [Char] -> Int -> Int -> CFNode
CFExecuteSubshell [Char]
s (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
m Int
a) (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
m Int
b)
        CFNode
_ -> CFNode
label

remapEffect :: Map Int Int -> IdTagged CFEffect -> IdTagged CFEffect
remapEffect Map Int Int
map old :: IdTagged CFEffect
old@(IdTagged Id
id CFEffect
effect) =
    case CFEffect
effect of
        CFDefineFunction [Char]
name Id
id Int
start Int
end -> Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> Id -> Int -> Int -> CFEffect
CFDefineFunction [Char]
name Id
id (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
map Int
start) (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
map Int
end)
        CFEffect
_ -> IdTagged CFEffect
old

remapEdge :: M.Map Node Node -> LEdge CFEdge -> LEdge CFEdge
remapEdge :: Map Int Int -> LEdge CFEdge -> LEdge CFEdge
remapEdge Map Int Int
map (Int
from, Int
to, CFEdge
label) = (Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
map Int
from, Map Int Int -> Int -> Int
forall {k}. Ord k => Map k k -> k -> k
remapHelper Map Int Int
map Int
to, CFEdge
label)
remapHelper :: Map k k -> k -> k
remapHelper Map k k
map k
n = k -> k -> Map k k -> k
forall k a. Ord k => a -> k -> Map k a -> a
M.findWithDefault k
n k
n Map k k
map

data Range = Range Node Node
  deriving (Range -> Range -> Bool
(Range -> Range -> Bool) -> (Range -> Range -> Bool) -> Eq Range
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Range -> Range -> Bool
== :: Range -> Range -> Bool
$c/= :: Range -> Range -> Bool
/= :: Range -> Range -> Bool
Eq, Int -> Range -> ShowS
[Range] -> ShowS
Range -> [Char]
(Int -> Range -> ShowS)
-> (Range -> [Char]) -> ([Range] -> ShowS) -> Show Range
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Range -> ShowS
showsPrec :: Int -> Range -> ShowS
$cshow :: Range -> [Char]
show :: Range -> [Char]
$cshowList :: [Range] -> ShowS
showList :: [Range] -> ShowS
Show)

data CFContext = CFContext {
    CFContext -> Bool
cfIsCondition :: Bool,
    CFContext -> Bool
cfIsFunction :: Bool,
    CFContext -> [(Int, Int)]
cfLoopStack :: [(Node, Node)],
    CFContext -> [Id]
cfTokenStack :: [Id],
    CFContext -> Maybe Int
cfExitTarget :: Maybe Node,
    CFContext -> Maybe Int
cfReturnTarget :: Maybe Node,
    CFContext -> CFGParameters
cfParameters :: CFGParameters
}
newCFContext :: CFGParameters -> CFContext
newCFContext CFGParameters
params = CFContext {
    cfIsCondition :: Bool
cfIsCondition = Bool
False,
    cfIsFunction :: Bool
cfIsFunction = Bool
False,
    cfLoopStack :: [(Int, Int)]
cfLoopStack = [],
    cfTokenStack :: [Id]
cfTokenStack = [],
    cfExitTarget :: Maybe Int
cfExitTarget = Maybe Int
forall a. Maybe a
Nothing,
    cfReturnTarget :: Maybe Int
cfReturnTarget = Maybe Int
forall a. Maybe a
Nothing,
    cfParameters :: CFGParameters
cfParameters = CFGParameters
params
}

-- The monad we generate a graph in
type CFM a = RWS CFContext CFW Int a
type CFW = ([LNode CFNode], [LEdge CFEdge], [(Id, (Node, Node))], [(Id, Node)])

newNode :: CFNode -> CFM Node
newNode :: CFNode -> CFM Int
newNode CFNode
label = do
    n <- CFM Int
forall s (m :: * -> *). MonadState s m => m s
get
    stack <- asks cfTokenStack
    put (n+1)
    tell ([(n, label)], [], [], map (\Id
c -> (Id
c, Int
n)) stack)
    return n

newNodeRange :: CFNode -> CFM Range
-- newNodeRange label = nodeToRange <$> newNode label
newNodeRange :: CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange CFNode
label = Int -> Range
nodeToRange (Int -> Range)
-> CFM Int
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CFNode -> CFM Int
newNode CFNode
label

-- Build a disjoint piece of the graph and return a CFExecuteSubshell. The Id is used purely for debug naming.
subshell :: Id -> String -> CFM Range -> CFM Range
subshell :: Id
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
subshell Id
id [Char]
reason RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
p = do
    start <- CFNode -> CFM Int
newNode (CFNode -> CFM Int) -> CFNode -> CFM Int
forall a b. (a -> b) -> a -> b
$ [Char] -> CFNode
CFEntryPoint ([Char] -> CFNode) -> [Char] -> CFNode
forall a b. (a -> b) -> a -> b
$ [Char]
"Subshell " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Id -> [Char]
forall a. Show a => a -> [Char]
show Id
id [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
reason
    end <- newNode CFStructuralNode
    middle <- local (\CFContext
c -> CFContext
c { cfExitTarget = Just end, cfReturnTarget = Just end}) p
    linkRanges [nodeToRange start, middle, nodeToRange end]
    newNodeRange $ CFExecuteSubshell reason start end


withFunctionScope :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
withFunctionScope RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
p = do
    end <- CFNode -> CFM Int
newNode CFNode
CFStructuralNode
    body <- local (\CFContext
c -> CFContext
c { cfReturnTarget = Just end, cfIsFunction = True }) p
    linkRanges [body, nodeToRange end]

-- Anything that happens recursively in f will be attributed to this id
under :: Id -> CFM a -> CFM a
under :: forall a. Id -> CFM a -> CFM a
under Id
id CFM a
f = (CFContext -> CFContext) -> CFM a -> CFM a
forall a.
(CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\CFContext
c -> CFContext
c { cfTokenStack = id:(cfTokenStack c) }) CFM a
f

nodeToRange :: Node -> Range
nodeToRange :: Int -> Range
nodeToRange Int
n = Int -> Int -> Range
Range Int
n Int
n

link :: Node -> Node -> CFEdge -> CFM ()
link :: Int
-> Int
-> CFEdge
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ()
link Int
from Int
to CFEdge
label = do
    ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([], [(Int
from, Int
to, CFEdge
label)], [], [])

registerNode :: Id -> Range -> CFM ()
registerNode :: Id
-> Range
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ()
registerNode Id
id (Range Int
start Int
end) = ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([], [], [(Id
id, (Int
start, Int
end))], [])

linkRange :: Range -> Range -> CFM Range
linkRange :: Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange = CFEdge
-> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRangeAs CFEdge
CFEFlow

linkRangeAs :: CFEdge -> Range -> Range -> CFM Range
linkRangeAs :: CFEdge
-> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRangeAs CFEdge
label (Range Int
start Int
mid1) (Range Int
mid2 Int
end) = do
    Int
-> Int
-> CFEdge
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ()
link Int
mid1 Int
mid2 CFEdge
label
    Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a.
a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Int -> Range
Range Int
start Int
end)

-- Like linkRange but without actually linking
spanRange :: Range -> Range -> Range
spanRange :: Range -> Range -> Range
spanRange (Range Int
start Int
mid1) (Range Int
mid2 Int
end) = Int -> Int -> Range
Range Int
start Int
end

linkRanges :: [Range] -> CFM Range
linkRanges :: [Range]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRanges [] = [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a. HasCallStack => [Char] -> a
error [Char]
"Empty range"
linkRanges (Range
first:[Range]
rest) = (Range
 -> Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> Range
-> [Range]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange Range
first [Range]
rest

sequentially :: [Token] -> CFM Range
sequentially :: [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list = do
    first <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
    rest <- mapM build list
    linkRanges (first:rest)

withContext :: (CFContext -> CFContext) -> CFM a -> CFM a
withContext :: forall a.
(CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
withContext = (CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall a.
(CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local

withReturn :: Range -> CFM a -> CFM a
withReturn :: forall a. Range -> CFM a -> CFM a
withReturn Range
_ CFM a
p = CFM a
p

asCondition :: CFM Range -> CFM Range
asCondition :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
asCondition = (CFContext -> CFContext)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a.
(CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
withContext (\CFContext
c -> CFContext
c { cfIsCondition = True })

newStructuralNode :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode = CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange CFNode
CFStructuralNode

buildRoot :: Token -> CFM Range
buildRoot :: Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildRoot Token
t = Id
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a. Id -> CFM a -> CFM a
under (Token -> Id
getId Token
t) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ do
    entry <- CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Char] -> CFNode
CFEntryPoint [Char]
"MAIN"
    impliedExit <- newNode CFImpliedExit
    end <- newNode CFStructuralNode
    start <- local (\CFContext
c -> CFContext
c { cfExitTarget = Just end, cfReturnTarget = Just impliedExit}) $ build t
    range <- linkRanges [entry, start, nodeToRange impliedExit, nodeToRange end]
    registerNode (getId t) range
    return range

applySingle :: IdTagged CFEffect -> CFNode
applySingle IdTagged CFEffect
e = [IdTagged CFEffect] -> CFNode
CFApplyEffects [IdTagged CFEffect
e]

-- Build the CFG.
build :: Token -> CFM Range
build :: Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t = do
    range <- Id
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a. Id -> CFM a -> CFM a
under (Token -> Id
getId Token
t) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build' Token
t
    registerNode (getId t) range
    return range
  where
    build' :: Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build' Token
t = case Token
t of
        T_Annotation Id
_ [Annotation]
_ Token
list -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
list
        T_Script Id
_ Token
_ [Token]
list -> do
            [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        TA_Assignment Id
id [Char]
op var :: Token
var@(TA_Variable Id
_ [Char]
name [Token]
indices) Token
rhs -> do
            -- value first: (( var[x=1] = (x=2) )) runs x=1 last
            value <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
rhs
            subscript <- sequentially indices
            read <-
                if op == "="
                then none
                -- This is += or something
                else newNodeRange $ applySingle $ IdTagged id $ CFReadVariable name

            write <- newNodeRange $ applySingle $ IdTagged id $ CFWriteVariable name $
                        if null indices
                        then CFValueInteger
                        else CFValueArray

            linkRanges [value, subscript, read, write]

        TA_Assignment Id
id [Char]
op Token
lhs Token
rhs -> do
            -- This is likely an invalid assignment like (( 1 = 2 )), but it
            -- could be e.g. x=y; (( $x = 3 )); echo $y, so expand both sides
            -- without updating anything
            [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token
lhs, Token
rhs]

        TA_Binary Id
_ [Char]
_ Token
a Token
b -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token
a,Token
b]
        TA_Expansion Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list
        TA_Sequence Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list
        TA_Parenthesis Id
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        TA_Trinary Id
_ Token
cond Token
a Token
b -> do
            condition <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
cond
            ifthen <- build a
            elsethen <- build b
            end <- newStructuralNode
            linkRanges [condition, ifthen, end]
            linkRanges [condition, elsethen, end]

        TA_Variable Id
id [Char]
name [Token]
indices -> do
            subscript <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
indices
            hint <-
                if null indices
                then none
                else nodeToRange <$> newNode (applySingle $ IdTagged id $ CFHintArray name)
            read <- nodeToRange <$> newNode (applySingle $ IdTagged id $ CFReadVariable name)
            linkRanges [subscript, hint, read]

        TA_Unary Id
id [Char]
op (TA_Variable Id
_ [Char]
name [Token]
indices) | [Char]
"--" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isInfixOf` [Char]
op Bool -> Bool -> Bool
|| [Char]
"++" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isInfixOf` [Char]
op -> do
            subscript <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
indices
            read <- newNodeRange $ applySingle $ IdTagged id $ CFReadVariable name
            write <- newNodeRange $ applySingle $ IdTagged id $ CFWriteVariable name $
                        if null indices
                        then CFValueInteger
                        else CFValueArray
            linkRanges [subscript, read, write]
        TA_Unary Id
_ [Char]
_ Token
arg -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
arg

        TC_And Id
_ ConditionType
SingleBracket [Char]
_ Token
lhs Token
rhs -> do
            [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token
lhs, Token
rhs]

        TC_And Id
_ ConditionType
DoubleBracket [Char]
_ Token
lhs Token
rhs -> do
            left <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
lhs
            right <- build rhs
            end <- newStructuralNode
            -- complete
            linkRanges [left, right, end]
            -- short circuit
            linkRange left end

        -- TODO: Handle integer ops
        TC_Binary Id
_ ConditionType
mode [Char]
str Token
lhs Token
rhs -> do
            left <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
lhs
            right <- build rhs
            linkRange left right

        TC_Empty {} -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode

        TC_Group Id
_ ConditionType
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        -- TODO: Mark as checked
        TC_Nullary Id
_ ConditionType
_ Token
arg -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
arg

        TC_Or Id
_ ConditionType
SingleBracket [Char]
_ Token
lhs Token
rhs -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token
lhs, Token
rhs]

        TC_Or Id
_ ConditionType
DoubleBracket [Char]
_ Token
lhs Token
rhs -> do
            left <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
lhs
            right <- build rhs
            end <- newStructuralNode
            -- complete
            linkRanges [left, right, end]
            -- short circuit
            linkRange left end

        -- TODO: Handle -v, -z, -n
        TC_Unary Id
_ ConditionType
_ [Char]
op Token
arg -> do
            Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
arg

        T_Arithmetic Id
id Token
root -> do
            exe <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
root
            status <- newNodeRange (CFSetExitCode id)
            linkRange exe status

        T_AndIf Id
_ Token
lhs Token
rhs -> do
            left <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
lhs
            right <- build rhs
            end <- newStructuralNode
            linkRange left right
            linkRange right end
            linkRange left end

        T_Array Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_Assignment {} -> Maybe Scope
-> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildAssignment Maybe Scope
forall a. Maybe a
Nothing Token
t

        T_Backgrounded Id
id Token
body -> do
            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            fork <- subshell id "backgrounding '&'" $ build body
            pid <- newNodeRange $ CFSetBackgroundPid id
            status <- newNodeRange $ CFSetExitCode id

            linkRange start fork
            -- Add a join from the fork to warn about variable changes
            linkRangeAs CFEFalseFlow fork pid
            linkRanges [start, pid, status]

        T_Backticked Id
id [Token]
body ->
            Id
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
subshell Id
id [Char]
"`..` expansion" (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
body

        T_Banged Id
id Token
cmd -> do
            main <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
cmd
            status <- newNodeRange (CFSetExitCode id)
            linkRange main status

        T_BatsTest Id
id [Char]
_ Token
body -> do
            -- These are technically set by the 'run' command, but we'll just define them
            -- up front to avoid figuring out which commands named "run" belong to Bats.
            status <- CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ IdTagged CFEffect -> CFNode
applySingle (IdTagged CFEffect -> CFNode) -> IdTagged CFEffect -> CFNode
forall a b. (a -> b) -> a -> b
$ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFValue -> CFEffect
CFWriteVariable [Char]
"status" CFValue
CFValueInteger
            output <- newNodeRange $ applySingle $ IdTagged id $ CFWriteVariable "output" CFValueString
            main <- build body
            linkRanges [status, output, main]

        T_BraceExpansion Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_BraceGroup Id
id [Token]
body ->
            [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
body

        T_CaseExpression Id
id Token
t [] -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        T_CaseExpression Id
id Token
t list :: [(CaseType, [Token], [Token])]
list@((CaseType, [Token], [Token])
hd:[(CaseType, [Token], [Token])]
tl) -> do
            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            token <- build t
            branches <- mapM buildBranch (hd NE.:| tl)
            end <- newStructuralNode

            let neighbors = [(CaseType, Range, Range)]
-> [(CaseType, Range, Range)]
-> [((CaseType, Range, Range), (CaseType, Range, Range))]
forall a b. [a] -> [b] -> [(a, b)]
zip (NonEmpty (CaseType, Range, Range) -> [(CaseType, Range, Range)]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (CaseType, Range, Range)
branches) ([(CaseType, Range, Range)]
 -> [((CaseType, Range, Range), (CaseType, Range, Range))])
-> [(CaseType, Range, Range)]
-> [((CaseType, Range, Range), (CaseType, Range, Range))]
forall a b. (a -> b) -> a -> b
$ NonEmpty (CaseType, Range, Range) -> [(CaseType, Range, Range)]
forall a. NonEmpty a -> [a]
NE.tail NonEmpty (CaseType, Range, Range)
branches
            let (_, firstCond, _) = NE.head branches
            let (_, lastCond, lastBody) = NE.last branches

            linkRange start token
            linkRange token firstCond
            mapM_ (uncurry $ linkBranch end) neighbors
            linkRange lastBody end

            unless (any hasCatchAll list) $
                -- There's no *) branch, so assume we can fall through
                void $ linkRange token end

            return $ spanRange start end

          where
            -- for a | b | c, evaluate each in turn and allow short circuiting
            buildCond :: [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildCond [Token]
list = do
                start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
                conds <- mapM build list
                end <- newStructuralNode
                linkRanges (start:conds)
                mapM_ (`linkRange` end) conds
                return $ spanRange start end

            buildBranch :: (a, [Token], [Token])
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     (a, Range, Range)
buildBranch (a
typ, [Token]
cond, [Token]
body) = do
                c <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildCond [Token]
cond
                b <- sequentially body
                linkRange c b
                return (typ, c, b)

            linkBranch :: Range
-> (CaseType, Range, Range)
-> (a, Range, Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkBranch Range
end (CaseType
typ, Range
cond, Range
body) (a
_, Range
nextCond, Range
nextBody) = do
                -- Failure case
                Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange Range
cond Range
nextCond
                -- After body
                case CaseType
typ of
                    CaseType
CaseBreak -> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange Range
body Range
end
                    CaseType
CaseFallThrough -> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange Range
body Range
nextBody
                    CaseType
CaseContinue -> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRange Range
body Range
nextCond

            -- Find a *) if any

            hasCatchAll :: (a, t Token, c) -> Bool
hasCatchAll (a
_,t Token
cond,c
_) = (Token -> Bool) -> t Token -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Token -> Bool
isCatchAll t Token
cond
            isCatchAll :: Token -> Bool
isCatchAll Token
c = Bool -> Maybe Bool -> Bool
forall a. a -> Maybe a -> a
fromMaybe Bool
False (Maybe Bool -> Bool) -> Maybe Bool -> Bool
forall a b. (a -> b) -> a -> b
$ do
                pg <- Token -> Maybe [PseudoGlob]
wordToExactPseudoGlob Token
c
                return $ pg `pseudoGlobIsSuperSetof` [PGMany]

        T_Condition Id
id ConditionType
_ Token
op -> do
            cond <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
op
            status <- newNodeRange $ CFSetExitCode id
            linkRange cond status

        T_CoProc Id
id Maybe Token
maybeNameToken Token
t -> do
            -- If unspecified, "COPROC". If not a constant string, Nothing.
            let maybeName :: Maybe [Char]
maybeName = case Maybe Token
maybeNameToken of
                    Just Token
x -> Token -> Maybe [Char]
getLiteralString Token
x
                    Maybe Token
Nothing -> [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
"COPROC"

            let parentNode :: CFNode
parentNode = case Maybe [Char]
maybeName of
                    Just [Char]
str -> IdTagged CFEffect -> CFNode
applySingle (IdTagged CFEffect -> CFNode) -> IdTagged CFEffect -> CFNode
forall a b. (a -> b) -> a -> b
$ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFValue -> CFEffect
CFWriteVariable [Char]
str CFValue
CFValueArray
                    Maybe [Char]
Nothing -> CFNode
CFStructuralNode

            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            parent <- newNodeRange parentNode
            child <- subshell id "coproc" $ build t
            end <- newNodeRange $ CFSetExitCode id

            linkRange start parent
            linkRange start child
            linkRange parent end
            linkRangeAs CFEFalseFlow child end

            return $ spanRange start end
        T_CoProcBody Id
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        T_DollarArithmetic Id
_ Token
arith -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
arith
        T_DollarDoubleQuoted Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list
        T_DollarSingleQuoted Id
_ [Char]
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_DollarBracket Id
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        T_DollarBraced Id
id Bool
_ Token
t -> do
            let str :: [Char]
str = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ Token -> [[Char]]
oversimplify Token
t
            let modifier :: [Char]
modifier = ShowS
getBracedModifier [Char]
str
            let reference :: [Char]
reference = ShowS
getBracedReference [Char]
str
            let indices :: [[Char]]
indices = [Char] -> [[Char]]
getIndexReferences [Char]
str
            let offsets :: [[Char]]
offsets = [Char] -> [[Char]]
getOffsetReferences [Char]
str
            vals <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t
            others <- mapM (\[Char]
x -> Int -> Range
nodeToRange (Int -> Range)
-> CFM Int
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CFNode -> CFM Int
newNode (IdTagged CFEffect -> CFNode
applySingle (IdTagged CFEffect -> CFNode) -> IdTagged CFEffect -> CFNode
forall a b. (a -> b) -> a -> b
$ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFEffect
CFReadVariable [Char]
x)) (indices ++ offsets)
            deps <- linkRanges (vals:others)
            read <- nodeToRange <$> newNode (applySingle $ IdTagged id $ CFReadVariable reference)
            totalRead <- linkRange deps read

            if any (`isPrefixOf` modifier) ["=", ":="]
              then do
                optionalAssign <- newNodeRange (applySingle $ IdTagged id $ CFWriteVariable reference CFValueString)
                result <- newStructuralNode
                linkRange optionalAssign result
                linkRange totalRead result
              else return totalRead

        T_DollarBraceCommandExpansion Id
id Piped
_ [Token]
body ->
            [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
body

        T_DoubleQuoted Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_DollarExpansion Id
id [Token]
body ->
            Id
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
subshell Id
id [Char]
"$(..) expansion" (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
body

        T_Extglob Id
_ [Char]
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_FdRedirect Id
id (Char
'{':[Char]
identifier) Token
op -> do
            let name :: [Char]
name = (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'}') [Char]
identifier
            expression <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
op
            rw <- newNodeRange $
                if isClosingFileOp op
                then applySingle $ IdTagged id $ CFReadVariable name
                else applySingle $ IdTagged id $ CFWriteVariable name CFValueInteger

            linkRange expression rw


        T_FdRedirect Id
_ [Char]
name Token
t -> do
            Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        T_ForArithmetic Id
_ Token
initT Token
condT Token
incT [Token]
bodyT -> do
            init <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
initT
            cond <- build condT
            body <- sequentially bodyT
            inc <- build incT
            end <- newStructuralNode

            -- Forward edges
            linkRanges [init, cond, body, inc]
            linkRange cond end
            -- Backward edge
            linkRange inc cond
            return $ spanRange init end

        T_ForIn Id
id [Char]
name [Token]
words [Token]
body -> Id
-> [Char]
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forInHelper Id
id [Char]
name [Token]
words [Token]
body

        -- For functions we generate an unlinked subgraph, and mention that in its definition node
        T_Function Id
id FunctionKeyword
_ FunctionParentheses
_ [Char]
name Token
body -> do
            range <- (CFContext -> CFContext)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a.
(CFContext -> CFContext)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local (\CFContext
c -> CFContext
c { cfExitTarget = Nothing }) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ do
                entry <- CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Char] -> CFNode
CFEntryPoint ([Char] -> CFNode) -> [Char] -> CFNode
forall a b. (a -> b) -> a -> b
$ [Char]
"function " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
name
                f <- withFunctionScope $ build body
                linkRange entry f
            let (Range entry exit) = range
            definition <- newNodeRange (applySingle $ IdTagged id $ CFDefineFunction name id entry exit)
            exe <- newNodeRange (CFSetExitCode id)
            linkRange definition exe

        T_Glob {} -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none

        T_HereString Id
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t
        T_HereDoc Id
_ Dashed
_ Quoted
_ [Char]
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_IfExpression Id
id [([Token], [Token])]
ifs [Token]
elses -> do
            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            branches <- doBranches start ifs elses []
            end <- newStructuralNode
            mapM_ (`linkRange` end) branches
            return $ spanRange start end
          where
            doBranches :: Range
-> [([Token], [Token])]
-> [Token]
-> [Range]
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     [Range]
doBranches Range
start (([Token]
conds, [Token]
thens):[([Token], [Token])]
rest) [Token]
elses [Range]
result = do
                cond <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
asCondition (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
conds
                action <- sequentially thens
                linkRange start cond
                linkRange cond action
                doBranches cond rest elses (action:result)
            doBranches Range
start [] [Token]
elses [Range]
result = do
                rest <-
                    if [Token] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Token]
elses
                    then CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (Id -> CFNode
CFSetExitCode Id
id)
                    else [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
elses
                linkRange start rest
                return (rest:result)

        T_Include Id
_ Token
t -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t

        T_IndexedElement Id
_ [Token]
indicesT Token
valueT -> do
            indices <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
indicesT
            value <- build valueT
            linkRange indices value

        T_IoDuplicate Id
_ Token
op [Char]
_ -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
op

        T_IoFile Id
_ Token
op Token
t -> do
            exp <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
t
            doesntDoMuch <- build op
            linkRange exp doesntDoMuch

        T_Literal {} -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none

        T_NormalWord Id
_ [Token]
list -> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
list

        T_OrIf Id
_ Token
lhs Token
rhs -> do
            left <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
lhs
            right <- build rhs
            end <- newStructuralNode
            linkRange left right
            linkRange right end
            linkRange left end

        T_Pipeline Id
_ [Token]
_ [Token
cmd] -> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
cmd
        T_Pipeline Id
id [Token]
_ [Token]
cmds -> do
            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            hasLastpipe <- reader $ cfLastpipe . cfParameters
            (leading, last) <- buildPipe hasLastpipe cmds
            -- Ideally we'd let this exit code be that of the last command in the pipeline but ok
            end <- newNodeRange $ CFSetExitCode id

            mapM_ (linkRange start) leading
            mapM_ (\Range
c -> CFEdge
-> Range
-> Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRangeAs CFEdge
CFEFalseFlow Range
c Range
end) leading
            linkRanges $ [start] ++ last ++ [end]
          where
            buildPipe :: Bool
-> [Token]
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ([Range], [Range])
buildPipe Bool
True [Token
x] = do
                last <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
x
                return ([], [last])
            buildPipe Bool
lp (Token
first:[Token]
rest) = do
                this <- Id
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
subshell Id
id [Char]
"pipeline" (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
first
                (leading, last) <- buildPipe lp rest
                return (this:leading, last)
            buildPipe Bool
_ [] = ([Range], [Range])
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     ([Range], [Range])
forall a.
a
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])

        T_ProcSub Id
id [Char]
op [Token]
cmds -> do
            start <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
            body <- subshell id (op ++ "() process substitution") $ sequentially cmds
            end <- newStructuralNode

            linkRange start body
            linkRangeAs CFEFalseFlow body end
            linkRange start end

        T_Redirecting Id
_ [Token]
redirs Token
cmd -> do
            -- For simple commands, this is the other way around in bash
            -- We do it in this order for comound commands like { x=name; } > "$x"
            redir <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
redirs
            body <- build cmd
            linkRange redir body

        T_SelectIn Id
id [Char]
name [Token]
words [Token]
body -> Id
-> [Char]
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forInHelper Id
id [Char]
name [Token]
words [Token]
body

        T_SimpleCommand Id
id [Token]
vars [] -> do
            -- Vars can also be empty, as in the command "> foo"
            assignments <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
vars
            status <- newNodeRange (CFSetExitCode id)
            linkRange assignments status

        T_SimpleCommand Id
id [Token]
vars (Token
cmd:[Token]
args) ->
            Token
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleCommand Token
t [Token]
vars (Token
cmd Token -> [Token] -> NonEmpty Token
forall a. a -> [a] -> NonEmpty a
NE.:| [Token]
args) (Maybe [Char]
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Token -> Maybe [Char]
getUnquotedLiteral Token
cmd

        T_SingleQuoted Id
_ [Char]
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none

        T_SourceCommand Id
_ Token
originalCommand Token
inlinedSource -> do
            cmd <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
originalCommand
            end <- newStructuralNode
            inline <- withReturn end $ build inlinedSource
            linkRange cmd inline
            linkRange inline end
            return $ spanRange cmd inline

        T_Subshell Id
id [Token]
body -> do
            main <- Id
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
subshell Id
id [Char]
"explicit (..) subshell" (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
body
            status <- newNodeRange (CFSetExitCode id)
            linkRange main status

        T_UntilExpression Id
id [Token]
cond [Token]
body -> Id
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
whileHelper Id
id [Token]
cond [Token]
body
        T_WhileExpression Id
id [Token]
cond [Token]
body -> Id
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
whileHelper Id
id [Token]
cond [Token]
body

        T_CLOBBER Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_GREATAND Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_LESSAND Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_LESSGREAT Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_DGREAT Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_Greater Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_Less Id
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
        T_ParamSubSpecialChar Id
_ [Char]
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none

        Token
x -> do
            [Char]
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     (ZonkAny 0)
forall a. HasCallStack => [Char] -> a
error ([Char]
"Unimplemented: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Token -> [Char]
forall a. Show a => a -> [Char]
show Token
x) -- STRIP
            RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none

--  Still in `where` clause
    forInHelper :: Id
-> [Char]
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forInHelper Id
id [Char]
name [Token]
words [Token]
body = do
        entry <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode
        expansion <- sequentially words
        assignmentChoice <- newStructuralNode
        assignments <-
            if null words || any willSplit words
            then (:[]) <$> (newNodeRange $ applySingle $ IdTagged id $ CFWriteVariable name CFValueString)
            else mapM (\Token
t -> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ IdTagged CFEffect -> CFNode
applySingle (IdTagged CFEffect -> CFNode) -> IdTagged CFEffect -> CFNode
forall a b. (a -> b) -> a -> b
$ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFValue -> CFEffect
CFWriteVariable [Char]
name (CFValue -> CFEffect) -> CFValue -> CFEffect
forall a b. (a -> b) -> a -> b
$ Id -> [CFStringPart] -> CFValue
CFValueComputed (Token -> Id
getId Token
t) ([CFStringPart] -> CFValue) -> [CFStringPart] -> CFValue
forall a b. (a -> b) -> a -> b
$ Token -> [CFStringPart]
tokenToParts Token
t) words
        body <- sequentially body
        exit <- newStructuralNode
        -- Forward edges
        linkRanges [entry, expansion, assignmentChoice]
        mapM_ (\Range
t -> [Range]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
linkRanges [Range
assignmentChoice, Range
t, Range
body]) assignments
        linkRange body exit
        linkRange expansion exit
        -- Backward edge
        linkRange body assignmentChoice
        return $ spanRange entry exit

    whileHelper :: Id
-> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
whileHelper Id
id [Token]
cond [Token]
body = do
        condRange <- RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
asCondition (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
cond
        bodyRange <- sequentially body
        end <- newNodeRange (CFSetExitCode id)

        linkRange condRange bodyRange
        linkRange bodyRange condRange
        linkRange condRange end


handleCommand :: Token
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleCommand Token
cmd [Token]
vars NonEmpty Token
args Maybe [Char]
literalCmd = do
    -- TODO: Handle assignments in declaring commands

    case Maybe [Char]
literalCmd of
        Just [Char]
"exit" -> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansion [Token]
vars (NonEmpty Token -> [Token]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Token
args) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
handleExit
        Just [Char]
"return" -> [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansion [Token]
vars (NonEmpty Token -> [Token]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Token
args) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
handleReturn
        Just [Char]
"unset" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleUnset NonEmpty Token
args

        Just [Char]
"declare" -> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDeclare NonEmpty Token
args
        Just [Char]
"local" -> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDeclare NonEmpty Token
args
        Just [Char]
"typeset" -> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDeclare NonEmpty Token
args

        Just [Char]
"printf" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handlePrintf NonEmpty Token
args
        Just [Char]
"wait" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleWait NonEmpty Token
args

        Just [Char]
"mapfile" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleMapfile NonEmpty Token
args
        Just [Char]
"readarray" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleMapfile NonEmpty Token
args

        Just [Char]
"read" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleRead NonEmpty Token
args

        Just [Char]
"DEFINE_boolean" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDEFINE NonEmpty Token
args
        Just [Char]
"DEFINE_float" ->   [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDEFINE NonEmpty Token
args
        Just [Char]
"DEFINE_integer" -> [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDEFINE NonEmpty Token
args
        Just [Char]
"DEFINE_string" ->  [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars NonEmpty Token
args (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDEFINE NonEmpty Token
args

        -- This will mostly behave like 'command' but ok
        Just [Char]
"builtin" ->
            case NonEmpty Token
args of
                Token
_ NE.:| [] -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
regular
                (Token
_ NE.:| Token
newcmd:[Token]
newargs) ->
                    Token
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleCommand Token
newcmd [Token]
vars (Token
newcmd Token -> [Token] -> NonEmpty Token
forall a. a -> [a] -> NonEmpty a
NE.:| [Token]
newargs) (Maybe [Char]
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Token -> Maybe [Char]
getLiteralString Token
newcmd
        Just [Char]
"command" ->
            case NonEmpty Token
args of
                Token
_ NE.:| [] -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
regular
                (Token
_ NE.:| Token
newcmd:[Token]
newargs) ->
                    Id
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleOthers (Token -> Id
getId Token
newcmd) [Token]
vars (Token
newcmd Token -> [Token] -> NonEmpty Token
forall a. a -> [a] -> NonEmpty a
NE.:| [Token]
newargs) (Maybe [Char]
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Token -> Maybe [Char]
getLiteralString Token
newcmd
        Maybe [Char]
_ -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
regular

  where
    regular :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
regular = Id
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleOthers (Token -> Id
getId Token
cmd) [Token]
vars NonEmpty Token
args Maybe [Char]
literalCmd
    handleExit :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
handleExit = do
        exitNode <- (CFContext -> Maybe Int)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     (Maybe Int)
forall a.
(CFContext -> a)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader CFContext -> Maybe Int
cfExitTarget
        case exitNode of
            Just Int
target -> do
                exit <- CFNode -> CFM Int
newNode CFNode
CFResolvedExit
                link exit target CFEExit
                unreachable <- newNode CFUnreachable
                return $ Range exit unreachable
            Maybe Int
Nothing -> do
                exit <- CFNode -> CFM Int
newNode CFNode
CFUnresolvedExit
                unreachable <- newNode CFUnreachable
                return $ Range exit unreachable

    handleReturn :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
handleReturn = do
        returnTarget <- (CFContext -> Maybe Int)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     (Maybe Int)
forall a.
(CFContext -> a)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     a
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader CFContext -> Maybe Int
cfReturnTarget
        case returnTarget of
            Maybe Int
Nothing -> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a. HasCallStack => [Char] -> a
error ([Char]
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ ShowS
pleaseReport [Char]
"missing return target"
            Just Int
target -> do
                ret <- CFNode -> CFM Int
newNode CFNode
CFStructuralNode
                link ret target CFEFlow
                unreachable <- newNode CFUnreachable
                return $ Range ret unreachable

    handleUnset :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleUnset (Token
cmd NE.:| [Token]
args) = do
        case () of
                ()
_ | [Char]
"n" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
flagNames -> ([Char] -> CFEffect)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
unsetWith [Char] -> CFEffect
CFUndefineNameref
                ()
_ | [Char]
"v" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
flagNames -> ([Char] -> CFEffect)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
unsetWith [Char] -> CFEffect
CFUndefineVariable
                ()
_ | [Char]
"f" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
flagNames -> ([Char] -> CFEffect)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
unsetWith [Char] -> CFEffect
CFUndefineFunction
                ()
_ -> ([Char] -> CFEffect)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
unsetWith [Char] -> CFEffect
CFUndefine
      where
        pairs :: [(String, Token)] -- [(Flag string, token)] e.g. [("-f", t), ("", myfunc)]
        pairs :: [([Char], Token)]
pairs = (([Char], (Token, Token)) -> ([Char], Token))
-> [([Char], (Token, Token))] -> [([Char], Token)]
forall a b. (a -> b) -> [a] -> [b]
map (\([Char]
str, (Token
flag, Token
val)) -> ([Char]
str, Token
flag)) ([([Char], (Token, Token))] -> [([Char], Token)])
-> [([Char], (Token, Token))] -> [([Char], Token)]
forall a b. (a -> b) -> a -> b
$ [([Char], (Token, Token))]
-> Maybe [([Char], (Token, Token))] -> [([Char], (Token, Token))]
forall a. a -> Maybe a -> a
fromMaybe ((Token -> ([Char], (Token, Token)))
-> [Token] -> [([Char], (Token, Token))]
forall a b. (a -> b) -> [a] -> [b]
map (\Token
c -> ([Char]
"", (Token
c,Token
c))) [Token]
args) (Maybe [([Char], (Token, Token))] -> [([Char], (Token, Token))])
-> Maybe [([Char], (Token, Token))] -> [([Char], (Token, Token))]
forall a b. (a -> b) -> a -> b
$ [Char] -> [Token] -> Maybe [([Char], (Token, Token))]
getGnuOpts [Char]
"vfn" [Token]
args
        ([([Char], Token)]
names, [([Char], Token)]
flags) = (([Char], Token) -> Bool)
-> [([Char], Token)] -> ([([Char], Token)], [([Char], Token)])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition ([Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Char] -> Bool)
-> (([Char], Token) -> [Char]) -> ([Char], Token) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char], Token) -> [Char]
forall a b. (a, b) -> a
fst) [([Char], Token)]
pairs
        flagNames :: [[Char]]
flagNames = (([Char], Token) -> [Char]) -> [([Char], Token)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], Token) -> [Char]
forall a b. (a, b) -> a
fst [([Char], Token)]
flags
        literalNames :: [(Token, String)] -- Literal names to unset, e.g. [(myfuncToken, "myfunc")]
        literalNames :: [(Token, [Char])]
literalNames = (([Char], Token) -> Maybe (Token, [Char]))
-> [([Char], Token)] -> [(Token, [Char])]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (\([Char]
_, Token
t) -> (,) Token
t ([Char] -> (Token, [Char]))
-> Maybe [Char] -> Maybe (Token, [Char])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Token -> Maybe [Char]
getLiteralString Token
t) [([Char], Token)]
names
        -- Apply a constructor like CFUndefineVariable to each literalName, and tag with its id
        unsetWith :: ([Char] -> CFEffect)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
unsetWith [Char] -> CFEffect
c = CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects ([IdTagged CFEffect] -> CFNode) -> [IdTagged CFEffect] -> CFNode
forall a b. (a -> b) -> a -> b
$ ((Token, [Char]) -> IdTagged CFEffect)
-> [(Token, [Char])] -> [IdTagged CFEffect]
forall a b. (a -> b) -> [a] -> [b]
map (\(Token
token, [Char]
name) -> Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged (Token -> Id
getId Token
token) (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFEffect
c [Char]
name) [(Token, [Char])]
literalNames


    variableAssignRegex :: Regex
variableAssignRegex = [Char] -> Regex
mkRegex [Char]
"^([_a-zA-Z][_a-zA-Z0-9]*)="

    handleDeclare :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDeclare (Token
cmd NE.:| [Token]
args) = do
        isFunc <- (CFContext -> Bool)
-> RWST
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Identity
     Bool
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks CFContext -> Bool
cfIsFunction
        -- This is a bit of a kludge: we don't have great support for things like
        -- 'declare -i x=$x' so do one round with declare x=$x, followed by declare -i x
        let (evaluated, assignments, added, removed) = mconcat $ map (toEffects isFunc) args
        before <- sequentially $ evaluated
        assignments <- newNodeRange $ CFApplyEffects assignments
        addedProps <- if null added then newStructuralNode else newNodeRange $ CFApplyEffects added
        removedProps <- if null removed then newStructuralNode else newNodeRange $ CFApplyEffects removed
        result <- newNodeRange $ CFSetExitCode (getId cmd)
        linkRanges [before, assignments, addedProps, removedProps, result]
      where
        opts :: [[Char]]
opts = (([Char], (Token, Token)) -> [Char])
-> [([Char], (Token, Token))] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], (Token, Token)) -> [Char]
forall a b. (a, b) -> a
fst ([([Char], (Token, Token))] -> [[Char]])
-> [([Char], (Token, Token))] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Token] -> [([Char], (Token, Token))]
getGenericOpts [Token]
args
        array :: Bool
array = [Char]
"a" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts Bool -> Bool -> Bool
|| Bool
associative
        associative :: Bool
associative = [Char]
"A" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts
        integer :: Bool
integer = [Char]
"i" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts
        func :: Bool
func = [Char]
"f" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts Bool -> Bool -> Bool
|| [Char]
"F" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts
        global :: Bool
global = [Char]
"g" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts
        export :: Bool
export = [Char]
"x" [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
opts
        writer :: Bool -> [Char] -> CFValue -> CFEffect
writer Bool
isFunc =
            case () of
                ()
_ | Bool
global -> [Char] -> CFValue -> CFEffect
CFWriteGlobal
                ()
_ | Bool
isFunc -> [Char] -> CFValue -> CFEffect
CFWriteLocal
                ()
_ -> [Char] -> CFValue -> CFEffect
CFWriteVariable

        scope :: Bool -> Maybe Scope
scope Bool
isFunc =
            case () of
                ()
_ | Bool
global -> Scope -> Maybe Scope
forall a. a -> Maybe a
Just Scope
GlobalScope
                ()
_ | Bool
isFunc -> Scope -> Maybe Scope
forall a. a -> Maybe a
Just Scope
LocalScope
                ()
_ -> Maybe Scope
forall a. Maybe a
Nothing

        addedProps :: Set CFVariableProp
addedProps = [CFVariableProp] -> Set CFVariableProp
forall a. Ord a => [a] -> Set a
S.fromList ([CFVariableProp] -> Set CFVariableProp)
-> [CFVariableProp] -> Set CFVariableProp
forall a b. (a -> b) -> a -> b
$ [[CFVariableProp]] -> [CFVariableProp]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[CFVariableProp]] -> [CFVariableProp])
-> [[CFVariableProp]] -> [CFVariableProp]
forall a b. (a -> b) -> a -> b
$ [
            [ CFVariableProp
CFVPArray | Bool
array ],
            [ CFVariableProp
CFVPInteger | Bool
integer ],
            [ CFVariableProp
CFVPExport | Bool
export ],
            [ CFVariableProp
CFVPAssociative | Bool
associative ]
          ]

        removedProps :: Set CFVariableProp
removedProps = [CFVariableProp] -> Set CFVariableProp
forall a. Ord a => [a] -> Set a
S.fromList ([CFVariableProp] -> Set CFVariableProp)
-> [CFVariableProp] -> Set CFVariableProp
forall a b. (a -> b) -> a -> b
$ [[CFVariableProp]] -> [CFVariableProp]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[CFVariableProp]] -> [CFVariableProp])
-> [[CFVariableProp]] -> [CFVariableProp]
forall a b. (a -> b) -> a -> b
$ [
            -- Array property can't be unset
            [ CFVariableProp
CFVPInteger | Char
'i' Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
unsetOptions ],
            [ CFVariableProp
CFVPExport | Char
'e' Char -> [Char] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
unsetOptions ]
          ]

        toEffects :: Bool
-> Token
-> ([Token], [IdTagged CFEffect], [IdTagged CFEffect],
    [IdTagged CFEffect])
toEffects Bool
isFunc (T_Assignment Id
id AssignmentMode
mode [Char]
var [Token]
idx Token
t) =
            let
                pre :: [Token]
pre = [Token]
idx [Token] -> [Token] -> [Token]
forall a. [a] -> [a] -> [a]
++ [Token
t]
                val :: [IdTagged CFEffect]
val = [ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ (Bool -> [Char] -> CFValue -> CFEffect
writer Bool
isFunc) [Char]
var (CFValue -> CFEffect) -> CFValue -> CFEffect
forall a b. (a -> b) -> a -> b
$ Id -> [CFStringPart] -> CFValue
CFValueComputed (Token -> Id
getId Token
t) ([CFStringPart] -> CFValue) -> [CFStringPart] -> CFValue
forall a b. (a -> b) -> a -> b
$ [ [Char] -> CFStringPart
CFStringVariable [Char]
var | AssignmentMode
mode AssignmentMode -> AssignmentMode -> Bool
forall a. Eq a => a -> a -> Bool
== AssignmentMode
Append ] [CFStringPart] -> [CFStringPart] -> [CFStringPart]
forall a. [a] -> [a] -> [a]
++ Token -> [CFStringPart]
tokenToParts Token
t ]
                added :: [IdTagged CFEffect]
added = [ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ Maybe Scope -> [Char] -> Set CFVariableProp -> CFEffect
CFSetProps (Bool -> Maybe Scope
scope Bool
isFunc) [Char]
var Set CFVariableProp
addedProps | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Set CFVariableProp -> Bool
forall a. Set a -> Bool
S.null Set CFVariableProp
addedProps ]
                removed :: [IdTagged CFEffect]
removed = [ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ Maybe Scope -> [Char] -> Set CFVariableProp -> CFEffect
CFUnsetProps (Bool -> Maybe Scope
scope Bool
isFunc) [Char]
var Set CFVariableProp
addedProps | Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Set CFVariableProp -> Bool
forall a. Set a -> Bool
S.null Set CFVariableProp
removedProps ]
            in
                ([Token]
pre, [IdTagged CFEffect]
val, [IdTagged CFEffect]
added, [IdTagged CFEffect]
removed)

        toEffects Bool
isFunc Token
t =
            let
                id :: Id
id = Token -> Id
getId Token
t
                pre :: [Token]
pre = [Token
t]
                literal :: [Char]
literal = [Char] -> Token -> [Char]
getLiteralStringDef [Char]
"\0" Token
t
                isKnown :: Bool
isKnown = Char
'\0' Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Char]
literal
                match :: Maybe [Char]
match = ([[Char]] -> [Char]) -> Maybe [[Char]] -> Maybe [Char]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[Char]] -> [Char]
forall a. HasCallStack => [a] -> a
head (Maybe [[Char]] -> Maybe [Char]) -> Maybe [[Char]] -> Maybe [Char]
forall a b. (a -> b) -> a -> b
$ Regex
variableAssignRegex Regex -> [Char] -> Maybe [[Char]]
`matchRegex` [Char]
literal
                name :: [Char]
name = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe [Char]
literal Maybe [Char]
match

                asLiteral :: IdTagged CFEffect
asLiteral =
                    Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ (Bool -> [Char] -> CFValue -> CFEffect
writer Bool
isFunc) [Char]
name (CFValue -> CFEffect) -> CFValue -> CFEffect
forall a b. (a -> b) -> a -> b
$
                        Id -> [CFStringPart] -> CFValue
CFValueComputed (Token -> Id
getId Token
t) [ [Char] -> CFStringPart
CFStringLiteral ([Char] -> CFStringPart) -> [Char] -> CFStringPart
forall a b. (a -> b) -> a -> b
$ Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'=') ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ [Char]
literal ]
                asUnknown :: IdTagged CFEffect
asUnknown =
                    Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ (Bool -> [Char] -> CFValue -> CFEffect
writer Bool
isFunc) [Char]
name (CFValue -> CFEffect) -> CFValue -> CFEffect
forall a b. (a -> b) -> a -> b
$
                        CFValue
CFValueString

                added :: [IdTagged CFEffect]
added = [ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ Maybe Scope -> [Char] -> Set CFVariableProp -> CFEffect
CFSetProps (Bool -> Maybe Scope
scope Bool
isFunc) [Char]
name Set CFVariableProp
addedProps ]
                removed :: [IdTagged CFEffect]
removed = [ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ Maybe Scope -> [Char] -> Set CFVariableProp -> CFEffect
CFUnsetProps (Bool -> Maybe Scope
scope Bool
isFunc) [Char]
name Set CFVariableProp
removedProps ]

            in
                case () of
                    ()
_ | Bool -> Bool
not ([Char] -> Bool
isVariableName [Char]
name) -> ([Token]
pre, [], [], [])
                    ()
_ | Maybe [Char] -> Bool
forall a. Maybe a -> Bool
isJust Maybe [Char]
match Bool -> Bool -> Bool
&& Bool
isKnown -> ([Token]
pre, [IdTagged CFEffect
asLiteral], [IdTagged CFEffect]
added, [IdTagged CFEffect]
removed)
                    ()
_ | Maybe [Char] -> Bool
forall a. Maybe a -> Bool
isJust Maybe [Char]
match -> ([Token]
pre, [IdTagged CFEffect
asUnknown], [IdTagged CFEffect]
added, [IdTagged CFEffect]
removed)
                    -- e.g. declare -i x
                    ()
_ -> ([Token]
pre, [], [IdTagged CFEffect]
added, [IdTagged CFEffect]
removed)

        -- find "ia" from `define +i +a`
        unsetOptions :: String
        unsetOptions :: [Char]
unsetOptions =
            let
                strings :: [[Char]]
strings = (Token -> Maybe [Char]) -> [Token] -> [[Char]]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Token -> Maybe [Char]
getLiteralString [Token]
args
                plusses :: [[Char]]
plusses = ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char]
"+" [Char] -> [Char] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf`) [[Char]]
strings
            in
                ShowS -> [[Char]] -> [Char]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1) [[Char]]
plusses

    handlePrintf :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handlePrintf (Token
cmd NE.:| [Token]
args) =
        CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects ([IdTagged CFEffect] -> CFNode) -> [IdTagged CFEffect] -> CFNode
forall a b. (a -> b) -> a -> b
$ Maybe (IdTagged CFEffect) -> [IdTagged CFEffect]
forall a. Maybe a -> [a]
maybeToList Maybe (IdTagged CFEffect)
findVar
      where
        findVar :: Maybe (IdTagged CFEffect)
findVar = do
            flags <- [Char] -> [Token] -> Maybe [([Char], (Token, Token))]
getBsdOpts [Char]
"v:" [Token]
args
            (flag, arg) <- lookup "v" flags
            name <- getLiteralString arg
            return $ IdTagged (getId arg) $ CFWriteVariable name CFValueString

    handleWait :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleWait (Token
cmd NE.:| [Token]
args) =
        CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects ([IdTagged CFEffect] -> CFNode) -> [IdTagged CFEffect] -> CFNode
forall a b. (a -> b) -> a -> b
$ Maybe (IdTagged CFEffect) -> [IdTagged CFEffect]
forall a. Maybe a -> [a]
maybeToList Maybe (IdTagged CFEffect)
findVar
      where
        findVar :: Maybe (IdTagged CFEffect)
findVar = do
            let flags :: [([Char], (Token, Token))]
flags = [Token] -> [([Char], (Token, Token))]
getGenericOpts [Token]
args
            (flag, arg) <- [Char] -> [([Char], (Token, Token))] -> Maybe (Token, Token)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"p" [([Char], (Token, Token))]
flags
            name <- getLiteralString arg
            return $ IdTagged (getId arg) $ CFWriteVariable name CFValueInteger

    handleMapfile :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleMapfile (Token
cmd NE.:| [Token]
args) =
        CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects [IdTagged CFEffect
findVar]
      where
        findVar :: IdTagged CFEffect
findVar =
            let (Id
id, [Char]
name) = (Id, [Char]) -> Maybe (Id, [Char]) -> (Id, [Char])
forall a. a -> Maybe a -> a
fromMaybe (Token -> Id
getId Token
cmd, [Char]
"MAPFILE") (Maybe (Id, [Char]) -> (Id, [Char]))
-> Maybe (Id, [Char]) -> (Id, [Char])
forall a b. (a -> b) -> a -> b
$ Maybe (Id, [Char])
getFromArg Maybe (Id, [Char]) -> Maybe (Id, [Char]) -> Maybe (Id, [Char])
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Maybe (Id, [Char])
getFromFallback
            in Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFValue -> CFEffect
CFWriteVariable [Char]
name CFValue
CFValueArray

        getFromArg :: Maybe (Id, [Char])
getFromArg = do
            flags <- [Char] -> [Token] -> Maybe [([Char], (Token, Token))]
getGnuOpts [Char]
flagsForMapfile [Token]
args
            (_, arg) <- lookup "" flags
            name <- getLiteralString arg
            return (getId arg, name)

        getFromFallback :: Maybe (Id, [Char])
getFromFallback =
            [(Id, [Char])] -> Maybe (Id, [Char])
forall a. [a] -> Maybe a
listToMaybe ([(Id, [Char])] -> Maybe (Id, [Char]))
-> [(Id, [Char])] -> Maybe (Id, [Char])
forall a b. (a -> b) -> a -> b
$ (Token -> Maybe (Id, [Char])) -> [Token] -> [(Id, [Char])]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Token -> Maybe (Id, [Char])
getIfVar ([Token] -> [(Id, [Char])]) -> [Token] -> [(Id, [Char])]
forall a b. (a -> b) -> a -> b
$ [Token] -> [Token]
forall a. [a] -> [a]
reverse [Token]
args
        getIfVar :: Token -> Maybe (Id, [Char])
getIfVar Token
c = do
            name <- Token -> Maybe [Char]
getLiteralString Token
c
            guard $ isVariableName name
            return (getId c, name)

    handleRead :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleRead (Token
cmd NE.:| [Token]
args) = CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects [IdTagged CFEffect]
main
      where
        main :: [IdTagged CFEffect]
main = [IdTagged CFEffect]
-> Maybe [IdTagged CFEffect] -> [IdTagged CFEffect]
forall a. a -> Maybe a -> a
fromMaybe [IdTagged CFEffect]
fallback (Maybe [IdTagged CFEffect] -> [IdTagged CFEffect])
-> Maybe [IdTagged CFEffect] -> [IdTagged CFEffect]
forall a b. (a -> b) -> a -> b
$ do
            flags <- [Char] -> [Token] -> Maybe [([Char], (Token, Token))]
getGnuOpts [Char]
flagsForRead [Token]
args
            return $ fromMaybe (withFields flags) $ withArray flags

        withArray :: [(String, (Token, Token))] -> Maybe [IdTagged CFEffect]
        withArray :: [([Char], (Token, Token))] -> Maybe [IdTagged CFEffect]
withArray [([Char], (Token, Token))]
flags = do
            (_, token) <- [Char] -> [([Char], (Token, Token))] -> Maybe (Token, Token)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"a" [([Char], (Token, Token))]
flags
            return $ fromMaybe [] $ do
                name <- getLiteralString token
                return [ IdTagged (getId token) $ CFWriteVariable name CFValueArray ]

        withFields :: [([Char], (Token, Token))] -> [IdTagged CFEffect]
withFields [([Char], (Token, Token))]
flags = (([Char], (Token, Token)) -> Maybe (IdTagged CFEffect))
-> [([Char], (Token, Token))] -> [IdTagged CFEffect]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe ([Char], (Token, Token)) -> Maybe (IdTagged CFEffect)
getAssignment [([Char], (Token, Token))]
flags

        getAssignment :: (String, (Token, Token)) -> Maybe (IdTagged CFEffect)
        getAssignment :: ([Char], (Token, Token)) -> Maybe (IdTagged CFEffect)
getAssignment ([Char], (Token, Token))
f = do
            ("", (t, _)) <- ([Char], (Token, Token)) -> Maybe ([Char], (Token, Token))
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char], (Token, Token))
f
            name <- getLiteralString t
            return $ IdTagged (getId t) $ CFWriteVariable name CFValueString

        fallback :: [IdTagged CFEffect]
fallback =
            let
                names :: [(Id, [Char])]
names = [(Id, [Char])] -> [(Id, [Char])]
forall a. [a] -> [a]
reverse ([(Id, [Char])] -> [(Id, [Char])])
-> [(Id, [Char])] -> [(Id, [Char])]
forall a b. (a -> b) -> a -> b
$ (Maybe (Id, [Char]) -> (Id, [Char]))
-> [Maybe (Id, [Char])] -> [(Id, [Char])]
forall a b. (a -> b) -> [a] -> [b]
map Maybe (Id, [Char]) -> (Id, [Char])
forall a. HasCallStack => Maybe a -> a
fromJust ([Maybe (Id, [Char])] -> [(Id, [Char])])
-> [Maybe (Id, [Char])] -> [(Id, [Char])]
forall a b. (a -> b) -> a -> b
$ (Maybe (Id, [Char]) -> Bool)
-> [Maybe (Id, [Char])] -> [Maybe (Id, [Char])]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile Maybe (Id, [Char]) -> Bool
forall a. Maybe a -> Bool
isJust ([Maybe (Id, [Char])] -> [Maybe (Id, [Char])])
-> [Maybe (Id, [Char])] -> [Maybe (Id, [Char])]
forall a b. (a -> b) -> a -> b
$ (Token -> Maybe (Id, [Char])) -> [Token] -> [Maybe (Id, [Char])]
forall a b. (a -> b) -> [a] -> [b]
map (\Token
c -> (Id, Maybe [Char]) -> Maybe (Id, [Char])
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => (Id, m a) -> m (Id, a)
sequence (Token -> Id
getId Token
c, Token -> Maybe [Char]
getLiteralString Token
c)) ([Token] -> [Maybe (Id, [Char])])
-> [Token] -> [Maybe (Id, [Char])]
forall a b. (a -> b) -> a -> b
$ [Token] -> [Token]
forall a. [a] -> [a]
reverse [Token]
args
                namesOrDefault :: [(Id, [Char])]
namesOrDefault = if [(Id, [Char])] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Id, [Char])]
names then [(Token -> Id
getId Token
cmd, [Char]
"REPLY")] else [(Id, [Char])]
names
                hasDashA :: Bool
hasDashA = ([Char] -> Bool) -> [[Char]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
"a") ([[Char]] -> Bool) -> [[Char]] -> Bool
forall a b. (a -> b) -> a -> b
$ (([Char], (Token, Token)) -> [Char])
-> [([Char], (Token, Token))] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], (Token, Token)) -> [Char]
forall a b. (a, b) -> a
fst ([([Char], (Token, Token))] -> [[Char]])
-> [([Char], (Token, Token))] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Token] -> [([Char], (Token, Token))]
getGenericOpts [Token]
args
                value :: CFValue
value = if Bool
hasDashA then CFValue
CFValueArray else CFValue
CFValueString
            in
                ((Id, [Char]) -> IdTagged CFEffect)
-> [(Id, [Char])] -> [IdTagged CFEffect]
forall a b. (a -> b) -> [a] -> [b]
map (\(Id
id, [Char]
name) -> Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFValue -> CFEffect
CFWriteVariable [Char]
name CFValue
value) [(Id, [Char])]
namesOrDefault

    handleDEFINE :: NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleDEFINE (Token
cmd NE.:| [Token]
args) =
        CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ [IdTagged CFEffect] -> CFNode
CFApplyEffects ([IdTagged CFEffect] -> CFNode) -> [IdTagged CFEffect] -> CFNode
forall a b. (a -> b) -> a -> b
$ Maybe (IdTagged CFEffect) -> [IdTagged CFEffect]
forall a. Maybe a -> [a]
maybeToList Maybe (IdTagged CFEffect)
findVar
      where
        findVar :: Maybe (IdTagged CFEffect)
findVar = do
            name <- [Token] -> Maybe Token
forall a. [a] -> Maybe a
listToMaybe ([Token] -> Maybe Token) -> [Token] -> Maybe Token
forall a b. (a -> b) -> a -> b
$ Int -> [Token] -> [Token]
forall a. Int -> [a] -> [a]
drop Int
1 [Token]
args
            str <- getLiteralString name
            guard $ isVariableName str
            return $ IdTagged (getId name) $ CFWriteVariable str CFValueString

    handleOthers :: Id
-> [Token]
-> NonEmpty Token
-> Maybe [Char]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
handleOthers Id
id [Token]
vars NonEmpty Token
args Maybe [Char]
cmd =
        [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansion [Token]
vars (NonEmpty Token -> [Token]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Token
args) (RWS
   CFContext
   ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
   Int
   Range
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ do
            exe <- CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (CFNode
 -> RWS
      CFContext
      ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
      Int
      Range)
-> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
forall a b. (a -> b) -> a -> b
$ Maybe [Char] -> CFNode
CFExecuteCommand Maybe [Char]
cmd
            status <- newNodeRange $ CFSetExitCode id
            linkRange exe status

    regularExpansion :: [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansion [Token]
vars [Token]
args RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
p = do
            args <- [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
sequentially [Token]
args
            assignments <- mapM (buildAssignment (Just PrefixScope)) vars
            exe <- p
            dropAssignments <-
                if null vars
                then
                    return []
                else do
                    drop <- newNodeRange CFDropPrefixAssignments
                    return [drop]

            linkRanges $ [args] ++ assignments ++ [exe] ++ dropAssignments

    regularExpansionWithStatus :: [Token]
-> NonEmpty Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansionWithStatus [Token]
vars args :: NonEmpty Token
args@(Token
cmd NE.:| [Token]
_) RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
p = do
        initial <- [Token]
-> [Token]
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
regularExpansion [Token]
vars (NonEmpty Token -> [Token]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty Token
args) RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
p
        status <- newNodeRange $ CFSetExitCode (getId cmd)
        linkRange initial status


none :: RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none = RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
newStructuralNode

data Scope = GlobalScope | LocalScope | PrefixScope
  deriving (Scope -> Scope -> Bool
(Scope -> Scope -> Bool) -> (Scope -> Scope -> Bool) -> Eq Scope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scope -> Scope -> Bool
== :: Scope -> Scope -> Bool
$c/= :: Scope -> Scope -> Bool
/= :: Scope -> Scope -> Bool
Eq, Eq Scope
Eq Scope =>
(Scope -> Scope -> Ordering)
-> (Scope -> Scope -> Bool)
-> (Scope -> Scope -> Bool)
-> (Scope -> Scope -> Bool)
-> (Scope -> Scope -> Bool)
-> (Scope -> Scope -> Scope)
-> (Scope -> Scope -> Scope)
-> Ord Scope
Scope -> Scope -> Bool
Scope -> Scope -> Ordering
Scope -> Scope -> Scope
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
$ccompare :: Scope -> Scope -> Ordering
compare :: Scope -> Scope -> Ordering
$c< :: Scope -> Scope -> Bool
< :: Scope -> Scope -> Bool
$c<= :: Scope -> Scope -> Bool
<= :: Scope -> Scope -> Bool
$c> :: Scope -> Scope -> Bool
> :: Scope -> Scope -> Bool
$c>= :: Scope -> Scope -> Bool
>= :: Scope -> Scope -> Bool
$cmax :: Scope -> Scope -> Scope
max :: Scope -> Scope -> Scope
$cmin :: Scope -> Scope -> Scope
min :: Scope -> Scope -> Scope
Ord, Int -> Scope -> ShowS
[Scope] -> ShowS
Scope -> [Char]
(Int -> Scope -> ShowS)
-> (Scope -> [Char]) -> ([Scope] -> ShowS) -> Show Scope
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scope -> ShowS
showsPrec :: Int -> Scope -> ShowS
$cshow :: Scope -> [Char]
show :: Scope -> [Char]
$cshowList :: [Scope] -> ShowS
showList :: [Scope] -> ShowS
Show, (forall x. Scope -> Rep Scope x)
-> (forall x. Rep Scope x -> Scope) -> Generic Scope
forall x. Rep Scope x -> Scope
forall x. Scope -> Rep Scope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Scope -> Rep Scope x
from :: forall x. Scope -> Rep Scope x
$cto :: forall x. Rep Scope x -> Scope
to :: forall x. Rep Scope x -> Scope
Generic, Scope -> ()
(Scope -> ()) -> NFData Scope
forall a. (a -> ()) -> NFData a
$crnf :: Scope -> ()
rnf :: Scope -> ()
NFData)

buildAssignment :: Maybe Scope
-> Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
buildAssignment Maybe Scope
scope Token
t = do
    op <- case Token
t of
            T_Assignment Id
id AssignmentMode
mode [Char]
var [Token]
indices Token
value -> do
                expand <- Token
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
build Token
value
                index <- sequentially indices
                read <- case mode of
                    AssignmentMode
Append -> CFNode
-> RWS
     CFContext
     ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
     Int
     Range
newNodeRange (IdTagged CFEffect -> CFNode
applySingle (IdTagged CFEffect -> CFNode) -> IdTagged CFEffect -> CFNode
forall a b. (a -> b) -> a -> b
$ Id -> CFEffect -> IdTagged CFEffect
forall a. Id -> a -> IdTagged a
IdTagged Id
id (CFEffect -> IdTagged CFEffect) -> CFEffect -> IdTagged CFEffect
forall a b. (a -> b) -> a -> b
$ [Char] -> CFEffect
CFReadVariable [Char]
var)
                    AssignmentMode
Assign -> RWS
  CFContext
  ([LNode CFNode], [LEdge CFEdge], [(Id, (Int, Int))], [(Id, Int)])
  Int
  Range
none
                let valueType = if [Token] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Token]
indices then Id -> Token -> CFValue
f Id
id Token
value else CFValue
CFValueArray
                let scoper =
                                case Maybe Scope
scope of
                                    Just Scope
PrefixScope -> [Char] -> CFValue -> CFEffect
CFWritePrefix
                                    Just Scope
LocalScope -> [Char] -> CFValue -> CFEffect
CFWriteLocal
                                    Just Scope
GlobalScope -> [Char] -> CFValue -> CFEffect
CFWriteGlobal
                                    Maybe Scope
Nothing -> [Char] -> CFValue -> CFEffect
CFWriteVariable
                write <- newNodeRange $ applySingle $ IdTagged id $ scoper var valueType
                linkRanges [expand, index, read, write]
              where
                f :: Id -> Token -> CFValue
                f :: Id -> Token -> CFValue
f Id
id t :: Token
t@T_NormalWord {} = Id -> [CFStringPart] -> CFValue
CFValueComputed Id
id ([CFStringPart] -> CFValue) -> [CFStringPart] -> CFValue
forall a b. (a -> b) -> a -> b
$ [[Char] -> CFStringPart
CFStringVariable [Char]
var | AssignmentMode
mode AssignmentMode -> AssignmentMode -> Bool
forall a. Eq a => a -> a -> Bool
== AssignmentMode
Append] [CFStringPart] -> [CFStringPart] -> [CFStringPart]
forall a. [a] -> [a] -> [a]
++ Token -> [CFStringPart]
tokenToParts Token
t
                f Id
id t :: Token
t@(T_Literal Id
_ [Char]
str) = Id -> [CFStringPart] -> CFValue
CFValueComputed Id
id ([CFStringPart] -> CFValue) -> [CFStringPart] -> CFValue
forall a b. (a -> b) -> a -> b
$ [[Char] -> CFStringPart
CFStringVariable [Char]
var | AssignmentMode
mode AssignmentMode -> AssignmentMode -> Bool
forall a. Eq a => a -> a -> Bool
== AssignmentMode
Append] [CFStringPart] -> [CFStringPart] -> [CFStringPart]
forall a. [a] -> [a] -> [a]
++ Token -> [CFStringPart]
tokenToParts Token
t
                f Id
_ T_Array {} = CFValue
CFValueArray

    registerNode (getId t) op
    return op


tokenToParts :: Token -> [CFStringPart]
tokenToParts Token
t =
    case Token
t of
        T_NormalWord Id
_ [Token]
list -> (Token -> [CFStringPart]) -> [Token] -> [CFStringPart]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Token -> [CFStringPart]
tokenToParts [Token]
list
        T_DoubleQuoted Id
_ [Token]
list -> (Token -> [CFStringPart]) -> [Token] -> [CFStringPart]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Token -> [CFStringPart]
tokenToParts [Token]
list
        T_SingleQuoted Id
_ [Char]
str -> [ [Char] -> CFStringPart
CFStringLiteral [Char]
str ]
        T_Literal Id
_ [Char]
str -> [ [Char] -> CFStringPart
CFStringLiteral [Char]
str ]
        T_DollarArithmetic {} -> [ CFStringPart
CFStringInteger ]
        T_DollarBracket {} -> [ CFStringPart
CFStringInteger ]
        T_DollarBraced Id
_ Bool
_ Token
list | Token -> Bool
isUnmodifiedParameterExpansion Token
t -> [ [Char] -> CFStringPart
CFStringVariable (ShowS
getBracedReference ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ Token -> [[Char]]
oversimplify Token
list) ]
        -- Check if getLiteralString can handle it, if not it's unknown
        Token
_ -> [CFStringPart
-> ([Char] -> CFStringPart) -> Maybe [Char] -> CFStringPart
forall b a. b -> (a -> b) -> Maybe a -> b
maybe CFStringPart
CFStringUnknown [Char] -> CFStringPart
CFStringLiteral (Maybe [Char] -> CFStringPart) -> Maybe [Char] -> CFStringPart
forall a b. (a -> b) -> a -> b
$ Token -> Maybe [Char]
getLiteralString Token
t]


-- Like & but well defined when the node already exists
safeUpdate :: (Adj b, Int, a, Adj b) -> gr a b -> gr a b
safeUpdate ctx :: (Adj b, Int, a, Adj b)
ctx@(Adj b
_,Int
node,a
_,Adj b
_) gr a b
graph = (Adj b, Int, a, Adj b)
ctx (Adj b, Int, a, Adj b) -> gr a b -> gr a b
forall a b. Context a b -> gr a b -> gr a b
forall (gr :: * -> * -> *) a b.
DynGraph gr =>
Context a b -> gr a b -> gr a b
& (Int -> gr a b -> gr a b
forall (gr :: * -> * -> *) a b. Graph gr => Int -> gr a b -> gr a b
delNode Int
node gr a b
graph)

-- Change all subshell invocations to instead link directly to their contents.
-- This is used for producing dominator trees.
inlineSubshells :: CFGraph -> CFGraph
inlineSubshells :: CFGraph -> CFGraph
inlineSubshells CFGraph
graph = CFGraph
relinkedGraph
  where
    subshells :: [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
subshells = (Context CFNode CFEdge
 -> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
 -> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)])
-> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
-> CFGraph
-> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
forall (gr :: * -> * -> *) a b c.
Graph gr =>
(Context a b -> c -> c) -> c -> gr a b -> c
ufold Context CFNode CFEdge
-> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
-> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
forall {e} {a} {f}.
(e, a, CFNode, f)
-> [(a, CFNode, Int, Int, e, f)] -> [(a, CFNode, Int, Int, e, f)]
find [] CFGraph
graph
    find :: (e, a, CFNode, f)
-> [(a, CFNode, Int, Int, e, f)] -> [(a, CFNode, Int, Int, e, f)]
find (e
incoming, a
node, CFNode
label, f
outgoing) [(a, CFNode, Int, Int, e, f)]
acc =
        case CFNode
label of
            CFExecuteSubshell [Char]
_ Int
start Int
end -> (a
node, CFNode
label, Int
start, Int
end, e
incoming, f
outgoing)(a, CFNode, Int, Int, e, f)
-> [(a, CFNode, Int, Int, e, f)] -> [(a, CFNode, Int, Int, e, f)]
forall a. a -> [a] -> [a]
:[(a, CFNode, Int, Int, e, f)]
acc
            CFNode
_ -> [(a, CFNode, Int, Int, e, f)]
acc

    relinkedGraph :: CFGraph
relinkedGraph = (CFGraph
 -> (Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge) -> CFGraph)
-> CFGraph
-> [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
-> CFGraph
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' CFGraph
-> (Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge) -> CFGraph
forall {gr :: * -> * -> *} {a}.
DynGraph gr =>
gr a CFEdge
-> (Int, a, Int, Int, Adj CFEdge, Adj CFEdge) -> gr a CFEdge
relink CFGraph
graph [(Int, CFNode, Int, Int, Adj CFEdge, Adj CFEdge)]
subshells
    relink :: gr a CFEdge
-> (Int, a, Int, Int, Adj CFEdge, Adj CFEdge) -> gr a CFEdge
relink gr a CFEdge
graph (Int
node, a
label, Int
start, Int
end, Adj CFEdge
incoming, Adj CFEdge
outgoing) =
        let
            -- Link CFExecuteSubshell to the CFEntryPoint
            subshellToStart :: (Adj CFEdge, Int, a, Adj CFEdge)
subshellToStart = (Adj CFEdge
incoming, Int
node, a
label, [(CFEdge
CFEFlow, Int
start)])
            -- Link the subshell exit to the
            endToNexts :: (Adj CFEdge, Int, a, Adj CFEdge)
endToNexts = (Adj CFEdge
endIncoming, Int
endNode, a
endLabel, Adj CFEdge
outgoing)
            (Adj CFEdge
endIncoming, Int
endNode, a
endLabel, Adj CFEdge
_) = gr a CFEdge -> Int -> (Adj CFEdge, Int, a, Adj CFEdge)
forall (gr :: * -> * -> *) a b.
Graph gr =>
gr a b -> Int -> Context a b
context gr a CFEdge
graph Int
end
        in
            (Adj CFEdge, Int, a, Adj CFEdge)
subshellToStart (Adj CFEdge, Int, a, Adj CFEdge) -> gr a CFEdge -> gr a CFEdge
forall {gr :: * -> * -> *} {b} {a}.
DynGraph gr =>
(Adj b, Int, a, Adj b) -> gr a b -> gr a b
`safeUpdate` ((Adj CFEdge, Int, a, Adj CFEdge)
endToNexts (Adj CFEdge, Int, a, Adj CFEdge) -> gr a CFEdge -> gr a CFEdge
forall {gr :: * -> * -> *} {b} {a}.
DynGraph gr =>
(Adj b, Int, a, Adj b) -> gr a b -> gr a b
`safeUpdate` gr a CFEdge
graph)

findEntryNodes :: CFGraph -> [Node]
findEntryNodes :: CFGraph -> [Int]
findEntryNodes CFGraph
graph = (Context CFNode CFEdge -> [Int] -> [Int])
-> [Int] -> CFGraph -> [Int]
forall (gr :: * -> * -> *) a b c.
Graph gr =>
(Context a b -> c -> c) -> c -> gr a b -> c
ufold Context CFNode CFEdge -> [Int] -> [Int]
forall {t :: * -> *} {a} {a} {d}.
Foldable t =>
(t a, a, CFNode, d) -> [a] -> [a]
find [] CFGraph
graph
  where
    find :: (t a, a, CFNode, d) -> [a] -> [a]
find (t a
incoming, a
node, CFNode
label, d
_) [a]
list =
        case CFNode
label of
            CFEntryPoint {} | t a -> Bool
forall a. t a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null t a
incoming -> a
nodea -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
list
            CFNode
_ -> [a]
list

findDominators :: Int -> CFGraph -> Map Int (Set Int)
findDominators Int
main CFGraph
graph = Map Int (Set Int)
asSetMap
  where
    inlined :: CFGraph
inlined = CFGraph -> CFGraph
inlineSubshells CFGraph
graph
    entryNodes :: [Int]
entryNodes = Int
main Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: CFGraph -> [Int]
findEntryNodes CFGraph
graph
    asLists :: [(Int, [Int])]
asLists = (Int -> [(Int, [Int])]) -> [Int] -> [(Int, [Int])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (CFGraph -> Int -> [(Int, [Int])]
forall (gr :: * -> * -> *) a b.
Graph gr =>
gr a b -> Int -> [(Int, [Int])]
dom CFGraph
inlined) [Int]
entryNodes
    asSetMap :: Map Int (Set Int)
asSetMap = [(Int, Set Int)] -> Map Int (Set Int)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Int, Set Int)] -> Map Int (Set Int))
-> [(Int, Set Int)] -> Map Int (Set Int)
forall a b. (a -> b) -> a -> b
$ ((Int, [Int]) -> (Int, Set Int))
-> [(Int, [Int])] -> [(Int, Set Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(Int
node, [Int]
list) -> (Int
node, [Int] -> Set Int
forall a. Ord a => [a] -> Set a
S.fromList [Int]
list)) [(Int, [Int])]
asLists

findTerminalNodes :: CFGraph -> [Node]
findTerminalNodes :: CFGraph -> [Int]
findTerminalNodes CFGraph
graph = (Context CFNode CFEdge -> [Int] -> [Int])
-> [Int] -> CFGraph -> [Int]
forall (gr :: * -> * -> *) a b c.
Graph gr =>
(Context a b -> c -> c) -> c -> gr a b -> c
ufold Context CFNode CFEdge -> [Int] -> [Int]
forall {a} {d}. (a, Int, CFNode, d) -> [Int] -> [Int]
find [] CFGraph
graph
  where
    find :: (a, Int, CFNode, d) -> [Int] -> [Int]
find (a
_, Int
node, CFNode
label, d
_) [Int]
list =
        case CFNode
label of
            CFNode
CFUnresolvedExit -> Int
nodeInt -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:[Int]
list
            CFApplyEffects [IdTagged CFEffect]
effects -> [IdTagged CFEffect] -> [Int] -> [Int]
f [IdTagged CFEffect]
effects [Int]
list
            CFNode
_ -> [Int]
list

    f :: [IdTagged CFEffect] -> [Int] -> [Int]
f [] [Int]
list = [Int]
list
    f (IdTagged Id
_ (CFDefineFunction [Char]
_ Id
id Int
start Int
end):[IdTagged CFEffect]
rest) [Int]
list = [IdTagged CFEffect] -> [Int] -> [Int]
f [IdTagged CFEffect]
rest (Int
endInt -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:[Int]
list)
    f (IdTagged CFEffect
_:[IdTagged CFEffect]
rest) [Int]
list = [IdTagged CFEffect] -> [Int] -> [Int]
f [IdTagged CFEffect]
rest [Int]
list

findPostDominators :: Node -> CFGraph -> Array Node [Node]
findPostDominators :: Int -> CFGraph -> Array Int [Int]
findPostDominators Int
mainexit CFGraph
graph = Array Int [Int]
asArray
  where
    inlined :: CFGraph
inlined = CFGraph -> CFGraph
inlineSubshells CFGraph
graph
    terminals :: [Int]
terminals = CFGraph -> [Int]
findTerminalNodes CFGraph
inlined
    (Adj CFEdge
incoming, Int
_, CFNode
label, Adj CFEdge
outgoing) = CFGraph -> Int -> Context CFNode CFEdge
forall (gr :: * -> * -> *) a b.
Graph gr =>
gr a b -> Int -> Context a b
context CFGraph
graph Int
mainexit
    withExitEdges :: CFGraph
withExitEdges = (Adj CFEdge
incoming Adj CFEdge -> Adj CFEdge -> Adj CFEdge
forall a. [a] -> [a] -> [a]
++ (Int -> (CFEdge, Int)) -> [Int] -> Adj CFEdge
forall a b. (a -> b) -> [a] -> [b]
map (\Int
c -> (CFEdge
CFEFlow, Int
c)) [Int]
terminals, Int
mainexit, CFNode
label, Adj CFEdge
outgoing) Context CFNode CFEdge -> CFGraph -> CFGraph
forall {gr :: * -> * -> *} {b} {a}.
DynGraph gr =>
(Adj b, Int, a, Adj b) -> gr a b -> gr a b
`safeUpdate` CFGraph
inlined
    reversed :: CFGraph
reversed = CFGraph -> CFGraph
forall (gr :: * -> * -> *) a b. DynGraph gr => gr a b -> gr a b
grev CFGraph
withExitEdges
    postDoms :: [(Int, [Int])]
postDoms = CFGraph -> Int -> [(Int, [Int])]
forall (gr :: * -> * -> *) a b.
Graph gr =>
gr a b -> Int -> [(Int, [Int])]
dom CFGraph
reversed Int
mainexit
    (Int
_, Int
maxNode) = CFGraph -> (Int, Int)
forall a b. Gr a b -> (Int, Int)
forall (gr :: * -> * -> *) a b. Graph gr => gr a b -> (Int, Int)
nodeRange CFGraph
graph
    -- Holes in the array cause "Exception: (Array.!): undefined array element" while
    -- inspecting/debugging, so fill the array first and then update.
    initializedArray :: Array Int [Int]
initializedArray = (Int, Int) -> [[Int]] -> Array Int [Int]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (Int
0, Int
maxNode) ([[Int]] -> Array Int [Int]) -> [[Int]] -> Array Int [Int]
forall a b. (a -> b) -> a -> b
$ [Int] -> [[Int]]
forall a. a -> [a]
repeat []
    asArray :: Array Int [Int]
asArray = Array Int [Int]
initializedArray Array Int [Int] -> [(Int, [Int])] -> Array Int [Int]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)] -> a i e
// [(Int, [Int])]
postDoms

return []
runTests :: IO Bool
runTests =  $( [| $(forAllProperties) (quickCheckWithResult (stdArgs { maxSuccess = 1 }) ) |])