{-# LANGUAGE ScopedTypeVariables #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Sindre.Main
-- License     :  MIT-style (see LICENSE)
--
-- Stability   :  provisional
-- Portability :  portable
--
-- Sindre, a programming language for writing simple GUIs
--
-----------------------------------------------------------------------------

module Sindre.Main( sindreMain,
                    emptyProgram,
                    classMap,
                    objectMap,
                    funcMap,
                    globMap,
                    module Export )
    where

import Sindre.Compiler as Export
import Sindre.Lib
import Sindre.Parser
import Sindre.Runtime as Export
import Sindre.Sindre as Export
import Sindre.Util
import Sindre.Widgets
import Sindre.X11

import Paths_sindre (version)

import System.Console.GetOpt
import System.Environment
import System.Exit
import System.IO
import System.Posix.IO
import System.Posix.Types
import System.Locale.SetLocale(setLocale, Category(..))

import Control.Applicative
import Control.Exception
import Control.Monad
import Data.Char
import qualified Data.Map as M
import qualified Data.Traversable as T
import Data.Version (showVersion)

setupLocale :: IO ()
setupLocale :: IO ()
setupLocale = do
  Maybe String
ret <- Category -> Maybe String -> IO (Maybe String)
setLocale Category
LC_ALL Maybe String
forall a. Maybe a
Nothing
  case Maybe String
ret of
    Maybe String
Nothing -> String -> IO ()
putStrLn String
"Can't set locale." IO () -> IO () -> IO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO ()
forall a. IO a
exitFailure
    Maybe String
_       -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | The main Sindre entry point.
sindreMain :: Program -> ClassMap SindreX11M -> ObjectMap SindreX11M
           -> FuncMap SindreX11M -> GlobMap SindreX11M
           -> [String] -> IO ()
sindreMain :: Program
-> ClassMap SindreX11M
-> ObjectMap SindreX11M
-> FuncMap SindreX11M
-> GlobMap SindreX11M
-> [String]
-> IO ()
sindreMain Program
prog ClassMap SindreX11M
cm ObjectMap SindreX11M
om FuncMap SindreX11M
fm GlobMap SindreX11M
gm [String]
args = do
  IO ()
setupLocale
  String
dstr <- String -> IO String
getEnv String
"DISPLAY" IO String -> (IOException -> IO String) -> IO String
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`catch` \(IOException
_ :: IOException) -> (String -> IO String
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
  let cfg :: AppConfig
cfg = AppConfig :: Program
-> String
-> (String -> SindreX11M ExitCode -> IO ExitCode)
-> Map String Fd
-> AppConfig
AppConfig { cfgDisplay :: String
cfgDisplay = String
dstr
                      , cfgProgram :: Program
cfgProgram = Program
prog
                      , cfgBackend :: String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend = String -> SindreX11M ExitCode -> IO ExitCode
sindreX11override
                      , cfgFiles :: Map String Fd
cfgFiles   = Map String Fd
forall k a. Map k a
M.empty }
  case ArgOrder (AppConfig -> IO AppConfig)
-> [OptDescr (AppConfig -> IO AppConfig)]
-> [String]
-> ([AppConfig -> IO AppConfig], [String], [String], [String])
forall a.
ArgOrder a
-> [OptDescr a] -> [String] -> ([a], [String], [String], [String])
getOpt' ArgOrder (AppConfig -> IO AppConfig)
forall a. ArgOrder a
Permute [OptDescr (AppConfig -> IO AppConfig)]
options [String]
args of
    ([AppConfig -> IO AppConfig]
opts, [String]
_, [String]
_, []) -> do
      AppConfig
cfg' <- (IO AppConfig -> (AppConfig -> IO AppConfig) -> IO AppConfig)
-> IO AppConfig -> [AppConfig -> IO AppConfig] -> IO AppConfig
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl IO AppConfig -> (AppConfig -> IO AppConfig) -> IO AppConfig
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=) (AppConfig -> IO AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return AppConfig
cfg) [AppConfig -> IO AppConfig]
opts
      ObjectMap SindreX11M
hom <- (Fd -> IO (ObjectRef -> SindreX11M (NewObject SindreX11M)))
-> Map String Fd -> IO (ObjectMap SindreX11M)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
T.mapM ((Handle -> ObjectRef -> SindreX11M (NewObject SindreX11M))
-> IO Handle -> IO (ObjectRef -> SindreX11M (NewObject SindreX11M))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Handle -> ObjectRef -> SindreX11M (NewObject SindreX11M)
mkInStream (IO Handle -> IO (ObjectRef -> SindreX11M (NewObject SindreX11M)))
-> (Fd -> IO Handle)
-> Fd
-> IO (ObjectRef -> SindreX11M (NewObject SindreX11M))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fd -> IO Handle
fdToHandle) (Map String Fd -> IO (ObjectMap SindreX11M))
-> Map String Fd -> IO (ObjectMap SindreX11M)
forall a b. (a -> b) -> a -> b
$ AppConfig -> Map String Fd
cfgFiles AppConfig
cfg'
      let ([SindreOption]
srcopts, Arguments -> SindreX11M ExitCode
start) =
            Program
-> ClassMap SindreX11M
-> ObjectMap SindreX11M
-> FuncMap SindreX11M
-> GlobMap SindreX11M
-> ([SindreOption], Arguments -> SindreX11M ExitCode)
forall (m :: * -> *).
MonadBackend m =>
Program
-> ClassMap m
-> ObjectMap m
-> FuncMap m
-> GlobMap m
-> ([SindreOption], Arguments -> m ExitCode)
compileSindre (AppConfig -> Program
cfgProgram AppConfig
cfg') ClassMap SindreX11M
cm (ObjectMap SindreX11M
om ObjectMap SindreX11M
-> ObjectMap SindreX11M -> ObjectMap SindreX11M
forall k a. Ord k => Map k a -> Map k a -> Map k a
`M.union` ObjectMap SindreX11M
hom) FuncMap SindreX11M
fm GlobMap SindreX11M
gm
          progopts :: [SindreOption]
progopts = [SindreOption] -> [SindreOption]
mergeOpts [SindreOption]
srcopts
      case ArgOrder (Arguments -> Arguments)
-> [SindreOption]
-> [String]
-> ([Arguments -> Arguments], [String], [String], [String])
forall a.
ArgOrder a
-> [OptDescr a] -> [String] -> ([a], [String], [String], [String])
getOpt' ArgOrder (Arguments -> Arguments)
forall a. ArgOrder a
Permute [SindreOption]
progopts [String]
args of
        ([Arguments -> Arguments]
opts', [], [], []) ->
          let start' :: SindreX11M ExitCode
start' = Arguments -> SindreX11M ExitCode
start (Arguments -> SindreX11M ExitCode)
-> Arguments -> SindreX11M ExitCode
forall a b. (a -> b) -> a -> b
$ (Arguments -> (Arguments -> Arguments) -> Arguments)
-> Arguments -> [Arguments -> Arguments] -> Arguments
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (((Arguments -> Arguments) -> Arguments -> Arguments)
-> Arguments -> (Arguments -> Arguments) -> Arguments
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Arguments -> Arguments) -> Arguments -> Arguments
forall a. a -> a
id) Arguments
forall k a. Map k a
M.empty [Arguments -> Arguments]
opts'
          in ExitCode -> IO ()
forall a. ExitCode -> IO a
exitWith (ExitCode -> IO ()) -> IO ExitCode -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< AppConfig -> String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend AppConfig
cfg' (AppConfig -> String
cfgDisplay AppConfig
cfg') SindreX11M ExitCode
start'
        ([Arguments -> Arguments]
_, [String]
nonopts, [String]
unrecs, [String]
errs) -> do
          String
usage <- [SindreOption] -> IO String
forall a. [OptDescr a] -> IO String
usageStr [SindreOption]
progopts
          String -> [String] -> [String] -> [String] -> IO ()
badOptions String
usage [String]
nonopts [String]
errs [String]
unrecs
    ([AppConfig -> IO AppConfig]
_, [String]
nonopts, [String]
unrecs, [String]
errs) -> do
      String
usage <- [OptDescr (AppConfig -> IO AppConfig)] -> IO String
forall a. [OptDescr a] -> IO String
usageStr [OptDescr (AppConfig -> IO AppConfig)]
options
      String -> [String] -> [String] -> [String] -> IO ()
badOptions String
usage [String]
nonopts [String]
errs [String]
unrecs

badOptions :: String -> [String] -> [String] -> [String] -> IO ()
badOptions :: String -> [String] -> [String] -> [String] -> IO ()
badOptions String
usage [String]
nonopts [String]
errs [String]
unrecs = do
  (String -> IO ()) -> [String] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (String -> IO ()
forall (m :: * -> *). MonadIO m => String -> m ()
err (String -> IO ()) -> (String -> String) -> String -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"Junk argument: " String -> String -> String
forall a. [a] -> [a] -> [a]
++)) [String]
nonopts
  (String -> IO ()) -> [String] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (String -> IO ()
forall (m :: * -> *). MonadIO m => String -> m ()
err (String -> IO ()) -> (String -> String) -> String -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"Unrecognised argument: " String -> String -> String
forall a. [a] -> [a] -> [a]
++)) [String]
unrecs
  Handle -> String -> IO ()
