-- 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.
@package language-lua
@version 0.1.2

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

-- | <=
LTokLEq :: LToken

-- | >=
LTokGEq :: LToken

-- | <
LTokLT :: LToken

-- | >
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]

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


-- | 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
type Name = String
data Stat

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

-- | function call
FunCall :: FunCall -> Stat

-- | label for goto
Label :: Name -> Stat

-- | break
Break :: Stat

-- | goto label
Goto :: Name -> Stat

-- | do .. end
Do :: Block -> Stat

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

-- | repeat .. until ..
Repeat :: Block -> Exp -> Stat

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

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

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

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

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

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

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

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

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

-- | table constructor
TableConst :: Table -> Exp

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

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

-- | variable
Name :: Name -> Var

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

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

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

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

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

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

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

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

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

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

-- | table constructor
TableArg :: Table -> FunArg

-- | string
StringArg :: String -> FunArg
instance Show Binop
instance Eq Binop
instance Show Unop
instance Eq Unop
instance Show FunName
instance Eq FunName
instance Show FunArg
instance Eq FunArg
instance Show Table
instance Eq Table
instance Show TableField
instance Eq TableField
instance Show Exp
instance Eq Exp
instance Show FunDef
instance Eq FunDef
instance Show FunBody
instance Eq FunBody
instance Show Block
instance Eq Block
instance Show Stat
instance Eq Stat
instance Show FunCall
instance Eq FunCall
instance Show PrefixExp
instance Eq PrefixExp
instance Show Var
instance Eq Var

module Language.Lua.Parser

-- | Runs Lua lexer before parsing.
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)

-- | Statement parser.
stat :: Parser Stat

-- | Expression parser.
exp :: Parser Exp

-- | Lua file parser.
chunk :: Parser Block
instance Show PrimaryExp
instance Eq PrimaryExp
instance Show SuffixExp
instance Eq SuffixExp
instance Show SuffixedExp
instance Eq SuffixedExp


-- | Lua pretty-printer.
module Language.Lua.PrettyPrinter
class LPretty a
pprint :: LPretty a => a -> Doc
instance LPretty Stat
instance LPretty FunArg
instance LPretty FunCall
instance LPretty FunBody
instance LPretty FunDef
instance LPretty FunName
instance LPretty Block
instance LPretty TableField
instance LPretty Table
instance LPretty PrefixExp
instance LPretty Unop
instance LPretty Binop
instance LPretty Var
instance LPretty Exp
instance LPretty Bool
instance LPretty [Char]

module Language.Lua