{- -----------------------------------------------------------------------------
Copyright 2019-2020 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE Safe #-}

module Parser.Common (
  ParseFromSource(..),
  ParserE,
  anyComment,
  assignOperator,
  blockComment,
  builtinValues,
  categorySymbolGet,
  char_,
  endOfDoc,
  escapeStart,
  inferredParam,
  infixFuncEnd,
  infixFuncStart,
  keyword,
  kwAll,
  kwAllows,
  kwAny,
  kwBreak,
  kwCategory,
  kwCleanup,
  kwConcrete,
  kwContinue,
  kwDefine,
  kwDefines,
  kwElif,
  kwElse,
  kwEmpty,
  kwFail,
  kwFalse,
  kwIf,
  kwIgnore,
  kwIn,
  kwInterface,
  kwOptional,
  kwPresent,
  kwReduce,
  kwRefines,
  kwRequire,
  kwRequires,
  kwReturn,
  kwScoped,
  kwSelf,
  kwStrong,
  kwTestcase,
  kwTrue,
  kwType,
  kwTypename,
  kwTypes,
  kwUnittest,
  kwUpdate,
  kwValue,
  kwWeak,
  kwWhile,
  labeled,
  lineComment,
  lineEnd,
  merge2,
  merge3,
  noKeywords,
  notAllowed,
  nullParse,
  operator,
  optionalSpace,
  parseAny2,
  parseAny3,
  parseBin,
  parseDec,
  parseHex,
  parseOct,
  parseSubOne,
  parseErrorM,
  pragmaArgsEnd,
  pragmaArgsStart,
  pragmaEnd,
  pragmaStart,
  put12,
  put13,
  put22,
  put23,
  put33,
  quotedString,
  regexChar,
  requiredSpace,
  runParserE,
  sepAfter,
  sepAfter1,
  sepAfter_,
  statementEnd,
  statementStart,
  stringChar,
  string_,
  typeSymbolGet,
  valueSymbolGet,
) where

import Control.Applicative (empty)
import Control.Monad.Trans (lift)
import Data.Char
import Data.Foldable
import Data.Functor
import Data.Monoid
import Prelude hiding (foldl,foldr)
import Text.Parsec
import qualified Data.Set as Set

import Base.CompileError


type ParserE = ParsecT String ()

class ParseFromSource a where
  -- Must never prune whitespace/comments from front, but always from back.
  sourceParser :: CompileErrorM m => ParserE m a

runParserE :: CompileErrorM m => ParserE m a -> String -> String -> m a
runParserE :: ParserE m a -> String -> String -> m a
runParserE ParserE m a
p String
n String
s = do
  Either ParseError a
result <- ParserE m a -> () -> String -> String -> m (Either ParseError a)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> u -> String -> s -> m (Either ParseError a)
runPT ParserE m a
p () String
n String
s
  case Either ParseError a
result of
       Left ParseError
e  -> String -> m a
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (ParseError -> String
forall a. Show a => a -> String
show ParseError
e)
       Right a
t -> a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
t

parseErrorM :: CompileErrorM m => SourcePos -> String -> ParserE m a
parseErrorM :: SourcePos -> String -> ParserE m a
parseErrorM SourcePos
c String
e = m a -> ParserE m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ParserE m a) -> m a -> ParserE m a
forall a b. (a -> b) -> a -> b
$ String -> m a
forall (m :: * -> *) a. CompileErrorM m => String -> m a
compileErrorM (String -> m a) -> String -> m a
forall a b. (a -> b) -> a -> b
$ String
"At " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SourcePos -> String
forall a. Show a => a -> String
show SourcePos
c String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e

labeled :: Monad m => String -> ParserE m a -> ParserE m a
labeled :: String -> ParserE m a -> ParserE m a
labeled = (ParserE m a -> String -> ParserE m a)
-> String -> ParserE m a -> ParserE m a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ParserE m a -> String -> ParserE m a
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
label

escapeStart :: Monad m => ParserE m ()
escapeStart :: ParserE m ()
escapeStart = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"\\")

statementStart :: Monad m => ParserE m ()
statementStart :: ParserE m ()
statementStart = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"\\")

statementEnd :: Monad m => ParserE m ()
statementEnd :: ParserE m ()
statementEnd = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"")

valueSymbolGet :: Monad m => ParserE m ()
valueSymbolGet :: ParserE m ()
valueSymbolGet = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
".")

categorySymbolGet :: CompileErrorM m => ParserE m ()
categorySymbolGet :: ParserE m ()
categorySymbolGet = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
":" (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParserE m ()
forall (m :: * -> *). CompileErrorM m => ParserE m ()
useNewOperators ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
":")

