1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{- |
Module : Text.Pandoc.Lua
Copyright : Copyright © 2017-2023 Albert Krewinkel
License : GNU GPL, version 2 or above
Maintainer : Albert Krewinkel <[email protected]>
Stability : alpha
Functions to initialize the Lua interpreter.
-}
module Text.Pandoc.Lua.Init
( runLua
, runLuaNoEnv
, runLuaWith
) where
import Control.Monad (forM, forM_, when)
import Control.Monad.Catch (throwM, try)
import Control.Monad.Trans (MonadIO (..))
import Data.Maybe (catMaybes)
import Data.Version (makeVersion)
import HsLua as Lua hiding (status, try)
import Text.Pandoc.Class (PandocMonad (..))
import Text.Pandoc.Data (readDataFile)
import Text.Pandoc.Error (PandocError (PandocLuaError))
import Text.Pandoc.Lua.Global (Global (..), setGlobals)
import Text.Pandoc.Lua.Marshal.List (newListMetatable, pushListModule)
import Text.Pandoc.Lua.PandocLua (PandocLua (..), liftPandocLua)
import qualified Data.ByteString.Char8 as Char8
import qualified Data.Text as T
import qualified Lua.LPeg as LPeg
import qualified HsLua.Aeson
import qualified HsLua.Module.DocLayout as Module.Layout
import qualified HsLua.Module.Path as Module.Path
import qualified HsLua.Module.Zip as Module.Zip
import qualified Text.Pandoc.Lua.Module.CLI as Pandoc.CLI
import qualified Text.Pandoc.Lua.Module.Format as Pandoc.Format
import qualified Text.Pandoc.Lua.Module.JSON as Pandoc.JSON
import qualified Text.Pandoc.Lua.Module.MediaBag as Pandoc.MediaBag
import qualified Text.Pandoc.Lua.Module.Pandoc as Module.Pandoc
import qualified Text.Pandoc.Lua.Module.Scaffolding as Pandoc.Scaffolding
import qualified Text.Pandoc.Lua.Module.Structure as Pandoc.Structure
import qualified Text.Pandoc.Lua.Module.System as Pandoc.System
import qualified Text.Pandoc.Lua.Module.Template as Pandoc.Template
import qualified Text.Pandoc.Lua.Module.Text as Pandoc.Text
import qualified Text.Pandoc.Lua.Module.Types as Pandoc.Types
import qualified Text.Pandoc.Lua.Module.Utils as Pandoc.Utils
-- | Run the Lua interpreter, using pandoc's default way of environment
-- initialization.
runLua :: (PandocMonad m, MonadIO m)
=> LuaE PandocError a -> m (Either PandocError a)
runLua action = do
runPandocLuaWith Lua.run . try $ do
initLuaState
liftPandocLua action
runLuaWith :: (PandocMonad m, MonadIO m)
=> GCManagedState -> LuaE PandocError a -> m (Either PandocError a)
runLuaWith luaState action = do
runPandocLuaWith (withGCManagedState luaState) . try $ do
initLuaState
liftPandocLua action
-- | Like 'runLua', but ignores all environment variables like @LUA_PATH@.
runLuaNoEnv :: (PandocMonad m, MonadIO m)
=> LuaE PandocError a -> m (Either PandocError a)
runLuaNoEnv action = do
runPandocLuaWith Lua.run . try $ do
liftPandocLua $ do
-- This is undocumented, but works -- the code is adapted from the
-- `lua.c` sources for the default interpreter.
Lua.pushboolean True
Lua.setfield Lua.registryindex "LUA_NOENV"
initLuaState
liftPandocLua action
-- | Modules that are loaded at startup and assigned to fields in the
-- pandoc module.
--
-- Note that @pandoc.List@ is not included here for technical reasons;
-- it must be handled separately.
loadedModules :: [Module PandocError]
loadedModules =
[ Pandoc.CLI.documentedModule
, Pandoc.Format.documentedModule
, Pandoc.JSON.documentedModule
, Pandoc.MediaBag.documentedModule
, Pandoc.Scaffolding.documentedModule
, Pandoc.Structure.documentedModule
, Pandoc.System.documentedModule
, Pandoc.Template.documentedModule
, Pandoc.Text.documentedModule
, Pandoc.Types.documentedModule
, Pandoc.Utils.documentedModule
, Module.Layout.documentedModule { moduleName = "pandoc.layout" }
`allSince` [2,18]
, Module.Path.documentedModule { moduleName = "pandoc.path" }
`allSince` [2,12]
, Module.Zip.documentedModule { moduleName = "pandoc.zip" }
`allSince` [3,0]
]
where
allSince mdl version = mdl
{ moduleFunctions = map (`since` makeVersion version) $ moduleFunctions mdl
}
-- | Initialize the lua state with all required values
initLuaState :: PandocLua ()
initLuaState = do
liftPandocLua Lua.openlibs
initJsonMetatable
initPandocModule
installLpegSearcher
setGlobalModules
loadInitScript "init.lua"
where
initPandocModule :: PandocLua ()
initPandocModule = liftPandocLua $ do
-- Push module table
registerModule Module.Pandoc.documentedModule
-- load modules and add them to the `pandoc` module table.
forM_ loadedModules $ \mdl -> do
registerModule mdl
-- pandoc.text must be require-able as 'text' for backwards compat.
when (moduleName mdl == "pandoc.text") $ do
getfield registryindex loaded
pushvalue (nth 2)
setfield (nth 2) "text"
pop 1 -- _LOADED
-- Shorten name, drop everything before the first dot (if any).
let fieldname (Name mdlname) = Name .
maybe mdlname snd . Char8.uncons . snd $
Char8.break (== '.') mdlname
Lua.setfield (nth 2) (fieldname $ moduleName mdl)
-- pandoc.List is low-level and must be opened differently.
requirehs "pandoc.List" (const pushListModule)
setfield (nth 2) "List"
-- assign module to global variable
Lua.setglobal "pandoc"
loadInitScript :: FilePath -> PandocLua ()
loadInitScript scriptFile = do
script <- readDataFile scriptFile
status <- liftPandocLua $ Lua.dostring script
when (status /= Lua.OK) . liftPandocLua $ do
err <- popException
let prefix = "Couldn't load '" <> T.pack scriptFile <> "':\n"
throwM . PandocLuaError . (prefix <>) $ case err of
PandocLuaError msg -> msg
_ -> T.pack $ show err
setGlobalModules :: PandocLua ()
setGlobalModules = liftPandocLua $ do
let globalModules =
[ ("lpeg", LPeg.luaopen_lpeg_ptr) -- must be loaded first
, ("re", LPeg.luaopen_re_ptr) -- re depends on lpeg
]
loadedBuiltInModules <- fmap catMaybes . forM globalModules $
\(pkgname, luaopen) -> do
Lua.pushcfunction luaopen
usedBuiltIn <- Lua.pcall 0 1 Nothing >>= \case
OK -> do -- all good, loading succeeded
-- register as loaded module so later modules can rely on this
Lua.getfield Lua.registryindex Lua.loaded
Lua.pushvalue (Lua.nth 2)
Lua.setfield (Lua.nth 2) pkgname
Lua.pop 1 -- pop _LOADED
return True
_ -> do -- built-in library failed, load system lib
Lua.pop 1 -- ignore error message
-- Try loading via the normal package loading mechanism.
Lua.getglobal "require"
Lua.pushName pkgname
Lua.call 1 1 -- Throws an exception if loading failed again!
return False
-- Module on top of stack. Register as global
Lua.setglobal pkgname
return $ if usedBuiltIn then Just pkgname else Nothing
-- Remove module entry from _LOADED table in registry if we used a
-- built-in library. This ensures that later calls to @require@ will
-- prefer the shared library, if any.
forM_ loadedBuiltInModules $ \pkgname -> do
Lua.getfield Lua.registryindex Lua.loaded
Lua.pushnil
Lua.setfield (Lua.nth 2) pkgname
Lua.pop 1 -- registry
installLpegSearcher :: PandocLua ()
installLpegSearcher = liftPandocLua $ do
Lua.getglobal' "package.searchers"
Lua.pushHaskellFunction $ Lua.state >>= liftIO . LPeg.lpeg_searcher
Lua.rawseti (Lua.nth 2) . (+1) . fromIntegral =<< Lua.rawlen (Lua.nth 2)
Lua.pop 1 -- remove 'package.searchers' from stack
-- | Setup the metatable that's assigned to Lua tables that were created
-- from/via JSON arrays.
initJsonMetatable :: PandocLua ()
initJsonMetatable = liftPandocLua $ do
newListMetatable HsLua.Aeson.jsonarray (pure ())
Lua.pop 1
-- | Evaluate a @'PandocLua'@ computation, running all contained Lua
-- operations.
runPandocLuaWith :: (PandocMonad m, MonadIO m)
=> (forall b. LuaE PandocError b -> IO b)
-> PandocLua a
-> m a
runPandocLuaWith runner pLua = do
origState <- getCommonState
globals <- defaultGlobals
(result, newState) <- liftIO . runner . unPandocLua $ do
putCommonState origState
liftPandocLua $ setGlobals globals
r <- pLua
c <- getCommonState
return (r, c)
putCommonState newState
return result
-- | Global variables which should always be set.
defaultGlobals :: PandocMonad m => m [Global]
defaultGlobals = do
commonState <- getCommonState
return
[ PANDOC_API_VERSION
, PANDOC_STATE commonState
, PANDOC_VERSION
]
|