hPutStr Handle
stderr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [String]
errs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
usage
  IO ()
forall a. IO a
exitFailure

mergeOpts :: [SindreOption] -> [SindreOption]
mergeOpts :: [SindreOption] -> [SindreOption]
mergeOpts = ([SindreOption] -> [SindreOption] -> [SindreOption]
forall a. [a] -> [a] -> [a]
++(OptDescr (AppConfig -> IO AppConfig) -> SindreOption)
-> [OptDescr (AppConfig -> IO AppConfig)] -> [SindreOption]
forall a b. (a -> b) -> [a] -> [b]
map OptDescr (AppConfig -> IO AppConfig) -> SindreOption
forall a a. OptDescr a -> OptDescr (a -> a)
defang [OptDescr (AppConfig -> IO AppConfig)]
options)
    where defang :: OptDescr a -> OptDescr (a -> a)
defang (Option String
s [String]
l ArgDescr a
arg String
doc) = String
-> [String] -> ArgDescr (a -> a) -> String -> OptDescr (a -> a)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
s [String]
l (ArgDescr a -> ArgDescr (a -> a)
forall a a. ArgDescr a -> ArgDescr (a -> a)
idarg ArgDescr a
arg) String
doc
          idarg :: ArgDescr a -> ArgDescr (a -> a)