typeSymbolGet :: CompileErrorM m => ParserE m ()
typeSymbolGet :: ParserE m ()
typeSymbolGet = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"." (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParserE m ()
forall (m :: * -> *). CompileErrorM m => ParserE m ()
useNewOperators ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
".")

-- TODO: Remove this after a reasonable amount of time.
useNewOperators :: CompileErrorM m => ParserE m ()
useNewOperators :: ParserE m ()
useNewOperators = ParserE m ()
forall b. ParsecT String () m b
newCategory ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m ()
forall b. ParsecT String () m b
newType where
  newCategory :: ParsecT String () m b
newCategory = do
    SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
    ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"$$"
    SourcePos -> String -> ParsecT String () m b
forall (m :: * -> *) a.
CompileErrorM m =>
SourcePos -> String -> ParserE m a
parseErrorM SourcePos
c String
"use \":\" instead of \"$$\" to call @category functions"
  newType :: ParsecT String () m b
newType = do
    SourcePos
c <- ParsecT String () m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
    ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"$"
    SourcePos -> String -> ParsecT String () m b
forall (m :: * -> *) a.
CompileErrorM m =>
SourcePos -> String -> ParserE m a
parseErrorM SourcePos
c String
"use \".\" instead of \"$\" to call @type functions"

assignOperator :: Monad m => ParserE m ()
assignOperator :: ParserE m ()
assignOperator = String -> ParserE m String
forall (m :: * -> *). Monad m => String -> ParserE m String
operator String
"<-" ParserE m String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

infixFuncStart :: Monad m => ParserE m ()
infixFuncStart :: ParserE m ()
infixFuncStart = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"`")

infixFuncEnd :: Monad m => ParserE m ()
infixFuncEnd :: ParserE m ()
infixFuncEnd = ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"`")

-- TODO: Maybe this should not use strings.
builtinValues :: Monad m => ParserE m String
builtinValues :: ParserE m String
builtinValues = (ParserE m String -> ParserE m String -> ParserE m String)
-> ParserE m String -> [ParserE m String] -> ParserE m String
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ParserE m String -> ParserE m String -> ParserE m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
(<|>) ParserE m String
forall (f :: * -> *) a. Alternative f => f a
empty ([ParserE m String] -> ParserE m String)
-> [ParserE m String] -> ParserE m String
forall a b. (a -> b) -> a -> b
$ (ParserE m String -> ParserE m String)
-> [ParserE m String] -> [ParserE m String]
forall a b. (a -> b) -> [a] -> [b]
map ParserE m String -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try [
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwSelf ParserE m () -> ParserE m String -> ParserE m String
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> ParserE m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
"self"
  ]

kwAll :: Monad m => ParserE m ()
kwAll :: ParserE m ()
kwAll = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"all"

kwAllows :: Monad m => ParserE m ()
kwAllows :: ParserE m ()
kwAllows = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"allows"

kwAny :: Monad m => ParserE m ()
kwAny :: ParserE m ()
kwAny = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"any"

kwBreak :: Monad m => ParserE m ()
kwBreak :: ParserE m ()
kwBreak = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"break"

kwCategory :: Monad m => ParserE m ()
kwCategory :: ParserE m ()
kwCategory = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"@category"

kwCleanup :: Monad m => ParserE m ()
kwCleanup :: ParserE m ()
kwCleanup = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"cleanup"

kwConcrete :: Monad m => ParserE m ()
kwConcrete :: ParserE m ()
kwConcrete = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"concrete"

kwContinue :: Monad m => ParserE m ()
kwContinue :: ParserE m ()
kwContinue = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"continue"

kwDefine :: Monad m => ParserE m ()
kwDefine :: ParserE m ()
kwDefine = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"define"

kwDefines :: Monad m => ParserE m ()
kwDefines :: ParserE m ()
kwDefines = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"defines"

kwElif :: Monad m => ParserE m ()
kwElif :: ParserE m ()
kwElif = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"elif"

kwElse :: Monad m => ParserE m ()
kwElse :: ParserE m ()
kwElse = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"else"

kwEmpty :: Monad m => ParserE m ()
kwEmpty :: ParserE m ()
kwEmpty = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"empty"

kwFail :: Monad m => ParserE m ()
kwFail :: ParserE m ()
kwFail = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"fail"

kwFalse :: Monad m => ParserE m ()
kwFalse :: ParserE m ()
kwFalse = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"false"

kwIf :: Monad m => ParserE m ()
kwIf :: ParserE m ()
kwIf = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"if"

kwIn :: Monad m => ParserE m ()
kwIn :: ParserE m ()
kwIn = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"in"

