-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Lua parser and pretty-printer
--   
--   Lua 5.2 lexer, parser and pretty-printer. Documentation:
--   (<a>https://osa1.github.com/language-lua</a>)
--   
--   Changelog: 0.2.3: - Minor internal changes.
--   
--   0.2.2:
--   
--   <ul>
--   <li>Some tweaks in pretty-printer.</li>
--   </ul>
--   
--   0.2.0:
--   
--   <ul>
--   <li>Syntax tree is annotated. All parsers(<a>parseText</a>,
--   <a>parseFile</a>) annotate resulting tree with source positions.</li>
--   </ul>
@package language-lua
@version 0.2.3

module Language.Lua.Token

-- | Lua tokens
data LToken

-- | +
LTokPlus :: LToken

-- | -
LTokMinus :: LToken

-- | *
LTokStar :: LToken

-- | /
LTokSlash :: LToken

-- | %
LTokPercent :: LToken

-- | ^
LTokExp :: LToken

-- | #
LTokSh :: LToken

-- | ==
LTokEqual :: LToken

-- | ~=
LTokNotequal :: LToken

-- | &lt;=
LTokLEq :: LToken

-- | &gt;=
LTokGEq :: LToken

-- | &lt;
LTokLT :: LToken

-- | &gt;
LTokGT :: LToken

-- | =
LTokAssign :: LToken

-- | (
LTokLParen :: LToken

-- | )
LTokRParen :: LToken

-- | {
LTokLBrace :: LToken

-- | }
LTokRBrace :: LToken

-- | [
LTokLBracket :: LToken

-- | ]
LTokRBracket :: LToken

-- | ::
LTokDColon :: LToken

-- | ;
LTokSemic :: LToken

-- | :
LTokColon :: LToken

-- | ,
LTokComma :: LToken

-- | .
LTokDot :: LToken

-- | ..
LTokDDot :: LToken

-- | ...
LTokEllipsis :: LToken

-- | and
LTokAnd :: LToken

-- | break
LTokBreak :: LToken

-- | do
LTokDo :: LToken

-- | else
LTokElse :: LToken

-- | elseif
LTokElseIf :: LToken

-- | end
LTokEnd :: LToken

-- | false
LTokFalse :: LToken

-- | for
LTokFor :: LToken

-- | function
LTokFunction :: LToken

-- | goto
LTokGoto :: LToken

-- | if
LTokIf :: LToken

-- | in
LTokIn :: LToken

-- | local
LTokLocal :: LToken

-- | nil
LTokNil :: LToken

-- | not
LTokNot :: LToken

-- | or
LTokOr :: LToken

-- | repeat
LTokRepeat :: LToken

-- | return
LTokReturn :: LToken

-- | then
LTokThen :: LToken

-- | true
LTokTrue :: LToken

-- | until
LTokUntil :: LToken

-- | while
LTokWhile :: LToken

-- | number constant
LTokNum :: String -> LToken

-- | string constant
LTokSLit :: String -> LToken

-- | identifier
LTokIdent :: String -> LToken

-- | end of file
LTokEof :: LToken

-- | Partial function, returns value of <a>LTokNum</a>, <a>LTokSLit</a> and
--   <a>LTokIdent</a>.
tokenValue :: LToken -> String
instance Eq LToken
instance Show LToken

module Language.Lua.Lexer

-- | Lua lexer.
llex :: String -> [LTok]

-- | Run Lua lexer on a file.
llexFile :: FilePath -> IO [LTok]

-- | Lua token with position information.
type LTok = (LToken, AlexPosn)
data AlexPosn
AlexPn :: !Int -> !Int -> !Int -> AlexPosn
instance Eq AlexPosn
instance Show AlexPosn
instance Show EOF
instance Functor AlexLastAcc
instance Monad Alex


-- | Lexer/Parsec interface
module Text.Parsec.LTok
type Parser = Parsec [LTok] ()

-- | This parser succeeds whenever the given predicate returns true when
--   called with parsed <a>LTok</a>. Same as <a>satisfy</a>.
satisfy :: Stream [LTok] m LTok => (LTok -> Bool) -> ParsecT [LTok] u m LToken

-- | Parses given <a>LToken</a>.
tok :: Stream [LTok] m LTok => LToken -> ParsecT [LTok] u m LToken

-- | Parses a <a>LTokIdent</a>.
anyIdent :: Monad m => ParsecT [LTok] u m LToken

-- | Parses a <a>LTokNum</a>.
anyNum :: Monad m => ParsecT [LTok] u m LToken

-- | Parses a <a>LTokSLit</a>.
string :: Monad m => ParsecT [LTok] u m LToken


-- | Lua 5.2 syntax tree, as specified in
--   <a>http://www.lua.org/manual/5.2/manual.html#9</a>.
module Language.Lua.Types
data Name a
Name :: a -> String -> Name a
data Stat a

-- | var1, var2 .. = exp1, exp2 ..
Assign :: a -> [Var a] -> [Exp a] -> Stat a

-- | function call
FunCall :: a -> (FunCall a) -> Stat a

-- | label for goto
Label :: a -> (Name a) -> Stat a

-- | break
Break :: a -> Stat a

-- | goto label
Goto :: a -> (Name a) -> Stat a

-- | do .. end
Do :: a -> (Block a) -> Stat a

-- | while .. do .. end
While :: a -> (Exp a) -> (Block a) -> Stat a

-- | repeat .. until ..
Repeat :: a -> (Block a) -> (Exp a) -> Stat a

-- | if .. then .. [elseif ..] [else ..] end
If :: a -> [(Exp a, Block a)] -> (Maybe (Block a)) -> Stat a

-- | for x=start, end [, step] do .. end
ForRange :: a -> (Name a) -> (Exp a) -> (Exp a) -> (Maybe (Exp a)) -> (Block a) -> Stat a

-- | for x in .. do .. end
ForIn :: a -> [Name a] -> [Exp a] -> (Block a) -> Stat a

-- | function &lt;var&gt; (..) .. end
FunAssign :: a -> (FunName a) -> (FunBody a) -> Stat a

-- | local function &lt;var&gt; (..) .. end
LocalFunAssign :: a -> (Name a) -> (FunBody a) -> Stat a

-- | local var1, var2 .. = exp1, exp2 ..
LocalAssign :: a -> [Name a] -> (Maybe [Exp a]) -> Stat a

-- | <i>;</i>
EmptyStat :: a -> Stat a
data Exp a
Nil :: a -> Exp a
Bool :: a -> Bool -> Exp a
Number :: a -> String -> Exp a
String :: a -> String -> Exp a

-- | <i>...</i>
Vararg :: a -> Exp a

-- | <i>function (..) .. end</i>
EFunDef :: a -> (FunDef a) -> Exp a
PrefixExp :: a -> (PrefixExp a) -> Exp a

-- | table constructor
TableConst :: a -> (Table a) -> Exp a

-- | binary operators, <i>+ - * ^ % .. &lt; &lt;= &gt; &gt;= == ~= and
--   or</i>
Binop :: a -> (Binop a) -> (Exp a) -> (Exp a) -> Exp a

-- | unary operators, <i>- not #</i>
Unop :: a -> (Unop a) -> (Exp a) -> Exp a
data Var a

-- | variable
VarName :: a -> (Name a) -> Var a

-- | <i>table[exp]</i>
Select :: a -> (PrefixExp a) -> (Exp a) -> Var a

-- | <i>table.variable</i>
SelectName :: a -> (PrefixExp a) -> (Name a) -> Var a
data Binop a
Add :: a -> Binop a
Sub :: a -> Binop a
Mul :: a -> Binop a
Div :: a -> Binop a
Exp :: a -> Binop a
Mod :: a -> Binop a
Concat :: a -> Binop a
LT :: a -> Binop a
LTE :: a -> Binop a
GT :: a -> Binop a
GTE :: a -> Binop a
EQ :: a -> Binop a
NEQ :: a -> Binop a
And :: a -> Binop a
Or :: a -> Binop a
data Unop a
Neg :: a -> Unop a
Not :: a -> Unop a
Len :: a -> Unop a
data PrefixExp a
PEVar :: a -> (Var a) -> PrefixExp a
PEFunCall :: a -> (FunCall a) -> PrefixExp a
Paren :: a -> (Exp a) -> PrefixExp a
data Table a

-- | list of table fields
Table :: a -> [TableField a] -> Table a
data TableField a

-- | <i>[exp] = exp</i>
ExpField :: a -> (Exp a) -> (Exp a) -> TableField a

-- | <i>name = exp</i>
NamedField :: a -> (Name a) -> (Exp a) -> TableField a
Field :: a -> (Exp a) -> TableField a

-- | A block is list of statements with optional return statement.
data Block a
Block :: a -> [Stat a] -> (Maybe [Exp a]) -> Block a
data FunName a
FunName :: a -> (Name a) -> [Name a] -> (Maybe (Name a)) -> FunName a
data FunDef a
FunDef :: a -> (FunBody a) -> FunDef a
data FunBody a

-- | (args, vararg, block)
FunBody :: a -> [Name a] -> (Maybe a) -> (Block a) -> FunBody a
data FunCall a

-- | <i>prefixexp ( funarg )</i>
NormalFunCall :: a -> (PrefixExp a) -> (FunArg a) -> FunCall a

-- | <i>prefixexp : name ( funarg )</i>
MethodCall :: a -> (PrefixExp a) -> (Name a) -> (FunArg a) -> FunCall a
data FunArg a

-- | list of args
Args :: a -> [Exp a] -> FunArg a

-- | table constructor
TableArg :: a -> (Table a) -> FunArg a

-- | string
StringArg :: a -> String -> FunArg a
class Functor ast => Annotated ast
ann :: Annotated ast => ast l -> l
amap :: Annotated ast => (l -> l) -> ast l -> ast l
instance Show a => Show (Name a)
instance Eq a => Eq (Name a)
instance Functor Name
instance Show a => Show (Binop a)
instance Eq a => Eq (Binop a)
instance Functor Binop
instance Show a => Show (Unop a)
instance Eq a => Eq (Unop a)
instance Functor Unop
instance Show a => Show (FunName a)
instance Eq a => Eq (FunName a)
instance Functor FunName
instance Show a => Show (FunArg a)
instance Eq a => Eq (FunArg a)
instance Functor FunArg
instance Show a => Show (Table a)
instance Eq a => Eq (Table a)
instance Functor Table
instance Show a => Show (TableField a)
instance Eq a => Eq (TableField a)
instance Functor TableField
instance Show a => Show (Exp a)
instance Eq a => Eq (Exp a)
instance Functor Exp
instance Show a => Show (FunDef a)
instance Eq a => Eq (FunDef a)
instance Functor FunDef
instance Show a => Show (FunBody a)
instance Eq a => Eq (FunBody a)
instance Functor FunBody
instance Show a => Show (Block a)
instance Eq a => Eq (Block a)
instance Functor Block
instance Show a => Show (Stat a)
instance Eq a => Eq (Stat a)
instance Functor Stat
instance Show a => Show (FunCall a)
instance Eq a => Eq (FunCall a)
instance Functor FunCall
instance Show a => Show (PrefixExp a)
instance Eq a => Eq (PrefixExp a)
instance Functor PrefixExp
instance Show a => Show (Var a)
instance Eq a => Eq (Var a)
instance Functor Var
instance Annotated FunArg
instance Annotated FunCall
instance Annotated FunBody
instance Annotated FunDef
instance Annotated FunName
instance Annotated Block
instance Annotated TableField
instance Annotated Table
instance Annotated PrefixExp
instance Annotated Unop
instance Annotated Binop
instance Annotated Var
instance Annotated Exp
instance Annotated Stat

module Language.Lua.Parser

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parsec [LTok] () a -> String -> Either ParseError a

-- | Parse a Lua file. You can use <tt>parseText chunk</tt> to parse a file
--   from a string.
parseFile :: FilePath -> IO (Either ParseError (Block SourcePos))

-- | Statement parser.
stat :: Parser (Stat SourcePos)

-- | Expression parser.
exp :: Parser (Exp SourcePos)

-- | Lua file parser.
chunk :: Parser (Block SourcePos)
instance Show a => Show (PrimaryExp a)
instance Eq a => Eq (PrimaryExp a)
instance Show a => Show (SuffixExp a)
instance Eq a => Eq (SuffixExp a)
instance Show a => Show (SuffixedExp a)
instance Eq a => Eq (SuffixedExp a)


-- | Lua pretty-printer.
module Language.Lua.PrettyPrinter

-- | This is the default pretty printer which is used by <a>show</a>,
--   <a>putDoc</a> and <a>hPutDoc</a>. <tt>(renderPretty ribbonfrac width
--   x)</tt> renders document <tt>x</tt> with a page width of
--   <tt>width</tt> and a ribbon width of <tt>(ribbonfrac * width)</tt>
--   characters. The ribbon width is the maximal amount of non-indentation
--   characters on a line. The parameter <tt>ribbonfrac</tt> should be
--   between <tt>0.0</tt> and <tt>1.0</tt>. If it is lower or higher, the
--   ribbon width will be 0 or <tt>width</tt> respectively.
renderPretty :: Float -> Int -> Doc -> SimpleDoc

-- | <tt>(displayS simpleDoc)</tt> takes the output <tt>simpleDoc</tt> from
--   a rendering function and transforms it to a <a>ShowS</a> type (for use
--   in the <a>Show</a> class).
--   
--   <pre>
--   showWidth :: Int -&gt; Doc -&gt; String
--   showWidth w x   = displayS (renderPretty 0.4 w x) ""
--   </pre>
displayS :: SimpleDoc -> ShowS

-- | <tt>(displayIO handle simpleDoc)</tt> writes <tt>simpleDoc</tt> to the
--   file handle <tt>handle</tt>. This function is used for example by
--   <a>hPutDoc</a>:
--   
--   <pre>
--   hPutDoc handle doc  = displayIO handle (renderPretty 0.4 100 doc)
--   </pre>
displayIO :: Handle -> SimpleDoc -> IO ()
class LPretty a
pprint :: LPretty a => a -> Doc
instance LPretty (Stat a)
instance LPretty (FunArg a)
instance LPretty (FunCall a)
instance LPretty (FunBody a)
instance LPretty (FunDef a)
instance LPretty (FunName a)
instance LPretty (Block a)
instance LPretty (TableField a)
instance LPretty (Table a)
instance LPretty (PrefixExp a)
instance LPretty (Unop a)
instance LPretty (Binop a)
instance LPretty (Var a)
instance LPretty (Exp a)
instance LPretty (Name a)
instance LPretty Bool
instance LPretty [Char]

module Language.Lua

-- | Runs Lua lexer before parsing. Use <tt>parseText stat</tt> to parse
--   statements, and <tt>parseText exp</tt> to parse expressions.
parseText :: Parsec [LTok] () a -> String -> Either ParseError a

-- | Parse a Lua file. You can use <tt>parseText chunk</tt> to parse a file
--   from a string.
parseFile :: FilePath -> IO (Either ParseError (Block SourcePos))

-- | Lua lexer.
llex :: String -> [LTok]

-- | Run Lua lexer on a file.
llexFile :: FilePath -> IO [LTok]

-- | Statement parser.
stat :: Parser (Stat SourcePos)

-- | Expression parser.
exp :: Parser (Exp SourcePos)

-- | Lua file parser.
chunk :: Parser (Block SourcePos)

-- | A block is list of statements with optional return statement.
data Block a
Block :: a -> [Stat a] -> (Maybe [Exp a]) -> Block a
data Stat a

-- | var1, var2 .. = exp1, exp2 ..
Assign :: a -> [Var a] -> [Exp a] -> Stat a

-- | function call
FunCall :: a -> (FunCall a) -> Stat a

-- | label for goto
Label :: a -> (Name a) -> Stat a

-- | break
Break :: a -> Stat a

-- | goto label
Goto :: a -> (Name a) -> Stat a

-- | do .. end
Do :: a -> (Block a) -> Stat a

-- | while .. do .. end
While :: a -> (Exp a) -> (Block a) -> Stat a

-- | repeat .. until ..
Repeat :: a -> (Block a) -> (Exp a) -> Stat a

-- | if .. then .. [elseif ..] [else ..] end
If :: a -> [(Exp a, Block a)] -> (Maybe (Block a)) -> Stat a

-- | for x=start, end [, step] do .. end
ForRange :: a -> (Name a) -> (Exp a) -> (Exp a) -> (Maybe (Exp a)) -> (Block a) -> Stat a

-- | for x in .. do .. end
ForIn :: a -> [Name a] -> [Exp a] -> (Block a) -> Stat a

-- | function &lt;var&gt; (..) .. end
FunAssign :: a -> (FunName a) -> (FunBody a) -> Stat a

-- | local function &lt;var&gt; (..) .. end
LocalFunAssign :: a -> (Name a) -> (FunBody a) -> Stat a

-- | local var1, var2 .. = exp1, exp2 ..
LocalAssign :: a -> [Name a] -> (Maybe [Exp a]) -> Stat a

-- | <i>;</i>
EmptyStat :: a -> Stat a
data Exp a
Nil :: a -> Exp a
Bool :: a -> Bool -> Exp a
Number :: a -> String -> Exp a
String :: a -> String -> Exp a

-- | <i>...</i>
Vararg :: a -> Exp a

-- | <i>function (..) .. end</i>
EFunDef :: a -> (FunDef a) -> Exp a
PrefixExp :: a -> (PrefixExp a) -> Exp a

-- | table constructor
TableConst :: a -> (Table a) -> Exp a

-- | binary operators, <i>+ - * ^ % .. &lt; &lt;= &gt; &gt;= == ~= and
--   or</i>
Binop :: a -> (Binop a) -> (Exp a) -> (Exp a) -> Exp a

-- | unary operators, <i>- not #</i>
Unop :: a -> (Unop a) -> (Exp a) -> Exp a
pprint :: LPretty a => a -> Doc