idarg (ReqArg String -> a
_ String
desc) = (String -> a -> a) -> String -> ArgDescr (a -> a)
forall a. (String -> a) -> String -> ArgDescr a
ReqArg ((a -> a) -> String -> a -> a
forall a b. a -> b -> a
const a -> a
forall a. a -> a
id) String
desc
          idarg (OptArg Maybe String -> a
_ String
desc) = (Maybe String -> a -> a) -> String -> ArgDescr (a -> a)
forall a. (Maybe String -> a) -> String -> ArgDescr a
OptArg ((a -> a) -> Maybe String -> a -> a
forall a b. a -> b -> a
const a -> a
forall a. a -> a
id) String
desc
          idarg (NoArg a
_)       = (a -> a) -> ArgDescr (a -> a)
forall a. a -> ArgDescr a
NoArg a -> a
forall a. a -> a
id

data AppConfig = AppConfig {
    AppConfig -> Program
cfgProgram :: Program
  , AppConfig -> String
cfgDisplay :: String
  , AppConfig -> String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend :: String
               -> SindreX11M ExitCode
               -> IO ExitCode
  , AppConfig -> Map String Fd
cfgFiles :: M.Map String Fd
  }

usageStr :: [OptDescr a] -> IO String
usageStr :: [OptDescr a] -> IO String
usageStr [OptDescr a]
opts = do
  String
prog <- IO String
getProgName
  let header :: String
header = String
"Help for " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
prog String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (Sindre " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Version -> String
showVersion Version
version String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
  String -> IO String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> IO String) -> String -> IO String
forall a b. (a -> b) -> a -> b
$ String -> [OptDescr a] -> String
forall a. String -> [OptDescr a] -> String
usageInfo String
header [OptDescr a]
opts

type AppOption = OptDescr (AppConfig -> IO AppConfig)

options :: [AppOption]
options :: [OptDescr (AppConfig -> IO AppConfig)]
options =
  [ String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"f" [String
"file"]
    ((String -> AppConfig -> IO AppConfig)
-> String -> ArgDescr (AppConfig -> IO AppConfig)
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\String
arg AppConfig
cfg -> do
               Either ParseError Program
result <- Program -> String -> String -> Either ParseError Program
parseSindre (AppConfig -> Program
cfgProgram AppConfig
cfg) String
arg (String -> Either ParseError Program)
-> IO String -> IO (Either ParseError Program)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> IO String
readFile String
arg
               case Either ParseError Program
result of
                 Left ParseError
e -> String -> IO AppConfig
forall a. HasCallStack => String -> a
error (String -> IO AppConfig) -> String -> IO AppConfig
forall a b. (a -> b) -> a -> b
$ ParseError -> String
forall a. Show a => a -> String
show ParseError
e
                 Right Program
prog -> AppConfig -> IO AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return (AppConfig -> IO AppConfig) -> AppConfig -> IO AppConfig
forall a b. (a -> b) -> a -> b
$ AppConfig
cfg { cfgProgram :: Program
cfgProgram = Program
prog })
     String
"FILE")
    String