kwIgnore :: Monad m => ParserE m ()
kwIgnore :: ParserE m ()
kwIgnore = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"_"

kwInterface :: Monad m => ParserE m ()
kwInterface :: ParserE m ()
kwInterface = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"interface"

kwOptional :: Monad m => ParserE m ()
kwOptional :: ParserE m ()
kwOptional = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"optional"

kwPresent :: Monad m => ParserE m ()
kwPresent :: ParserE m ()
kwPresent = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"present"

kwReduce :: Monad m => ParserE m ()
kwReduce :: ParserE m ()
kwReduce = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"reduce"

kwRefines :: Monad m => ParserE m ()
kwRefines :: ParserE m ()
kwRefines = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"refines"

kwRequire :: Monad m => ParserE m ()
kwRequire :: ParserE m ()
kwRequire = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"require"

kwRequires :: Monad m => ParserE m ()
kwRequires :: ParserE m ()
kwRequires = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"requires"

kwReturn :: Monad m => ParserE m ()
kwReturn :: ParserE m ()
kwReturn = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"return"

kwSelf :: Monad m => ParserE m ()
kwSelf :: ParserE m ()
kwSelf = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"self"

kwScoped :: Monad m => ParserE m ()
kwScoped :: ParserE m ()
kwScoped = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"scoped"

kwStrong :: Monad m => ParserE m ()
kwStrong :: ParserE m ()
kwStrong = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"strong"

kwTestcase :: Monad m => ParserE m ()
kwTestcase :: ParserE m ()
kwTestcase = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"testcase"

kwTrue :: Monad m => ParserE m ()
kwTrue :: ParserE m ()
kwTrue = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"true"

kwType :: Monad m => ParserE m ()
kwType :: ParserE m ()
kwType = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"@type"

kwTypename :: Monad m => ParserE m ()
kwTypename :: ParserE m ()
kwTypename = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"typename"

kwTypes :: Monad m => ParserE m ()
kwTypes :: ParserE m ()
kwTypes = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"types"

kwUnittest :: Monad m => ParserE m ()
kwUnittest :: ParserE m ()
kwUnittest = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"unittest"

kwUpdate :: Monad m => ParserE m ()
kwUpdate :: ParserE m ()
kwUpdate = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"update"

kwValue :: Monad m => ParserE m ()
kwValue :: ParserE m ()
kwValue = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"@value"

kwWeak :: Monad m => ParserE m ()
kwWeak :: ParserE m ()
kwWeak = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"weak"

kwWhile :: Monad m => ParserE m ()
kwWhile :: ParserE m ()
kwWhile = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
keyword String
"while"

