glualint-1.26.0: src/GLua/AG/PrettyPrint.hs
{-# LANGUAGE DeriveGeneric #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- UUAGC 0.9.55 (src/GLua/AG/PrettyPrint.ag)
module GLua.AG.PrettyPrint where
{-# LINE 10 "src/GLua/AG/AST.ag" #-}
import Data.Aeson
import GHC.Generics
import GLua.AG.Token
import GLua.TokenTypes ()
{-# LINE 15 "src/GLua/AG/PrettyPrint.hs" #-}
{-# LINE 4 "src/GLua/AG/PrettyPrint.ag" #-}
import Data.List (foldl', isInfixOf)
import Data.Maybe
import Debug.Trace
import GLua.AG.AST
import GLua.TokenTypes
import Text.Parsec
import Text.Parsec.Error
import Text.ParserCombinators.UU.BasicInstances hiding (pos)
import Text.PrettyPrint hiding (braces, brackets, parens)
import Prelude hiding ((<>))
{-# LINE 29 "src/GLua/AG/PrettyPrint.hs" #-}
{-# LINE 19 "src/GLua/AG/PrettyPrint.ag" #-}
tok :: MToken -> Doc
tok (MToken _ t) = zeroWidthText . show $ t
printList :: (a -> Doc) -> String -> [a] -> Doc
printList _ _ [] = empty
printList f sep' (e : es) = (f e) <> g es
where
g [] = empty
g (e' : es') = zeroWidthText sep' <> (f e') <> g es'
data IsEmpty = IsEmpty | NonEmpty
fromEmpty :: IsEmpty -> Bool
fromEmpty IsEmpty = True
fromEmpty NonEmpty = False
toEmpty :: Bool -> IsEmpty
toEmpty b = if b then IsEmpty else NonEmpty
data PrettyPrintConfig = PPConfig
{ spaceAfterParens :: Bool
, spaceAfterBrackets :: Bool
, spaceAfterBraces :: Bool
, spaceEmptyParens :: Bool
, spaceEmptyBraces :: Bool
, spaceAfterLabel :: Bool
, spaceBeforeComma :: Bool
, spaceAfterComma :: Bool
, semicolons :: Bool
, cStyle :: Bool
, removeRedundantParens :: Bool
, minimizeParens :: Bool
, assumeOperatorAssociativity :: Bool
, indentation :: String
}
defaultPPConfig :: PrettyPrintConfig
defaultPPConfig =
PPConfig
{ spaceAfterParens = False
, spaceAfterBrackets = False
, spaceAfterBraces = False
, spaceEmptyParens = False
, spaceEmptyBraces = False
, spaceAfterLabel = False
, spaceBeforeComma = False
, spaceAfterComma = True
, semicolons = False
, cStyle = False
, removeRedundantParens = True
, assumeOperatorAssociativity = True
, minimizeParens = False
, indentation = " "
}
metaDoc :: Maybe MToken -> Doc
metaDoc (Just m) = zchr ':' <> tok m
metaDoc Nothing = empty
printVarList :: [(PrefixExp, Maybe MExpr)] -> Doc
printVarList vars =
printList pp_prefixexp ", " (map fst vars)
<-> zchr '='
<-> printList pp_mexpr ", " (catMaybes . map snd $ vars)
printStats :: [MStat] -> Int -> Doc
printStats [] _ = empty
printStats (x : xs) i = nest (i * 4) (pp_mstat x i) $+$ printStats xs i
printElIfs :: [(MExpr, Block)] -> Int -> Doc
printElIfs [] _ = empty
printElIfs ((e, b) : es) i =
zeroWidthText "elseif"
<-> pp_mexpr e
<-> zeroWidthText "then"
$+$ pp_block b i
$+$ printElIfs es i
printEls :: Maybe Block -> Int -> Doc
printEls Nothing _ = empty
printEls (Just b) i = zeroWidthText "else" $+$ pp_block b i
renderPos :: LineColPos -> String
renderPos (LineColPos l c _) = "line " ++ show (succ l) ++ ", column " ++ show (succ c)
renderRegion :: Region -> String
renderRegion (Region l r) = renderPos l ++ " - " ++ renderPos r
renderSourcePos :: SourcePos -> String
renderSourcePos sp =
"line "
++ (show . succ . sourceLine $ sp)
++ ", column "
++ (show . succ . sourceColumn $ sp)
getMStatPos :: MStat -> String
getMStatPos (MStat p _) = renderRegion p
getAReturnPos :: AReturn -> String
getAReturnPos (AReturn p _) = renderRegion p
getAReturnPos NoReturn = "<unknown>"
getMExprPos :: MExpr -> String
getMExprPos (MExpr p _) = renderRegion p
renderError :: Error LineColPos -> String
renderError (Inserted str pos strs) =
renderPos pos
++ ": Inserted '"
++ str
++ "'."
++ render_expecting strs
renderError (Deleted str pos strs) =
renderPos pos
++ ": Removed '"
++ str
++ "'. "
++ render_expecting strs
renderError (Replaced str1 str2 pos strs) =
renderPos pos
++ ": Replaced '"
++ str1
++ "' with '"
++ str2
++ "' at "
++ renderPos pos
++ render_expecting strs
renderError (DeletedAtEnd str) =
"Deleted '"
++ str
++ "' at the end of the Lua file because the parser doesn't know what to do with it."
render_expecting :: [String] -> String
render_expecting [a] = "Parser expected a " ++ a
render_expecting (a : as) = "Parser expected one of [" ++ a ++ concat (map (", " ++) as) ++ "]"
render_expecting [] = "Parser expected nothing"
renderPSError :: ParseError -> String
renderPSError ps =
map replNL
. showErrorMessages
"or"
"unknown parse error"
"expecting"
"unexpected"
"end of input"
. errorMessages
$ ps
where
replNL '\n' = ' '
replNL c = c
-- | Render comments on multiple lines
renderMLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc
renderMLComments conf ind toks =
foldl' ($+$) empty . map (indent conf ind . tok . convertComment conf) $ toks
-- | Render comments, and prefer having them on a single line. It may not print comments on the same
-- line if that would cause a syntax error (e.g. a multiline comment after a single line comment)
renderSLComments :: PrettyPrintConfig -> Int -> [MToken] -> Doc
renderSLComments conf ind toks = foldl' combine empty . map (convertComment conf) $ toks
where
combine :: Doc -> MToken -> Doc
combine acc mt@(MToken _pos t) =
case t of
-- Block comments after single line comments cannot be printed on the same line, as that
-- would cause a syntax error, e.g. in this case:
-- foo = { -- single line comment
-- --[[multiline
-- comment
-- ]]
-- }
-- Make sure in these cases the comment is printed on a new line, rather than on the
-- same line
DashBlockComment _depth comment
| '\n' `elem` comment ->
acc $+$ (indent conf ind $ tok mt)
SlashBlockComment comment
| '\n' `elem` comment ->
acc $+$ (indent conf ind $ tok mt)
_ -> acc <-> tok mt
convertComment :: PrettyPrintConfig -> MToken -> MToken
convertComment conf (MToken p t) = MToken p $ convert' t
where
convert' :: Token -> Token
convert' = if cStyle conf then cComment else luaComment
luaComment :: Token -> Token
luaComment (SlashComment s) = DashComment s
luaComment (SlashBlockComment s) = DashBlockComment (lastBracket s) s
luaComment t' = t'
-- converting /*]*/ would end up in --[[]]] when plainly converted
-- Deepen the block comment by 1 if that's the case
lastBracket :: String -> Int
lastBracket [] = 0
lastBracket s = if last s == ']' then 1 else 0
cComment :: Token -> Token
cComment (DashComment s) = SlashComment s
cComment (DashBlockComment _ s) = SlashBlockComment s
cComment t' = t'
indent :: PrettyPrintConfig -> Int -> Doc -> Doc
indent conf n = (<>) $ zeroWidthText (concat . replicate n $ indentation conf)
parens :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc
parens conf ie doc = zchr '(' `sep'` doc `sep'` zchr ')'
where
sep' :: Doc -> Doc -> Doc
sep' =
if spaceAfterParens conf && (not (fromEmpty ie) || spaceEmptyParens conf)
then (<->)
else (<>)
brackets :: PrettyPrintConfig -> Doc -> Doc
brackets conf doc = zchr '[' `sep'` doc `sep'` zchr ']'
where
sep' :: Doc -> Doc -> Doc
sep' = if spaceAfterBrackets conf then (<->) else (<>)
braces :: PrettyPrintConfig -> IsEmpty -> Doc -> Doc
braces conf ie doc = zchr '{' `sep'` doc `sep'` zchr '}'
where
sep' :: Doc -> Doc -> Doc
sep' =
if spaceAfterBraces conf && (not (fromEmpty ie) || spaceEmptyBraces conf)
then (<->)
else (<>)
-- Zero width char
zchr :: Char -> Doc
zchr c = zeroWidthText [c]
-- Zero width <+>
infixl 6 <->
(<->) :: Doc -> Doc -> Doc
a <-> b
| a == empty = b
| b == empty = a
| otherwise = a <> zchr ' ' <> b
-- Operator levels, where level 1 is the lowest level, and level 8 is the highest one
-- See http://www.lua.org/manual/5.2/manual.html#3.4.7
data OperatorLevel
= -- At the top level, there is no assigned operator level yet. This serves as a bottom value.
TopLevelExpression
| OperatorLevel1
| OperatorLevel2
| OperatorLevel3
| OperatorLevel4
| OperatorLevel5
| OperatorLevel6
| OperatorLevel7
| OperatorLevel8
deriving (Eq, Ord)
-- | Returns true when any of the comments contain the string "format: multiline"
commentsForceMultiline :: [MToken] -> Bool
commentsForceMultiline commentTokens = any containsFormatMultiline commentTokens
where
containsFormatMultiline :: MToken -> Bool
containsFormatMultiline (MToken _pos t) = case t of
DashComment comment -> stringForcesFormat comment
DashBlockComment _ comment -> stringForcesFormat comment
SlashComment comment -> stringForcesFormat comment
SlashBlockComment comment -> stringForcesFormat comment
_ -> False
stringForcesFormat :: String -> Bool
stringForcesFormat s = "format: multiline" `isInfixOf` s
{-# LINE 304 "src/GLua/AG/PrettyPrint.hs" #-}
{-# LINE 1235 "src/GLua/AG/PrettyPrint.ag" #-}
pp_block :: Block -> Int -> Doc
pp_block p i = pretty_Syn_Block (wrap_Block (sem_Block p) (emptyInh_Block{indent_Inh_Block = i}))
pp_mstat :: MStat -> Int -> Doc
pp_mstat p i = pretty_Syn_MStat (wrap_MStat (sem_MStat p) emptyInh_MStat{indent_Inh_MStat = i})
pp_prefixexp :: PrefixExp -> Doc
pp_prefixexp p = pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) emptyInh_PrefixExp)
pp_pfexprsuffix :: PFExprSuffix -> Doc
pp_pfexprsuffix p =
pretty_Syn_PFExprSuffix (wrap_PFExprSuffix (sem_PFExprSuffix p) emptyInh_PFExprSuffix)
pp_field :: Field -> Doc
pp_field p = pretty_Syn_Field (wrap_Field (sem_Field p) emptyInh_Field)
pp_mexpr :: MExpr -> Doc
pp_mexpr p = pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) emptyInh_MExpr)
prettyprint :: AST -> String
prettyprint p = render $ pretty_Syn_AST (wrap_AST (sem_AST p) emptyInh_AST)
prettyprintConf :: PrettyPrintConfig -> AST -> String
prettyprintConf conf p =
render $ pretty_Syn_AST (wrap_AST (sem_AST p) emptyInh_AST{ppconf_Inh_AST = conf})
renderBlock :: Block -> String
renderBlock p = render $ pretty_Syn_Block (wrap_Block (sem_Block p) emptyInh_Block)
renderStat :: Stat -> String
renderStat p = render $ pretty_Syn_Stat (wrap_Stat (sem_Stat p) emptyInh_Stat)
renderMStat :: MStat -> String
renderMStat p = render $ pretty_Syn_MStat (wrap_MStat (sem_MStat p) emptyInh_MStat)
renderAReturn :: AReturn -> String
renderAReturn p = render $ pretty_Syn_AReturn (wrap_AReturn (sem_AReturn p) emptyInh_AReturn)
renderFuncName :: FuncName -> String
renderFuncName p = render $ pretty_Syn_FuncName (wrap_FuncName (sem_FuncName p) emptyInh_FuncName)
renderPrefixExp :: PrefixExp -> String
renderPrefixExp p =
render $ pretty_Syn_PrefixExp (wrap_PrefixExp (sem_PrefixExp p) emptyInh_PrefixExp)
renderExpr :: Expr -> String
renderExpr p = render $ pretty_Syn_Expr (wrap_Expr (sem_Expr p) emptyInh_Expr)
renderMExpr :: MExpr -> String
renderMExpr p = render $ pretty_Syn_MExpr (wrap_MExpr (sem_MExpr p) emptyInh_MExpr)
renderArgs :: Args -> String
renderArgs p = render $ pretty_Syn_Args (wrap_Args (sem_Args p) emptyInh_Args)
renderField :: Field -> String
renderField p = render $ pretty_Syn_Field (wrap_Field (sem_Field p) emptyInh_Field)
emptyInh_Field :: Inh_Field
emptyInh_Field =
Inh_Field
{ comments_Inh_Field = []
, forceMultiline_Inh_Field = False
, indent_Inh_Field = 0
, ppconf_Inh_Field = defaultPPConfig
}
emptyInh_Args :: Inh_Args
emptyInh_Args =
Inh_Args
{ comments_Inh_Args = []
, forceMultiline_Inh_Args = False
, indent_Inh_Args = 0
, ppconf_Inh_Args = defaultPPConfig
}
emptyInh_MExpr :: Inh_MExpr
emptyInh_MExpr =
Inh_MExpr
{ comments_Inh_MExpr = []
, forceMultiline_Inh_MExpr = False
, indent_Inh_MExpr = 0
, parentOperatorAssociative_Inh_MExpr = True
, parentOperatorPrecedence_Inh_MExpr = TopLevelExpression
, ppconf_Inh_MExpr = defaultPPConfig
}
emptyInh_Expr :: Inh_Expr
emptyInh_Expr =
Inh_Expr
{ comments_Inh_Expr = []
, forceMultiline_Inh_Expr = False
, indent_Inh_Expr = 0
, parentOperatorAssociative_Inh_Expr = True
, parentOperatorPrecedence_Inh_Expr = TopLevelExpression
, ppconf_Inh_Expr = defaultPPConfig
, statRegion_Inh_Expr = emptyRg
}
emptyInh_PrefixExp :: Inh_PrefixExp
emptyInh_PrefixExp =
Inh_PrefixExp
{ comments_Inh_PrefixExp = []
, forceMultiline_Inh_PrefixExp = False
, indent_Inh_PrefixExp = 0
, parentOperatorAssociative_Inh_PrefixExp = True
, parentOperatorPrecedence_Inh_PrefixExp = TopLevelExpression
, ppconf_Inh_PrefixExp = defaultPPConfig
}
emptyInh_FuncName :: Inh_FuncName
emptyInh_FuncName =
Inh_FuncName
{ comments_Inh_FuncName = []
, indent_Inh_FuncName = 0
, ppconf_Inh_FuncName = defaultPPConfig
}
emptyInh_AReturn :: Inh_AReturn
emptyInh_AReturn =
Inh_AReturn
{ comments_Inh_AReturn = []
, forceMultiline_Inh_AReturn = False
, indent_Inh_AReturn = 0
, ppconf_Inh_AReturn = defaultPPConfig
}
emptyInh_MStat :: Inh_MStat
emptyInh_MStat =
Inh_MStat
{ comments_Inh_MStat = []
, forceMultiline_Inh_MStat = False
, indent_Inh_MStat = 0
, isLastStatement_Inh_MStat = False
, ppconf_Inh_MStat = defaultPPConfig
, wouldBeAmbiguousWithoutSemicolon_Inh_MStat = False
}
emptyInh_Stat :: Inh_Stat
emptyInh_Stat =
Inh_Stat
{ comments_Inh_Stat = []
, forceMultiline_Inh_Stat = False
, indent_Inh_Stat = 0
, isLastStatement_Inh_Stat = False
, ppconf_Inh_Stat = defaultPPConfig
, statRegion_Inh_Stat = emptyRg
, wouldBeAmbiguousWithoutSemicolon_Inh_Stat = False
}
emptyInh_Block :: Inh_Block
emptyInh_Block =
Inh_Block
{ comments_Inh_Block = []
, forceMultiline_Inh_Block = False
, indent_Inh_Block = 0
, ppconf_Inh_Block = defaultPPConfig
, statRegion_Inh_Block = emptyRg
}
emptyInh_AST :: Inh_AST
emptyInh_AST =
Inh_AST
{ indent_Inh_AST = 0
, ppconf_Inh_AST = defaultPPConfig
}
emptyInh_PFExprSuffix :: Inh_PFExprSuffix
emptyInh_PFExprSuffix =
Inh_PFExprSuffix
{ comments_Inh_PFExprSuffix = []
, forceMultiline_Inh_PFExprSuffix = False
, indent_Inh_PFExprSuffix = 0
, ppconf_Inh_PFExprSuffix = defaultPPConfig
}
{-# LINE 484 "src/GLua/AG/PrettyPrint.hs" #-}
-- AReturn -----------------------------------------------------
-- cata
sem_AReturn
:: AReturn
-> T_AReturn
sem_AReturn (AReturn _pos _values) =
(sem_AReturn_AReturn _pos (sem_MExprList _values))
sem_AReturn (NoReturn) =
(sem_AReturn_NoReturn)
-- semantic domain
type T_AReturn =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), AReturn, Bool, Doc, Int)
data Inh_AReturn = Inh_AReturn {comments_Inh_AReturn :: ([MToken]), forceMultiline_Inh_AReturn :: Bool, indent_Inh_AReturn :: Int, ppconf_Inh_AReturn :: PrettyPrintConfig}
data Syn_AReturn = Syn_AReturn {comments_Syn_AReturn :: ([MToken]), copy_Syn_AReturn :: AReturn, isMultiline_Syn_AReturn :: Bool, pretty_Syn_AReturn :: Doc, statementCount_Syn_AReturn :: Int}
wrap_AReturn
:: T_AReturn
-> Inh_AReturn
-> Syn_AReturn
wrap_AReturn sem (Inh_AReturn _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_AReturn _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty _lhsOstatementCount)
)
sem_AReturn_AReturn
:: Region
-> T_MExprList
-> T_AReturn
sem_AReturn_AReturn pos_ values_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_valuesOcomments :: ([MToken])
_lhsOcomments :: ([MToken])
_valuesOforceMultiline :: Bool
_valuesOsomeElementsInListAreMultiline :: Bool
_lhsOstatementCount :: Int
_lhsOcopy :: AReturn
_valuesOindent :: Int
_valuesOppconf :: PrettyPrintConfig
_valuesIcomments :: ([MToken])
_valuesIcopy :: MExprList
_valuesIisAssociative :: Bool
_valuesIisLast :: Bool
_valuesIisMultiline :: Bool
_valuesIpos :: Region
_valuesIprecedence :: OperatorLevel
_valuesIpretty :: Doc
_lhsOpretty =
( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore)
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "return")
<-> _valuesIpretty
<> _semicolon
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
)
_lhsOisMultiline =
( _valuesIisMultiline
|| not (null $ fst _commentsBefore)
|| not (null $ fst _commentsAfter)
)
_semicolon =
( if semicolons _lhsIppconf then zchr ';' else empty
)
_commentsBefore =
( span (\(MToken pos _) -> pos `before` pos_) _lhsIcomments
)
_valuesOcomments =
( snd _commentsBefore
)
_commentsAfter =
( span (\(MToken pos _) -> pos `beforeOrOnLine` (rgOr _valuesIpos pos_)) _valuesIcomments
)
_lhsOcomments =
( snd _commentsAfter
)
_valuesOforceMultiline =
( False
)
_valuesOsomeElementsInListAreMultiline =
( False
)
_lhsOstatementCount =
( 1
)
_copy =
( AReturn pos_ _valuesIcopy
)
_lhsOcopy =
( _copy
)
_valuesOindent =
( _lhsIindent
)
_valuesOppconf =
( _lhsIppconf
)
(_valuesIcomments, _valuesIcopy, _valuesIisAssociative, _valuesIisLast, _valuesIisMultiline, _valuesIpos, _valuesIprecedence, _valuesIpretty) =
values_ _valuesOcomments _valuesOforceMultiline _valuesOindent _valuesOppconf _valuesOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
)
)
sem_AReturn_NoReturn :: T_AReturn
sem_AReturn_NoReturn =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOstatementCount :: Int
_lhsOisMultiline :: Bool
_lhsOcopy :: AReturn
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOstatementCount =
( 0
)
_lhsOisMultiline =
( False
)
_copy =
( NoReturn
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
)
)
-- AST ---------------------------------------------------------
-- cata
sem_AST
:: AST
-> T_AST
sem_AST (AST _comments _chunk) =
(sem_AST_AST _comments (sem_Block _chunk))
-- semantic domain
type T_AST =
Int
-> PrettyPrintConfig
-> (AST, Bool, Doc)
data Inh_AST = Inh_AST {indent_Inh_AST :: Int, ppconf_Inh_AST :: PrettyPrintConfig}
data Syn_AST = Syn_AST {copy_Syn_AST :: AST, isMultiline_Syn_AST :: Bool, pretty_Syn_AST :: Doc}
wrap_AST
:: T_AST
-> Inh_AST
-> Syn_AST
wrap_AST sem (Inh_AST _lhsIindent _lhsIppconf) =
( let
(_lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIindent _lhsIppconf
in
(Syn_AST _lhsOcopy _lhsOisMultiline _lhsOpretty)
)
sem_AST_AST
:: ([MToken])
-> T_Block
-> T_AST
sem_AST_AST comments_ chunk_ =
( \_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_chunkOcomments :: ([MToken])
_chunkOstatRegion :: Region
_chunkOforceMultiline :: Bool
_lhsOcopy :: AST
_chunkOindent :: Int
_chunkOppconf :: PrettyPrintConfig
_chunkIcomments :: ([MToken])
_chunkIcopy :: Block
_chunkIisMultiline :: Bool
_chunkIpretty :: Doc
_chunkIstatementCount :: Int
_lhsOpretty =
( _chunkIpretty $+$ _prettyComments
)
_lhsOisMultiline =
( _chunkIisMultiline
)
_prettyComments =
( renderMLComments _lhsIppconf _lhsIindent _chunkIcomments
)
_chunkOcomments =
( comments_
)
_chunkOstatRegion =
( emptyRg
)
_chunkOforceMultiline =
( False
)
_copy =
( AST comments_ _chunkIcopy
)
_lhsOcopy =
( _copy
)
_chunkOindent =
( _lhsIindent
)
_chunkOppconf =
( _lhsIppconf
)
(_chunkIcomments, _chunkIcopy, _chunkIisMultiline, _chunkIpretty, _chunkIstatementCount) =
chunk_ _chunkOcomments _chunkOforceMultiline _chunkOindent _chunkOppconf _chunkOstatRegion
in
(_lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
-- Args --------------------------------------------------------
-- cata
sem_Args
:: Args
-> T_Args
sem_Args (ListArgs _args) =
(sem_Args_ListArgs (sem_MExprList _args))
sem_Args (TableArg _arg) =
(sem_Args_TableArg (sem_FieldList _arg))
sem_Args (StringArg _arg) =
(sem_Args_StringArg _arg)
-- semantic domain
type T_Args =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), Args, Bool, Doc)
data Inh_Args = Inh_Args {comments_Inh_Args :: ([MToken]), forceMultiline_Inh_Args :: Bool, indent_Inh_Args :: Int, ppconf_Inh_Args :: PrettyPrintConfig}
data Syn_Args = Syn_Args {comments_Syn_Args :: ([MToken]), copy_Syn_Args :: Args, isMultiline_Syn_Args :: Bool, pretty_Syn_Args :: Doc}
wrap_Args
:: T_Args
-> Inh_Args
-> Syn_Args
wrap_Args sem (Inh_Args _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_Args _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
)
sem_Args_ListArgs
:: T_MExprList
-> T_Args
sem_Args_ListArgs args_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_argsOindent :: Int
_argsOsomeElementsInListAreMultiline :: Bool
_lhsOcopy :: Args
_lhsOcomments :: ([MToken])
_argsOcomments :: ([MToken])
_argsOforceMultiline :: Bool
_argsOppconf :: PrettyPrintConfig
_argsIcomments :: ([MToken])
_argsIcopy :: MExprList
_argsIisAssociative :: Bool
_argsIisLast :: Bool
_argsIisMultiline :: Bool
_argsIpos :: Region
_argsIprecedence :: OperatorLevel
_argsIpretty :: Doc
_lhsOpretty =
( if _argsIisMultiline
then
zchr '('
$+$ _argsIpretty
$+$ indent _lhsIppconf _lhsIindent (zchr ')')
else parens _lhsIppconf _emptyParams _argsIpretty
)
_lhsOisMultiline =
( _argsIisMultiline
)
_emptyParams =
( toEmpty $ null _argsIcopy
)
_argsOindent =
( if _argsIisMultiline then _lhsIindent + 1 else 0
)
_argsOsomeElementsInListAreMultiline =
( False
)
_copy =
( ListArgs _argsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _argsIcomments
)
_argsOcomments =
( _lhsIcomments
)
_argsOforceMultiline =
( _lhsIforceMultiline
)
_argsOppconf =
( _lhsIppconf
)
(_argsIcomments, _argsIcopy, _argsIisAssociative, _argsIisLast, _argsIisMultiline, _argsIpos, _argsIprecedence, _argsIpretty) =
args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf _argsOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
sem_Args_TableArg
:: T_FieldList
-> T_Args
sem_Args_TableArg arg_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_argOindent :: Int
_argOsomeElementsInListAreMultiline :: Bool
_lhsOcopy :: Args
_lhsOcomments :: ([MToken])
_argOcomments :: ([MToken])
_argOforceMultiline :: Bool
_argOppconf :: PrettyPrintConfig
_argIcomments :: ([MToken])
_argIcopy :: FieldList
_argIisMultiline :: Bool
_argIisNil :: Bool
_argIpretty :: Doc
_lhsOpretty =
( if _argIisMultiline then _prettyMulti else _prettySingle
)
_lhsOisMultiline =
( _argIisMultiline
)
_prettyMulti =
( zchr '{' $+$ _argIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')
)
_prettySingle =
( braces _lhsIppconf _emptyContents _argIpretty
)
_emptyContents =
( toEmpty $ null _argIcopy
)
_argOindent =
( _lhsIindent + (if _argIisMultiline then 1 else 0)
)
_argOsomeElementsInListAreMultiline =
( False
)
_copy =
( TableArg _argIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _argIcomments
)
_argOcomments =
( _lhsIcomments
)
_argOforceMultiline =
( _lhsIforceMultiline
)
_argOppconf =
( _lhsIppconf
)
(_argIcomments, _argIcopy, _argIisMultiline, _argIisNil, _argIpretty) =
arg_ _argOcomments _argOforceMultiline _argOindent _argOppconf _argOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
sem_Args_StringArg
:: MToken
-> T_Args
sem_Args_StringArg arg_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOcopy :: Args
_lhsOcomments :: ([MToken])
_lhsOpretty =
( tok arg_
)
_lhsOisMultiline =
( False
)
_copy =
( StringArg arg_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
-- BinOp -------------------------------------------------------
-- cata
sem_BinOp
:: BinOp
-> T_BinOp
sem_BinOp (AOr) =
(sem_BinOp_AOr)
sem_BinOp (AAnd) =
(sem_BinOp_AAnd)
sem_BinOp (ALT) =
(sem_BinOp_ALT)
sem_BinOp (AGT) =
(sem_BinOp_AGT)
sem_BinOp (ALEQ) =
(sem_BinOp_ALEQ)
sem_BinOp (AGEQ) =
(sem_BinOp_AGEQ)
sem_BinOp (ANEq) =
(sem_BinOp_ANEq)
sem_BinOp (AEq) =
(sem_BinOp_AEq)
sem_BinOp (AConcatenate) =
(sem_BinOp_AConcatenate)
sem_BinOp (APlus) =
(sem_BinOp_APlus)
sem_BinOp (BinMinus) =
(sem_BinOp_BinMinus)
sem_BinOp (AMultiply) =
(sem_BinOp_AMultiply)
sem_BinOp (ADivide) =
(sem_BinOp_ADivide)
sem_BinOp (AModulus) =
(sem_BinOp_AModulus)
sem_BinOp (APower) =
(sem_BinOp_APower)
-- semantic domain
type T_BinOp =
([MToken])
-> Int
-> PrettyPrintConfig
-> (([MToken]), BinOp, Bool, Bool, OperatorLevel, Doc)
data Inh_BinOp = Inh_BinOp {comments_Inh_BinOp :: ([MToken]), indent_Inh_BinOp :: Int, ppconf_Inh_BinOp :: PrettyPrintConfig}
data Syn_BinOp = Syn_BinOp {comments_Syn_BinOp :: ([MToken]), copy_Syn_BinOp :: BinOp, isAssociative_Syn_BinOp :: Bool, isMultiline_Syn_BinOp :: Bool, precedence_Syn_BinOp :: OperatorLevel, pretty_Syn_BinOp :: Doc}
wrap_BinOp
:: T_BinOp
-> Inh_BinOp
-> Syn_BinOp
wrap_BinOp sem (Inh_BinOp _lhsIcomments _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
in
(Syn_BinOp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
)
sem_BinOp_AOr :: T_BinOp
sem_BinOp_AOr =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText (if cStyle _lhsIppconf then "||" else "or")
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel1
)
_lhsOisAssociative =
( True
)
_copy =
( AOr
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AAnd :: T_BinOp
sem_BinOp_AAnd =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText (if cStyle _lhsIppconf then "&&" else "and")
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel2
)
_lhsOisAssociative =
( True
)
_copy =
( AAnd
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_ALT :: T_BinOp
sem_BinOp_ALT =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "<"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( ALT
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AGT :: T_BinOp
sem_BinOp_AGT =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText ">"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( AGT
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_ALEQ :: T_BinOp
sem_BinOp_ALEQ =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "<="
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( ALEQ
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AGEQ :: T_BinOp
sem_BinOp_AGEQ =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText ">="
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( AGEQ
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_ANEq :: T_BinOp
sem_BinOp_ANEq =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText (if cStyle _lhsIppconf then "!=" else "~=")
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( ANEq
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AEq :: T_BinOp
sem_BinOp_AEq =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "=="
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel3
)
_lhsOisAssociative =
( True
)
_copy =
( AEq
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AConcatenate :: T_BinOp
sem_BinOp_AConcatenate =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText ".."
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel4
)
_lhsOisAssociative =
( True
)
_copy =
( AConcatenate
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_APlus :: T_BinOp
sem_BinOp_APlus =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "+"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel5
)
_lhsOisAssociative =
( True
)
_copy =
( APlus
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_BinMinus :: T_BinOp
sem_BinOp_BinMinus =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "-"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel5
)
_lhsOisAssociative =
( False
)
_copy =
( BinMinus
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AMultiply :: T_BinOp
sem_BinOp_AMultiply =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "*"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel6
)
_lhsOisAssociative =
( True
)
_copy =
( AMultiply
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_ADivide :: T_BinOp
sem_BinOp_ADivide =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "/"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel6
)
_lhsOisAssociative =
( False
)
_copy =
( ADivide
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_AModulus :: T_BinOp
sem_BinOp_AModulus =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "%"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel6
)
_lhsOisAssociative =
( False
)
_copy =
( AModulus
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_BinOp_APower :: T_BinOp
sem_BinOp_APower =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOcopy :: BinOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "^"
)
_lhsOisMultiline =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_lhsOisAssociative =
( False
)
_copy =
( APower
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
-- Block -------------------------------------------------------
-- cata
sem_Block
:: Block
-> T_Block
sem_Block (Block _stats _ret) =
(sem_Block_Block (sem_MStatList _stats) (sem_AReturn _ret))
-- semantic domain
type T_Block =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Region
-> (([MToken]), Block, Bool, Doc, Int)
data Inh_Block = Inh_Block {comments_Inh_Block :: ([MToken]), forceMultiline_Inh_Block :: Bool, indent_Inh_Block :: Int, ppconf_Inh_Block :: PrettyPrintConfig, statRegion_Inh_Block :: Region}
data Syn_Block = Syn_Block {comments_Syn_Block :: ([MToken]), copy_Syn_Block :: Block, isMultiline_Syn_Block :: Bool, pretty_Syn_Block :: Doc, statementCount_Syn_Block :: Int}
wrap_Block
:: T_Block
-> Inh_Block
-> Syn_Block
wrap_Block sem (Inh_Block _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
in
(Syn_Block _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty _lhsOstatementCount)
)
sem_Block_Block
:: T_MStatList
-> T_AReturn
-> T_Block
sem_Block_Block stats_ ret_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOstatementCount :: Int
_lhsOcopy :: Block
_lhsOcomments :: ([MToken])
_lhsOisMultiline :: Bool
_statsOcomments :: ([MToken])
_statsOforceMultiline :: Bool
_statsOindent :: Int
_statsOppconf :: PrettyPrintConfig
_statsOstatRegion :: Region
_retOcomments :: ([MToken])
_retOforceMultiline :: Bool
_retOindent :: Int
_retOppconf :: PrettyPrintConfig
_statsIcomments :: ([MToken])
_statsIcopy :: MStatList
_statsIisLast :: Bool
_statsIisMultiline :: Bool
_statsIpretty :: Doc
_statsIstartsWithExprPrefixExpression :: Bool
_statsIstatementCount :: Int
_retIcomments :: ([MToken])
_retIcopy :: AReturn
_retIisMultiline :: Bool
_retIpretty :: Doc
_retIstatementCount :: Int
_lhsOpretty =
( if _isMultiline
then _statsIpretty $+$ _retIpretty
else _statsIpretty <-> _retIpretty
)
_statementCount =
( _statsIstatementCount + _retIstatementCount
)
_isMultiline =
( _statsIisMultiline || _retIisMultiline || _statementCount > 1
)
_lhsOstatementCount =
( _statementCount
)
_copy =
( Block _statsIcopy _retIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _retIcomments
)
_lhsOisMultiline =
( _isMultiline
)
_statsOcomments =
( _lhsIcomments
)
_statsOforceMultiline =
( _lhsIforceMultiline
)
_statsOindent =
( _lhsIindent
)
_statsOppconf =
( _lhsIppconf
)
_statsOstatRegion =
( _lhsIstatRegion
)
_retOcomments =
( _statsIcomments
)
_retOforceMultiline =
( _lhsIforceMultiline
)
_retOindent =
( _lhsIindent
)
_retOppconf =
( _lhsIppconf
)
(_statsIcomments, _statsIcopy, _statsIisLast, _statsIisMultiline, _statsIpretty, _statsIstartsWithExprPrefixExpression, _statsIstatementCount) =
stats_ _statsOcomments _statsOforceMultiline _statsOindent _statsOppconf _statsOstatRegion
(_retIcomments, _retIcopy, _retIisMultiline, _retIpretty, _retIstatementCount) =
ret_ _retOcomments _retOforceMultiline _retOindent _retOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty, _lhsOstatementCount)
)
)
-- Declaration -------------------------------------------------
-- cata
sem_Declaration
:: Declaration
-> T_Declaration
sem_Declaration (x1, x2) =
(sem_Declaration_Tuple (sem_PrefixExp x1) (sem_MaybeMExpr x2))
-- semantic domain
type T_Declaration =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), Declaration, Bool, Doc, Bool, Bool, Doc, Bool, Doc)
data Inh_Declaration = Inh_Declaration {comments_Inh_Declaration :: ([MToken]), forceMultiline_Inh_Declaration :: Bool, indent_Inh_Declaration :: Int, ppconf_Inh_Declaration :: PrettyPrintConfig}
data Syn_Declaration = Syn_Declaration {comments_Syn_Declaration :: ([MToken]), copy_Syn_Declaration :: Declaration, endsWithPrefixExpression_Syn_Declaration :: Bool, exprPretty_Syn_Declaration :: Doc, isDefined_Syn_Declaration :: Bool, isMultiline_Syn_Declaration :: Bool, pretty_Syn_Declaration :: Doc, startsWithExprPrefixExpression_Syn_Declaration :: Bool, varPretty_Syn_Declaration :: Doc}
wrap_Declaration
:: T_Declaration
-> Inh_Declaration
-> Syn_Declaration
wrap_Declaration sem (Inh_Declaration _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_Declaration _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOexprPretty _lhsOisDefined _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOvarPretty)
)
sem_Declaration_Tuple
:: T_PrefixExp
-> T_MaybeMExpr
-> T_Declaration
sem_Declaration_Tuple x1_ x2_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOvarPretty :: Doc
_lhsOexprPretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_x1OparentOperatorPrecedence :: OperatorLevel
_x1OparentOperatorAssociative :: Bool
_lhsOisDefined :: Bool
_lhsOcopy :: Declaration
_lhsOcomments :: ([MToken])
_lhsOpretty :: Doc
_x1Ocomments :: ([MToken])
_x1OforceMultiline :: Bool
_x1Oindent :: Int
_x1Oppconf :: PrettyPrintConfig
_x2Ocomments :: ([MToken])
_x2OforceMultiline :: Bool
_x2Oindent :: Int
_x2Oppconf :: PrettyPrintConfig
_x1Icomments :: ([MToken])
_x1Icopy :: PrefixExp
_x1IisAssociative :: Bool
_x1IisLiteral :: Bool
_x1IisMultiline :: Bool
_x1Iprecedence :: OperatorLevel
_x1Ipretty :: Doc
_x1IstartsWithExprPrefixExpression :: Bool
_x2Icomments :: ([MToken])
_x2Icopy :: MaybeMExpr
_x2IendsWithPrefixExpression :: Bool
_x2IisAssociative :: Bool
_x2IisDefined :: Bool
_x2IisMultiline :: Bool
_x2Iprecedence :: OperatorLevel
_x2Ipretty :: Doc
_lhsOvarPretty =
( _x1Ipretty
)
_lhsOexprPretty =
( _x2Ipretty
)
_lhsOstartsWithExprPrefixExpression =
( _x1IstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( _x2IendsWithPrefixExpression
)
_lhsOisMultiline =
( _x1IisMultiline || _x2IisMultiline
)
_x1OparentOperatorPrecedence =
( TopLevelExpression
)
_x1OparentOperatorAssociative =
( True
)
_lhsOisDefined =
( _x2IisDefined
)
_copy =
( (_x1Icopy, _x2Icopy)
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _x2Icomments
)
_lhsOpretty =
( _x2Ipretty
)
_x1Ocomments =
( _lhsIcomments
)
_x1OforceMultiline =
( _lhsIforceMultiline
)
_x1Oindent =
( _lhsIindent
)
_x1Oppconf =
( _lhsIppconf
)
_x2Ocomments =
( _x1Icomments
)
_x2OforceMultiline =
( _lhsIforceMultiline
)
_x2Oindent =
( _lhsIindent
)
_x2Oppconf =
( _lhsIppconf
)
(_x1Icomments, _x1Icopy, _x1IisAssociative, _x1IisLiteral, _x1IisMultiline, _x1Iprecedence, _x1Ipretty, _x1IstartsWithExprPrefixExpression) =
x1_ _x1Ocomments _x1OforceMultiline _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf
(_x2Icomments, _x2Icopy, _x2IendsWithPrefixExpression, _x2IisAssociative, _x2IisDefined, _x2IisMultiline, _x2Iprecedence, _x2Ipretty) =
x2_ _x2Ocomments _x2OforceMultiline _x2Oindent _x2Oppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
)
)
-- Else --------------------------------------------------------
-- cata
sem_Else
:: Else
-> T_Else
sem_Else (Prelude.Just x) =
(sem_Else_Just (sem_MElse x))
sem_Else Prelude.Nothing =
sem_Else_Nothing
-- semantic domain
type T_Else =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Region
-> (([MToken]), Else, Bool, Bool, Region, Doc)
data Inh_Else = Inh_Else {comments_Inh_Else :: ([MToken]), forceMultiline_Inh_Else :: Bool, indent_Inh_Else :: Int, ppconf_Inh_Else :: PrettyPrintConfig, statRegion_Inh_Else :: Region}
data Syn_Else = Syn_Else {comments_Syn_Else :: ([MToken]), copy_Syn_Else :: Else, elsesExist_Syn_Else :: Bool, isMultiline_Syn_Else :: Bool, pos_Syn_Else :: Region, pretty_Syn_Else :: Doc}
wrap_Else
:: T_Else
-> Inh_Else
-> Syn_Else
wrap_Else sem (Inh_Else _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
in
(Syn_Else _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
)
sem_Else_Just
:: T_MElse
-> T_Else
sem_Else_Just just_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOelsesExist :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Else
_lhsOcomments :: ([MToken])
_lhsOpos :: Region
_lhsOpretty :: Doc
_justOcomments :: ([MToken])
_justOforceMultiline :: Bool
_justOindent :: Int
_justOppconf :: PrettyPrintConfig
_justOstatRegion :: Region
_justIcomments :: ([MToken])
_justIcopy :: MElse
_justIelsesExist :: Bool
_justIisMultiline :: Bool
_justIpos :: Region
_justIpretty :: Doc
_lhsOelsesExist =
( True
)
_lhsOisMultiline =
( _justIisMultiline
)
_copy =
( Just _justIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _justIcomments
)
_lhsOpos =
( _justIpos
)
_lhsOpretty =
( _justIpretty
)
_justOcomments =
( _lhsIcomments
)
_justOforceMultiline =
( _lhsIforceMultiline
)
_justOindent =
( _lhsIindent
)
_justOppconf =
( _lhsIppconf
)
_justOstatRegion =
( _lhsIstatRegion
)
(_justIcomments, _justIcopy, _justIelsesExist, _justIisMultiline, _justIpos, _justIpretty) =
just_ _justOcomments _justOforceMultiline _justOindent _justOppconf _justOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
sem_Else_Nothing :: T_Else
sem_Else_Nothing =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOpos :: Region
_lhsOisMultiline :: Bool
_lhsOelsesExist :: Bool
_lhsOcopy :: Else
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOpos =
( emptyRg
)
_lhsOisMultiline =
( False
)
_lhsOelsesExist =
( False
)
_copy =
( Nothing
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
-- ElseIf ------------------------------------------------------
-- cata
sem_ElseIf
:: ElseIf
-> T_ElseIf
sem_ElseIf (x1, x2) =
(sem_ElseIf_Tuple (sem_MExpr x1) (sem_Block x2))
-- semantic domain
type T_ElseIf =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), ElseIf, Bool, Doc)
data Inh_ElseIf = Inh_ElseIf {comments_Inh_ElseIf :: ([MToken]), forceMultiline_Inh_ElseIf :: Bool, indent_Inh_ElseIf :: Int, ppconf_Inh_ElseIf :: PrettyPrintConfig}
data Syn_ElseIf = Syn_ElseIf {comments_Syn_ElseIf :: ([MToken]), copy_Syn_ElseIf :: ElseIf, isMultiline_Syn_ElseIf :: Bool, pretty_Syn_ElseIf :: Doc}
wrap_ElseIf
:: T_ElseIf
-> Inh_ElseIf
-> Syn_ElseIf
wrap_ElseIf sem (Inh_ElseIf _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_ElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
)
sem_ElseIf_Tuple
:: T_MExpr
-> T_Block
-> T_ElseIf
sem_ElseIf_Tuple x1_ x2_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_x2Oindent :: Int
_x2OstatRegion :: Region
_x1OparentOperatorPrecedence :: OperatorLevel
_x1OparentOperatorAssociative :: Bool
_lhsOcopy :: ElseIf
_lhsOcomments :: ([MToken])
_x1Ocomments :: ([MToken])
_x1OforceMultiline :: Bool
_x1Oindent :: Int
_x1Oppconf :: PrettyPrintConfig
_x2Ocomments :: ([MToken])
_x2OforceMultiline :: Bool
_x2Oppconf :: PrettyPrintConfig
_x1Icomments :: ([MToken])
_x1Icopy :: MExpr
_x1IendsWithPrefixExpression :: Bool
_x1IisAssociative :: Bool
_x1IisLiteral :: Bool
_x1IisMultiline :: Bool
_x1Ipos :: Region
_x1Iprecedence :: OperatorLevel
_x1Ipretty :: Doc
_x2Icomments :: ([MToken])
_x2Icopy :: Block
_x2IisMultiline :: Bool
_x2Ipretty :: Doc
_x2IstatementCount :: Int
_lhsOpretty =
( zeroWidthText "elseif" <-> _x1Ipretty <-> zeroWidthText "then" $+$ _x2Ipretty
)
_lhsOisMultiline =
( _x1IisMultiline || _x2IisMultiline
)
_x2Oindent =
( _lhsIindent + 1
)
_x2OstatRegion =
( emptyRg
)
_x1OparentOperatorPrecedence =
( TopLevelExpression
)
_x1OparentOperatorAssociative =
( True
)
_copy =
( (_x1Icopy, _x2Icopy)
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _x2Icomments
)
_x1Ocomments =
( _lhsIcomments
)
_x1OforceMultiline =
( _lhsIforceMultiline
)
_x1Oindent =
( _lhsIindent
)
_x1Oppconf =
( _lhsIppconf
)
_x2Ocomments =
( _x1Icomments
)
_x2OforceMultiline =
( _lhsIforceMultiline
)
_x2Oppconf =
( _lhsIppconf
)
(_x1Icomments, _x1Icopy, _x1IendsWithPrefixExpression, _x1IisAssociative, _x1IisLiteral, _x1IisMultiline, _x1Ipos, _x1Iprecedence, _x1Ipretty) =
x1_ _x1Ocomments _x1OforceMultiline _x1Oindent _x1OparentOperatorAssociative _x1OparentOperatorPrecedence _x1Oppconf
(_x2Icomments, _x2Icopy, _x2IisMultiline, _x2Ipretty, _x2IstatementCount) =
x2_ _x2Ocomments _x2OforceMultiline _x2Oindent _x2Oppconf _x2OstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
-- ElseIfList --------------------------------------------------
-- cata
sem_ElseIfList
:: ElseIfList
-> T_ElseIfList
sem_ElseIfList list =
(Prelude.foldr sem_ElseIfList_Cons sem_ElseIfList_Nil (Prelude.map sem_MElseIf list))
-- semantic domain
type T_ElseIfList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), ElseIfList, Bool, Bool, Region, Doc)
data Inh_ElseIfList = Inh_ElseIfList {comments_Inh_ElseIfList :: ([MToken]), forceMultiline_Inh_ElseIfList :: Bool, indent_Inh_ElseIfList :: Int, ppconf_Inh_ElseIfList :: PrettyPrintConfig}
data Syn_ElseIfList = Syn_ElseIfList {comments_Syn_ElseIfList :: ([MToken]), copy_Syn_ElseIfList :: ElseIfList, elsesExist_Syn_ElseIfList :: Bool, isMultiline_Syn_ElseIfList :: Bool, pos_Syn_ElseIfList :: Region, pretty_Syn_ElseIfList :: Doc}
wrap_ElseIfList
:: T_ElseIfList
-> Inh_ElseIfList
-> Syn_ElseIfList
wrap_ElseIfList sem (Inh_ElseIfList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_ElseIfList _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
)
sem_ElseIfList_Cons
:: T_MElseIf
-> T_ElseIfList
-> T_ElseIfList
sem_ElseIfList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOelsesExist :: Bool
_lhsOpos :: Region
_lhsOisMultiline :: Bool
_lhsOcopy :: ElseIfList
_lhsOcomments :: ([MToken])
_hdOcomments :: ([MToken])
_hdOforceMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOcomments :: ([MToken])
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_hdIcomments :: ([MToken])
_hdIcopy :: MElseIf
_hdIisMultiline :: Bool
_hdIpos :: Region
_hdIpretty :: Doc
_tlIcomments :: ([MToken])
_tlIcopy :: ElseIfList
_tlIelsesExist :: Bool
_tlIisMultiline :: Bool
_tlIpos :: Region
_tlIpretty :: Doc
_lhsOpretty =
( indent _lhsIppconf _lhsIindent _hdIpretty $+$ _tlIpretty
)
_lhsOelsesExist =
( True
)
_lhsOpos =
( _hdIpos
)
_lhsOisMultiline =
( _hdIisMultiline || _tlIisMultiline
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _tlIcomments
)
_hdOcomments =
( _lhsIcomments
)
_hdOforceMultiline =
( _lhsIforceMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOcomments =
( _hdIcomments
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
(_hdIcomments, _hdIcopy, _hdIisMultiline, _hdIpos, _hdIpretty) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
(_tlIcomments, _tlIcopy, _tlIelsesExist, _tlIisMultiline, _tlIpos, _tlIpretty) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
sem_ElseIfList_Nil :: T_ElseIfList
sem_ElseIfList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOpos :: Region
_lhsOisMultiline :: Bool
_lhsOelsesExist :: Bool
_lhsOcopy :: ElseIfList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOpos =
( emptyRg
)
_lhsOisMultiline =
( False
)
_lhsOelsesExist =
( False
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
-- Expr --------------------------------------------------------
-- cata
sem_Expr
:: Expr
-> T_Expr
sem_Expr (ANil) =
(sem_Expr_ANil)
sem_Expr (AFalse) =
(sem_Expr_AFalse)
sem_Expr (ATrue) =
(sem_Expr_ATrue)
sem_Expr (ANumber _num) =
(sem_Expr_ANumber _num)
sem_Expr (AString _str) =
(sem_Expr_AString _str)
sem_Expr (AVarArg) =
(sem_Expr_AVarArg)
sem_Expr (AnonymousFunc _pars _body) =
(sem_Expr_AnonymousFunc _pars (sem_Block _body))
sem_Expr (APrefixExpr _pexpr) =
(sem_Expr_APrefixExpr (sem_PrefixExp _pexpr))
sem_Expr (ATableConstructor _fields) =
(sem_Expr_ATableConstructor (sem_FieldList _fields))
sem_Expr (BinOpExpr _op _left _right) =
(sem_Expr_BinOpExpr (sem_BinOp _op) (sem_MExpr _left) (sem_MExpr _right))
sem_Expr (UnOpExpr _op _right) =
(sem_Expr_UnOpExpr (sem_UnOp _op) (sem_MExpr _right))
-- semantic domain
type T_Expr =
([MToken])
-> Bool
-> Int
-> Bool
-> OperatorLevel
-> PrettyPrintConfig
-> Region
-> (([MToken]), Expr, Bool, Bool, Bool, Bool, OperatorLevel, Doc)
data Inh_Expr = Inh_Expr {comments_Inh_Expr :: ([MToken]), forceMultiline_Inh_Expr :: Bool, indent_Inh_Expr :: Int, parentOperatorAssociative_Inh_Expr :: Bool, parentOperatorPrecedence_Inh_Expr :: OperatorLevel, ppconf_Inh_Expr :: PrettyPrintConfig, statRegion_Inh_Expr :: Region}
data Syn_Expr = Syn_Expr {comments_Syn_Expr :: ([MToken]), copy_Syn_Expr :: Expr, endsWithPrefixExpression_Syn_Expr :: Bool, isAssociative_Syn_Expr :: Bool, isLiteral_Syn_Expr :: Bool, isMultiline_Syn_Expr :: Bool, precedence_Syn_Expr :: OperatorLevel, pretty_Syn_Expr :: Doc}
wrap_Expr
:: T_Expr
-> Inh_Expr
-> Syn_Expr
wrap_Expr sem (Inh_Expr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf _lhsIstatRegion
in
(Syn_Expr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOprecedence _lhsOpretty)
)
sem_Expr_ANil :: T_Expr
sem_Expr_ANil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "nil"
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( ANil
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_AFalse :: T_Expr
sem_Expr_AFalse =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "false"
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( AFalse
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_ATrue :: T_Expr
sem_Expr_ATrue =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "true"
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( ATrue
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_ANumber
:: String
-> T_Expr
sem_Expr_ANumber num_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText num_
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( ANumber num_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_AString
:: MToken
-> T_Expr
sem_Expr_AString str_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( tok str_
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( AString str_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_AVarArg :: T_Expr
sem_Expr_AVarArg =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "..."
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( AVarArg
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_AnonymousFunc
:: ([MToken])
-> T_Block
-> T_Expr
sem_Expr_AnonymousFunc pars_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOendsWithPrefixExpression :: Bool
_bodyOindent :: Int
_lhsOpretty :: Doc
_lhsOisAssociative :: Bool
_lhsOisLiteral :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOisMultiline :: Bool
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_isMultiline =
( _lhsIforceMultiline || _bodyIisMultiline
)
_lhsOendsWithPrefixExpression =
( False
)
_singleLinePretty =
( zeroWidthText "function"
<> parens _lhsIppconf _emptyParams (printList tok (render _comma) pars_)
<-> _bodyIpretty
<-> zeroWidthText "end"
)
_multilinePretty =
( zeroWidthText "function"
<> parens _lhsIppconf _emptyParams (printList tok (render _comma) pars_)
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_emptyParams =
( toEmpty $ null pars_
)
_bodyOindent =
( if _isMultiline then _lhsIindent + 1 else 0
)
_lhsOpretty =
( if _isMultiline then _multilinePretty else _singleLinePretty
)
_lhsOisAssociative =
( False
)
_lhsOisLiteral =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( AnonymousFunc pars_ _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_lhsOisMultiline =
( _isMultiline
)
_bodyOcomments =
( _lhsIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_APrefixExpr
:: T_PrefixExp
-> T_Expr
sem_Expr_APrefixExpr pexpr_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOisLiteral :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_pexprOcomments :: ([MToken])
_pexprOforceMultiline :: Bool
_pexprOindent :: Int
_pexprOparentOperatorAssociative :: Bool
_pexprOparentOperatorPrecedence :: OperatorLevel
_pexprOppconf :: PrettyPrintConfig
_pexprIcomments :: ([MToken])
_pexprIcopy :: PrefixExp
_pexprIisAssociative :: Bool
_pexprIisLiteral :: Bool
_pexprIisMultiline :: Bool
_pexprIprecedence :: OperatorLevel
_pexprIpretty :: Doc
_pexprIstartsWithExprPrefixExpression :: Bool
_lhsOpretty =
( _pexprIpretty
)
_lhsOendsWithPrefixExpression =
( True
)
_lhsOisMultiline =
( _pexprIisMultiline
)
_lhsOisAssociative =
( _pexprIisAssociative
)
_lhsOisLiteral =
( _pexprIisLiteral
)
_lhsOprecedence =
( _pexprIprecedence
)
_copy =
( APrefixExpr _pexprIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _pexprIcomments
)
_pexprOcomments =
( _lhsIcomments
)
_pexprOforceMultiline =
( _lhsIforceMultiline
)
_pexprOindent =
( _lhsIindent
)
_pexprOparentOperatorAssociative =
( _lhsIparentOperatorAssociative
)
_pexprOparentOperatorPrecedence =
( _lhsIparentOperatorPrecedence
)
_pexprOppconf =
( _lhsIppconf
)
(_pexprIcomments, _pexprIcopy, _pexprIisAssociative, _pexprIisLiteral, _pexprIisMultiline, _pexprIprecedence, _pexprIpretty, _pexprIstartsWithExprPrefixExpression) =
pexpr_ _pexprOcomments _pexprOforceMultiline _pexprOindent _pexprOparentOperatorAssociative _pexprOparentOperatorPrecedence _pexprOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_ATableConstructor
:: T_FieldList
-> T_Expr
sem_Expr_ATableConstructor fields_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOendsWithPrefixExpression :: Bool
_fieldsOindent :: Int
_fieldsOsomeElementsInListAreMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_lhsOisMultiline :: Bool
_fieldsOcomments :: ([MToken])
_fieldsOforceMultiline :: Bool
_fieldsOppconf :: PrettyPrintConfig
_fieldsIcomments :: ([MToken])
_fieldsIcopy :: FieldList
_fieldsIisMultiline :: Bool
_fieldsIisNil :: Bool
_fieldsIpretty :: Doc
_lhsOpretty =
( if _isMultiline then _prettyMulti else _prettySingle
)
_isMultiline =
( _lhsIforceMultiline || _fieldsIisMultiline
)
_lhsOisLiteral =
( True
)
_lhsOendsWithPrefixExpression =
( False
)
_prettyMulti =
( zchr '{' $+$ _fieldsIpretty $+$ indent _lhsIppconf _lhsIindent (zchr '}')
)
_prettySingle =
( braces _lhsIppconf _emptyContents _fieldsIpretty
)
_emptyContents =
( toEmpty $ null _fieldsIcopy
)
_fieldsOindent =
( _lhsIindent + (if _fieldsIisMultiline then 1 else 0)
)
_fieldsOsomeElementsInListAreMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( ATableConstructor _fieldsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _fieldsIcomments
)
_lhsOisMultiline =
( _isMultiline
)
_fieldsOcomments =
( _lhsIcomments
)
_fieldsOforceMultiline =
( _lhsIforceMultiline
)
_fieldsOppconf =
( _lhsIppconf
)
(_fieldsIcomments, _fieldsIcopy, _fieldsIisMultiline, _fieldsIisNil, _fieldsIpretty) =
fields_ _fieldsOcomments _fieldsOforceMultiline _fieldsOindent _fieldsOppconf _fieldsOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_BinOpExpr
:: T_BinOp
-> T_MExpr
-> T_MExpr
-> T_Expr
sem_Expr_BinOpExpr op_ left_ right_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOendsWithPrefixExpression :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOisMultiline :: Bool
_leftOparentOperatorPrecedence :: OperatorLevel
_rightOparentOperatorPrecedence :: OperatorLevel
_leftOparentOperatorAssociative :: Bool
_rightOparentOperatorAssociative :: Bool
_lhsOisAssociative :: Bool
_lhsOisLiteral :: Bool
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_opOcomments :: ([MToken])
_opOindent :: Int
_opOppconf :: PrettyPrintConfig
_leftOcomments :: ([MToken])
_leftOforceMultiline :: Bool
_leftOindent :: Int
_leftOppconf :: PrettyPrintConfig
_rightOcomments :: ([MToken])
_rightOforceMultiline :: Bool
_rightOindent :: Int
_rightOppconf :: PrettyPrintConfig
_opIcomments :: ([MToken])
_opIcopy :: BinOp
_opIisAssociative :: Bool
_opIisMultiline :: Bool
_opIprecedence :: OperatorLevel
_opIpretty :: Doc
_leftIcomments :: ([MToken])
_leftIcopy :: MExpr
_leftIendsWithPrefixExpression :: Bool
_leftIisAssociative :: Bool
_leftIisLiteral :: Bool
_leftIisMultiline :: Bool
_leftIpos :: Region
_leftIprecedence :: OperatorLevel
_leftIpretty :: Doc
_rightIcomments :: ([MToken])
_rightIcopy :: MExpr
_rightIendsWithPrefixExpression :: Bool
_rightIisAssociative :: Bool
_rightIisLiteral :: Bool
_rightIisMultiline :: Bool
_rightIpos :: Region
_rightIprecedence :: OperatorLevel
_rightIpretty :: Doc
_lhsOpretty =
( _leftIpretty <-> _opIpretty <-> _rightIpretty
)
_lhsOendsWithPrefixExpression =
( _rightIendsWithPrefixExpression
)
_lhsOprecedence =
( min _opIprecedence $ min _leftIprecedence _rightIprecedence
)
_lhsOisMultiline =
( _leftIisMultiline || _rightIisMultiline
)
_leftOparentOperatorPrecedence =
( _opIprecedence
)
_rightOparentOperatorPrecedence =
( _opIprecedence
)
_leftOparentOperatorAssociative =
( _opIisAssociative
)
_rightOparentOperatorAssociative =
( _opIisAssociative
)
_lhsOisAssociative =
( _opIisAssociative && _leftIisAssociative && _rightIisAssociative
)
_lhsOisLiteral =
( ((\_ _ -> False) _leftIisLiteral _rightIisLiteral)
)
_copy =
( BinOpExpr _opIcopy _leftIcopy _rightIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _rightIcomments
)
_opOcomments =
( _lhsIcomments
)
_opOindent =
( _lhsIindent
)
_opOppconf =
( _lhsIppconf
)
_leftOcomments =
( _opIcomments
)
_leftOforceMultiline =
( _lhsIforceMultiline
)
_leftOindent =
( _lhsIindent
)
_leftOppconf =
( _lhsIppconf
)
_rightOcomments =
( _leftIcomments
)
_rightOforceMultiline =
( _lhsIforceMultiline
)
_rightOindent =
( _lhsIindent
)
_rightOppconf =
( _lhsIppconf
)
(_opIcomments, _opIcopy, _opIisAssociative, _opIisMultiline, _opIprecedence, _opIpretty) =
op_ _opOcomments _opOindent _opOppconf
(_leftIcomments, _leftIcopy, _leftIendsWithPrefixExpression, _leftIisAssociative, _leftIisLiteral, _leftIisMultiline, _leftIpos, _leftIprecedence, _leftIpretty) =
left_ _leftOcomments _leftOforceMultiline _leftOindent _leftOparentOperatorAssociative _leftOparentOperatorPrecedence _leftOppconf
(_rightIcomments, _rightIcopy, _rightIendsWithPrefixExpression, _rightIisAssociative, _rightIisLiteral, _rightIisMultiline, _rightIpos, _rightIprecedence, _rightIpretty) =
right_ _rightOcomments _rightOforceMultiline _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_Expr_UnOpExpr
:: T_UnOp
-> T_MExpr
-> T_Expr
sem_Expr_UnOpExpr op_ right_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOprecedence :: OperatorLevel
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_rightOparentOperatorPrecedence :: OperatorLevel
_lhsOisAssociative :: Bool
_lhsOisLiteral :: Bool
_lhsOcopy :: Expr
_lhsOcomments :: ([MToken])
_opOcomments :: ([MToken])
_opOindent :: Int
_opOppconf :: PrettyPrintConfig
_rightOcomments :: ([MToken])
_rightOforceMultiline :: Bool
_rightOindent :: Int
_rightOparentOperatorAssociative :: Bool
_rightOppconf :: PrettyPrintConfig
_opIcomments :: ([MToken])
_opIcopy :: UnOp
_opIisMultiline :: Bool
_opIpretty :: Doc
_rightIcomments :: ([MToken])
_rightIcopy :: MExpr
_rightIendsWithPrefixExpression :: Bool
_rightIisAssociative :: Bool
_rightIisLiteral :: Bool
_rightIisMultiline :: Bool
_rightIpos :: Region
_rightIprecedence :: OperatorLevel
_rightIpretty :: Doc
_lhsOpretty =
( _opIpretty <> _rightIpretty
)
_lhsOprecedence =
( min _rightIprecedence OperatorLevel7
)
_lhsOendsWithPrefixExpression =
( _rightIendsWithPrefixExpression
)
_lhsOisMultiline =
( _opIisMultiline || _rightIisMultiline
)
_rightOparentOperatorPrecedence =
( OperatorLevel7
)
_lhsOisAssociative =
( _rightIisAssociative
)
_lhsOisLiteral =
( _rightIisLiteral
)
_copy =
( UnOpExpr _opIcopy _rightIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _rightIcomments
)
_opOcomments =
( _lhsIcomments
)
_opOindent =
( _lhsIindent
)
_opOppconf =
( _lhsIppconf
)
_rightOcomments =
( _opIcomments
)
_rightOforceMultiline =
( _lhsIforceMultiline
)
_rightOindent =
( _lhsIindent
)
_rightOparentOperatorAssociative =
( _lhsIparentOperatorAssociative
)
_rightOppconf =
( _lhsIppconf
)
(_opIcomments, _opIcopy, _opIisMultiline, _opIpretty) =
op_ _opOcomments _opOindent _opOppconf
(_rightIcomments, _rightIcopy, _rightIendsWithPrefixExpression, _rightIisAssociative, _rightIisLiteral, _rightIisMultiline, _rightIpos, _rightIprecedence, _rightIpretty) =
right_ _rightOcomments _rightOforceMultiline _rightOindent _rightOparentOperatorAssociative _rightOparentOperatorPrecedence _rightOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
-- ExprSuffixList ----------------------------------------------
-- cata
sem_ExprSuffixList
:: ExprSuffixList
-> T_ExprSuffixList
sem_ExprSuffixList list =
(Prelude.foldr sem_ExprSuffixList_Cons sem_ExprSuffixList_Nil (Prelude.map sem_PFExprSuffix list))
-- semantic domain
type T_ExprSuffixList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), ExprSuffixList, Bool, Bool, OperatorLevel, Doc)
data Inh_ExprSuffixList = Inh_ExprSuffixList {comments_Inh_ExprSuffixList :: ([MToken]), forceMultiline_Inh_ExprSuffixList :: Bool, indent_Inh_ExprSuffixList :: Int, ppconf_Inh_ExprSuffixList :: PrettyPrintConfig}
data Syn_ExprSuffixList = Syn_ExprSuffixList {comments_Syn_ExprSuffixList :: ([MToken]), copy_Syn_ExprSuffixList :: ExprSuffixList, isAssociative_Syn_ExprSuffixList :: Bool, isMultiline_Syn_ExprSuffixList :: Bool, precedence_Syn_ExprSuffixList :: OperatorLevel, pretty_Syn_ExprSuffixList :: Doc}
wrap_ExprSuffixList
:: T_ExprSuffixList
-> Inh_ExprSuffixList
-> Syn_ExprSuffixList
wrap_ExprSuffixList sem (Inh_ExprSuffixList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_ExprSuffixList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
)
sem_ExprSuffixList_Cons
:: T_PFExprSuffix
-> T_ExprSuffixList
-> T_ExprSuffixList
sem_ExprSuffixList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: ExprSuffixList
_lhsOcomments :: ([MToken])
_hdOcomments :: ([MToken])
_hdOforceMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOcomments :: ([MToken])
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_hdIcomments :: ([MToken])
_hdIcopy :: PFExprSuffix
_hdIisAssociative :: Bool
_hdIisMultiline :: Bool
_hdIprecedence :: OperatorLevel
_hdIpretty :: Doc
_tlIcomments :: ([MToken])
_tlIcopy :: ExprSuffixList
_tlIisAssociative :: Bool
_tlIisMultiline :: Bool
_tlIprecedence :: OperatorLevel
_tlIpretty :: Doc
_lhsOpretty =
( _hdIpretty <> _tlIpretty
)
_lhsOisMultiline =
( _hdIisMultiline || _tlIisMultiline
)
_lhsOisAssociative =
( _hdIisAssociative && _tlIisAssociative
)
_lhsOprecedence =
( (min _hdIprecedence _tlIprecedence)
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _tlIcomments
)
_hdOcomments =
( _lhsIcomments
)
_hdOforceMultiline =
( _lhsIforceMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOcomments =
( _hdIcomments
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
(_hdIcomments, _hdIcopy, _hdIisAssociative, _hdIisMultiline, _hdIprecedence, _hdIpretty) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
(_tlIcomments, _tlIcopy, _tlIisAssociative, _tlIisMultiline, _tlIprecedence, _tlIpretty) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_ExprSuffixList_Nil :: T_ExprSuffixList
sem_ExprSuffixList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: ExprSuffixList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
-- Field -------------------------------------------------------
-- cata
sem_Field
:: Field
-> T_Field
sem_Field (ExprField _key _value _sep) =
(sem_Field_ExprField (sem_MExpr _key) (sem_MExpr _value) (sem_FieldSep _sep))
sem_Field (NamedField _key _value _sep) =
(sem_Field_NamedField _key (sem_MExpr _value) (sem_FieldSep _sep))
sem_Field (UnnamedField _value _sep) =
(sem_Field_UnnamedField (sem_MExpr _value) (sem_FieldSep _sep))
-- semantic domain
type T_Field =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), Field, Bool, Bool, Region, Doc)
data Inh_Field = Inh_Field {comments_Inh_Field :: ([MToken]), forceMultiline_Inh_Field :: Bool, indent_Inh_Field :: Int, ppconf_Inh_Field :: PrettyPrintConfig}
data Syn_Field = Syn_Field {comments_Syn_Field :: ([MToken]), copy_Syn_Field :: Field, isMultiline_Syn_Field :: Bool, isSemiColon_Syn_Field :: Bool, pos_Syn_Field :: Region, pretty_Syn_Field :: Doc}
wrap_Field
:: T_Field
-> Inh_Field
-> Syn_Field
wrap_Field sem (Inh_Field _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_Field _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpos _lhsOpretty)
)
sem_Field_ExprField
:: T_MExpr
-> T_MExpr
-> T_FieldSep
-> T_Field
sem_Field_ExprField key_ value_ sep_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_keyOparentOperatorPrecedence :: OperatorLevel
_keyOparentOperatorAssociative :: Bool
_valueOparentOperatorPrecedence :: OperatorLevel
_valueOparentOperatorAssociative :: Bool
_lhsOisSemiColon :: Bool
_lhsOcopy :: Field
_lhsOcomments :: ([MToken])
_lhsOpos :: Region
_keyOcomments :: ([MToken])
_keyOforceMultiline :: Bool
_keyOindent :: Int
_keyOppconf :: PrettyPrintConfig
_valueOcomments :: ([MToken])
_valueOforceMultiline :: Bool
_valueOindent :: Int
_valueOppconf :: PrettyPrintConfig
_sepOindent :: Int
_sepOppconf :: PrettyPrintConfig
_keyIcomments :: ([MToken])
_keyIcopy :: MExpr
_keyIendsWithPrefixExpression :: Bool
_keyIisAssociative :: Bool
_keyIisLiteral :: Bool
_keyIisMultiline :: Bool
_keyIpos :: Region
_keyIprecedence :: OperatorLevel
_keyIpretty :: Doc
_valueIcomments :: ([MToken])
_valueIcopy :: MExpr
_valueIendsWithPrefixExpression :: Bool
_valueIisAssociative :: Bool
_valueIisLiteral :: Bool
_valueIisMultiline :: Bool
_valueIpos :: Region
_valueIprecedence :: OperatorLevel
_valueIpretty :: Doc
_sepIcopy :: FieldSep
_sepIisMultiline :: Bool
_sepIisSemiColon :: Bool
_sepIpretty :: Doc
_lhsOpretty =
( brackets _lhsIppconf _keyIpretty <-> zchr '=' <-> _valueIpretty <> _sepIpretty
)
_lhsOisMultiline =
( True
)
_keyOparentOperatorPrecedence =
( TopLevelExpression
)
_keyOparentOperatorAssociative =
( True
)
_valueOparentOperatorPrecedence =
( TopLevelExpression
)
_valueOparentOperatorAssociative =
( True
)
_lhsOisSemiColon =
( _sepIisSemiColon
)
_copy =
( ExprField _keyIcopy _valueIcopy _sepIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _valueIcomments
)
_lhsOpos =
( _valueIpos
)
_keyOcomments =
( _lhsIcomments
)
_keyOforceMultiline =
( _lhsIforceMultiline
)
_keyOindent =
( _lhsIindent
)
_keyOppconf =
( _lhsIppconf
)
_valueOcomments =
( _keyIcomments
)
_valueOforceMultiline =
( _lhsIforceMultiline
)
_valueOindent =
( _lhsIindent
)
_valueOppconf =
( _lhsIppconf
)
_sepOindent =
( _lhsIindent
)
_sepOppconf =
( _lhsIppconf
)
(_keyIcomments, _keyIcopy, _keyIendsWithPrefixExpression, _keyIisAssociative, _keyIisLiteral, _keyIisMultiline, _keyIpos, _keyIprecedence, _keyIpretty) =
key_ _keyOcomments _keyOforceMultiline _keyOindent _keyOparentOperatorAssociative _keyOparentOperatorPrecedence _keyOppconf
(_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
(_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
sep_ _sepOindent _sepOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
)
)
sem_Field_NamedField
:: MToken
-> T_MExpr
-> T_FieldSep
-> T_Field
sem_Field_NamedField key_ value_ sep_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_valueOparentOperatorPrecedence :: OperatorLevel
_valueOparentOperatorAssociative :: Bool
_lhsOisSemiColon :: Bool
_lhsOcopy :: Field
_lhsOcomments :: ([MToken])
_lhsOpos :: Region
_valueOcomments :: ([MToken])
_valueOforceMultiline :: Bool
_valueOindent :: Int
_valueOppconf :: PrettyPrintConfig
_sepOindent :: Int
_sepOppconf :: PrettyPrintConfig
_valueIcomments :: ([MToken])
_valueIcopy :: MExpr
_valueIendsWithPrefixExpression :: Bool
_valueIisAssociative :: Bool
_valueIisLiteral :: Bool
_valueIisMultiline :: Bool
_valueIpos :: Region
_valueIprecedence :: OperatorLevel
_valueIpretty :: Doc
_sepIcopy :: FieldSep
_sepIisMultiline :: Bool
_sepIisSemiColon :: Bool
_sepIpretty :: Doc
_lhsOpretty =
( tok key_ <-> zchr '=' <-> _valueIpretty <> _sepIpretty
)
_lhsOisMultiline =
( True
)
_valueOparentOperatorPrecedence =
( TopLevelExpression
)
_valueOparentOperatorAssociative =
( True
)
_lhsOisSemiColon =
( _sepIisSemiColon
)
_copy =
( NamedField key_ _valueIcopy _sepIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _valueIcomments
)
_lhsOpos =
( _valueIpos
)
_valueOcomments =
( _lhsIcomments
)
_valueOforceMultiline =
( _lhsIforceMultiline
)
_valueOindent =
( _lhsIindent
)
_valueOppconf =
( _lhsIppconf
)
_sepOindent =
( _lhsIindent
)
_sepOppconf =
( _lhsIppconf
)
(_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
(_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
sep_ _sepOindent _sepOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
)
)
sem_Field_UnnamedField
:: T_MExpr
-> T_FieldSep
-> T_Field
sem_Field_UnnamedField value_ sep_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_valueOparentOperatorPrecedence :: OperatorLevel
_valueOparentOperatorAssociative :: Bool
_lhsOisSemiColon :: Bool
_lhsOcopy :: Field
_lhsOcomments :: ([MToken])
_lhsOpos :: Region
_valueOcomments :: ([MToken])
_valueOforceMultiline :: Bool
_valueOindent :: Int
_valueOppconf :: PrettyPrintConfig
_sepOindent :: Int
_sepOppconf :: PrettyPrintConfig
_valueIcomments :: ([MToken])
_valueIcopy :: MExpr
_valueIendsWithPrefixExpression :: Bool
_valueIisAssociative :: Bool
_valueIisLiteral :: Bool
_valueIisMultiline :: Bool
_valueIpos :: Region
_valueIprecedence :: OperatorLevel
_valueIpretty :: Doc
_sepIcopy :: FieldSep
_sepIisMultiline :: Bool
_sepIisSemiColon :: Bool
_sepIpretty :: Doc
_lhsOpretty =
( _valueIpretty <> _sepIpretty
)
_lhsOisMultiline =
( _valueIisMultiline || _sepIisMultiline
)
_valueOparentOperatorPrecedence =
( TopLevelExpression
)
_valueOparentOperatorAssociative =
( True
)
_lhsOisSemiColon =
( _sepIisSemiColon
)
_copy =
( UnnamedField _valueIcopy _sepIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _valueIcomments
)
_lhsOpos =
( _valueIpos
)
_valueOcomments =
( _lhsIcomments
)
_valueOforceMultiline =
( _lhsIforceMultiline
)
_valueOindent =
( _lhsIindent
)
_valueOppconf =
( _lhsIppconf
)
_sepOindent =
( _lhsIindent
)
_sepOppconf =
( _lhsIppconf
)
(_valueIcomments, _valueIcopy, _valueIendsWithPrefixExpression, _valueIisAssociative, _valueIisLiteral, _valueIisMultiline, _valueIpos, _valueIprecedence, _valueIpretty) =
value_ _valueOcomments _valueOforceMultiline _valueOindent _valueOparentOperatorAssociative _valueOparentOperatorPrecedence _valueOppconf
(_sepIcopy, _sepIisMultiline, _sepIisSemiColon, _sepIpretty) =
sep_ _sepOindent _sepOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpos, _lhsOpretty)
)
)
-- FieldList ---------------------------------------------------
-- cata
sem_FieldList
:: FieldList
-> T_FieldList
sem_FieldList list =
(Prelude.foldr sem_FieldList_Cons sem_FieldList_Nil (Prelude.map sem_Field list))
-- semantic domain
type T_FieldList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Bool
-> (([MToken]), FieldList, Bool, Bool, Doc)
data Inh_FieldList = Inh_FieldList {comments_Inh_FieldList :: ([MToken]), forceMultiline_Inh_FieldList :: Bool, indent_Inh_FieldList :: Int, ppconf_Inh_FieldList :: PrettyPrintConfig, someElementsInListAreMultiline_Inh_FieldList :: Bool}
data Syn_FieldList = Syn_FieldList {comments_Syn_FieldList :: ([MToken]), copy_Syn_FieldList :: FieldList, isMultiline_Syn_FieldList :: Bool, isNil_Syn_FieldList :: Bool, pretty_Syn_FieldList :: Doc}
wrap_FieldList
:: T_FieldList
-> Inh_FieldList
-> Syn_FieldList
wrap_FieldList sem (Inh_FieldList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline
in
(Syn_FieldList _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOisNil _lhsOpretty)
)
sem_FieldList_Cons
:: T_Field
-> T_FieldList
-> T_FieldList
sem_FieldList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIsomeElementsInListAreMultiline ->
( let
_lhsOpretty :: Doc
_lhsOisNil :: Bool
_tlOsomeElementsInListAreMultiline :: Bool
_hdOcomments :: ([MToken])
_tlOcomments :: ([MToken])
_lhsOcomments :: ([MToken])
_lhsOcopy :: FieldList
_lhsOisMultiline :: Bool
_hdOforceMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_hdIcomments :: ([MToken])
_hdIcopy :: Field
_hdIisMultiline :: Bool
_hdIisSemiColon :: Bool
_hdIpos :: Region
_hdIpretty :: Doc
_tlIcomments :: ([MToken])
_tlIcopy :: FieldList
_tlIisMultiline :: Bool
_tlIisNil :: Bool
_tlIpretty :: Doc
_lhsOpretty =
( if _isMultiline
then
renderMLComments _lhsIppconf _lhsIindent (fst _commentsBefore)
$+$ indent _lhsIppconf _lhsIindent _hdIpretty
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
$+$ _tlIpretty
else
_hdIpretty
`_optionalSpaceAfterSep` _tlIpretty
)
_lhsOisNil =
( False
)
_optionalSpaceAfterSep =
( if spaceAfterComma _lhsIppconf then (<->) else (<>)
)
_isMultiline =
( _lhsIforceMultiline
|| _hdIisMultiline
|| _tlIisMultiline
|| _lhsIsomeElementsInListAreMultiline
|| not (null $ fst _commentsBefore)
|| not (null $ fst _commentsAfter)
)
_tlOsomeElementsInListAreMultiline =
( _lhsIsomeElementsInListAreMultiline
|| _hdIisMultiline
|| not (null $ fst _commentsBefore)
|| not (null $ fst _commentsAfter)
)
_commentsBefore =
( span (\(MToken pos _) -> pos `before` _hdIpos) _lhsIcomments
)
_hdOcomments =
( snd _commentsBefore
)
_commentsAfter =
( span (\(MToken pos _) -> pos `beforeOrOnLine` _hdIpos) _hdIcomments
)
_tlOcomments =
( snd _commentsAfter
)
_lhsOcomments =
( _tlIcomments
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOisMultiline =
( _isMultiline
)
_hdOforceMultiline =
( _lhsIforceMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
(_hdIcomments, _hdIcopy, _hdIisMultiline, _hdIisSemiColon, _hdIpos, _hdIpretty) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
(_tlIcomments, _tlIcopy, _tlIisMultiline, _tlIisNil, _tlIpretty) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty)
)
)
sem_FieldList_Nil :: T_FieldList
sem_FieldList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIsomeElementsInListAreMultiline ->
( let
_lhsOpretty :: Doc
_lhsOisNil :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: FieldList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOisNil =
( True
)
_lhsOisMultiline =
( False
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOisNil, _lhsOpretty)
)
)
-- FieldSep ----------------------------------------------------
-- cata
sem_FieldSep
:: FieldSep
-> T_FieldSep
sem_FieldSep (CommaSep) =
(sem_FieldSep_CommaSep)
sem_FieldSep (SemicolonSep) =
(sem_FieldSep_SemicolonSep)
sem_FieldSep (NoSep) =
(sem_FieldSep_NoSep)
-- semantic domain
type T_FieldSep =
Int
-> PrettyPrintConfig
-> (FieldSep, Bool, Bool, Doc)
data Inh_FieldSep = Inh_FieldSep {indent_Inh_FieldSep :: Int, ppconf_Inh_FieldSep :: PrettyPrintConfig}
data Syn_FieldSep = Syn_FieldSep {copy_Syn_FieldSep :: FieldSep, isMultiline_Syn_FieldSep :: Bool, isSemiColon_Syn_FieldSep :: Bool, pretty_Syn_FieldSep :: Doc}
wrap_FieldSep
:: T_FieldSep
-> Inh_FieldSep
-> Syn_FieldSep
wrap_FieldSep sem (Inh_FieldSep _lhsIindent _lhsIppconf) =
( let
(_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty) = sem _lhsIindent _lhsIppconf
in
(Syn_FieldSep _lhsOcopy _lhsOisMultiline _lhsOisSemiColon _lhsOpretty)
)
sem_FieldSep_CommaSep :: T_FieldSep
sem_FieldSep_CommaSep =
( \_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisSemiColon :: Bool
_lhsOcopy :: FieldSep
_lhsOpretty =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ','
)
_lhsOisMultiline =
( False
)
_lhsOisSemiColon =
( False
)
_copy =
( CommaSep
)
_lhsOcopy =
( _copy
)
in
(_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
)
)
sem_FieldSep_SemicolonSep :: T_FieldSep
sem_FieldSep_SemicolonSep =
( \_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisSemiColon :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: FieldSep
_lhsOpretty =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty) <> zchr ';'
)
_lhsOisSemiColon =
( True
)
_lhsOisMultiline =
( True
)
_copy =
( SemicolonSep
)
_lhsOcopy =
( _copy
)
in
(_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
)
)
sem_FieldSep_NoSep :: T_FieldSep
sem_FieldSep_NoSep =
( \_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisSemiColon :: Bool
_lhsOcopy :: FieldSep
_lhsOpretty =
( empty
)
_lhsOisMultiline =
( False
)
_lhsOisSemiColon =
( False
)
_copy =
( NoSep
)
_lhsOcopy =
( _copy
)
in
(_lhsOcopy, _lhsOisMultiline, _lhsOisSemiColon, _lhsOpretty)
)
)
-- FuncName ----------------------------------------------------
-- cata
sem_FuncName
:: FuncName
-> T_FuncName
sem_FuncName (FuncName _names _meta) =
(sem_FuncName_FuncName _names _meta)
-- semantic domain
type T_FuncName =
([MToken])
-> Int
-> PrettyPrintConfig
-> (([MToken]), FuncName, Bool, Region, Doc)
data Inh_FuncName = Inh_FuncName {comments_Inh_FuncName :: ([MToken]), indent_Inh_FuncName :: Int, ppconf_Inh_FuncName :: PrettyPrintConfig}
data Syn_FuncName = Syn_FuncName {comments_Syn_FuncName :: ([MToken]), copy_Syn_FuncName :: FuncName, isMultiline_Syn_FuncName :: Bool, pos_Syn_FuncName :: Region, pretty_Syn_FuncName :: Doc}
wrap_FuncName
:: T_FuncName
-> Inh_FuncName
-> Syn_FuncName
wrap_FuncName sem (Inh_FuncName _lhsIcomments _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
in
(Syn_FuncName _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpos _lhsOpretty)
)
sem_FuncName_FuncName
:: ([MToken])
-> (Maybe MToken)
-> T_FuncName
sem_FuncName_FuncName names_ meta_ =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOpos :: Region
_lhsOcopy :: FuncName
_lhsOcomments :: ([MToken])
_lhsOpretty =
( printList tok "." names_ <> metaDoc meta_
)
_lhsOisMultiline =
( False
)
_lhsOpos =
( case meta_ of
Nothing -> _namesPos
Just name -> rgOr _namesPos (mpos name)
)
_namesPos =
( foldl1 rgOr $ map mpos names_
)
_copy =
( FuncName names_ meta_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
-- MElse -------------------------------------------------------
-- cata
sem_MElse
:: MElse
-> T_MElse
sem_MElse (MElse _pos _body) =
(sem_MElse_MElse _pos (sem_Block _body))
-- semantic domain
type T_MElse =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Region
-> (([MToken]), MElse, Bool, Bool, Region, Doc)
data Inh_MElse = Inh_MElse {comments_Inh_MElse :: ([MToken]), forceMultiline_Inh_MElse :: Bool, indent_Inh_MElse :: Int, ppconf_Inh_MElse :: PrettyPrintConfig, statRegion_Inh_MElse :: Region}
data Syn_MElse = Syn_MElse {comments_Syn_MElse :: ([MToken]), copy_Syn_MElse :: MElse, elsesExist_Syn_MElse :: Bool, isMultiline_Syn_MElse :: Bool, pos_Syn_MElse :: Region, pretty_Syn_MElse :: Doc}
wrap_MElse
:: T_MElse
-> Inh_MElse
-> Syn_MElse
wrap_MElse sem (Inh_MElse _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
in
(Syn_MElse _lhsOcomments _lhsOcopy _lhsOelsesExist _lhsOisMultiline _lhsOpos _lhsOpretty)
)
sem_MElse_MElse
:: Region
-> T_Block
-> T_MElse
sem_MElse_MElse pos_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_bodyOindent :: Int
_lhsOpos :: Region
_bodyOcomments :: ([MToken])
_lhsOelsesExist :: Bool
_lhsOcopy :: MElse
_lhsOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOpretty =
( indent _lhsIppconf _lhsIindent (zeroWidthText "else")
<-> _prettyCommentsAfter
$+$ _bodyIpretty
)
_lhsOisMultiline =
( _bodyIisMultiline
)
_bodyOindent =
( _lhsIindent + 1
)
_prettyCommentsAfter =
( renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
)
_commentsAfter =
( span (\(MToken pos _) -> pos `beforeOrOnLine` pos_) _lhsIcomments
)
_lhsOpos =
( pos_
)
_bodyOcomments =
( snd _commentsAfter
)
_lhsOelsesExist =
( False
)
_copy =
( MElse pos_ _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOelsesExist, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
-- MElseIf -----------------------------------------------------
-- cata
sem_MElseIf
:: MElseIf
-> T_MElseIf
sem_MElseIf (MElseIf _pos _elif) =
(sem_MElseIf_MElseIf _pos (sem_ElseIf _elif))
-- semantic domain
type T_MElseIf =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), MElseIf, Bool, Region, Doc)
data Inh_MElseIf = Inh_MElseIf {comments_Inh_MElseIf :: ([MToken]), forceMultiline_Inh_MElseIf :: Bool, indent_Inh_MElseIf :: Int, ppconf_Inh_MElseIf :: PrettyPrintConfig}
data Syn_MElseIf = Syn_MElseIf {comments_Syn_MElseIf :: ([MToken]), copy_Syn_MElseIf :: MElseIf, isMultiline_Syn_MElseIf :: Bool, pos_Syn_MElseIf :: Region, pretty_Syn_MElseIf :: Doc}
wrap_MElseIf
:: T_MElseIf
-> Inh_MElseIf
-> Syn_MElseIf
wrap_MElseIf sem (Inh_MElseIf _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_MElseIf _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpos _lhsOpretty)
)
sem_MElseIf_MElseIf
:: Region
-> T_ElseIf
-> T_MElseIf
sem_MElseIf_MElseIf pos_ elif_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpos :: Region
_lhsOisMultiline :: Bool
_lhsOcopy :: MElseIf
_lhsOcomments :: ([MToken])
_lhsOpretty :: Doc
_elifOcomments :: ([MToken])
_elifOforceMultiline :: Bool
_elifOindent :: Int
_elifOppconf :: PrettyPrintConfig
_elifIcomments :: ([MToken])
_elifIcopy :: ElseIf
_elifIisMultiline :: Bool
_elifIpretty :: Doc
_lhsOpos =
( pos_
)
_lhsOisMultiline =
( _elifIisMultiline
)
_copy =
( MElseIf pos_ _elifIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _elifIcomments
)
_lhsOpretty =
( _elifIpretty
)
_elifOcomments =
( _lhsIcomments
)
_elifOforceMultiline =
( _lhsIforceMultiline
)
_elifOindent =
( _lhsIindent
)
_elifOppconf =
( _lhsIppconf
)
(_elifIcomments, _elifIcopy, _elifIisMultiline, _elifIpretty) =
elif_ _elifOcomments _elifOforceMultiline _elifOindent _elifOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpos, _lhsOpretty)
)
)
-- MExpr -------------------------------------------------------
-- cata
sem_MExpr
:: MExpr
-> T_MExpr
sem_MExpr (MExpr _pos _expr) =
(sem_MExpr_MExpr _pos (sem_Expr _expr))
-- semantic domain
type T_MExpr =
([MToken])
-> Bool
-> Int
-> Bool
-> OperatorLevel
-> PrettyPrintConfig
-> (([MToken]), MExpr, Bool, Bool, Bool, Bool, Region, OperatorLevel, Doc)
data Inh_MExpr = Inh_MExpr {comments_Inh_MExpr :: ([MToken]), forceMultiline_Inh_MExpr :: Bool, indent_Inh_MExpr :: Int, parentOperatorAssociative_Inh_MExpr :: Bool, parentOperatorPrecedence_Inh_MExpr :: OperatorLevel, ppconf_Inh_MExpr :: PrettyPrintConfig}
data Syn_MExpr = Syn_MExpr {comments_Syn_MExpr :: ([MToken]), copy_Syn_MExpr :: MExpr, endsWithPrefixExpression_Syn_MExpr :: Bool, isAssociative_Syn_MExpr :: Bool, isLiteral_Syn_MExpr :: Bool, isMultiline_Syn_MExpr :: Bool, pos_Syn_MExpr :: Region, precedence_Syn_MExpr :: OperatorLevel, pretty_Syn_MExpr :: Doc}
wrap_MExpr
:: T_MExpr
-> Inh_MExpr
-> Syn_MExpr
wrap_MExpr sem (Inh_MExpr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf
in
(Syn_MExpr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty)
)
sem_MExpr_MExpr
:: Region
-> T_Expr
-> T_MExpr
sem_MExpr_MExpr pos_ expr_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf ->
( let
_lhsOpos :: Region
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_exprOstatRegion :: Region
_lhsOisAssociative :: Bool
_lhsOisLiteral :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: MExpr
_lhsOcomments :: ([MToken])
_lhsOpretty :: Doc
_exprOcomments :: ([MToken])
_exprOforceMultiline :: Bool
_exprOindent :: Int
_exprOparentOperatorAssociative :: Bool
_exprOparentOperatorPrecedence :: OperatorLevel
_exprOppconf :: PrettyPrintConfig
_exprIcomments :: ([MToken])
_exprIcopy :: Expr
_exprIendsWithPrefixExpression :: Bool
_exprIisAssociative :: Bool
_exprIisLiteral :: Bool
_exprIisMultiline :: Bool
_exprIprecedence :: OperatorLevel
_exprIpretty :: Doc
_lhsOpos =
( pos_
)
_lhsOendsWithPrefixExpression =
( _exprIendsWithPrefixExpression
)
_lhsOisMultiline =
( _exprIisMultiline
)
_exprOstatRegion =
( pos_
)
_lhsOisAssociative =
( _exprIisAssociative
)
_lhsOisLiteral =
( _exprIisLiteral
)
_lhsOprecedence =
( _exprIprecedence
)
_copy =
( MExpr pos_ _exprIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _exprIcomments
)
_lhsOpretty =
( _exprIpretty
)
_exprOcomments =
( _lhsIcomments
)
_exprOforceMultiline =
( _lhsIforceMultiline
)
_exprOindent =
( _lhsIindent
)
_exprOparentOperatorAssociative =
( _lhsIparentOperatorAssociative
)
_exprOparentOperatorPrecedence =
( _lhsIparentOperatorPrecedence
)
_exprOppconf =
( _lhsIppconf
)
(_exprIcomments, _exprIcopy, _exprIendsWithPrefixExpression, _exprIisAssociative, _exprIisLiteral, _exprIisMultiline, _exprIprecedence, _exprIpretty) =
expr_ _exprOcomments _exprOforceMultiline _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf _exprOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
)
)
-- MExprList ---------------------------------------------------
-- cata
sem_MExprList
:: MExprList
-> T_MExprList
sem_MExprList list =
(Prelude.foldr sem_MExprList_Cons sem_MExprList_Nil (Prelude.map sem_MExpr list))
-- semantic domain
type T_MExprList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Bool
-> (([MToken]), MExprList, Bool, Bool, Bool, Region, OperatorLevel, Doc)
data Inh_MExprList = Inh_MExprList {comments_Inh_MExprList :: ([MToken]), forceMultiline_Inh_MExprList :: Bool, indent_Inh_MExprList :: Int, ppconf_Inh_MExprList :: PrettyPrintConfig, someElementsInListAreMultiline_Inh_MExprList :: Bool}
data Syn_MExprList = Syn_MExprList {comments_Syn_MExprList :: ([MToken]), copy_Syn_MExprList :: MExprList, isAssociative_Syn_MExprList :: Bool, isLast_Syn_MExprList :: Bool, isMultiline_Syn_MExprList :: Bool, pos_Syn_MExprList :: Region, precedence_Syn_MExprList :: OperatorLevel, pretty_Syn_MExprList :: Doc}
wrap_MExprList
:: T_MExprList
-> Inh_MExprList
-> Syn_MExprList
wrap_MExprList sem (Inh_MExprList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIsomeElementsInListAreMultiline
in
(Syn_MExprList _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLast _lhsOisMultiline _lhsOpos _lhsOprecedence _lhsOpretty)
)
sem_MExprList_Cons
:: T_MExpr
-> T_MExprList
-> T_MExprList
sem_MExprList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIsomeElementsInListAreMultiline ->
( let
_lhsOpretty :: Doc
_hdOcomments :: ([MToken])
_tlOcomments :: ([MToken])
_lhsOcomments :: ([MToken])
_lhsOpos :: Region
_lhsOisLast :: Bool
_hdOparentOperatorPrecedence :: OperatorLevel
_hdOparentOperatorAssociative :: Bool
_tlOsomeElementsInListAreMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: MExprList
_lhsOisMultiline :: Bool
_hdOforceMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_hdIcomments :: ([MToken])
_hdIcopy :: MExpr
_hdIendsWithPrefixExpression :: Bool
_hdIisAssociative :: Bool
_hdIisLiteral :: Bool
_hdIisMultiline :: Bool
_hdIpos :: Region
_hdIprecedence :: OperatorLevel
_hdIpretty :: Doc
_tlIcomments :: ([MToken])
_tlIcopy :: MExprList
_tlIisAssociative :: Bool
_tlIisLast :: Bool
_tlIisMultiline :: Bool
_tlIpos :: Region
_tlIprecedence :: OperatorLevel
_tlIpretty :: Doc
_lhsOpretty =
( if _isMultiline then _prettyMultiLine else _prettySingleLine
)
_prettySingleLine =
( _hdIpretty
<> _comma
<> _tlIpretty
)
_prettyMultiLine =
( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBeforeLine)
$+$ indent _lhsIppconf _lhsIindent _hdIpretty
<> _comma
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
$+$ _tlIpretty
)
_comma =
( if _tlIisLast
then empty
else
(if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if not _isMultiline && spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_commentsBeforeLine =
( span (\(MToken pos' _) -> pos' `before` _hdIpos) _lhsIcomments
)
_hdOcomments =
( snd _commentsBeforeLine
)
_commentsAfter =
( span (\(MToken pos' _) -> pos' `before` _tlIpos) _hdIcomments
)
_tlOcomments =
( snd _commentsAfter
)
_lhsOcomments =
( _tlIcomments
)
_lhsOpos =
( _hdIpos
)
_lhsOisLast =
( False
)
_hdOparentOperatorPrecedence =
( TopLevelExpression
)
_hdOparentOperatorAssociative =
( True
)
_isMultiline =
( _lhsIforceMultiline
|| not (null $ fst _commentsBeforeLine)
|| not (null $ fst _commentsAfter)
|| _lhsIsomeElementsInListAreMultiline
|| _hdIisMultiline
|| _tlIisMultiline
)
_tlOsomeElementsInListAreMultiline =
( _lhsIsomeElementsInListAreMultiline
|| _hdIisMultiline
|| not (null $ fst _commentsBeforeLine)
|| not (null $ fst _commentsAfter)
)
_lhsOisAssociative =
( _hdIisAssociative && _tlIisAssociative
)
_lhsOprecedence =
( (min _hdIprecedence _tlIprecedence)
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOisMultiline =
( _isMultiline
)
_hdOforceMultiline =
( _lhsIforceMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
(_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIisAssociative, _hdIisLiteral, _hdIisMultiline, _hdIpos, _hdIprecedence, _hdIpretty) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOparentOperatorAssociative _hdOparentOperatorPrecedence _hdOppconf
(_tlIcomments, _tlIcopy, _tlIisAssociative, _tlIisLast, _tlIisMultiline, _tlIpos, _tlIprecedence, _tlIpretty) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOsomeElementsInListAreMultiline
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
)
)
sem_MExprList_Nil :: T_MExprList
sem_MExprList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIsomeElementsInListAreMultiline ->
( let
_lhsOpretty :: Doc
_lhsOpos :: Region
_lhsOisMultiline :: Bool
_lhsOisLast :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: MExprList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOpos =
( emptyRg
)
_lhsOisMultiline =
( False
)
_lhsOisLast =
( True
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLast, _lhsOisMultiline, _lhsOpos, _lhsOprecedence, _lhsOpretty)
)
)
-- MStat -------------------------------------------------------
-- cata
sem_MStat
:: MStat
-> T_MStat
sem_MStat (MStat _pos _stat) =
(sem_MStat_MStat _pos (sem_Stat _stat))
-- semantic domain
type T_MStat =
([MToken])
-> Bool
-> Int
-> Bool
-> PrettyPrintConfig
-> Bool
-> (([MToken]), MStat, Bool, Bool, Region, Doc, Bool, Int)
data Inh_MStat = Inh_MStat {comments_Inh_MStat :: ([MToken]), forceMultiline_Inh_MStat :: Bool, indent_Inh_MStat :: Int, isLastStatement_Inh_MStat :: Bool, ppconf_Inh_MStat :: PrettyPrintConfig, wouldBeAmbiguousWithoutSemicolon_Inh_MStat :: Bool}
data Syn_MStat = Syn_MStat {comments_Syn_MStat :: ([MToken]), copy_Syn_MStat :: MStat, endsWithPrefixExpression_Syn_MStat :: Bool, isMultiline_Syn_MStat :: Bool, pos_Syn_MStat :: Region, pretty_Syn_MStat :: Doc, startsWithExprPrefixExpression_Syn_MStat :: Bool, statementCount_Syn_MStat :: Int}
wrap_MStat
:: T_MStat
-> Inh_MStat
-> Syn_MStat
wrap_MStat sem (Inh_MStat _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIwouldBeAmbiguousWithoutSemicolon) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpos, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIwouldBeAmbiguousWithoutSemicolon
in
(Syn_MStat _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisMultiline _lhsOpos _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOstatementCount)
)
sem_MStat_MStat
:: Region
-> T_Stat
-> T_MStat
sem_MStat_MStat pos_ stat_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpos :: Region
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_statOstatRegion :: Region
_statOwouldBeAmbiguousWithoutSemicolon :: Bool
_lhsOstatementCount :: Int
_lhsOcopy :: MStat
_lhsOcomments :: ([MToken])
_lhsOpretty :: Doc
_statOcomments :: ([MToken])
_statOforceMultiline :: Bool
_statOindent :: Int
_statOisLastStatement :: Bool
_statOppconf :: PrettyPrintConfig
_statIcomments :: ([MToken])
_statIcopy :: Stat
_statIendsWithPrefixExpression :: Bool
_statIisMultiline :: Bool
_statIpretty :: Doc
_statIstartsWithExprPrefixExpression :: Bool
_lhsOpos =
( pos_
)
_lhsOstartsWithExprPrefixExpression =
( _statIstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( _statIendsWithPrefixExpression
)
_lhsOisMultiline =
( _statIisMultiline
)
_statOstatRegion =
( pos_
)
_statOwouldBeAmbiguousWithoutSemicolon =
( _lhsIwouldBeAmbiguousWithoutSemicolon
)
_lhsOstatementCount =
( 1
)
_copy =
( MStat pos_ _statIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _statIcomments
)
_lhsOpretty =
( _statIpretty
)
_statOcomments =
( _lhsIcomments
)
_statOforceMultiline =
( _lhsIforceMultiline
)
_statOindent =
( _lhsIindent
)
_statOisLastStatement =
( _lhsIisLastStatement
)
_statOppconf =
( _lhsIppconf
)
(_statIcomments, _statIcopy, _statIendsWithPrefixExpression, _statIisMultiline, _statIpretty, _statIstartsWithExprPrefixExpression) =
stat_ _statOcomments _statOforceMultiline _statOindent _statOisLastStatement _statOppconf _statOstatRegion _statOwouldBeAmbiguousWithoutSemicolon
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpos, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
)
)
-- MStatList ---------------------------------------------------
-- cata
sem_MStatList
:: MStatList
-> T_MStatList
sem_MStatList list =
(Prelude.foldr sem_MStatList_Cons sem_MStatList_Nil (Prelude.map sem_MStat list))
-- semantic domain
type T_MStatList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> Region
-> (([MToken]), MStatList, Bool, Bool, Doc, Bool, Int)
data Inh_MStatList = Inh_MStatList {comments_Inh_MStatList :: ([MToken]), forceMultiline_Inh_MStatList :: Bool, indent_Inh_MStatList :: Int, ppconf_Inh_MStatList :: PrettyPrintConfig, statRegion_Inh_MStatList :: Region}
data Syn_MStatList = Syn_MStatList {comments_Syn_MStatList :: ([MToken]), copy_Syn_MStatList :: MStatList, isLast_Syn_MStatList :: Bool, isMultiline_Syn_MStatList :: Bool, pretty_Syn_MStatList :: Doc, startsWithExprPrefixExpression_Syn_MStatList :: Bool, statementCount_Syn_MStatList :: Int}
wrap_MStatList
:: T_MStatList
-> Inh_MStatList
-> Syn_MStatList
wrap_MStatList sem (Inh_MStatList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf _lhsIstatRegion
in
(Syn_MStatList _lhsOcomments _lhsOcopy _lhsOisLast _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOstatementCount)
)
sem_MStatList_Cons
:: T_MStat
-> T_MStatList
-> T_MStatList
sem_MStatList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOisLast :: Bool
_hdOcomments :: ([MToken])
_tlOcomments :: ([MToken])
_lhsOcomments :: ([MToken])
_hdOisLastStatement :: Bool
_hdOwouldBeAmbiguousWithoutSemicolon :: Bool
_hdOforceMultiline :: Bool
_lhsOstatementCount :: Int
_lhsOcopy :: MStatList
_lhsOisMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_tlOstatRegion :: Region
_hdIcomments :: ([MToken])
_hdIcopy :: MStat
_hdIendsWithPrefixExpression :: Bool
_hdIisMultiline :: Bool
_hdIpos :: Region
_hdIpretty :: Doc
_hdIstartsWithExprPrefixExpression :: Bool
_hdIstatementCount :: Int
_tlIcomments :: ([MToken])
_tlIcopy :: MStatList
_tlIisLast :: Bool
_tlIisMultiline :: Bool
_tlIpretty :: Doc
_tlIstartsWithExprPrefixExpression :: Bool
_tlIstatementCount :: Int
_lhsOpretty =
( renderMLComments _lhsIppconf _lhsIindent (fst _commentsBeforeLine)
$+$ indent _lhsIppconf _lhsIindent _hdIpretty
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfter)
<> _addNewline
$+$ _tlIpretty
)
_lhsOstartsWithExprPrefixExpression =
( _hdIstartsWithExprPrefixExpression
)
_lhsOisLast =
( False
)
_isMultiline =
( _hdIisMultiline
|| _tlIisMultiline
|| not (null $ fst _commentsBeforeLine)
|| not (null $ fst _commentsAfter)
)
_addNewline =
( if not _tlIisLast && _hdIisMultiline then zchr '\n' else empty
)
_commentsBeforeLine =
( span (\(MToken pos' _) -> pos' `before` _hdIpos) _lhsIcomments
)
_hdOcomments =
( snd _commentsBeforeLine
)
_commentsAfter =
( span (\(MToken pos' _) -> pos' `beforeOrOnLine` _hdIpos) _hdIcomments
)
_tlOcomments =
( snd _commentsAfter
)
_lhsOcomments =
( _tlIcomments
)
_hdOisLastStatement =
( _tlIisLast
)
_hdOwouldBeAmbiguousWithoutSemicolon =
( _hdIendsWithPrefixExpression && _tlIstartsWithExprPrefixExpression
)
_hdOforceMultiline =
( commentsForceMultiline $ fst _commentsBeforeLine
)
_lhsOstatementCount =
( _hdIstatementCount + _tlIstatementCount
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOisMultiline =
( _isMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
_tlOstatRegion =
( _lhsIstatRegion
)
(_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIisMultiline, _hdIpos, _hdIpretty, _hdIstartsWithExprPrefixExpression, _hdIstatementCount) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOisLastStatement _hdOppconf _hdOwouldBeAmbiguousWithoutSemicolon
(_tlIcomments, _tlIcopy, _tlIisLast, _tlIisMultiline, _tlIpretty, _tlIstartsWithExprPrefixExpression, _tlIstatementCount) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf _tlOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
)
)
sem_MStatList_Nil :: T_MStatList
sem_MStatList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf
_lhsIstatRegion ->
( let
_lhsOpretty :: Doc
_lhsOstatementCount :: Int
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisLast :: Bool
_lhsOcopy :: MStatList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOstatementCount =
( 0
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisLast =
( True
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOstatementCount)
)
)
-- MaybeMExpr --------------------------------------------------
-- cata
sem_MaybeMExpr
:: MaybeMExpr
-> T_MaybeMExpr
sem_MaybeMExpr (Prelude.Just x) =
(sem_MaybeMExpr_Just (sem_MExpr x))
sem_MaybeMExpr Prelude.Nothing =
sem_MaybeMExpr_Nothing
-- semantic domain
type T_MaybeMExpr =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), MaybeMExpr, Bool, Bool, Bool, Bool, OperatorLevel, Doc)
data Inh_MaybeMExpr = Inh_MaybeMExpr {comments_Inh_MaybeMExpr :: ([MToken]), forceMultiline_Inh_MaybeMExpr :: Bool, indent_Inh_MaybeMExpr :: Int, ppconf_Inh_MaybeMExpr :: PrettyPrintConfig}
data Syn_MaybeMExpr = Syn_MaybeMExpr {comments_Syn_MaybeMExpr :: ([MToken]), copy_Syn_MaybeMExpr :: MaybeMExpr, endsWithPrefixExpression_Syn_MaybeMExpr :: Bool, isAssociative_Syn_MaybeMExpr :: Bool, isDefined_Syn_MaybeMExpr :: Bool, isMultiline_Syn_MaybeMExpr :: Bool, precedence_Syn_MaybeMExpr :: OperatorLevel, pretty_Syn_MaybeMExpr :: Doc}
wrap_MaybeMExpr
:: T_MaybeMExpr
-> Inh_MaybeMExpr
-> Syn_MaybeMExpr
wrap_MaybeMExpr sem (Inh_MaybeMExpr _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_MaybeMExpr _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisAssociative _lhsOisDefined _lhsOisMultiline _lhsOprecedence _lhsOpretty)
)
sem_MaybeMExpr_Just
:: T_MExpr
-> T_MaybeMExpr
sem_MaybeMExpr_Just just_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisDefined :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_justOparentOperatorPrecedence :: OperatorLevel
_justOparentOperatorAssociative :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: MaybeMExpr
_lhsOcomments :: ([MToken])
_justOcomments :: ([MToken])
_justOforceMultiline :: Bool
_justOindent :: Int
_justOppconf :: PrettyPrintConfig
_justIcomments :: ([MToken])
_justIcopy :: MExpr
_justIendsWithPrefixExpression :: Bool
_justIisAssociative :: Bool
_justIisLiteral :: Bool
_justIisMultiline :: Bool
_justIpos :: Region
_justIprecedence :: OperatorLevel
_justIpretty :: Doc
_lhsOpretty =
( _justIpretty
)
_lhsOisDefined =
( True
)
_lhsOendsWithPrefixExpression =
( _justIendsWithPrefixExpression
)
_lhsOisMultiline =
( _justIisMultiline
)
_justOparentOperatorPrecedence =
( TopLevelExpression
)
_justOparentOperatorAssociative =
( True
)
_lhsOisAssociative =
( _justIisAssociative
)
_lhsOprecedence =
( _justIprecedence
)
_copy =
( Just _justIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _justIcomments
)
_justOcomments =
( _lhsIcomments
)
_justOforceMultiline =
( _lhsIforceMultiline
)
_justOindent =
( _lhsIindent
)
_justOppconf =
( _lhsIppconf
)
(_justIcomments, _justIcopy, _justIendsWithPrefixExpression, _justIisAssociative, _justIisLiteral, _justIisMultiline, _justIpos, _justIprecedence, _justIpretty) =
just_ _justOcomments _justOforceMultiline _justOindent _justOparentOperatorAssociative _justOparentOperatorPrecedence _justOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_MaybeMExpr_Nothing :: T_MaybeMExpr
sem_MaybeMExpr_Nothing =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisDefined :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: MaybeMExpr
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOisDefined =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( Nothing
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisAssociative, _lhsOisDefined, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
-- PFExprSuffix ------------------------------------------------
-- cata
sem_PFExprSuffix
:: PFExprSuffix
-> T_PFExprSuffix
sem_PFExprSuffix (Call _args) =
(sem_PFExprSuffix_Call (sem_Args _args))
sem_PFExprSuffix (MetaCall _fn _args) =
(sem_PFExprSuffix_MetaCall _fn (sem_Args _args))
sem_PFExprSuffix (ExprIndex _index) =
(sem_PFExprSuffix_ExprIndex (sem_MExpr _index))
sem_PFExprSuffix (DotIndex _index) =
(sem_PFExprSuffix_DotIndex _index)
-- semantic domain
type T_PFExprSuffix =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), PFExprSuffix, Bool, Bool, OperatorLevel, Doc)
data Inh_PFExprSuffix = Inh_PFExprSuffix {comments_Inh_PFExprSuffix :: ([MToken]), forceMultiline_Inh_PFExprSuffix :: Bool, indent_Inh_PFExprSuffix :: Int, ppconf_Inh_PFExprSuffix :: PrettyPrintConfig}
data Syn_PFExprSuffix = Syn_PFExprSuffix {comments_Syn_PFExprSuffix :: ([MToken]), copy_Syn_PFExprSuffix :: PFExprSuffix, isAssociative_Syn_PFExprSuffix :: Bool, isMultiline_Syn_PFExprSuffix :: Bool, precedence_Syn_PFExprSuffix :: OperatorLevel, pretty_Syn_PFExprSuffix :: Doc}
wrap_PFExprSuffix
:: T_PFExprSuffix
-> Inh_PFExprSuffix
-> Syn_PFExprSuffix
wrap_PFExprSuffix sem (Inh_PFExprSuffix _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_PFExprSuffix _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisMultiline _lhsOprecedence _lhsOpretty)
)
sem_PFExprSuffix_Call
:: T_Args
-> T_PFExprSuffix
sem_PFExprSuffix_Call args_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: PFExprSuffix
_lhsOcomments :: ([MToken])
_argsOcomments :: ([MToken])
_argsOforceMultiline :: Bool
_argsOindent :: Int
_argsOppconf :: PrettyPrintConfig
_argsIcomments :: ([MToken])
_argsIcopy :: Args
_argsIisMultiline :: Bool
_argsIpretty :: Doc
_lhsOpretty =
( _argsIpretty
)
_lhsOisMultiline =
( _argsIisMultiline
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( Call _argsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _argsIcomments
)
_argsOcomments =
( _lhsIcomments
)
_argsOforceMultiline =
( _lhsIforceMultiline
)
_argsOindent =
( _lhsIindent
)
_argsOppconf =
( _lhsIppconf
)
(_argsIcomments, _argsIcopy, _argsIisMultiline, _argsIpretty) =
args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_PFExprSuffix_MetaCall
:: MToken
-> T_Args
-> T_PFExprSuffix
sem_PFExprSuffix_MetaCall fn_ args_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: PFExprSuffix
_lhsOcomments :: ([MToken])
_argsOcomments :: ([MToken])
_argsOforceMultiline :: Bool
_argsOindent :: Int
_argsOppconf :: PrettyPrintConfig
_argsIcomments :: ([MToken])
_argsIcopy :: Args
_argsIisMultiline :: Bool
_argsIpretty :: Doc
_lhsOpretty =
( zchr ':' <> tok fn_ <> _argsIpretty
)
_lhsOisMultiline =
( _argsIisMultiline
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( MetaCall fn_ _argsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _argsIcomments
)
_argsOcomments =
( _lhsIcomments
)
_argsOforceMultiline =
( _lhsIforceMultiline
)
_argsOindent =
( _lhsIindent
)
_argsOppconf =
( _lhsIppconf
)
(_argsIcomments, _argsIcopy, _argsIisMultiline, _argsIpretty) =
args_ _argsOcomments _argsOforceMultiline _argsOindent _argsOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_PFExprSuffix_ExprIndex
:: T_MExpr
-> T_PFExprSuffix
sem_PFExprSuffix_ExprIndex index_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_indexOparentOperatorPrecedence :: OperatorLevel
_indexOparentOperatorAssociative :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: PFExprSuffix
_lhsOcomments :: ([MToken])
_indexOcomments :: ([MToken])
_indexOforceMultiline :: Bool
_indexOindent :: Int
_indexOppconf :: PrettyPrintConfig
_indexIcomments :: ([MToken])
_indexIcopy :: MExpr
_indexIendsWithPrefixExpression :: Bool
_indexIisAssociative :: Bool
_indexIisLiteral :: Bool
_indexIisMultiline :: Bool
_indexIpos :: Region
_indexIprecedence :: OperatorLevel
_indexIpretty :: Doc
_lhsOpretty =
( brackets _lhsIppconf _indexIpretty
)
_lhsOisMultiline =
( _indexIisMultiline
)
_indexOparentOperatorPrecedence =
( TopLevelExpression
)
_indexOparentOperatorAssociative =
( True
)
_lhsOisAssociative =
( _indexIisAssociative
)
_lhsOprecedence =
( _indexIprecedence
)
_copy =
( ExprIndex _indexIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _indexIcomments
)
_indexOcomments =
( _lhsIcomments
)
_indexOforceMultiline =
( _lhsIforceMultiline
)
_indexOindent =
( _lhsIindent
)
_indexOppconf =
( _lhsIppconf
)
(_indexIcomments, _indexIcopy, _indexIendsWithPrefixExpression, _indexIisAssociative, _indexIisLiteral, _indexIisMultiline, _indexIpos, _indexIprecedence, _indexIpretty) =
index_ _indexOcomments _indexOforceMultiline _indexOindent _indexOparentOperatorAssociative _indexOparentOperatorPrecedence _indexOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
sem_PFExprSuffix_DotIndex
:: MToken
-> T_PFExprSuffix
sem_PFExprSuffix_DotIndex index_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: PFExprSuffix
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zchr '.' <> tok index_
)
_lhsOisMultiline =
( False
)
_lhsOisAssociative =
( False
)
_lhsOprecedence =
( OperatorLevel8
)
_copy =
( DotIndex index_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty)
)
)
-- PrefixExp ---------------------------------------------------
-- cata
sem_PrefixExp
:: PrefixExp
-> T_PrefixExp
sem_PrefixExp (PFVar _name _suffixes) =
(sem_PrefixExp_PFVar _name (sem_ExprSuffixList _suffixes))
sem_PrefixExp (ExprVar _expr _suffixes) =
(sem_PrefixExp_ExprVar (sem_MExpr _expr) (sem_ExprSuffixList _suffixes))
-- semantic domain
type T_PrefixExp =
([MToken])
-> Bool
-> Int
-> Bool
-> OperatorLevel
-> PrettyPrintConfig
-> (([MToken]), PrefixExp, Bool, Bool, Bool, OperatorLevel, Doc, Bool)
data Inh_PrefixExp = Inh_PrefixExp {comments_Inh_PrefixExp :: ([MToken]), forceMultiline_Inh_PrefixExp :: Bool, indent_Inh_PrefixExp :: Int, parentOperatorAssociative_Inh_PrefixExp :: Bool, parentOperatorPrecedence_Inh_PrefixExp :: OperatorLevel, ppconf_Inh_PrefixExp :: PrettyPrintConfig}
data Syn_PrefixExp = Syn_PrefixExp {comments_Syn_PrefixExp :: ([MToken]), copy_Syn_PrefixExp :: PrefixExp, isAssociative_Syn_PrefixExp :: Bool, isLiteral_Syn_PrefixExp :: Bool, isMultiline_Syn_PrefixExp :: Bool, precedence_Syn_PrefixExp :: OperatorLevel, pretty_Syn_PrefixExp :: Doc, startsWithExprPrefixExpression_Syn_PrefixExp :: Bool}
wrap_PrefixExp
:: T_PrefixExp
-> Inh_PrefixExp
-> Syn_PrefixExp
wrap_PrefixExp sem (Inh_PrefixExp _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIparentOperatorAssociative _lhsIparentOperatorPrecedence _lhsIppconf
in
(Syn_PrefixExp _lhsOcomments _lhsOcopy _lhsOisAssociative _lhsOisLiteral _lhsOisMultiline _lhsOprecedence _lhsOpretty _lhsOstartsWithExprPrefixExpression)
)
sem_PrefixExp_PFVar
:: MToken
-> T_ExprSuffixList
-> T_PrefixExp
sem_PrefixExp_PFVar name_ suffixes_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisLiteral :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOprecedence :: OperatorLevel
_lhsOcopy :: PrefixExp
_lhsOcomments :: ([MToken])
_suffixesOcomments :: ([MToken])
_suffixesOforceMultiline :: Bool
_suffixesOindent :: Int
_suffixesOppconf :: PrettyPrintConfig
_suffixesIcomments :: ([MToken])
_suffixesIcopy :: ExprSuffixList
_suffixesIisAssociative :: Bool
_suffixesIisMultiline :: Bool
_suffixesIprecedence :: OperatorLevel
_suffixesIpretty :: Doc
_lhsOpretty =
( tok name_ <> _suffixesIpretty
)
_lhsOisLiteral =
( False
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOisMultiline =
( _suffixesIisMultiline
)
_lhsOisAssociative =
( _suffixesIisAssociative
)
_lhsOprecedence =
( _suffixesIprecedence
)
_copy =
( PFVar name_ _suffixesIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _suffixesIcomments
)
_suffixesOcomments =
( _lhsIcomments
)
_suffixesOforceMultiline =
( _lhsIforceMultiline
)
_suffixesOindent =
( _lhsIindent
)
_suffixesOppconf =
( _lhsIppconf
)
(_suffixesIcomments, _suffixesIcopy, _suffixesIisAssociative, _suffixesIisMultiline, _suffixesIprecedence, _suffixesIpretty) =
suffixes_ _suffixesOcomments _suffixesOforceMultiline _suffixesOindent _suffixesOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_PrefixExp_ExprVar
:: T_MExpr
-> T_ExprSuffixList
-> T_PrefixExp
sem_PrefixExp_ExprVar expr_ suffixes_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIparentOperatorAssociative
_lhsIparentOperatorPrecedence
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOprecedence :: OperatorLevel
_lhsOisLiteral :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisAssociative :: Bool
_lhsOcopy :: PrefixExp
_lhsOcomments :: ([MToken])
_exprOcomments :: ([MToken])
_exprOforceMultiline :: Bool
_exprOindent :: Int
_exprOparentOperatorAssociative :: Bool
_exprOparentOperatorPrecedence :: OperatorLevel
_exprOppconf :: PrettyPrintConfig
_suffixesOcomments :: ([MToken])
_suffixesOforceMultiline :: Bool
_suffixesOindent :: Int
_suffixesOppconf :: PrettyPrintConfig
_exprIcomments :: ([MToken])
_exprIcopy :: MExpr
_exprIendsWithPrefixExpression :: Bool
_exprIisAssociative :: Bool
_exprIisLiteral :: Bool
_exprIisMultiline :: Bool
_exprIpos :: Region
_exprIprecedence :: OperatorLevel
_exprIpretty :: Doc
_suffixesIcomments :: ([MToken])
_suffixesIcopy :: ExprSuffixList
_suffixesIisAssociative :: Bool
_suffixesIisMultiline :: Bool
_suffixesIprecedence :: OperatorLevel
_suffixesIpretty :: Doc
_lhsOpretty =
( (if _noparens then _exprIpretty else parens _lhsIppconf NonEmpty _exprIpretty)
<> _suffixesIpretty
)
_lhsOprecedence =
( if _noparens then _exprIprecedence else OperatorLevel8
)
_lhsOisLiteral =
( False
)
_lhsOstartsWithExprPrefixExpression =
( True
)
_lhsOisMultiline =
( _exprIisMultiline || _suffixesIisMultiline
)
_containsParenthesizedExpr =
( case _exprIcopy of
MExpr _ (APrefixExpr (ExprVar (MExpr _ AVarArg) _)) -> False
MExpr _ (APrefixExpr _) -> True
_ -> False
)
_noparens =
( (removeRedundantParens _lhsIppconf || minimizeParens _lhsIppconf)
&& ( _containsParenthesizedExpr
|| (_lhsIparentOperatorPrecedence == TopLevelExpression || _exprIisLiteral)
&& length _suffixesIcopy == 0
)
|| ( minimizeParens _lhsIppconf
&& length _suffixesIcopy == 0
&& ( _lhsIparentOperatorPrecedence < _exprIprecedence
|| assumeOperatorAssociativity _lhsIppconf
&& _lhsIparentOperatorPrecedence == _exprIprecedence
&& _lhsIparentOperatorAssociative
)
)
)
_lhsOisAssociative =
( _exprIisAssociative && _suffixesIisAssociative
)
_copy =
( ExprVar _exprIcopy _suffixesIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _suffixesIcomments
)
_exprOcomments =
( _lhsIcomments
)
_exprOforceMultiline =
( _lhsIforceMultiline
)
_exprOindent =
( _lhsIindent
)
_exprOparentOperatorAssociative =
( _lhsIparentOperatorAssociative
)
_exprOparentOperatorPrecedence =
( _lhsIparentOperatorPrecedence
)
_exprOppconf =
( _lhsIppconf
)
_suffixesOcomments =
( _exprIcomments
)
_suffixesOforceMultiline =
( _lhsIforceMultiline
)
_suffixesOindent =
( _lhsIindent
)
_suffixesOppconf =
( _lhsIppconf
)
(_exprIcomments, _exprIcopy, _exprIendsWithPrefixExpression, _exprIisAssociative, _exprIisLiteral, _exprIisMultiline, _exprIpos, _exprIprecedence, _exprIpretty) =
expr_ _exprOcomments _exprOforceMultiline _exprOindent _exprOparentOperatorAssociative _exprOparentOperatorPrecedence _exprOppconf
(_suffixesIcomments, _suffixesIcopy, _suffixesIisAssociative, _suffixesIisMultiline, _suffixesIprecedence, _suffixesIpretty) =
suffixes_ _suffixesOcomments _suffixesOforceMultiline _suffixesOindent _suffixesOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOisAssociative, _lhsOisLiteral, _lhsOisMultiline, _lhsOprecedence, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
-- Stat --------------------------------------------------------
-- cata
sem_Stat
:: Stat
-> T_Stat
sem_Stat (Def _vars) =
(sem_Stat_Def (sem_VarsList _vars))
sem_Stat (LocDef _vars) =
(sem_Stat_LocDef (sem_VarsList _vars))
sem_Stat (AFuncCall _fn) =
(sem_Stat_AFuncCall (sem_PrefixExp _fn))
sem_Stat (ALabel _lbl) =
(sem_Stat_ALabel _lbl)
sem_Stat (ABreak) =
(sem_Stat_ABreak)
sem_Stat (AContinue) =
(sem_Stat_AContinue)
sem_Stat (AGoto _lbl) =
(sem_Stat_AGoto _lbl)
sem_Stat (ADo _body) =
(sem_Stat_ADo (sem_Block _body))
sem_Stat (AWhile _cond _body) =
(sem_Stat_AWhile (sem_MExpr _cond) (sem_Block _body))
sem_Stat (ARepeat _body _cond) =
(sem_Stat_ARepeat (sem_Block _body) (sem_MExpr _cond))
sem_Stat (AIf _cond _body _elifs _els) =
(sem_Stat_AIf (sem_MExpr _cond) (sem_Block _body) (sem_ElseIfList _elifs) (sem_Else _els))
sem_Stat (ANFor _var _val _to _step _body) =
(sem_Stat_ANFor _var (sem_MExpr _val) (sem_MExpr _to) (sem_MExpr _step) (sem_Block _body))
sem_Stat (AGFor _vars _vals _body) =
(sem_Stat_AGFor _vars (sem_MExprList _vals) (sem_Block _body))
sem_Stat (AFunc _name _args _body) =
(sem_Stat_AFunc (sem_FuncName _name) _args (sem_Block _body))
sem_Stat (ALocFunc _name _args _body) =
(sem_Stat_ALocFunc (sem_FuncName _name) _args (sem_Block _body))
-- semantic domain
type T_Stat =
([MToken])
-> Bool
-> Int
-> Bool
-> PrettyPrintConfig
-> Region
-> Bool
-> (([MToken]), Stat, Bool, Bool, Doc, Bool)
data Inh_Stat = Inh_Stat {comments_Inh_Stat :: ([MToken]), forceMultiline_Inh_Stat :: Bool, indent_Inh_Stat :: Int, isLastStatement_Inh_Stat :: Bool, ppconf_Inh_Stat :: PrettyPrintConfig, statRegion_Inh_Stat :: Region, wouldBeAmbiguousWithoutSemicolon_Inh_Stat :: Bool}
data Syn_Stat = Syn_Stat {comments_Syn_Stat :: ([MToken]), copy_Syn_Stat :: Stat, endsWithPrefixExpression_Syn_Stat :: Bool, isMultiline_Syn_Stat :: Bool, pretty_Syn_Stat :: Doc, startsWithExprPrefixExpression_Syn_Stat :: Bool}
wrap_Stat
:: T_Stat
-> Inh_Stat
-> Syn_Stat
wrap_Stat sem (Inh_Stat _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIstatRegion _lhsIwouldBeAmbiguousWithoutSemicolon) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIisLastStatement _lhsIppconf _lhsIstatRegion _lhsIwouldBeAmbiguousWithoutSemicolon
in
(Syn_Stat _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression)
)
sem_Stat_Def
:: T_VarsList
-> T_Stat
sem_Stat_Def vars_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_varsOcomments :: ([MToken])
_varsOforceMultiline :: Bool
_varsOindent :: Int
_varsOppconf :: PrettyPrintConfig
_varsIcomments :: ([MToken])
_varsIcopy :: VarsList
_varsIendsWithPrefixExpression :: Bool
_varsIexprPretty :: Doc
_varsIisDefined :: Bool
_varsIisLast :: Bool
_varsIisMultiline :: Bool
_varsIpretty :: Doc
_varsIstartsWithExprPrefixExpression :: Bool
_varsIvarPretty :: Doc
_lhsOpretty =
( _varsIpretty <> _semicolon
)
_lhsOstartsWithExprPrefixExpression =
( _varsIstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( _varsIendsWithPrefixExpression
)
_lhsOisMultiline =
( _varsIisMultiline
)
_semicolon =
( if semicolons _lhsIppconf || _lhsIwouldBeAmbiguousWithoutSemicolon
then zchr ';'
else empty
)
_copy =
( Def _varsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _varsIcomments
)
_varsOcomments =
( _lhsIcomments
)
_varsOforceMultiline =
( _lhsIforceMultiline
)
_varsOindent =
( _lhsIindent
)
_varsOppconf =
( _lhsIppconf
)
(_varsIcomments, _varsIcopy, _varsIendsWithPrefixExpression, _varsIexprPretty, _varsIisDefined, _varsIisLast, _varsIisMultiline, _varsIpretty, _varsIstartsWithExprPrefixExpression, _varsIvarPretty) =
vars_ _varsOcomments _varsOforceMultiline _varsOindent _varsOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_LocDef
:: T_VarsList
-> T_Stat
sem_Stat_LocDef vars_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_varsOcomments :: ([MToken])
_varsOforceMultiline :: Bool
_varsOindent :: Int
_varsOppconf :: PrettyPrintConfig
_varsIcomments :: ([MToken])
_varsIcopy :: VarsList
_varsIendsWithPrefixExpression :: Bool
_varsIexprPretty :: Doc
_varsIisDefined :: Bool
_varsIisLast :: Bool
_varsIisMultiline :: Bool
_varsIpretty :: Doc
_varsIstartsWithExprPrefixExpression :: Bool
_varsIvarPretty :: Doc
_lhsOpretty =
( zeroWidthText "local" <-> _varsIpretty <> _semicolon
)
_lhsOstartsWithExprPrefixExpression =
( _varsIstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( _varsIendsWithPrefixExpression
)
_lhsOisMultiline =
( _varsIisMultiline
)
_semicolon =
( if semicolons _lhsIppconf || _lhsIwouldBeAmbiguousWithoutSemicolon
then zchr ';'
else empty
)
_copy =
( LocDef _varsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _varsIcomments
)
_varsOcomments =
( _lhsIcomments
)
_varsOforceMultiline =
( _lhsIforceMultiline
)
_varsOindent =
( _lhsIindent
)
_varsOppconf =
( _lhsIppconf
)
(_varsIcomments, _varsIcopy, _varsIendsWithPrefixExpression, _varsIexprPretty, _varsIisDefined, _varsIisLast, _varsIisMultiline, _varsIpretty, _varsIstartsWithExprPrefixExpression, _varsIvarPretty) =
vars_ _varsOcomments _varsOforceMultiline _varsOindent _varsOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AFuncCall
:: T_PrefixExp
-> T_Stat
sem_Stat_AFuncCall fn_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_fnOparentOperatorPrecedence :: OperatorLevel
_fnOparentOperatorAssociative :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_fnOcomments :: ([MToken])
_fnOforceMultiline :: Bool
_fnOindent :: Int
_fnOppconf :: PrettyPrintConfig
_fnIcomments :: ([MToken])
_fnIcopy :: PrefixExp
_fnIisAssociative :: Bool
_fnIisLiteral :: Bool
_fnIisMultiline :: Bool
_fnIprecedence :: OperatorLevel
_fnIpretty :: Doc
_fnIstartsWithExprPrefixExpression :: Bool
_lhsOpretty =
( _fnIpretty <> _semicolon
)
_lhsOisMultiline =
( _fnIisMultiline
)
_semicolon =
( if semicolons _lhsIppconf then zchr ';' else empty
)
_lhsOstartsWithExprPrefixExpression =
( _fnIstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( True
)
_fnOparentOperatorPrecedence =
( TopLevelExpression
)
_fnOparentOperatorAssociative =
( True
)
_copy =
( AFuncCall _fnIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _fnIcomments
)
_fnOcomments =
( _lhsIcomments
)
_fnOforceMultiline =
( _lhsIforceMultiline
)
_fnOindent =
( _lhsIindent
)
_fnOppconf =
( _lhsIppconf
)
(_fnIcomments, _fnIcopy, _fnIisAssociative, _fnIisLiteral, _fnIisMultiline, _fnIprecedence, _fnIpretty, _fnIstartsWithExprPrefixExpression) =
fn_ _fnOcomments _fnOforceMultiline _fnOindent _fnOparentOperatorAssociative _fnOparentOperatorPrecedence _fnOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ALabel
:: MToken
-> T_Stat
sem_Stat_ALabel lbl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "::"
<> _whitespace
<> tok lbl_
<> _whitespace
<> zeroWidthText "::"
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_whitespace =
( if spaceAfterLabel _lhsIppconf then zeroWidthText " " else empty
)
_copy =
( ALabel lbl_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ABreak :: T_Stat
sem_Stat_ABreak =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "break" <> _semicolon
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_semicolon =
( if semicolons _lhsIppconf then zchr ';' else empty
)
_copy =
( ABreak
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AContinue :: T_Stat
sem_Stat_AContinue =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "continue" <> _semicolon
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_semicolon =
( if semicolons _lhsIppconf then zchr ';' else empty
)
_copy =
( AContinue
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AGoto
:: MToken
-> T_Stat
sem_Stat_AGoto lbl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "goto" <-> tok lbl_ <> _semicolon
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_semicolon =
( if semicolons _lhsIppconf then zchr ';' else empty
)
_copy =
( AGoto lbl_
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ADo
:: T_Block
-> T_Stat
sem_Stat_ADo body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_bodyOindent :: Int
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOpretty =
( zeroWidthText "do"
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_bodyOindent =
( _lhsIindent + 1
)
_copy =
( ADo _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_bodyOcomments =
( _lhsIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AWhile
:: T_MExpr
-> T_Block
-> T_Stat
sem_Stat_AWhile cond_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_condOparentOperatorPrecedence :: OperatorLevel
_condOparentOperatorAssociative :: Bool
_lhsOpretty :: Doc
_bodyOindent :: Int
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_condOcomments :: ([MToken])
_condOforceMultiline :: Bool
_condOindent :: Int
_condOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_condIcomments :: ([MToken])
_condIcopy :: MExpr
_condIendsWithPrefixExpression :: Bool
_condIisAssociative :: Bool
_condIisLiteral :: Bool
_condIisMultiline :: Bool
_condIpos :: Region
_condIprecedence :: OperatorLevel
_condIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_condOparentOperatorPrecedence =
( TopLevelExpression
)
_condOparentOperatorAssociative =
( True
)
_lhsOpretty =
( zeroWidthText "while"
<-> _condIpretty
<-> zeroWidthText "do"
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_bodyOindent =
( _lhsIindent + 1
)
_copy =
( AWhile _condIcopy _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_condOcomments =
( _lhsIcomments
)
_condOforceMultiline =
( _lhsIforceMultiline
)
_condOindent =
( _lhsIindent
)
_condOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _condIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ARepeat
:: T_Block
-> T_MExpr
-> T_Stat
sem_Stat_ARepeat body_ cond_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_bodyOindent :: Int
_condOparentOperatorPrecedence :: OperatorLevel
_condOparentOperatorAssociative :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_condOcomments :: ([MToken])
_condOforceMultiline :: Bool
_condOindent :: Int
_condOppconf :: PrettyPrintConfig
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_condIcomments :: ([MToken])
_condIcopy :: MExpr
_condIendsWithPrefixExpression :: Bool
_condIisAssociative :: Bool
_condIisLiteral :: Bool
_condIisMultiline :: Bool
_condIpos :: Region
_condIprecedence :: OperatorLevel
_condIpretty :: Doc
_lhsOpretty =
( zeroWidthText "repeat"
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "until" <-> _condIpretty)
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( True
)
_bodyOindent =
( _lhsIindent + 1
)
_condOparentOperatorPrecedence =
( TopLevelExpression
)
_condOparentOperatorAssociative =
( True
)
_copy =
( ARepeat _bodyIcopy _condIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _condIcomments
)
_bodyOcomments =
( _lhsIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
_condOcomments =
( _bodyIcomments
)
_condOforceMultiline =
( _lhsIforceMultiline
)
_condOindent =
( _lhsIindent
)
_condOppconf =
( _lhsIppconf
)
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
(_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AIf
:: T_MExpr
-> T_Block
-> T_ElseIfList
-> T_Else
-> T_Stat
sem_Stat_AIf cond_ body_ elifs_ els_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_condOcomments :: ([MToken])
_condOparentOperatorPrecedence :: OperatorLevel
_condOparentOperatorAssociative :: Bool
_bodyOindent :: Int
_bodyOstatRegion :: Region
_lhsOpretty :: Doc
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_lhsOisMultiline :: Bool
_condOforceMultiline :: Bool
_condOindent :: Int
_condOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_elifsOcomments :: ([MToken])
_elifsOforceMultiline :: Bool
_elifsOindent :: Int
_elifsOppconf :: PrettyPrintConfig
_elsOcomments :: ([MToken])
_elsOforceMultiline :: Bool
_elsOindent :: Int
_elsOppconf :: PrettyPrintConfig
_elsOstatRegion :: Region
_condIcomments :: ([MToken])
_condIcopy :: MExpr
_condIendsWithPrefixExpression :: Bool
_condIisAssociative :: Bool
_condIisLiteral :: Bool
_condIisMultiline :: Bool
_condIpos :: Region
_condIprecedence :: OperatorLevel
_condIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_elifsIcomments :: ([MToken])
_elifsIcopy :: ElseIfList
_elifsIelsesExist :: Bool
_elifsIisMultiline :: Bool
_elifsIpos :: Region
_elifsIpretty :: Doc
_elsIcomments :: ([MToken])
_elsIcopy :: Else
_elsIelsesExist :: Bool
_elsIisMultiline :: Bool
_elsIpos :: Region
_elsIpretty :: Doc
_isMultiline =
( _lhsIforceMultiline
|| _condIisMultiline
|| _bodyIisMultiline
|| _elifsIelsesExist
|| _elsIelsesExist
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_singleLinePretty =
( zeroWidthText "if"
<-> _condIpretty
<-> zeroWidthText "then"
<-> _bodyIpretty
<-> zeroWidthText "end"
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterThen)
)
_multilinePretty =
( zeroWidthText "if"
<-> _condIpretty
<-> zeroWidthText "then"
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterThen)
$+$ _bodyIpretty
$+$ _elifsIpretty
$+$ _elsIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_commentsAfterThen =
( span (\(MToken pos _) -> pos `beforeOrOnLine` _condIpos) _lhsIcomments
)
_condOcomments =
( snd _commentsAfterThen
)
_condOparentOperatorPrecedence =
( TopLevelExpression
)
_condOparentOperatorAssociative =
( True
)
_bodyOindent =
( if _isMultiline then _lhsIindent + 1 else 0
)
_bodyOstatRegion =
( _lhsIstatRegion `upto` _elifsIpos `upto` _elsIpos
)
_lhsOpretty =
( if _isMultiline then _multilinePretty else _singleLinePretty
)
_copy =
( AIf _condIcopy _bodyIcopy _elifsIcopy _elsIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _elsIcomments
)
_lhsOisMultiline =
( _isMultiline
)
_condOforceMultiline =
( _lhsIforceMultiline
)
_condOindent =
( _lhsIindent
)
_condOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _condIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_elifsOcomments =
( _bodyIcomments
)
_elifsOforceMultiline =
( _lhsIforceMultiline
)
_elifsOindent =
( _lhsIindent
)
_elifsOppconf =
( _lhsIppconf
)
_elsOcomments =
( _elifsIcomments
)
_elsOforceMultiline =
( _lhsIforceMultiline
)
_elsOindent =
( _lhsIindent
)
_elsOppconf =
( _lhsIppconf
)
_elsOstatRegion =
( _lhsIstatRegion
)
(_condIcomments, _condIcopy, _condIendsWithPrefixExpression, _condIisAssociative, _condIisLiteral, _condIisMultiline, _condIpos, _condIprecedence, _condIpretty) =
cond_ _condOcomments _condOforceMultiline _condOindent _condOparentOperatorAssociative _condOparentOperatorPrecedence _condOppconf
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
(_elifsIcomments, _elifsIcopy, _elifsIelsesExist, _elifsIisMultiline, _elifsIpos, _elifsIpretty) =
elifs_ _elifsOcomments _elifsOforceMultiline _elifsOindent _elifsOppconf
(_elsIcomments, _elsIcopy, _elsIelsesExist, _elsIisMultiline, _elsIpos, _elsIpretty) =
els_ _elsOcomments _elsOforceMultiline _elsOindent _elsOppconf _elsOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ANFor
:: MToken
-> T_MExpr
-> T_MExpr
-> T_MExpr
-> T_Block
-> T_Stat
sem_Stat_ANFor var_ val_ to_ step_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOpretty :: Doc
_valOcomments :: ([MToken])
_valOparentOperatorPrecedence :: OperatorLevel
_valOparentOperatorAssociative :: Bool
_toOparentOperatorPrecedence :: OperatorLevel
_toOparentOperatorAssociative :: Bool
_stepOparentOperatorPrecedence :: OperatorLevel
_stepOparentOperatorAssociative :: Bool
_bodyOindent :: Int
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_valOforceMultiline :: Bool
_valOindent :: Int
_valOppconf :: PrettyPrintConfig
_toOcomments :: ([MToken])
_toOforceMultiline :: Bool
_toOindent :: Int
_toOppconf :: PrettyPrintConfig
_stepOcomments :: ([MToken])
_stepOforceMultiline :: Bool
_stepOindent :: Int
_stepOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_valIcomments :: ([MToken])
_valIcopy :: MExpr
_valIendsWithPrefixExpression :: Bool
_valIisAssociative :: Bool
_valIisLiteral :: Bool
_valIisMultiline :: Bool
_valIpos :: Region
_valIprecedence :: OperatorLevel
_valIpretty :: Doc
_toIcomments :: ([MToken])
_toIcopy :: MExpr
_toIendsWithPrefixExpression :: Bool
_toIisAssociative :: Bool
_toIisLiteral :: Bool
_toIisMultiline :: Bool
_toIpos :: Region
_toIprecedence :: OperatorLevel
_toIpretty :: Doc
_stepIcomments :: ([MToken])
_stepIcopy :: MExpr
_stepIendsWithPrefixExpression :: Bool
_stepIisAssociative :: Bool
_stepIisLiteral :: Bool
_stepIisMultiline :: Bool
_stepIpos :: Region
_stepIprecedence :: OperatorLevel
_stepIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_step =
( case _stepIcopy of
MExpr _ (ANumber "1") -> empty
_ -> _comma <> _stepIpretty
)
_lhsOpretty =
( zeroWidthText "for"
<-> tok var_
<-> zchr '='
<-> _valIpretty
<> _comma
<> _toIpretty
<> _step
<-> zeroWidthText "do"
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFor)
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_commentsAfterFor =
( span (\(MToken pos _) -> pos `beforeOrOnLine` mpos var_) _lhsIcomments
)
_valOcomments =
( snd _commentsAfterFor
)
_valOparentOperatorPrecedence =
( TopLevelExpression
)
_valOparentOperatorAssociative =
( True
)
_toOparentOperatorPrecedence =
( TopLevelExpression
)
_toOparentOperatorAssociative =
( True
)
_stepOparentOperatorPrecedence =
( TopLevelExpression
)
_stepOparentOperatorAssociative =
( True
)
_bodyOindent =
( _lhsIindent + 1
)
_copy =
( ANFor var_ _valIcopy _toIcopy _stepIcopy _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_valOforceMultiline =
( _lhsIforceMultiline
)
_valOindent =
( _lhsIindent
)
_valOppconf =
( _lhsIppconf
)
_toOcomments =
( _valIcomments
)
_toOforceMultiline =
( _lhsIforceMultiline
)
_toOindent =
( _lhsIindent
)
_toOppconf =
( _lhsIppconf
)
_stepOcomments =
( _toIcomments
)
_stepOforceMultiline =
( _lhsIforceMultiline
)
_stepOindent =
( _lhsIindent
)
_stepOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _stepIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_valIcomments, _valIcopy, _valIendsWithPrefixExpression, _valIisAssociative, _valIisLiteral, _valIisMultiline, _valIpos, _valIprecedence, _valIpretty) =
val_ _valOcomments _valOforceMultiline _valOindent _valOparentOperatorAssociative _valOparentOperatorPrecedence _valOppconf
(_toIcomments, _toIcopy, _toIendsWithPrefixExpression, _toIisAssociative, _toIisLiteral, _toIisMultiline, _toIpos, _toIprecedence, _toIpretty) =
to_ _toOcomments _toOforceMultiline _toOindent _toOparentOperatorAssociative _toOparentOperatorPrecedence _toOppconf
(_stepIcomments, _stepIcopy, _stepIendsWithPrefixExpression, _stepIisAssociative, _stepIisLiteral, _stepIisMultiline, _stepIpos, _stepIprecedence, _stepIpretty) =
step_ _stepOcomments _stepOforceMultiline _stepOindent _stepOparentOperatorAssociative _stepOparentOperatorPrecedence _stepOppconf
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AGFor
:: ([MToken])
-> T_MExprList
-> T_Block
-> T_Stat
sem_Stat_AGFor vars_ vals_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOpretty :: Doc
_bodyOindent :: Int
_valsOcomments :: ([MToken])
_valsOforceMultiline :: Bool
_valsOsomeElementsInListAreMultiline :: Bool
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_valsOindent :: Int
_valsOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_valsIcomments :: ([MToken])
_valsIcopy :: MExprList
_valsIisAssociative :: Bool
_valsIisLast :: Bool
_valsIisMultiline :: Bool
_valsIpos :: Region
_valsIprecedence :: OperatorLevel
_valsIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOpretty =
( zeroWidthText "for"
<-> printList tok (render _comma) vars_
<-> zeroWidthText "in"
<-> _valsIpretty
<-> zeroWidthText "do"
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFor)
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_bodyOindent =
( _lhsIindent + 1
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_commentsAfterFor =
( span (\(MToken pos _) -> pos `beforeOrOnLine` mpos (head vars_)) _lhsIcomments
)
_valsOcomments =
( snd _commentsAfterFor
)
_valsOforceMultiline =
( False
)
_valsOsomeElementsInListAreMultiline =
( False
)
_copy =
( AGFor vars_ _valsIcopy _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_valsOindent =
( _lhsIindent
)
_valsOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _valsIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_valsIcomments, _valsIcopy, _valsIisAssociative, _valsIisLast, _valsIisMultiline, _valsIpos, _valsIprecedence, _valsIpretty) =
vals_ _valsOcomments _valsOforceMultiline _valsOindent _valsOppconf _valsOsomeElementsInListAreMultiline
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_AFunc
:: T_FuncName
-> ([MToken])
-> T_Block
-> T_Stat
sem_Stat_AFunc name_ args_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOpretty :: Doc
_nameOcomments :: ([MToken])
_bodyOindent :: Int
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_nameOindent :: Int
_nameOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_nameIcomments :: ([MToken])
_nameIcopy :: FuncName
_nameIisMultiline :: Bool
_nameIpos :: Region
_nameIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOpretty =
( zeroWidthText "function"
<-> _nameIpretty
<> parens _lhsIppconf _emptyParams (printList tok (render _comma) args_)
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFunc)
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_commentsAfterFunc =
( span (\(MToken pos _) -> pos `beforeOrOnLine` _nameIpos) _lhsIcomments
)
_nameOcomments =
( snd _commentsAfterFunc
)
_emptyParams =
( toEmpty $ null args_
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_bodyOindent =
( _lhsIindent + 1
)
_copy =
( AFunc _nameIcopy args_ _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_nameOindent =
( _lhsIindent
)
_nameOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _nameIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_nameIcomments, _nameIcopy, _nameIisMultiline, _nameIpos, _nameIpretty) =
name_ _nameOcomments _nameOindent _nameOppconf
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
sem_Stat_ALocFunc
:: T_FuncName
-> ([MToken])
-> T_Block
-> T_Stat
sem_Stat_ALocFunc name_ args_ body_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIisLastStatement
_lhsIppconf
_lhsIstatRegion
_lhsIwouldBeAmbiguousWithoutSemicolon ->
( let
_lhsOisMultiline :: Bool
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_nameOcomments :: ([MToken])
_bodyOindent :: Int
_lhsOcopy :: Stat
_lhsOcomments :: ([MToken])
_nameOindent :: Int
_nameOppconf :: PrettyPrintConfig
_bodyOcomments :: ([MToken])
_bodyOforceMultiline :: Bool
_bodyOppconf :: PrettyPrintConfig
_bodyOstatRegion :: Region
_nameIcomments :: ([MToken])
_nameIcopy :: FuncName
_nameIisMultiline :: Bool
_nameIpos :: Region
_nameIpretty :: Doc
_bodyIcomments :: ([MToken])
_bodyIcopy :: Block
_bodyIisMultiline :: Bool
_bodyIpretty :: Doc
_bodyIstatementCount :: Int
_lhsOisMultiline =
( True
)
_lhsOpretty =
( zeroWidthText "local function"
<-> _nameIpretty
<> parens _lhsIppconf _emptyParams (printList tok (render _comma) args_)
<-> renderSLComments _lhsIppconf _lhsIindent (fst _commentsAfterFunc)
$+$ _bodyIpretty
$+$ indent _lhsIppconf _lhsIindent (zeroWidthText "end")
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_commentsAfterFunc =
( span (\(MToken pos _) -> pos `beforeOrOnLine` _nameIpos) _lhsIcomments
)
_nameOcomments =
( snd _commentsAfterFunc
)
_emptyParams =
( toEmpty $ null args_
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_bodyOindent =
( _lhsIindent + 1
)
_copy =
( ALocFunc _nameIcopy args_ _bodyIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _bodyIcomments
)
_nameOindent =
( _lhsIindent
)
_nameOppconf =
( _lhsIppconf
)
_bodyOcomments =
( _nameIcomments
)
_bodyOforceMultiline =
( _lhsIforceMultiline
)
_bodyOppconf =
( _lhsIppconf
)
_bodyOstatRegion =
( _lhsIstatRegion
)
(_nameIcomments, _nameIcopy, _nameIisMultiline, _nameIpos, _nameIpretty) =
name_ _nameOcomments _nameOindent _nameOppconf
(_bodyIcomments, _bodyIcopy, _bodyIisMultiline, _bodyIpretty, _bodyIstatementCount) =
body_ _bodyOcomments _bodyOforceMultiline _bodyOindent _bodyOppconf _bodyOstatRegion
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression)
)
)
-- UnOp --------------------------------------------------------
-- cata
sem_UnOp
:: UnOp
-> T_UnOp
sem_UnOp (UnMinus) =
(sem_UnOp_UnMinus)
sem_UnOp (ANot) =
(sem_UnOp_ANot)
sem_UnOp (AHash) =
(sem_UnOp_AHash)
-- semantic domain
type T_UnOp =
([MToken])
-> Int
-> PrettyPrintConfig
-> (([MToken]), UnOp, Bool, Doc)
data Inh_UnOp = Inh_UnOp {comments_Inh_UnOp :: ([MToken]), indent_Inh_UnOp :: Int, ppconf_Inh_UnOp :: PrettyPrintConfig}
data Syn_UnOp = Syn_UnOp {comments_Syn_UnOp :: ([MToken]), copy_Syn_UnOp :: UnOp, isMultiline_Syn_UnOp :: Bool, pretty_Syn_UnOp :: Doc}
wrap_UnOp
:: T_UnOp
-> Inh_UnOp
-> Syn_UnOp
wrap_UnOp sem (Inh_UnOp _lhsIcomments _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty) = sem _lhsIcomments _lhsIindent _lhsIppconf
in
(Syn_UnOp _lhsOcomments _lhsOcopy _lhsOisMultiline _lhsOpretty)
)
sem_UnOp_UnMinus :: T_UnOp
sem_UnOp_UnMinus =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOcopy :: UnOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "-"
)
_lhsOisMultiline =
( False
)
_copy =
( UnMinus
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
sem_UnOp_ANot :: T_UnOp
sem_UnOp_ANot =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOcopy :: UnOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText (if cStyle _lhsIppconf then "!" else "not ")
)
_lhsOisMultiline =
( False
)
_copy =
( ANot
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
sem_UnOp_AHash :: T_UnOp
sem_UnOp_AHash =
( \_lhsIcomments
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOisMultiline :: Bool
_lhsOcopy :: UnOp
_lhsOcomments :: ([MToken])
_lhsOpretty =
( zeroWidthText "#"
)
_lhsOisMultiline =
( False
)
_copy =
( AHash
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOisMultiline, _lhsOpretty)
)
)
-- VarsList ----------------------------------------------------
-- cata
sem_VarsList
:: VarsList
-> T_VarsList
sem_VarsList list =
(Prelude.foldr sem_VarsList_Cons sem_VarsList_Nil (Prelude.map sem_Declaration list))
-- semantic domain
type T_VarsList =
([MToken])
-> Bool
-> Int
-> PrettyPrintConfig
-> (([MToken]), VarsList, Bool, Doc, Bool, Bool, Bool, Doc, Bool, Doc)
data Inh_VarsList = Inh_VarsList {comments_Inh_VarsList :: ([MToken]), forceMultiline_Inh_VarsList :: Bool, indent_Inh_VarsList :: Int, ppconf_Inh_VarsList :: PrettyPrintConfig}
data Syn_VarsList = Syn_VarsList {comments_Syn_VarsList :: ([MToken]), copy_Syn_VarsList :: VarsList, endsWithPrefixExpression_Syn_VarsList :: Bool, exprPretty_Syn_VarsList :: Doc, isDefined_Syn_VarsList :: Bool, isLast_Syn_VarsList :: Bool, isMultiline_Syn_VarsList :: Bool, pretty_Syn_VarsList :: Doc, startsWithExprPrefixExpression_Syn_VarsList :: Bool, varPretty_Syn_VarsList :: Doc}
wrap_VarsList
:: T_VarsList
-> Inh_VarsList
-> Syn_VarsList
wrap_VarsList sem (Inh_VarsList _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf) =
( let
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty) = sem _lhsIcomments _lhsIforceMultiline _lhsIindent _lhsIppconf
in
(Syn_VarsList _lhsOcomments _lhsOcopy _lhsOendsWithPrefixExpression _lhsOexprPretty _lhsOisDefined _lhsOisLast _lhsOisMultiline _lhsOpretty _lhsOstartsWithExprPrefixExpression _lhsOvarPretty)
)
sem_VarsList_Cons
:: T_Declaration
-> T_VarsList
-> T_VarsList
sem_VarsList_Cons hd_ tl_ =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisLast :: Bool
_lhsOexprPretty :: Doc
_lhsOisDefined :: Bool
_lhsOvarPretty :: Doc
_lhsOcopy :: VarsList
_lhsOcomments :: ([MToken])
_hdOcomments :: ([MToken])
_hdOforceMultiline :: Bool
_hdOindent :: Int
_hdOppconf :: PrettyPrintConfig
_tlOcomments :: ([MToken])
_tlOforceMultiline :: Bool
_tlOindent :: Int
_tlOppconf :: PrettyPrintConfig
_hdIcomments :: ([MToken])
_hdIcopy :: Declaration
_hdIendsWithPrefixExpression :: Bool
_hdIexprPretty :: Doc
_hdIisDefined :: Bool
_hdIisMultiline :: Bool
_hdIpretty :: Doc
_hdIstartsWithExprPrefixExpression :: Bool
_hdIvarPretty :: Doc
_tlIcomments :: ([MToken])
_tlIcopy :: VarsList
_tlIendsWithPrefixExpression :: Bool
_tlIexprPretty :: Doc
_tlIisDefined :: Bool
_tlIisLast :: Bool
_tlIisMultiline :: Bool
_tlIpretty :: Doc
_tlIstartsWithExprPrefixExpression :: Bool
_tlIvarPretty :: Doc
_lhsOpretty =
( _varPretty
<-> if _isDefined then zchr '=' <-> _exprPretty else empty
)
_lhsOstartsWithExprPrefixExpression =
( _hdIstartsWithExprPrefixExpression
)
_lhsOendsWithPrefixExpression =
( if _tlIisDefined then _tlIendsWithPrefixExpression else _hdIendsWithPrefixExpression
)
_lhsOisMultiline =
( _hdIisMultiline || _tlIisMultiline
)
_isDefined =
( _hdIisDefined || _tlIisDefined
)
_varPretty =
( _hdIvarPretty
<> (if _tlIisLast then empty else _comma)
<> _tlIvarPretty
)
_exprPretty =
( _hdIexprPretty
<> (if not _tlIisLast && _tlIisDefined then _comma else empty)
<> _tlIexprPretty
)
_comma =
( (if spaceBeforeComma _lhsIppconf then zchr ' ' else empty)
<> zchr ','
<> (if spaceAfterComma _lhsIppconf then zchr ' ' else empty)
)
_lhsOisLast =
( False
)
_lhsOexprPretty =
( _exprPretty
)
_lhsOisDefined =
( _isDefined
)
_lhsOvarPretty =
( _varPretty
)
_copy =
( (:) _hdIcopy _tlIcopy
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _tlIcomments
)
_hdOcomments =
( _lhsIcomments
)
_hdOforceMultiline =
( _lhsIforceMultiline
)
_hdOindent =
( _lhsIindent
)
_hdOppconf =
( _lhsIppconf
)
_tlOcomments =
( _hdIcomments
)
_tlOforceMultiline =
( _lhsIforceMultiline
)
_tlOindent =
( _lhsIindent
)
_tlOppconf =
( _lhsIppconf
)
(_hdIcomments, _hdIcopy, _hdIendsWithPrefixExpression, _hdIexprPretty, _hdIisDefined, _hdIisMultiline, _hdIpretty, _hdIstartsWithExprPrefixExpression, _hdIvarPretty) =
hd_ _hdOcomments _hdOforceMultiline _hdOindent _hdOppconf
(_tlIcomments, _tlIcopy, _tlIendsWithPrefixExpression, _tlIexprPretty, _tlIisDefined, _tlIisLast, _tlIisMultiline, _tlIpretty, _tlIstartsWithExprPrefixExpression, _tlIvarPretty) =
tl_ _tlOcomments _tlOforceMultiline _tlOindent _tlOppconf
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
)
)
sem_VarsList_Nil :: T_VarsList
sem_VarsList_Nil =
( \_lhsIcomments
_lhsIforceMultiline
_lhsIindent
_lhsIppconf ->
( let
_lhsOpretty :: Doc
_lhsOstartsWithExprPrefixExpression :: Bool
_lhsOendsWithPrefixExpression :: Bool
_lhsOisMultiline :: Bool
_lhsOisLast :: Bool
_lhsOexprPretty :: Doc
_lhsOisDefined :: Bool
_lhsOvarPretty :: Doc
_lhsOcopy :: VarsList
_lhsOcomments :: ([MToken])
_lhsOpretty =
( empty
)
_lhsOstartsWithExprPrefixExpression =
( False
)
_lhsOendsWithPrefixExpression =
( False
)
_lhsOisMultiline =
( False
)
_lhsOisLast =
( True
)
_lhsOexprPretty =
( empty
)
_lhsOisDefined =
( False
)
_lhsOvarPretty =
( empty
)
_copy =
( []
)
_lhsOcopy =
( _copy
)
_lhsOcomments =
( _lhsIcomments
)
in
(_lhsOcomments, _lhsOcopy, _lhsOendsWithPrefixExpression, _lhsOexprPretty, _lhsOisDefined, _lhsOisLast, _lhsOisMultiline, _lhsOpretty, _lhsOstartsWithExprPrefixExpression, _lhsOvarPretty)
)
)