"Read program code from the given file."
  , String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"e" [String
"expression"]
    ((String -> AppConfig -> IO AppConfig)
-> String -> ArgDescr (AppConfig -> IO AppConfig)
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\String
arg AppConfig
cfg ->
               case Program -> String -> String -> Either ParseError Program
parseSindre (AppConfig -> Program
cfgProgram AppConfig
cfg) String
"expression" String
arg of
                 Left ParseError
e -> String -> IO AppConfig
forall a. HasCallStack => String -> a
error (String -> IO AppConfig) -> String -> IO AppConfig
forall a b. (a -> b) -> a -> b
$ ParseError -> String
forall a. Show a => a -> String
show ParseError
e
                 Right Program
prog -> AppConfig -> IO AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return (AppConfig -> IO AppConfig) -> AppConfig -> IO AppConfig
forall a b. (a -> b) -> a -> b
$ AppConfig
cfg { cfgProgram :: Program
cfgProgram = Program
prog })
     String
"code")
    String
"Add the given code to the program."
  , String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"wmmode"]
    (let wmmode :: String -> AppConfig -> m AppConfig
wmmode String
"normal" AppConfig
cfg = AppConfig -> m AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return AppConfig
cfg { cfgBackend :: String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend = String -> SindreX11M ExitCode -> IO ExitCode
sindreX11 }
         wmmode String
"override" AppConfig
cfg = AppConfig -> m AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return AppConfig
cfg { cfgBackend :: String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend = String -> SindreX11M ExitCode -> IO ExitCode
sindreX11override }
         wmmode String
"dock" AppConfig
cfg = AppConfig -> m AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return AppConfig
cfg { cfgBackend :: String -> SindreX11M ExitCode -> IO ExitCode
cfgBackend = String -> SindreX11M ExitCode -> IO ExitCode
sindreX11dock }
         wmmode String
_ AppConfig
_ = String -> m AppConfig
forall a. HasCallStack => String -> a
error String
"Argument to --wmmode must be normal, override or dock."
     in (String -> AppConfig -> IO AppConfig)
-> String -> ArgDescr (AppConfig -> IO AppConfig)
forall a. (String -> a) -> String -> ArgDescr a
ReqArg String -> AppConfig -> IO AppConfig
forall (m :: * -> *). Monad m => String -> AppConfig -> m AppConfig
wmmode String
"normal|override|dock")
    String
"How Sindre interacts with the window manager (defaults to 'override')."
  , String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"v" [String
"version"]
    ((AppConfig -> IO AppConfig) -> ArgDescr (AppConfig -> IO AppConfig)
forall a. a -> ArgDescr a
NoArg (\AppConfig
_ -> do Handle -> String -> IO ()
hPutStrLn Handle
stderr (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"Sindre " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Version -> String
showVersion Version
version String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (C) " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
mail
                     IO AppConfig
forall a. IO a
exitSuccess))
    String
"Show version information."
  , String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"h" [String
"help"]
    ((AppConfig -> IO AppConfig) -> ArgDescr (AppConfig -> IO AppConfig)
forall a. a -> ArgDescr a
NoArg (\AppConfig
_ -> do Handle -> String -> IO ()
hPutStr Handle
stderr (String -> IO ()) -> IO String -> IO ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [OptDescr (AppConfig -> IO AppConfig)] -> IO String
forall a. [OptDescr a] -> IO String
usageStr [OptDescr (AppConfig -> IO AppConfig)]
options
                     IO AppConfig
forall a. IO a
exitSuccess))
    String
"Show usage information."
  , String
-> [String]
-> ArgDescr (AppConfig -> IO AppConfig)
-> String
-> OptDescr (AppConfig -> IO AppConfig)
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"fd"]
    ((String -> AppConfig -> IO AppConfig)
-> String -> ArgDescr (AppConfig -> IO AppConfig)
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\String
arg AppConfig
cfg ->
             case (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
isAlpha String
arg of
               (name :: String
name@(Char
_:String
_), Char
'=':fdnum :: String
fdnum@(Char
_:String
_)) | (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit String
fdnum ->
                 AppConfig -> IO AppConfig
forall (m :: * -> *) a. Monad m => a -> m a
return AppConfig
cfg { cfgFiles :: Map String Fd
cfgFiles = String -> Fd -> Map String Fd -> Map String Fd
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert String
name (String -> Fd
forall a. Read a => String -> a
read String
fdnum)
                                         (Map String Fd -> Map String Fd) -> Map String Fd -> Map String Fd
forall a b. (a -> b) -> a -> b
$ AppConfig -> Map String Fd
cfgFiles AppConfig
cfg }
               (String, String)
_ -> String -> IO AppConfig
forall a. HasCallStack => String -> a
error String
"Malformed --fd option")
    String
"STREAMNAME=FD")
     String
"Create input stream from file descriptor"
  ]