operatorSymbol :: Monad m => ParserE m Char
operatorSymbol :: ParserE m Char
operatorSymbol = String -> ParserE m Char -> ParserE m Char
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"operator symbol" (ParserE m Char -> ParserE m Char)
-> ParserE m Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ParserE m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (Char -> Set Char -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` String -> Set Char
forall a. Ord a => [a] -> Set a
Set.fromList String
"+-*/%=!<>&|")

isKeyword :: Monad m => ParserE m ()
isKeyword :: ParserE m ()
isKeyword = (ParserE m () -> ParserE m () -> ParserE m ())
-> ParserE m () -> [ParserE m ()] -> ParserE m ()
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
(<|>) ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse ([ParserE m ()] -> ParserE m ()) -> [ParserE m ()] -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ (ParserE m () -> ParserE m ()) -> [ParserE m ()] -> [ParserE m ()]
forall a b. (a -> b) -> [a] -> [b]
map ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try [
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwAll,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwAllows,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwAny,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwBreak,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwCategory,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwCleanup,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwConcrete,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwContinue,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwDefine,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwDefines,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwElif,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwElse,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwEmpty,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwFail,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwFalse,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwIf,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwIn,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwIgnore,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwInterface,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwOptional,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwPresent,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwReduce,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwRefines,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwRequire,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwRequires,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwReturn,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwSelf,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwScoped,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwStrong,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwTestcase,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwTrue,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwType,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwTypename,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwTypes,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwUnittest,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwUpdate,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwValue,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwWeak,
    ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
kwWhile
  ]

nullParse :: Monad m => ParserE m ()
nullParse :: ParserE m ()
nullParse = () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

char_ :: Monad m => Char -> ParserE m ()
char_ :: Char -> ParserE m ()
char_ = (ParsecT String () m Char -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (ParsecT String () m Char -> ParserE m ())
-> (Char -> ParsecT String () m Char) -> Char -> ParserE m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ParsecT String () m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char

string_ :: Monad m => String -> ParserE m ()
string_ :: String -> ParserE m ()
string_ = (ParsecT String () m String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (ParsecT String () m String -> ParserE m ())
-> (String -> ParsecT String () m String) -> String -> ParserE m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string

lineEnd :: Monad m => ParserE m ()
lineEnd :: ParserE m ()
lineEnd = (ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
endOfLine ParsecT String () m Char -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
endOfDoc

lineComment :: Monad m => ParserE m String
lineComment :: ParserE m String
lineComment = ParsecT String () m ()
-> ParsecT String () m () -> ParserE m String -> ParserE m String
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"//")
                      ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
lineEnd
                      (ParsecT String () m Char -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT String () m Char -> ParserE m String)
-> ParsecT String () m Char -> ParserE m String
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> ParsecT String () m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n'))

blockComment :: Monad m => ParserE m String
blockComment :: ParserE m String
blockComment = ParsecT String () m ()
-> ParsecT String () m () -> ParserE m String -> ParserE m String
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"/*")
                       (String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"*/")
                       (ParsecT String () m Char -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT String () m Char -> ParserE m String)
-> ParsecT String () m Char -> ParserE m String
forall a b. (a -> b) -> a -> b
$ ParsecT String () m () -> ParsecT String () m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (String -> ParsecT String () m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"*/") ParsecT String () m ()
-> ParsecT String () m Char -> ParsecT String () m Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar)

anyComment :: Monad m => ParserE m String
anyComment :: ParserE m String
anyComment = ParserE m String -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m String
forall (m :: * -> *). Monad m => ParserE m String
blockComment ParserE m String -> ParserE m String -> ParserE m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m String -> ParserE m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m String
forall (m :: * -> *). Monad m => ParserE m String
lineComment

optionalSpace :: Monad m => ParserE m ()
optionalSpace :: ParserE m ()
optionalSpace = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"" (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParsecT String () m String -> ParsecT String () m [String]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT String () m String
forall (m :: * -> *). Monad m => ParserE m String
anyComment ParsecT String () m String
-> ParsecT String () m String -> ParsecT String () m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () m Char -> ParsecT String () m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
space) ParsecT String () m [String] -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse

requiredSpace :: Monad m => ParserE m ()
requiredSpace :: ParserE m ()
requiredSpace = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"break" (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParserE m ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (ParsecT String () m String -> ParsecT String () m [String]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (ParsecT String () m String
forall (m :: * -> *). Monad m => ParserE m String
anyComment ParsecT String () m String
-> ParsecT String () m String -> ParsecT String () m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT String () m Char -> ParsecT String () m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
space) ParsecT String () m [String] -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse)

sepAfter :: Monad m => ParserE m a -> ParserE m a
sepAfter :: ParserE m a -> ParserE m a
sepAfter = ParsecT String () m ()
-> ParsecT String () m () -> ParserE m a -> ParserE m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace

sepAfter_ :: Monad m => ParserE m a -> ParserE m ()
sepAfter_ :: ParserE m a -> ParserE m ()
sepAfter_ = (ParserE m a -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (ParserE m a -> ParserE m ())
-> (ParserE m a -> ParserE m a) -> ParserE m a -> ParserE m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParserE m () -> ParserE m () -> ParserE m a -> ParserE m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace

sepAfter1 :: Monad m => ParserE m a -> ParserE m a
sepAfter1 :: ParserE m a -> ParserE m a
sepAfter1 = ParsecT String () m ()
-> ParsecT String () m () -> ParserE m a -> ParserE m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
nullParse ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
requiredSpace

keyword :: Monad m => String -> ParserE m ()
keyword :: String -> ParserE m ()
keyword String
s = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
s (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParserE m () -> ParserE m ()
forall (m :: * -> *) a. Monad m => ParserE m a -> ParserE m a
sepAfter (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String () m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
s ParsecT String () m String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"" (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParsecT String () m String -> ParserE m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (ParsecT String () m Char -> ParsecT String () m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum))

noKeywords :: Monad m => ParserE m ()
noKeywords :: ParserE m ()
noKeywords = ParserE m () -> ParserE m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
isKeyword

endOfDoc :: Monad m => ParserE m ()
endOfDoc :: ParserE m ()
endOfDoc = String -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"" (ParserE m () -> ParserE m ()) -> ParserE m () -> ParserE m ()
forall a b. (a -> b) -> a -> b
$ ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace ParserE m () -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParserE m ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof

notAllowed :: ParserE m a -> String -> ParserE m ()
-- Based on implementation of notFollowedBy.
notAllowed :: ParserE m a -> String -> ParserE m ()
notAllowed ParserE m a
p String
s = (ParserE m a -> ParserE m a
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ParserE m a
p ParserE m a -> ParserE m () -> ParserE m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> ParserE m ()
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
s) ParserE m () -> ParserE m () -> ParserE m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> () -> ParserE m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

pragmaStart :: Monad m => ParserE m ()
pragmaStart :: ParserE m ()
pragmaStart = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"$"

pragmaEnd :: Monad m => ParserE m ()
pragmaEnd :: ParserE m ()
pragmaEnd = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"$"

pragmaArgsStart :: Monad m => ParserE m ()
pragmaArgsStart :: ParserE m ()
pragmaArgsStart = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"["

pragmaArgsEnd :: Monad m => ParserE m ()
pragmaArgsEnd :: ParserE m ()
pragmaArgsEnd = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"]"

inferredParam :: Monad m => ParserE m ()
inferredParam :: ParserE m ()
inferredParam = String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"?"

operator :: Monad m => String -> ParserE m String
operator :: String -> ParserE m String
operator String
o = String -> ParserE m String -> ParserE m String
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
o (ParserE m String -> ParserE m String)
-> ParserE m String -> ParserE m String
forall a b. (a -> b) -> a -> b
$ do
  String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
o
  ParsecT String () m Char -> ParserE m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy ParsecT String () m Char
forall (m :: * -> *). Monad m => ParserE m Char
operatorSymbol
  ParserE m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace
  String -> ParserE m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
o

stringChar :: Monad m => ParserE m Char
stringChar :: ParserE m Char
stringChar = ParserE m Char
escaped ParserE m Char -> ParserE m Char -> ParserE m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m Char
forall u. ParsecT String u m Char
notEscaped where
  escaped :: ParserE m Char
escaped = String -> ParserE m Char -> ParserE m Char
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"escaped char sequence" (ParserE m Char -> ParserE m Char)
-> ParserE m Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ do
    Char -> ParserE m ()
forall (m :: * -> *). Monad m => Char -> ParserE m ()
char_ Char
'\\'
    ParserE m Char
octChar ParserE m Char -> ParserE m Char -> ParserE m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m Char
otherEscape where
      otherEscape :: ParserE m Char
otherEscape = do
        Char
v <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar
        case Char
v of
            Char
'\'' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\''
            Char
'"' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'"'
            Char
'?' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'?'
            Char
'\\' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'\\'
            Char
'a' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
7
            Char
'b' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
8
            Char
'f' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
12
            Char
'n' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
10
            Char
'r' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
13
            Char
't' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
9
            Char
'v' -> Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
11
            Char
'x' -> ParserE m Char
hexChar
            Char
_ -> String -> ParserE m Char
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (Char -> String
forall a. Show a => a -> String
show Char
v)
      octChar :: ParserE m Char
octChar = String -> ParserE m Char -> ParserE m Char
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"3 octal chars" (ParserE m Char -> ParserE m Char)
-> ParserE m Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ do
        Int
o1 <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit ParserE m Char
-> (Char -> ParsecT String () m Int) -> ParsecT String () m Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> ParsecT String () m Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () m Int)
-> (Char -> Int) -> Char -> ParsecT String () m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
digitVal
        Int
o2 <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit ParserE m Char
-> (Char -> ParsecT String () m Int) -> ParsecT String () m Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> ParsecT String () m Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () m Int)
-> (Char -> Int) -> Char -> ParsecT String () m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
digitVal
        Int
o3 <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit ParserE m Char
-> (Char -> ParsecT String () m Int) -> ParsecT String () m Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> ParsecT String () m Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () m Int)
-> (Char -> Int) -> Char -> ParsecT String () m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
digitVal
        Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ Int
8Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
8Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
o1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
8Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
o2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
o3
      hexChar :: ParserE m Char
hexChar = String -> ParserE m Char -> ParserE m Char
forall (m :: * -> *) a.
Monad m =>
String -> ParserE m a -> ParserE m a
labeled String
"2 hex chars" (ParserE m Char -> ParserE m Char)
-> ParserE m Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ do
        Int
h1 <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
hexDigit ParserE m Char
-> (Char -> ParsecT String () m Int) -> ParsecT String () m Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> ParsecT String () m Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () m Int)
-> (Char -> Int) -> Char -> ParsecT String () m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
digitVal
        Int
h2 <- ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
hexDigit ParserE m Char
-> (Char -> ParsecT String () m Int) -> ParsecT String () m Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> ParsecT String () m Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ParsecT String () m Int)
-> (Char -> Int) -> Char -> ParsecT String () m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
digitVal
        Char -> ParserE m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> ParserE m Char) -> Char -> ParserE m Char
forall a b. (a -> b) -> a -> b
$ Int -> Char
chr (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ Int
16Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
h1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
h2
  notEscaped :: ParsecT String u m Char
notEscaped = String -> ParsecT String u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
noneOf String
"\""

quotedString :: Monad m => ParserE m String
quotedString :: ParserE m String
quotedString = do
  String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"\""
  ParsecT String () m Char -> ParserE m () -> ParserE m String
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
manyTill ParsecT String () m Char
forall (m :: * -> *). Monad m => ParserE m Char
stringChar (String -> ParserE m ()
forall (m :: * -> *). Monad m => String -> ParserE m ()
string_ String
"\"")

digitVal :: Char -> Int
digitVal :: Char -> Int
digitVal Char
c
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'0' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9' = Char -> Int
ord(Char
c) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord(Char
'0')
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'A' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'F' = Int
10 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
ord(Char
c) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord(Char
'A')
  | Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'a' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'f' = Int
10 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Char -> Int
ord(Char
c) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
ord(Char
'a')
  | Bool
otherwise = Int
forall a. HasCallStack => a
undefined

parseDec :: Monad m => ParserE m Integer
parseDec :: ParserE m Integer
parseDec = ((Integer, Integer) -> Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer, Integer) -> Integer
forall a b. (a, b) -> b
snd (ParsecT String () m (Integer, Integer) -> ParserE m Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall a b. (a -> b) -> a -> b
$ Integer -> ParserE m Char -> ParsecT String () m (Integer, Integer)
forall (m :: * -> *).
Monad m =>
Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
10 ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit

parseHex :: Monad m => ParserE m Integer
parseHex :: ParserE m Integer
parseHex = ((Integer, Integer) -> Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer, Integer) -> Integer
forall a b. (a, b) -> b
snd (ParsecT String () m (Integer, Integer) -> ParserE m Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall a b. (a -> b) -> a -> b
$ Integer -> ParserE m Char -> ParsecT String () m (Integer, Integer)
forall (m :: * -> *).
Monad m =>
Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
16 ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
hexDigit

parseOct :: Monad m => ParserE m Integer
parseOct :: ParserE m Integer
parseOct = ((Integer, Integer) -> Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer, Integer) -> Integer
forall a b. (a, b) -> b
snd (ParsecT String () m (Integer, Integer) -> ParserE m Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall a b. (a -> b) -> a -> b
$ Integer -> ParserE m Char -> ParsecT String () m (Integer, Integer)
forall (m :: * -> *).
Monad m =>
Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
8 ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit

parseBin :: Monad m => ParserE m Integer
parseBin :: ParserE m Integer
parseBin = ((Integer, Integer) -> Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer, Integer) -> Integer
forall a b. (a, b) -> b
snd (ParsecT String () m (Integer, Integer) -> ParserE m Integer)
-> ParsecT String () m (Integer, Integer) -> ParserE m Integer
forall a b. (a -> b) -> a -> b
$ Integer -> ParserE m Char -> ParsecT String () m (Integer, Integer)
forall (m :: * -> *).
Monad m =>
Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
2 (String -> ParserE m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"01")

parseSubOne :: Monad m => ParserE m (Integer,Integer)
parseSubOne :: ParserE m (Integer, Integer)
parseSubOne = Integer -> ParserE m Char -> ParserE m (Integer, Integer)
forall (m :: * -> *).
Monad m =>
Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
10 ParserE m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit

parseIntCommon :: Monad m => Integer -> ParserE m Char -> ParserE m (Integer,Integer)
parseIntCommon :: Integer -> ParserE m Char -> ParserE m (Integer, Integer)
parseIntCommon Integer
b ParserE m Char
p = do
  String
ds <- ParserE m Char -> ParsecT String () m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParserE m Char
p
  (Integer, Integer) -> ParserE m (Integer, Integer)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Integer, Integer) -> ParserE m (Integer, Integer))
-> (Integer, Integer) -> ParserE m (Integer, Integer)
forall a b. (a -> b) -> a -> b
$ ((Integer, Integer) -> Char -> (Integer, Integer))
-> (Integer, Integer) -> String -> (Integer, Integer)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\(Integer
n,Integer
x) Char
y -> (Integer
nInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1,Integer
bInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
*Integer
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ (Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ Char -> Int
digitVal Char
y :: Integer))) (Integer
0,Integer
0) String
ds

regexChar :: Monad m => ParserE m String
regexChar :: ParserE m String
regexChar = ParserE m String
escaped ParserE m String -> ParserE m String -> ParserE m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m String
forall u. ParsecT String u m String
notEscaped where
  escaped :: ParserE m String
escaped = do
    Char -> ParserE m ()
forall (m :: * -> *). Monad m => Char -> ParserE m ()
char_ Char
'\\'
    Char
v <- ParsecT String () m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar
    case Char
v of
         Char
'"' -> String -> ParserE m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
"\""
         Char
_ -> String -> ParserE m String
forall (m :: * -> *) a. Monad m => a -> m a
return [Char
'\\',Char
v]
  notEscaped :: ParsecT String u m String
notEscaped = (Char -> String)
-> ParsecT String u m Char -> ParsecT String u m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> String -> String
forall a. a -> [a] -> [a]
:[]) (ParsecT String u m Char -> ParsecT String u m String)
-> ParsecT String u m Char -> ParsecT String u m String
forall a b. (a -> b) -> a -> b
$ String -> ParsecT String u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
noneOf String
"\""

put12 :: (Functor m, Monad m) => m a -> m ([a],[b])
put12 :: m a -> m ([a], [b])
put12 = (a -> ([a], [b])) -> m a -> m ([a], [b])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ([a], [b])
forall a a. a -> ([a], [a])
put where put :: a -> ([a], [a])
put a
x = ([a
x],[])

put22 :: (Functor m, Monad m) => m b -> m ([a],[b])
put22 :: m b -> m ([a], [b])
put22 = (b -> ([a], [b])) -> m b -> m ([a], [b])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> ([a], [b])
forall a a. a -> ([a], [a])
put where put :: a -> ([a], [a])
put a
x = ([],[a
x])

merge2 :: (Foldable f, Monoid a, Monoid b) => f (a,b) -> (a,b)
merge2 :: f (a, b) -> (a, b)
merge2 = ((a, b) -> (a, b) -> (a, b)) -> (a, b) -> f (a, b) -> (a, b)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a, b) -> (a, b) -> (a, b)
forall a b.
(Semigroup a, Semigroup b) =>
(a, b) -> (a, b) -> (a, b)
merge (a
forall a. Monoid a => a
mempty,b
forall a. Monoid a => a
mempty) where
  merge :: (a, b) -> (a, b) -> (a, b)
merge (a
xs1,b
ys1) (a
xs2,b
ys2) = (a
xs1a -> a -> a
forall a. Semigroup a => a -> a -> a
<>a
xs2,b
ys1b -> b -> b
forall a. Semigroup a => a -> a -> a
<>b
ys2)

put13 :: (Functor m, Monad m) => m a -> m ([a],[b],[c])
put13 :: m a -> m ([a], [b], [c])
put13 = (a -> ([a], [b], [c])) -> m a -> m ([a], [b], [c])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ([a], [b], [c])
forall a a a. a -> ([a], [a], [a])
put where put :: a -> ([a], [a], [a])
put a
x = ([a
x],[],[])

put23 :: (Functor m, Monad m) => m b -> m ([a],[b],[c])
put23 :: m b -> m ([a], [b], [c])
put23 = (b -> ([a], [b], [c])) -> m b -> m ([a], [b], [c])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> ([a], [b], [c])
forall a a a. a -> ([a], [a], [a])
put where put :: a -> ([a], [a], [a])
put a
x = ([],[a
x],[])

put33 :: (Functor m, Monad m) => m c -> m ([a],[b],[c])
put33 :: m c -> m ([a], [b], [c])
put33 = (c -> ([a], [b], [c])) -> m c -> m ([a], [b], [c])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap c -> ([a], [b], [c])
forall a a a. a -> ([a], [a], [a])
put where put :: a -> ([a], [a], [a])
put a
x = ([],[],[a
x])

merge3 :: (Foldable f, Monoid a, Monoid b, Monoid c) => f (a,b,c) -> (a,b,c)
merge3 :: f (a, b, c) -> (a, b, c)
merge3 = ((a, b, c) -> (a, b, c) -> (a, b, c))
-> (a, b, c) -> f (a, b, c) -> (a, b, c)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a, b, c) -> (a, b, c) -> (a, b, c)
forall a b c.
(Semigroup a, Semigroup b, Semigroup c) =>
(a, b, c) -> (a, b, c) -> (a, b, c)
merge (a
forall a. Monoid a => a
mempty,b
forall a. Monoid a => a
mempty,c
forall a. Monoid a => a
mempty) where
  merge :: (a, b, c) -> (a, b, c) -> (a, b, c)
merge (a
xs1,b
ys1,c
zs1) (a
xs2,b
ys2,c
zs2) = (a
xs1a -> a -> a
forall a. Semigroup a => a -> a -> a
<>a
xs2,b
ys1b -> b -> b
forall a. Semigroup a => a -> a -> a
<>b
ys2,c
zs1c -> c -> c
forall a. Semigroup a => a -> a -> a
<>c
zs2)

parseAny2 :: Monad m => ParserE m a -> ParserE m b -> ParserE m ([a],[b])
parseAny2 :: ParserE m a -> ParserE m b -> ParserE m ([a], [b])
parseAny2 ParserE m a
p1 ParserE m b
p2 = ParserE m ([a], [b])
-> ParsecT String () m () -> ParsecT String () m [([a], [b])]
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
sepBy ParserE m ([a], [b])
anyType ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace ParsecT String () m [([a], [b])]
-> ([([a], [b])] -> ParserE m ([a], [b])) -> ParserE m ([a], [b])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([a], [b]) -> ParserE m ([a], [b])
forall (m :: * -> *) a. Monad m => a -> m a
return (([a], [b]) -> ParserE m ([a], [b]))
-> ([([a], [b])] -> ([a], [b]))
-> [([a], [b])]
-> ParserE m ([a], [b])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([a], [b])] -> ([a], [b])
forall (f :: * -> *) a b.
(Foldable f, Monoid a, Monoid b) =>
f (a, b) -> (a, b)
merge2 where
  anyType :: ParserE m ([a], [b])
anyType = ParserE m ([a], [b])
forall a. ParsecT String () m ([a], [a])
p1' ParserE m ([a], [b])
-> ParserE m ([a], [b]) -> ParserE m ([a], [b])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m ([a], [b])
forall a. ParsecT String () m ([a], [b])
p2'
  p1' :: ParsecT String () m ([a], [a])
p1' = do
    a
x <- ParserE m a
p1
    ([a], [a]) -> ParsecT String () m ([a], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([a
x],[])
  p2' :: ParsecT String () m ([a], [b])
p2' = do
    b
y <- ParserE m b
p2
    ([a], [b]) -> ParsecT String () m ([a], [b])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[b
y])

parseAny3 :: Monad m => ParserE m a -> ParserE m b -> ParserE m c -> ParserE m ([a],[b],[c])
parseAny3 :: ParserE m a
-> ParserE m b -> ParserE m c -> ParserE m ([a], [b], [c])
parseAny3 ParserE m a
p1 ParserE m b
p2 ParserE m c
p3 = ParserE m ([a], [b], [c])
-> ParsecT String () m () -> ParsecT String () m [([a], [b], [c])]
forall s (m :: * -> *) t u a end.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
sepBy ParserE m ([a], [b], [c])
anyType ParsecT String () m ()
forall (m :: * -> *). Monad m => ParserE m ()
optionalSpace ParsecT String () m [([a], [b], [c])]
-> ([([a], [b], [c])] -> ParserE m ([a], [b], [c]))
-> ParserE m ([a], [b], [c])
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([a], [b], [c]) -> ParserE m ([a], [b], [c])
forall (m :: * -> *) a. Monad m => a -> m a
return (([a], [b], [c]) -> ParserE m ([a], [b], [c]))
-> ([([a], [b], [c])] -> ([a], [b], [c]))
-> [([a], [b], [c])]
-> ParserE m ([a], [b], [c])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([a], [b], [c])] -> ([a], [b], [c])
forall (f :: * -> *) a b c.
(Foldable f, Monoid a, Monoid b, Monoid c) =>
f (a, b, c) -> (a, b, c)
merge3 where
  anyType :: ParserE m ([a], [b], [c])
anyType = ParserE m ([a], [b], [c])
forall a a. ParsecT String () m ([a], [a], [a])
p1' ParserE m ([a], [b], [c])
-> ParserE m ([a], [b], [c]) -> ParserE m ([a], [b], [c])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m ([a], [b], [c])
forall a a. ParsecT String () m ([a], [b], [a])
p2' ParserE m ([a], [b], [c])
-> ParserE m ([a], [b], [c]) -> ParserE m ([a], [b], [c])
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParserE m ([a], [b], [c])
forall a a. ParsecT String () m ([a], [a], [c])
p3'
  p1' :: ParsecT String () m ([a], [a], [a])
p1' = do
    a
x <- ParserE m a
p1
    ([a], [a], [a]) -> ParsecT String () m ([a], [a], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([a
x],[],[])
  p2' :: ParsecT String () m ([a], [b], [a])
p2' = do
    b
y <- ParserE m b
p2
    ([a], [b], [a]) -> ParsecT String () m ([a], [b], [a])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[b
y],[])
  p3' :: ParsecT String () m ([a], [a], [c])
p3' = do
    c
z <- ParserE m c
p3
    ([a], [a], [c]) -> ParsecT String () m ([a], [a], [c])
forall (m :: * -> *) a. Monad m => a -> m a
return ([],[],[c
z])