-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

-- | Parsing of Michelson instructions.

module Morley.Michelson.Parser.Instr
  ( primInstr
  , ops'
  -- * These are handled separately to have better error messages
  , mapOp
  , pairOp
  , unpairOp
  , pairNOp
  , cmpOp
  , dupOp
  , carOp
  , cdrOp
  , viewOp
  ) where

import Prelude hiding (EQ, GT, LT, many, note, some, try)

import Text.Megaparsec (choice, label, many, notFollowedBy, try)
import Text.Megaparsec.Char.Lexer qualified as L

import Morley.Michelson.Macro (ParsedInstr, ParsedOp(..))
import Morley.Michelson.Parser.Annotations
import Morley.Michelson.Parser.Common
import Morley.Michelson.Parser.Lexer
import Morley.Michelson.Parser.Type
import Morley.Michelson.Parser.Types (Parser)
import Morley.Michelson.Parser.Value
import Morley.Michelson.Untyped

-- | Parser for primitive Michelson instruction (no macros and extensions).
primInstr :: Parser (Contract' ParsedOp) -> Parser ParsedOp -> Parser ParsedInstr
primInstr :: Parser (Contract' ParsedOp)
-> Parser ParsedOp -> Parser ParsedInstr
primInstr Parser (Contract' ParsedOp)
contractParser Parser ParsedOp
opParser = String -> Parser ParsedInstr -> Parser ParsedInstr
forall e s (m :: * -> *) a.
MonadParsec e s m =>
String -> m a -> m a
label String
"primitive instruction" (Parser ParsedInstr -> Parser ParsedInstr)
-> Parser ParsedInstr -> Parser ParsedInstr
forall a b. (a -> b) -> a -> b
$ [Parser ParsedInstr] -> Parser ParsedInstr
forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
  [ Parser ParsedInstr
dropOp, Parser ParsedInstr
swapOp, Parser ParsedInstr
digOp, Parser ParsedInstr
dugOp, Parser ParsedOp -> Parser ParsedInstr
pushOp Parser ParsedOp
opParser, Parser ParsedInstr
someOp, Parser ParsedInstr
noneOp, Parser ParsedInstr
unitOp
  , Parser ParsedOp -> Parser ParsedInstr
ifNoneOp Parser ParsedOp
opParser, Parser ParsedInstr
leftOp, Parser ParsedInstr
rightOp, Parser ParsedOp -> Parser ParsedInstr
ifLeftOp Parser ParsedOp
opParser, Parser ParsedInstr
nilOp
  , Parser ParsedInstr
consOp, Parser ParsedOp -> Parser ParsedInstr
ifConsOp Parser ParsedOp
opParser, Parser ParsedInstr
sizeOp, Parser ParsedInstr
emptySetOp, Parser ParsedInstr
emptyMapOp, Parser ParsedInstr
emptyBigMapOp, Parser ParsedOp -> Parser ParsedInstr
iterOp Parser ParsedOp
opParser
  , Parser ParsedInstr
memOp, Parser ParsedInstr
getAndUpdateOp, Parser ParsedInstr
getOp, Parser ParsedInstr
updateOp, Parser ParsedOp -> Parser ParsedInstr
loopLOp Parser ParsedOp
opParser, Parser ParsedOp -> Parser ParsedInstr
loopOp Parser ParsedOp
opParser
  , Parser ParsedOp -> Parser ParsedInstr
lambdaOp Parser ParsedOp
opParser, Parser ParsedInstr
execOp, Parser ParsedInstr
applyOp, Parser ParsedOp -> Parser ParsedInstr
dipOp Parser ParsedOp
opParser, Parser ParsedInstr
failWithOp, Parser ParsedInstr
castOp, Parser ParsedInstr
renameOp, Parser ParsedInstr
levelOp
  , Parser ParsedInstr
concatOp, Parser ParsedInstr
packOp, Parser ParsedInstr
unpackOp, Parser ParsedInstr
sliceOp, Parser ParsedInstr
isNatOp, Parser ParsedInstr
addressOp, Parser ParsedInstr
selfAddressOp, Parser ParsedInstr
addOp, Parser ParsedInstr
subOp
  , Parser ParsedInstr
subMutezOp, Parser ParsedInstr
mulOp, Parser ParsedInstr
edivOp, Parser ParsedInstr
absOp, Parser ParsedInstr
negOp, Parser ParsedInstr
lslOp, Parser ParsedInstr
lsrOp, Parser ParsedInstr
orOp, Parser ParsedInstr
andOp, Parser ParsedInstr
xorOp, Parser ParsedInstr
notOp
  , Parser ParsedInstr
compareOp, Parser ParsedInstr
eqOp, Parser ParsedInstr
neqOp, Parser ParsedInstr
ltOp, Parser ParsedInstr
leOp, Parser ParsedInstr
gtOp, Parser ParsedInstr
geOp, Parser ParsedInstr
intOp, Parser ParsedInstr
viewOp, Parser ParsedInstr
selfOp, Parser ParsedInstr
contractOp
  , Parser ParsedInstr
transferTokensOp, Parser ParsedInstr
setDelegateOp
  , Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp Parser (Contract' ParsedOp)
contractParser, Parser ParsedInstr
implicitAccountOp, Parser ParsedInstr
nowOp, Parser ParsedInstr
amountOp
  , Parser ParsedInstr
balanceOp, Parser ParsedInstr
checkSigOp, Parser ParsedInstr
sha256Op, Parser ParsedInstr
sha512Op, Parser ParsedInstr
blake2BOp, Parser ParsedInstr
hashKeyOp, Parser ParsedInstr
pairingCheckOp
  , Parser ParsedInstr
sourceOp, Parser ParsedInstr
senderOp, Parser ParsedInstr
chainIdOp, Parser ParsedInstr
sha3Op, Parser ParsedInstr
keccakOp, Parser ParsedInstr
neverOp
  , Parser ParsedInstr
votingPowerOp, Parser ParsedInstr
totalVotingPowerOp, Parser ParsedInstr -> Parser ParsedInstr
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try Parser ParsedInstr
unpairNOp
  , Parser ParsedInstr
unpairOp
  , Parser ParsedInstr
ticketOp, Parser ParsedInstr
readTicketOp, Parser ParsedInstr
splitTicketOp, Parser ParsedInstr
joinTicketsOp
  , Parser ParsedInstr
openChestOp
  , Parser ParsedInstr
saplingEmptyStateOp, Parser ParsedInstr
saplingVerifyUpdateOp, Parser ParsedInstr
minBlockTimeOp
  ]

-- | Parse a sequence of instructions.
ops' :: Parser ParsedOp -> Parser [ParsedOp]
ops' :: Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser = (Parser [ParsedOp] -> Parser [ParsedOp]
forall a. Parser a -> Parser a
braces (Parser [ParsedOp] -> Parser [ParsedOp])
-> Parser [ParsedOp] -> Parser [ParsedOp]
forall a b. (a -> b) -> a -> b
$ Parser [ParsedOp]
parseSeq) Parser [ParsedOp] -> Parser [ParsedOp] -> Parser [ParsedOp]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (ParsedOp -> [ParsedOp]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ParsedOp -> [ParsedOp]) -> Parser ParsedOp -> Parser [ParsedOp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser ParsedOp
opParser)
  where
    parseSeq :: Parser [ParsedOp]
parseSeq =
      do{ ParsedOp
op <- Parser ParsedOp
opParser
        ; let separator :: ParsecT CustomParserException Text Identity ()
separator = case ParsedOp
op of
                Seq [ParsedOp]
_ SrcPos
_ -> ParsecT CustomParserException Text Identity (Maybe ())
-> ParsecT CustomParserException Text Identity ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT CustomParserException Text Identity ()
-> ParsecT CustomParserException Text Identity (Maybe ())
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional ParsecT CustomParserException Text Identity ()
semicolon)
                ParsedOp
_       -> ParsecT CustomParserException Text Identity ()
semicolon
        ; do{ ()
_ <- ParsecT CustomParserException Text Identity ()
separator
            ; [ParsedOp]
ops <- Parser [ParsedOp]
parseSeq
            ; return (ParsedOp
opParsedOp -> [ParsedOp] -> [ParsedOp]
forall a. a -> [a] -> [a]
:[ParsedOp]
ops)
            }
           Parser [ParsedOp] -> Parser [ParsedOp] -> Parser [ParsedOp]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [ParsedOp] -> Parser [ParsedOp]
forall (m :: * -> *) a. Monad m => a -> m a
return [ParsedOp
op]
      }
      Parser [ParsedOp] -> Parser [ParsedOp] -> Parser [ParsedOp]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [ParsedOp] -> Parser [ParsedOp]
forall (m :: * -> *) a. Monad m => a -> m a
return []


-- Control Structures

failWithOp :: Parser ParsedInstr
failWithOp :: Parser ParsedInstr
failWithOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"FAILWITH" ParsedInstr
forall op. InstrAbstract op
FAILWITH

loopOp :: Parser ParsedOp -> Parser ParsedInstr
loopOp :: Parser ParsedOp -> Parser ParsedInstr
loopOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LOOP" [ParsedOp] -> ParsedInstr
forall op. [op] -> InstrAbstract op
LOOP Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

loopLOp :: Parser ParsedOp -> Parser ParsedInstr
loopLOp :: Parser ParsedOp -> Parser ParsedInstr
loopLOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LOOP_LEFT" [ParsedOp] -> ParsedInstr
forall op. [op] -> InstrAbstract op
LOOP_LEFT Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

execOp :: Parser ParsedInstr
execOp :: Parser ParsedInstr
execOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"EXEC" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
EXEC Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

applyOp :: Parser ParsedInstr
applyOp :: Parser ParsedInstr
applyOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"APPLY" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
APPLY Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Parses both `DIP` and `DIP n`.
dipOp :: Parser ParsedOp -> Parser ParsedInstr
dipOp :: Parser ParsedOp -> Parser ParsedInstr
dipOp Parser ParsedOp
opParser = Text
-> (Word -> [ParsedOp] -> ParsedInstr)
-> ([ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> ParsedInstr)
forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
"DIP" Word -> [ParsedOp] -> ParsedInstr
forall op. Word -> [op] -> InstrAbstract op
DIPN [ParsedOp] -> ParsedInstr
forall op. [op] -> InstrAbstract op
DIP Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

-- Helper for instructions which have optional numeric non-negative parameter.
parseWithOptionalParameter :: Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter :: forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
instrName Word -> instr
constructorWithParam instr
constructorNoParam =
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Text
Tokens Text
instrName ParsecT CustomParserException Text Identity ()
-> ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
  (ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (Word -> instr
constructorWithParam (Word -> instr)
-> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity instr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal) ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
-> ParsecT CustomParserException Text Identity instr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> instr -> ParsecT CustomParserException Text Identity instr
forall (f :: * -> *) a. Applicative f => a -> f a
pure instr
constructorNoParam)

-- Stack Operations

-- Parses both `DROP` and `DROP n`.
dropOp :: Parser ParsedInstr
dropOp :: Parser ParsedInstr
dropOp = Text -> (Word -> ParsedInstr) -> ParsedInstr -> Parser ParsedInstr
forall instr. Text -> (Word -> instr) -> instr -> Parser instr
parseWithOptionalParameter Text
"DROP" Word -> ParsedInstr
forall op. Word -> InstrAbstract op
DROPN ParsedInstr
forall op. InstrAbstract op
DROP

dupOp :: Parser ParsedInstr
dupOp :: Parser ParsedInstr
dupOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"DUP"
  VarAnn
varAnn <- ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal) ParsecT CustomParserException Text Identity (Maybe Word)
-> (Maybe Word -> ParsedInstr) -> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
DUP VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall op. VarAnn -> Word -> InstrAbstract op
DUPN VarAnn
varAnn)

swapOp :: Parser ParsedInstr
swapOp :: Parser ParsedInstr
swapOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SWAP" ParsedInstr
forall op. InstrAbstract op
SWAP

digOp :: Parser ParsedInstr
digOp :: Parser ParsedInstr
digOp = Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"DIG" Word -> ParsedInstr
forall op. Word -> InstrAbstract op
DIG Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

dugOp :: Parser ParsedInstr
dugOp :: Parser ParsedInstr
dugOp = Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"DUG" Word -> ParsedInstr
forall op. Word -> InstrAbstract op
DUG Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

pushOp :: Parser ParsedOp -> Parser ParsedInstr
pushOp :: Parser ParsedOp -> Parser ParsedInstr
pushOp Parser ParsedOp
opParser = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"PUSH"
  VarAnn
v <- ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  VarAnn -> Parser ParsedInstr
push' VarAnn
v
  where
    push' :: VarAnn -> Parser ParsedInstr
    push' :: VarAnn -> Parser ParsedInstr
push' VarAnn
v = VarAnn -> Ty -> Value' ParsedOp -> ParsedInstr
forall op. VarAnn -> Ty -> Value' op -> InstrAbstract op
PUSH VarAnn
v (Ty -> Value' ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> ParsecT
     CustomParserException
     Text
     Identity
     (Value' ParsedOp -> ParsedInstr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_ ParsecT
  CustomParserException
  Text
  Identity
  (Value' ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity (Value' ParsedOp)
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp
-> ParsecT CustomParserException Text Identity (Value' ParsedOp)
value' Parser ParsedOp
opParser

unitOp :: Parser ParsedInstr
unitOp :: Parser ParsedInstr
unitOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"UNIT"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; return $ TypeAnn -> VarAnn -> ParsedInstr
forall op. TypeAnn -> VarAnn -> InstrAbstract op
UNIT TypeAnn
t VarAnn
v

lambdaOp :: Parser ParsedOp -> Parser ParsedInstr
lambdaOp :: Parser ParsedOp -> Parser ParsedInstr
lambdaOp Parser ParsedOp
opParser =
  Tokens Text
-> (VarAnn -> Ty -> Ty -> [ParsedOp] -> ParsedInstr)
-> Parser (VarAnn -> Ty -> Ty -> [ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LAMBDA" VarAnn -> Ty -> Ty -> [ParsedOp] -> ParsedInstr
forall op. VarAnn -> Ty -> Ty -> [op] -> InstrAbstract op
LAMBDA Parser (VarAnn -> Ty -> Ty -> [ParsedOp] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> Ty -> [ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> Ty -> [ParsedOp] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> ParsecT
     CustomParserException
     Text
     Identity
     (Ty -> [ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ ParsecT
  CustomParserException
  Text
  Identity
  (Ty -> [ParsedOp] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ([ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_ Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

neverOp :: Parser ParsedInstr
neverOp :: Parser ParsedInstr
neverOp = Tokens Text -> ParsedInstr -> Parser ParsedInstr
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"NEVER" ParsedInstr
forall op. InstrAbstract op
NEVER
-- Generic comparison

cmpOp :: Parser ParsedInstr
cmpOp :: Parser ParsedInstr
cmpOp = Parser ParsedInstr
eqOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
neqOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
ltOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
gtOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
leOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
gtOp Parser ParsedInstr -> Parser ParsedInstr -> Parser ParsedInstr
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser ParsedInstr
geOp

eqOp :: Parser ParsedInstr
eqOp :: Parser ParsedInstr
eqOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"EQ" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
EQ Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

neqOp :: Parser ParsedInstr
neqOp :: Parser ParsedInstr
neqOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"NEQ" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
NEQ Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

ltOp :: Parser ParsedInstr
ltOp :: Parser ParsedInstr
ltOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
LT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

gtOp :: Parser ParsedInstr
gtOp :: Parser ParsedInstr
gtOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"GT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
GT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

leOp :: Parser ParsedInstr
leOp :: Parser ParsedInstr
leOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
LE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

geOp :: Parser ParsedInstr
geOp :: Parser ParsedInstr
geOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"GE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
GE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- ad-hoc comparison

compareOp :: Parser ParsedInstr
compareOp :: Parser ParsedInstr
compareOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"COMPARE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
COMPARE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on booleans

orOp :: Parser ParsedInstr
orOp :: Parser ParsedInstr
orOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"OR"  VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
OR Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

andOp :: Parser ParsedInstr
andOp :: Parser ParsedInstr
andOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"AND" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
AND Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

xorOp :: Parser ParsedInstr
xorOp :: Parser ParsedInstr
xorOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"XOR" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
XOR Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

notOp :: Parser ParsedInstr
notOp :: Parser ParsedInstr
notOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"NOT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
NOT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on integers and natural numbers

addOp :: Parser ParsedInstr
addOp :: Parser ParsedInstr
addOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"ADD" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
ADD Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

saplingEmptyStateOp :: Parser ParsedInstr
saplingEmptyStateOp :: Parser ParsedInstr
saplingEmptyStateOp = Tokens Text
-> (VarAnn -> Natural -> ParsedInstr)
-> Parser (VarAnn -> Natural -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SAPLING_EMPTY_STATE" VarAnn -> Natural -> ParsedInstr
forall op. VarAnn -> Natural -> InstrAbstract op
SAPLING_EMPTY_STATE Parser (VarAnn -> Natural -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException Text Identity (Natural -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (Natural -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Natural
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Natural
-> ParsecT CustomParserException Text Identity Natural
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Natural
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

saplingVerifyUpdateOp :: Parser ParsedInstr
saplingVerifyUpdateOp :: Parser ParsedInstr
saplingVerifyUpdateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SAPLING_VERIFY_UPDATE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SAPLING_VERIFY_UPDATE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

minBlockTimeOp :: Parser ParsedInstr
minBlockTimeOp :: Parser ParsedInstr
minBlockTimeOp = Tokens Text
-> ([AnyAnn] -> ParsedInstr) -> Parser ([AnyAnn] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"MIN_BLOCK_TIME" [AnyAnn] -> ParsedInstr
forall op. [AnyAnn] -> InstrAbstract op
MIN_BLOCK_TIME Parser ([AnyAnn] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity [AnyAnn]
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity AnyAnn
-> ParsecT CustomParserException Text Identity [AnyAnn]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many ParsecT CustomParserException Text Identity AnyAnn
anyNote

subOp :: Parser ParsedInstr
subOp :: Parser ParsedInstr
subOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SUB" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SUB Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

subMutezOp :: Parser ParsedInstr
subMutezOp :: Parser ParsedInstr
subMutezOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SUB_MUTEZ" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SUB_MUTEZ Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

mulOp :: Parser ParsedInstr
mulOp :: Parser ParsedInstr
mulOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"MUL" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
MUL Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

edivOp :: Parser ParsedInstr
edivOp :: Parser ParsedInstr
edivOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"EDIV" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
EDIV Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

absOp :: Parser ParsedInstr
absOp :: Parser ParsedInstr
absOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"ABS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
ABS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

negOp :: Parser ParsedInstr
negOp :: Parser ParsedInstr
negOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"NEG" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
NEG Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Bitwise logical operators

lslOp :: Parser ParsedInstr
lslOp :: Parser ParsedInstr
lslOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LSL" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
LSL Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

lsrOp :: Parser ParsedInstr
lsrOp :: Parser ParsedInstr
lsrOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LSR" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
LSR Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on string's

concatOp :: Parser ParsedInstr
concatOp :: Parser ParsedInstr
concatOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CONCAT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
CONCAT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sliceOp :: Parser ParsedInstr
sliceOp :: Parser ParsedInstr
sliceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SLICE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SLICE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on pairs
pairOp :: Parser ParsedInstr
pairOp :: Parser ParsedInstr
pairOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"PAIR"
  (TypeAnn
t, VarAnn
v, (FieldAnn
p, FieldAnn
q)) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def

  -- Make sure this is a `PAIR` instruction,
  -- and not a `PAIR n` instruction.
  ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal :: Parser Word)

  return $ TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> ParsedInstr
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op
PAIR TypeAnn
t VarAnn
v FieldAnn
p FieldAnn
q

unpairOp :: Parser ParsedInstr
unpairOp :: Parser ParsedInstr
unpairOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"UNPAIR"
  ((VarAnn
vn1, VarAnn
vn2), (FieldAnn
fn1, FieldAnn
fn2)) <- Parser ((VarAnn, VarAnn), (FieldAnn, FieldAnn))
notesVVFF

  -- Make sure this is an `UNPAIR` instruction,
  -- and not an `UNPAIR n` instruction.
  ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity ()
forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal :: Parser Word)

  return $ VarAnn -> VarAnn -> FieldAnn -> FieldAnn -> ParsedInstr
forall op.
VarAnn -> VarAnn -> FieldAnn -> FieldAnn -> InstrAbstract op
UNPAIR VarAnn
vn1 VarAnn
vn2 FieldAnn
fn1 FieldAnn
fn2

pairNOp :: Parser ParsedInstr
pairNOp :: Parser ParsedInstr
pairNOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"PAIR"
  VarAnn -> Word -> ParsedInstr
forall op. VarAnn -> Word -> InstrAbstract op
PAIRN
    (VarAnn -> Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser (Word -> ParsedInstr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
    Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

unpairNOp :: Parser ParsedInstr
unpairNOp :: Parser ParsedInstr
unpairNOp =
  Tokens Text
-> (Word -> ParsedInstr) -> Parser (Word -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"UNPAIR" Word -> ParsedInstr
forall op. Word -> InstrAbstract op
UNPAIRN Parser (Word -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Word
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal

carOp :: Parser ParsedInstr
carOp :: Parser ParsedInstr
carOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"CAR"; (VarAnn
v, FieldAnn
f) <- Parser (VarAnn, FieldAnn)
notesVF; return $ VarAnn -> FieldAnn -> ParsedInstr
forall op. VarAnn -> FieldAnn -> InstrAbstract op
CAR VarAnn
v FieldAnn
f

cdrOp :: Parser ParsedInstr
cdrOp :: Parser ParsedInstr
cdrOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"CDR"; (VarAnn
v, FieldAnn
f) <- Parser (VarAnn, FieldAnn)
notesVF; return $ VarAnn -> FieldAnn -> ParsedInstr
forall op. VarAnn -> FieldAnn -> InstrAbstract op
CDR VarAnn
v FieldAnn
f

-- Operations on collections (sets, maps, lists)

emptySetOp :: Parser ParsedInstr
emptySetOp :: Parser ParsedInstr
emptySetOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"EMPTY_SET"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV;
                TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
EMPTY_SET TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

emptyMapOp :: Parser ParsedInstr
emptyMapOp :: Parser ParsedInstr
emptyMapOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"EMPTY_MAP"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; Ty
a <- ParsecT CustomParserException Text Identity Ty
type_;
                TypeAnn -> VarAnn -> Ty -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
EMPTY_MAP TypeAnn
t VarAnn
v Ty
a (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

emptyBigMapOp :: Parser ParsedInstr
emptyBigMapOp :: Parser ParsedInstr
emptyBigMapOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"EMPTY_BIG_MAP"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; Ty
a <- ParsecT CustomParserException Text Identity Ty
type_;
                   TypeAnn -> VarAnn -> Ty -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> Ty -> InstrAbstract op
EMPTY_BIG_MAP TypeAnn
t VarAnn
v Ty
a (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

memOp :: Parser ParsedInstr
memOp :: Parser ParsedInstr
memOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"MEM" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
MEM Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

updateOp :: Parser ParsedInstr
updateOp :: Parser ParsedInstr
updateOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"UPDATE"
  VarAnn
varAnn <- ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  Maybe Word
ix <- ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal)
  pure $ ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
UPDATE VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall op. VarAnn -> Word -> InstrAbstract op
UPDATEN VarAnn
varAnn) Maybe Word
ix

getAndUpdateOp :: Parser ParsedInstr
getAndUpdateOp :: Parser ParsedInstr
getAndUpdateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"GET_AND_UPDATE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
GET_AND_UPDATE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

iterOp :: Parser ParsedOp -> Parser ParsedInstr
iterOp :: Parser ParsedOp -> Parser ParsedInstr
iterOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"ITER" [ParsedOp] -> ParsedInstr
forall op. [op] -> InstrAbstract op
ITER Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

sizeOp :: Parser ParsedInstr
sizeOp :: Parser ParsedInstr
sizeOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SIZE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SIZE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

mapOp :: Parser ParsedOp -> Parser ParsedInstr
mapOp :: Parser ParsedOp -> Parser ParsedInstr
mapOp Parser ParsedOp
opParser = Tokens Text
-> (VarAnn -> [ParsedOp] -> ParsedInstr)
-> Parser (VarAnn -> [ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"MAP" VarAnn -> [ParsedOp] -> ParsedInstr
forall op. VarAnn -> [op] -> InstrAbstract op
MAP Parser (VarAnn -> [ParsedOp] -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ([ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>  ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

getOp :: Parser ParsedInstr
getOp :: Parser ParsedInstr
getOp = do
  Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"GET"
  VarAnn
varAnn <- ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef
  Maybe Word
ix <- ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity (Maybe Word)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (ParsecT CustomParserException Text Identity Word
-> ParsecT CustomParserException Text Identity Word
forall a. Parser a -> Parser a
lexeme ParsecT CustomParserException Text Identity Word
forall e s (m :: * -> *) a.
(MonadParsec e s m, Token s ~ Char, Num a) =>
m a
L.decimal)
  pure $ ParsedInstr -> (Word -> ParsedInstr) -> Maybe Word -> ParsedInstr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
GET VarAnn
varAnn) (VarAnn -> Word -> ParsedInstr
forall op. VarAnn -> Word -> InstrAbstract op
GETN VarAnn
varAnn) Maybe Word
ix

nilOp :: Parser ParsedInstr
nilOp :: Parser ParsedInstr
nilOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"NIL"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
NIL TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

consOp :: Parser ParsedInstr
consOp :: Parser ParsedInstr
consOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CONS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
CONS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

ifConsOp :: Parser ParsedOp -> Parser ParsedInstr
ifConsOp :: Parser ParsedOp -> Parser ParsedInstr
ifConsOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"IF_CONS" [ParsedOp] -> [ParsedOp] -> ParsedInstr
forall op. [op] -> [op] -> InstrAbstract op
IF_CONS Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ([ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

-- Operations on options

someOp :: Parser ParsedInstr
someOp :: Parser ParsedInstr
someOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"SOME"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; return $ TypeAnn -> VarAnn -> ParsedInstr
forall op. TypeAnn -> VarAnn -> InstrAbstract op
SOME TypeAnn
t VarAnn
v

noneOp :: Parser ParsedInstr
noneOp :: Parser ParsedInstr
noneOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"NONE"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
NONE TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

ifNoneOp :: Parser ParsedOp -> Parser ParsedInstr
ifNoneOp :: Parser ParsedOp -> Parser ParsedInstr
ifNoneOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"IF_NONE" [ParsedOp] -> [ParsedOp] -> ParsedInstr
forall op. [op] -> [op] -> InstrAbstract op
IF_NONE Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ([ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

-- Operations on unions

leftOp :: Parser ParsedInstr
leftOp :: Parser ParsedInstr
leftOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"LEFT"; (TypeAnn
t, VarAnn
v, (FieldAnn
f, FieldAnn
f')) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def;
               TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> ParsedInstr
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op
LEFT TypeAnn
t VarAnn
v FieldAnn
f FieldAnn
f' (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

rightOp :: Parser ParsedInstr
rightOp :: Parser ParsedInstr
rightOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"RIGHT"; (TypeAnn
t, VarAnn
v, (FieldAnn
f, FieldAnn
f')) <- Parser (TypeAnn, VarAnn, (FieldAnn, FieldAnn))
notesTVF2Def;
               TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> ParsedInstr
forall op.
TypeAnn -> VarAnn -> FieldAnn -> FieldAnn -> Ty -> InstrAbstract op
RIGHT TypeAnn
t VarAnn
v FieldAnn
f FieldAnn
f' (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

ifLeftOp :: Parser ParsedOp -> Parser ParsedInstr
ifLeftOp :: Parser ParsedOp -> Parser ParsedInstr
ifLeftOp Parser ParsedOp
opParser = Tokens Text
-> ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"IF_LEFT" [ParsedOp] -> [ParsedOp] -> ParsedInstr
forall op. [op] -> [op] -> InstrAbstract op
IF_LEFT Parser ([ParsedOp] -> [ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ([ParsedOp] -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser Parser ([ParsedOp] -> ParsedInstr)
-> Parser [ParsedOp] -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser ParsedOp -> Parser [ParsedOp]
ops' Parser ParsedOp
opParser

-- Operations on contracts

createContractOp :: Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp :: Parser (Contract' ParsedOp) -> Parser ParsedInstr
createContractOp Parser (Contract' ParsedOp)
contractParser =
  Tokens Text
-> (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> Parser (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CREATE_CONTRACT" VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr
forall op. VarAnn -> VarAnn -> Contract' op -> InstrAbstract op
CREATE_CONTRACT
    Parser (VarAnn -> VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (VarAnn -> Contract' ParsedOp -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (VarAnn -> Contract' ParsedOp -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException
     Text
     Identity
     (Contract' ParsedOp -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException
  Text
  Identity
  (Contract' ParsedOp -> ParsedInstr)
-> Parser (Contract' ParsedOp) -> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Contract' ParsedOp) -> Parser (Contract' ParsedOp)
forall a. Parser a -> Parser a
braces Parser (Contract' ParsedOp)
contractParser

transferTokensOp :: Parser ParsedInstr
transferTokensOp :: Parser ParsedInstr
transferTokensOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"TRANSFER_TOKENS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
TRANSFER_TOKENS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

setDelegateOp :: Parser ParsedInstr
setDelegateOp :: Parser ParsedInstr
setDelegateOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SET_DELEGATE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SET_DELEGATE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

balanceOp :: Parser ParsedInstr
balanceOp :: Parser ParsedInstr
balanceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"BALANCE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
BALANCE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

contractOp :: Parser ParsedInstr
contractOp :: Parser ParsedInstr
contractOp = Tokens Text
-> (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
-> Parser (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CONTRACT" VarAnn -> FieldAnn -> Ty -> ParsedInstr
forall op. VarAnn -> FieldAnn -> Ty -> InstrAbstract op
CONTRACT Parser (VarAnn -> FieldAnn -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException Text Identity (FieldAnn -> Ty -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (FieldAnn -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity FieldAnn
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity FieldAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

sourceOp :: Parser ParsedInstr
sourceOp :: Parser ParsedInstr
sourceOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SOURCE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SOURCE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

senderOp :: Parser ParsedInstr
senderOp :: Parser ParsedInstr
senderOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SENDER" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SENDER Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

amountOp :: Parser ParsedInstr
amountOp :: Parser ParsedInstr
amountOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"AMOUNT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
AMOUNT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

votingPowerOp :: Parser ParsedInstr
votingPowerOp :: Parser ParsedInstr
votingPowerOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"VOTING_POWER" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
VOTING_POWER Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

totalVotingPowerOp :: Parser ParsedInstr
totalVotingPowerOp :: Parser ParsedInstr
totalVotingPowerOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"TOTAL_VOTING_POWER" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
TOTAL_VOTING_POWER Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

implicitAccountOp :: Parser ParsedInstr
implicitAccountOp :: Parser ParsedInstr
implicitAccountOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"IMPLICIT_ACCOUNT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
IMPLICIT_ACCOUNT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

viewOp :: Parser ParsedInstr
viewOp :: Parser ParsedInstr
viewOp =
  -- @VIEW_@ A1 macro should not be parsed by this
  Tokens Text
-> (VarAnn -> ViewName -> Ty -> ParsedInstr)
-> Parser (VarAnn -> ViewName -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"VIEW" VarAnn -> ViewName -> Ty -> ParsedInstr
forall op. VarAnn -> ViewName -> Ty -> InstrAbstract op
VIEW Parser (VarAnn -> ViewName -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException Text Identity (ViewName -> Ty -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (ViewName -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity ViewName
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity ViewName
viewName_ ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

selfOp :: Parser ParsedInstr
selfOp :: Parser ParsedInstr
selfOp = Tokens Text
-> (VarAnn -> FieldAnn -> ParsedInstr)
-> Parser (VarAnn -> FieldAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SELF" VarAnn -> FieldAnn -> ParsedInstr
forall op. VarAnn -> FieldAnn -> InstrAbstract op
SELF Parser (VarAnn -> FieldAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT
     CustomParserException Text Identity (FieldAnn -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT
  CustomParserException Text Identity (FieldAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity FieldAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity FieldAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

addressOp :: Parser ParsedInstr
addressOp :: Parser ParsedInstr
addressOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"ADDRESS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
ADDRESS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

selfAddressOp :: Parser ParsedInstr
selfAddressOp :: Parser ParsedInstr
selfAddressOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SELF_ADDRESS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SELF_ADDRESS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Special Operations

nowOp :: Parser ParsedInstr
nowOp :: Parser ParsedInstr
nowOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"NOW" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
NOW Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

levelOp :: Parser ParsedInstr
levelOp :: Parser ParsedInstr
levelOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"LEVEL" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
LEVEL Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

chainIdOp :: Parser ParsedInstr
chainIdOp :: Parser ParsedInstr
chainIdOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CHAIN_ID" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
CHAIN_ID Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Operations on bytes

packOp :: Parser ParsedInstr
packOp :: Parser ParsedInstr
packOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"PACK" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
PACK Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

unpackOp :: Parser ParsedInstr
unpackOp :: Parser ParsedInstr
unpackOp = do Tokens Text -> ParsecT CustomParserException Text Identity ()
symbol1 Tokens Text
"UNPACK"; (TypeAnn
t, VarAnn
v) <- Parser (TypeAnn, VarAnn)
notesTV; TypeAnn -> VarAnn -> Ty -> ParsedInstr
forall op. TypeAnn -> VarAnn -> Ty -> InstrAbstract op
UNPACK TypeAnn
t VarAnn
v (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT CustomParserException Text Identity Ty
type_

-- Cryptographic Primitives

checkSigOp :: Parser ParsedInstr
checkSigOp :: Parser ParsedInstr
checkSigOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CHECK_SIGNATURE" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
CHECK_SIGNATURE Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

blake2BOp :: Parser ParsedInstr
blake2BOp :: Parser ParsedInstr
blake2BOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"BLAKE2B" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
BLAKE2B Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha256Op :: Parser ParsedInstr
sha256Op :: Parser ParsedInstr
sha256Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SHA256" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SHA256 Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha512Op :: Parser ParsedInstr
sha512Op :: Parser ParsedInstr
sha512Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SHA512" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SHA512 Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

sha3Op :: Parser ParsedInstr
sha3Op :: Parser ParsedInstr
sha3Op = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SHA3" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SHA3 Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

keccakOp :: Parser ParsedInstr
keccakOp :: Parser ParsedInstr
keccakOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"KECCAK" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
KECCAK Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

hashKeyOp :: Parser ParsedInstr
hashKeyOp :: Parser ParsedInstr
hashKeyOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"HASH_KEY" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
HASH_KEY Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

pairingCheckOp :: Parser ParsedInstr
pairingCheckOp :: Parser ParsedInstr
pairingCheckOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"PAIRING_CHECK" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
PAIRING_CHECK Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Type operations

castOp :: Parser ParsedInstr
castOp :: Parser ParsedInstr
castOp = Tokens Text
-> (VarAnn -> Ty -> ParsedInstr)
-> Parser (VarAnn -> Ty -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"CAST" VarAnn -> Ty -> ParsedInstr
forall op. VarAnn -> Ty -> InstrAbstract op
CAST Parser (VarAnn -> Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef ParsecT CustomParserException Text Identity (Ty -> ParsedInstr)
-> ParsecT CustomParserException Text Identity Ty
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity Ty
type_

renameOp :: Parser ParsedInstr
renameOp :: Parser ParsedInstr
renameOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"RENAME" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
RENAME Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

isNatOp :: Parser ParsedInstr
isNatOp :: Parser ParsedInstr
isNatOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"ISNAT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
ISNAT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

intOp :: Parser ParsedInstr
intOp :: Parser ParsedInstr
intOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"INT" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
INT Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

-- Ticket Operations

ticketOp :: Parser ParsedInstr
ticketOp :: Parser ParsedInstr
ticketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"TICKET" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
TICKET Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

readTicketOp :: Parser ParsedInstr
readTicketOp :: Parser ParsedInstr
readTicketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"READ_TICKET" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
READ_TICKET Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

splitTicketOp :: Parser ParsedInstr
splitTicketOp :: Parser ParsedInstr
splitTicketOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"SPLIT_TICKET" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
SPLIT_TICKET Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

joinTicketsOp :: Parser ParsedInstr
joinTicketsOp :: Parser ParsedInstr
joinTicketsOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"JOIN_TICKETS" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
JOIN_TICKETS Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef

openChestOp :: Parser ParsedInstr
openChestOp :: Parser ParsedInstr
openChestOp = Tokens Text
-> (VarAnn -> ParsedInstr) -> Parser (VarAnn -> ParsedInstr)
forall a. Tokens Text -> a -> Parser a
word Tokens Text
"OPEN_CHEST" VarAnn -> ParsedInstr
forall op. VarAnn -> InstrAbstract op
OPEN_CHEST Parser (VarAnn -> ParsedInstr)
-> ParsecT CustomParserException Text Identity VarAnn
-> Parser ParsedInstr
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ParsecT CustomParserException Text Identity VarAnn
forall tag. KnownAnnTag tag => Parser (Annotation tag)
noteDef