mail :: String
mail :: String
mail = String
"Troels Henriksen <athas@sigkill.dk>"

mkUndef :: MonadBackend m => Constructor m
mkUndef :: Constructor m
mkUndef ObjectRef
_ [(Maybe Value, ObjectRef)]
_ = Sindre m (NewWidget m) -> ConstructorM m (NewWidget m)
forall (im :: * -> *) (m :: (* -> *) -> * -> *) a.
MonadSindre im m =>
Sindre im a -> m im a
sindre (Sindre m (NewWidget m) -> ConstructorM m (NewWidget m))
-> Sindre m (NewWidget m) -> ConstructorM m (NewWidget m)
forall a b. (a -> b) -> a -> b
$ String -> Sindre m (NewWidget m)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"No GUI defined (empty program?)"

emptyProgram :: Program
emptyProgram :: Program
emptyProgram = Program :: (Maybe (P Expr), GUI)
-> [P (Pattern, Action)]
-> [P (String, P Expr)]
-> [P (String, (SindreOption, Maybe Value))]
-> [P (String, Function)]
-> [P Stmt]
-> Program
Program {
                 programGUI :: (Maybe (P Expr), GUI)
programGUI = (Maybe (P Expr)
forall a. Maybe a
Nothing, Maybe String
-> P String -> WidgetArgs -> [(Maybe (P Expr), GUI)] -> GUI
GUI Maybe String
forall a. Maybe a
Nothing (SourcePos -> String -> P String
forall a. SourcePos -> a -> P a
P SourcePos
nowhere String
"") WidgetArgs
forall k a. Map k a
M.empty [])
               , programActions :: [P (Pattern, Action)]
programActions = []
               , programGlobals :: [P (String, P Expr)]
programGlobals = []
               , programOptions :: [P (String, (SindreOption, Maybe Value))]
programOptions = []
               , programFunctions :: [P (String, Function)]
programFunctions = []
               , programBegin :: [P Stmt]
programBegin = []
               }

classMap :: ClassMap SindreX11M
classMap :: ClassMap SindreX11M
classMap = [(String, Constructor SindreX11M)] -> ClassMap SindreX11M
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [ (String
"Dial", Constructor SindreX11M
mkDial)
                      , (String
"Label", Constructor SindreX11M
mkLabel)
                      , (String
"Blank", Constructor SindreX11M
mkBlank)
                      , (String
"Horizontally", Constructor SindreX11M
forall (m :: * -> *). MonadBackend m => Constructor m
mkHorizontally)
                      , (String
"Vertically", Constructor SindreX11M
forall (m :: * -> *). MonadBackend m => Constructor m
mkVertically)
                      , (String
"Input", Constructor SindreX11M
mkTextField)
                      , (String
"HList", Constructor SindreX11M
mkHList)
                      , (String
"VList", Constructor SindreX11M
mkVList)
                      , (String
"Graph", Constructor SindreX11M
mkGraph)
                      , (String
"", Constructor SindreX11M
forall (m :: * -> *). MonadBackend m => Constructor m
mkUndef)
                      ]

objectMap :: ObjectMap SindreX11M
objectMap :: ObjectMap SindreX11M
objectMap = [(String, ObjectRef -> SindreX11M (NewObject SindreX11M))]
-> ObjectMap SindreX11M
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [ (String
"stdin", Handle -> ObjectRef -> SindreX11M (NewObject SindreX11M)
mkInStream Handle
stdin) ]

funcMap :: FuncMap SindreX11M
funcMap :: FuncMap SindreX11M
funcMap = FuncMap SindreX11M
forall (im :: * -> *). MonadBackend im => FuncMap im
stdFunctions FuncMap SindreX11M -> FuncMap SindreX11M -> FuncMap SindreX11M
forall k a. Ord k => Map k a -> Map k a -> Map k a
`M.union` FuncMap SindreX11M
forall (m :: * -> *). (MonadIO m, MonadBackend m) => FuncMap m
ioFunctions

globMap :: GlobMap SindreX11M
globMap :: GlobMap SindreX11M
globMap = GlobMap SindreX11M
forall (im :: * -> *). MonadIO im => Map String (im Value)
ioGlobals