{-# Language FlexibleContexts, FlexibleInstances, OverloadedStrings, Rank2Types, RecordWildCards, ScopedTypeVariables,
             TypeFamilies, TypeSynonymInstances, TemplateHaskell #-}

-- | Modula-2 grammar adapted from ''Report on the Programming Language Modula-2''

module Language.Modula2.Grammar (module Language.Modula2.Grammar, Lexeme(..), ParsedLexemes(..)) where

import Control.Applicative
import Control.Arrow (first)
import Control.Monad (guard, void)
import Data.Char (isAlphaNum, isDigit, isHexDigit, isLetter, isOctDigit, isSpace)
import Data.List.NonEmpty (NonEmpty, toList)
import Data.Ord (Down)
import Data.Maybe (catMaybes)
import Data.Monoid ((<>))
import Data.Text (Text, unpack)
import Numeric (readOct, readDec, readHex, readFloat)
import Text.Grampa
import Text.Grampa.ContextFree.SortedMemoizing.Transformer.LeftRecursive (ParserT, autochain, lift, tmap)
import Text.Parser.Combinators (sepBy, sepBy1, sepByNonEmpty, try)
import Text.Parser.Token (braces, brackets, parens)

import qualified Rank2
import qualified Rank2.TH
import Language.Oberon.Grammar (Lexeme(..), TokenType(..), ParsedLexemes(Trailing))

import qualified Language.Modula2.Abstract as Abstract
import qualified Language.Modula2.AST as AST

type Parser = ParserT ((,) [[Lexeme]])

-- | The names and types of all the Modula-2 grammar productions
data Modula2Grammar l f p = Modula2Grammar {
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
ident :: p Abstract.Ident,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
number :: p (Abstract.Value l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
integer :: p (Abstract.Value l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
real :: p (Abstract.Value l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
scaleFactor :: p Text,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
hexDigit :: p Text,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
digit :: p Text,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
octalDigit :: p Text,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
string_prod :: p Text,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (QualIdent l)
qualident :: p (Abstract.QualIdent l),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
constantDeclaration :: p (Abstract.Declaration l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
constantDefinition :: p (Abstract.Definition l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
constExpression :: p (NodeWrap (Abstract.ConstExpression l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p RelOp
relation :: p Abstract.RelOp,
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
addOperator :: p (f (Abstract.Expression l l f f) -> f (Abstract.Expression l l f f) -> Abstract.Expression l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
mulOperator :: p (f (Abstract.Expression l l f f) -> f (Abstract.Expression l l f f) -> Abstract.Expression l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (ConstExpression l l f f)
set :: p (Abstract.Expression l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Element l l f f)
element :: p (Abstract.Element l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
typeDeclaration :: p (Abstract.Declaration l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
typeDefinition :: p (Abstract.Definition l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
type_prod :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
simpleType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
enumeration :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (IdentList l)
identList :: p (Abstract.IdentList l),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
subrangeType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
arrayType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
recordType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (FieldList l l f f)]
fieldListSequence :: p [f (Abstract.FieldList l l f f)],
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FieldList l l f f)
fieldList :: p (Abstract.FieldList l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Variant l l f f)
variant :: p (Abstract.Variant l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (CaseLabels l l f f)))
caseLabelList :: p (NonEmpty (f (Abstract.CaseLabels l l f f))),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (CaseLabels l l f f)
caseLabels :: p (Abstract.CaseLabels l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
setType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
pointerType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
procedureType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
formalTypeList :: p (Abstract.FormalParameters l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
variableDeclaration :: p (Abstract.Declaration l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
variableDefinition :: p (Abstract.Definition l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Designator l l f f)
designator :: p (Abstract.Designator l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (ConstExpression l l f f)))
expList :: p (NonEmpty (f (Abstract.Expression l l f f))),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
expression :: p (NodeWrap (Abstract.Expression l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
simpleExpression :: p (NodeWrap (Abstract.Expression l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
term :: p (NodeWrap (Abstract.Expression l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
factor :: p (NodeWrap (Abstract.Expression l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (ConstExpression l l f f)]
actualParameters :: p [f (Abstract.Expression l l f f)],
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
statement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
assignment :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
procedureCall :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (StatementSequence l l f f))
statementSequence :: p (NodeWrap (Abstract.StatementSequence l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
ifStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
caseStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Case l l f f)
case_prod :: p (Abstract.Case l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
whileStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
repeatStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
forStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
loopStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
withStatement :: p (Abstract.Statement l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
procedureDeclaration :: p (Abstract.Declaration l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Text, ProcedureHeading l l f f)
procedureHeading :: p (Abstract.Ident, Abstract.ProcedureHeading l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Block l l f f)
block :: p (Abstract.Block l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Declaration l l f f)]
declarationSequence :: p [f (Abstract.Declaration l l f f)],
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
formalParameters :: p (Abstract.FormalParameters l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FPSection l l f f)
fPSection :: p (Abstract.FPSection l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
formalType :: p (Abstract.Type l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
moduleDeclaration :: p (Abstract.Declaration l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
priority :: p (NodeWrap (Abstract.Priority l l f f)),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Export l)
export :: p (Abstract.Export l),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Import l)
import_prod :: p (Abstract.Import l),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
definitionModule :: p (Abstract.Module l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Definition l l f f)]
definitionSequence :: p [f (Abstract.Definition l l f f)],
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
programModule :: p (Abstract.Module l l f f),
   forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (Module l l f f))
compilationUnit :: p (NodeWrap (Abstract.Module l l f f))
   }

type NodeWrap = (,) (Down Int, ParsedLexemes, Down Int)

$(Rank2.TH.deriveAll ''Modula2Grammar)

modula2grammar :: Grammar (Modula2Grammar AST.Language NodeWrap) Parser Text
modula2grammar :: Grammar (Modula2Grammar Language NodeWrap) Parser Text
modula2grammar = forall (p :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) s
       (f :: * -> *) (rl :: * -> * -> *) (cb :: * -> *).
(cb ~ Const (g (Const Bool)), f ~ GrammarFunctor (p g s), f ~ rl s,
 LeftRecParsing p g s rl, DeterministicParsing (p g s), Apply g,
 Traversable g, Distributive g, Logistic g) =>
g (Fixed p g s) -> g (Fixed p g s)
autochain forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) (g :: (* -> *) -> *).
(GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g,
 Distributive g) =>
(g m -> g m) -> g m
fixGrammar forall l (g :: (* -> *) -> *).
(Modula2 l, Apply g, LexicalParsing (Parser g Text)) =>
GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Text
grammar

-- | All the productions of Modula-2 grammar
grammar :: forall l g. (Abstract.Modula2 l, Rank2.Apply g, LexicalParsing (Parser g Text))
        => GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Text
grammar :: forall l (g :: (* -> *) -> *).
(Modula2 l, Apply g, LexicalParsing (Parser g Text)) =>
GrammarBuilder (Modula2Grammar l NodeWrap) g Parser Text
grammar g :: Modula2Grammar l NodeWrap (Parser g Text)
g@Modula2Grammar{Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
Parser g Text [NodeWrap (Expression l l NodeWrap NodeWrap)]
Parser g Text [NodeWrap (Declaration l l NodeWrap NodeWrap)]
Parser g Text [NodeWrap (Definition l l NodeWrap NodeWrap)]
Parser
  g Text (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
Parser
  g Text (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
Parser g Text (IdentList l)
Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
Parser g Text (NodeWrap (Module l l NodeWrap NodeWrap))
Parser g Text (Text, ProcedureHeading l l NodeWrap NodeWrap)
Fixed (ParserT ((,) [[Lexeme]])) g Text Text
Parser g Text RelOp
Parser g Text (QualIdent l)
Parser g Text (Import l)
Parser g Text (Element l l NodeWrap NodeWrap)
Parser g Text (CaseLabels l l NodeWrap NodeWrap)
Parser g Text (Case l l NodeWrap NodeWrap)
Parser g Text (Block l l NodeWrap NodeWrap)
Parser g Text (FPSection l l NodeWrap NodeWrap)
Parser g Text (FormalParameters l l NodeWrap NodeWrap)
Parser g Text (FieldList l l NodeWrap NodeWrap)
Parser g Text (Value l l NodeWrap NodeWrap)
Parser g Text (Designator l l NodeWrap NodeWrap)
Parser g Text (Expression l l NodeWrap NodeWrap)
Parser g Text (Statement l l NodeWrap NodeWrap)
Parser g Text (Type l l NodeWrap NodeWrap)
Parser g Text (Declaration l l NodeWrap NodeWrap)
Parser g Text (Module l l NodeWrap NodeWrap)
Parser g Text (Export l)
Parser g Text (Definition l l NodeWrap NodeWrap)
Parser g Text (Variant l l NodeWrap NodeWrap)
Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
compilationUnit :: Parser g Text (NodeWrap (Module l l NodeWrap NodeWrap))
programModule :: Parser g Text (Module l l NodeWrap NodeWrap)
definitionSequence :: Parser g Text [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionModule :: Parser g Text (Module l l NodeWrap NodeWrap)
import_prod :: Parser g Text (Import l)
export :: Parser g Text (Export l)
priority :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
moduleDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
formalType :: Parser g Text (Type l l NodeWrap NodeWrap)
fPSection :: Parser g Text (FPSection l l NodeWrap NodeWrap)
formalParameters :: Parser g Text (FormalParameters l l NodeWrap NodeWrap)
declarationSequence :: Parser g Text [NodeWrap (Declaration l l NodeWrap NodeWrap)]
block :: Parser g Text (Block l l NodeWrap NodeWrap)
procedureHeading :: Parser g Text (Text, ProcedureHeading l l NodeWrap NodeWrap)
procedureDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
withStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
loopStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
forStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
repeatStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
whileStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
case_prod :: Parser g Text (Case l l NodeWrap NodeWrap)
caseStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
ifStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
statementSequence :: Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
procedureCall :: Parser g Text (Statement l l NodeWrap NodeWrap)
assignment :: Parser g Text (Statement l l NodeWrap NodeWrap)
statement :: Parser g Text (Statement l l NodeWrap NodeWrap)
actualParameters :: Parser g Text [NodeWrap (Expression l l NodeWrap NodeWrap)]
factor :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expList :: Parser
  g Text (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
designator :: Parser g Text (Designator l l NodeWrap NodeWrap)
variableDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
variableDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
formalTypeList :: Parser g Text (FormalParameters l l NodeWrap NodeWrap)
procedureType :: Parser g Text (Type l l NodeWrap NodeWrap)
pointerType :: Parser g Text (Type l l NodeWrap NodeWrap)
setType :: Parser g Text (Type l l NodeWrap NodeWrap)
caseLabels :: Parser g Text (CaseLabels l l NodeWrap NodeWrap)
caseLabelList :: Parser
  g Text (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
variant :: Parser g Text (Variant l l NodeWrap NodeWrap)
fieldList :: Parser g Text (FieldList l l NodeWrap NodeWrap)
fieldListSequence :: Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
recordType :: Parser g Text (Type l l NodeWrap NodeWrap)
arrayType :: Parser g Text (Type l l NodeWrap NodeWrap)
subrangeType :: Parser g Text (Type l l NodeWrap NodeWrap)
identList :: Parser g Text (IdentList l)
enumeration :: Parser g Text (Type l l NodeWrap NodeWrap)
simpleType :: Parser g Text (Type l l NodeWrap NodeWrap)
type_prod :: Parser g Text (Type l l NodeWrap NodeWrap)
typeDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
typeDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
element :: Parser g Text (Element l l NodeWrap NodeWrap)
set :: Parser g Text (Expression l l NodeWrap NodeWrap)
mulOperator :: Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator :: Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
relation :: Parser g Text RelOp
constExpression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constantDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
constantDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
qualident :: Parser g Text (QualIdent l)
string_prod :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
octalDigit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
digit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
hexDigit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
scaleFactor :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
real :: Parser g Text (Value l l NodeWrap NodeWrap)
integer :: Parser g Text (Value l l NodeWrap NodeWrap)
number :: Parser g Text (Value l l NodeWrap NodeWrap)
ident :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
compilationUnit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (Module l l f f))
programModule :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
definitionSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Definition l l f f)]
definitionModule :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Module l l f f)
import_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Import l)
export :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Export l)
priority :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
moduleDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
formalType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
fPSection :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FPSection l l f f)
formalParameters :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
declarationSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (Declaration l l f f)]
block :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Block l l f f)
procedureHeading :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Text, ProcedureHeading l l f f)
procedureDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
withStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
loopStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
forStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
repeatStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
whileStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
case_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Case l l f f)
caseStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
ifStatement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
statementSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (StatementSequence l l f f))
procedureCall :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
assignment :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
statement :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Statement l l f f)
actualParameters :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (ConstExpression l l f f)]
factor :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
term :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
simpleExpression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
expression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
expList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (ConstExpression l l f f)))
designator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Designator l l f f)
variableDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
variableDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
formalTypeList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FormalParameters l l f f)
procedureType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
pointerType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
setType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
caseLabels :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (CaseLabels l l f f)
caseLabelList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NonEmpty (f (CaseLabels l l f f)))
variant :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Variant l l f f)
fieldList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (FieldList l l f f)
fieldListSequence :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p [f (FieldList l l f f)]
recordType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
arrayType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
subrangeType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
identList :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (IdentList l)
enumeration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
simpleType :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
type_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Type l l f f)
typeDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
typeDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
element :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Element l l f f)
set :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (ConstExpression l l f f)
mulOperator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
addOperator :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p
-> p (f (ConstExpression l l f f)
      -> f (ConstExpression l l f f) -> ConstExpression l l f f)
relation :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p RelOp
constExpression :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (NodeWrap (ConstExpression l l f f))
constantDefinition :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Definition l l f f)
constantDeclaration :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Declaration l l f f)
qualident :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (QualIdent l)
string_prod :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
octalDigit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
digit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
hexDigit :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
scaleFactor :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
real :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
integer :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
number :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p (Value l l f f)
ident :: forall l (f :: * -> *) (p :: * -> *).
Modula2Grammar l f p -> p Text
..} = Modula2Grammar l NodeWrap (Parser g Text)
g{
   ident :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident = forall (m :: * -> *). LexicalParsing m => m (ParserInput m)
identifier,
   number :: Parser g Text (Value l l NodeWrap NodeWrap)
number = Parser g Text (Value l l NodeWrap NodeWrap)
integer forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Value l l NodeWrap NodeWrap)
real forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"a number",
   integer :: Parser g Text (Value l l NodeWrap NodeWrap)
integer = forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Integer -> Value l l' f' f
Abstract.integer forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head
                           forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall a. (Eq a, Num a) => ReadS a
readDec forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit
                                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. (Eq a, Num a) => ReadS a
readOct forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isOctDigit forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"B"
                                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. (Eq a, Num a) => ReadS a
readHex forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fixed (ParserT ((,) [[Lexeme]])) g Text Text
digit forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isHexDigit) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"H")
                           forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Int -> Value l l' f' f
Abstract.charCode forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Eq a, Num a) => ReadS a
readOct forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack
                               forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Fixed (ParserT ((,) [[Lexeme]])) g Text Text
octalDigit forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isOctDigit forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"C")),
   real :: Parser g Text (Value l l NodeWrap NodeWrap)
real = forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Double -> Value l l' f' f
Abstract.real forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> a
head forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. RealFrac a => ReadS a
readFloat forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"." forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isDigit forall a. Semigroup a => a -> a -> a
<> forall {f :: * -> *} {a}.
(Alternative f, Monoid (f a)) =>
f a -> f a
moptional Fixed (ParserT ((,) [[Lexeme]])) g Text Text
scaleFactor),
   scaleFactor :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
scaleFactor = forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"E" forall a. Semigroup a => a -> a -> a
<> forall {f :: * -> *} {a}.
(Alternative f, Monoid (f a)) =>
f a -> f a
moptional (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"+" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"-") forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isDigit,
   hexDigit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
hexDigit = forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isHexDigit,
   digit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
digit = forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isDigit,
   octalDigit :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
octalDigit = forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
satisfyCharInput Char -> Bool
isOctDigit,
   string_prod :: Fixed (ParserT ((,) [[Lexeme]])) g Text Text
string_prod = forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\'' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile (\Char
c-> Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\'' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\n') forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\''
                               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'"' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile (\Char
c-> Char
c forall a. Eq a => a -> a -> Bool
/= Char
'"' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\n') forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'"'),
   qualident :: Parser g Text (QualIdent l)
qualident = forall l. Modula2 l => [Text] -> Text -> QualIdent l
Abstract.qualIdent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident,
   constantDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
constantDeclaration = forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentDef l'
-> f (ConstExpression l' l' f' f') -> Declaration l l' f' f
Abstract.constantDeclaration forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall l. Wirthy l => Text -> IdentDef l
Abstract.identDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident)
                         forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"=" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   constantDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
constantDefinition = forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentDef l'
-> f (ConstExpression l' l' f' f') -> Definition l l' f' f
Abstract.constantDefinition forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall l. Wirthy l => Text -> IdentDef l
Abstract.identDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident)
                        forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"=" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   constExpression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression = Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   relation :: Parser g Text RelOp
relation = RelOp
Abstract.Equal forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"=" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Unequal forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"#" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"<>")
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Less forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"<" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.LessOrEqual forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"<=" 
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.Greater forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
">" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.GreaterOrEqual forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
">=" 
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> RelOp
Abstract.In forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"IN",
   addOperator :: Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.add forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"+" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.subtract forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"-" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.or forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OR",
   mulOperator :: Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
mulOperator = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.multiply forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"*" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.divide forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"/"
                 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.integerDivide forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"DIV" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.modulo forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"MOD"
                 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.and forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"&" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"AND"),
   set :: Parser g Text (Expression l l NodeWrap NodeWrap)
set = forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe (QualIdent l')
-> [f (Element l' l' f' f')] -> Expression l l' f' f
Abstract.set forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (QualIdent l)
qualident forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. TokenParsing m => m a -> m a
braces (forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Element l l NodeWrap NodeWrap)
element) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",")),
   element :: Parser g Text (Element l l NodeWrap NodeWrap)
element = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Element l l' f' f
Abstract.element forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
             forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (Expression l' l' f' f') -> Element l l' f' f
Abstract.range forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".." forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   typeDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
typeDeclaration = forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentDef l' -> f (Type l' l' f' f') -> Declaration l l' f' f
Abstract.typeDeclaration forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall l. Wirthy l => Text -> IdentDef l
Abstract.identDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"=" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod,
   typeDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
typeDefinition = forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentDef l' -> Maybe (f (Type l' l' f' f')) -> Definition l l' f' f
Abstract.typeDefinition forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall l. Wirthy l => Text -> IdentDef l
Abstract.identDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"=" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod),
   type_prod :: Parser g Text (Type l l NodeWrap NodeWrap)
type_prod = Parser g Text (Type l l NodeWrap NodeWrap)
simpleType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
arrayType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
recordType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
setType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
pointerType forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
procedureType,
   simpleType :: Parser g Text (Type l l NodeWrap NodeWrap)
simpleType = forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Type l l' f' f
Abstract.typeReference forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (QualIdent l)
qualident
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
enumeration
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Type l l NodeWrap NodeWrap)
subrangeType,
   enumeration :: Parser g Text (Type l l NodeWrap NodeWrap)
enumeration = forall l l' (f' :: * -> *) (f :: * -> *).
Modula2 l =>
IdentList l' -> Type l l' f' f
Abstract.enumeration forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens Parser g Text (IdentList l)
identList,
   identList :: Parser g Text (IdentList l)
identList = forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (forall l. Wirthy l => Text -> IdentDef l
Abstract.identDef forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
","),
   subrangeType :: Parser g Text (Type l l NodeWrap NodeWrap)
subrangeType = forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets (forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe (QualIdent l')
-> f (ConstExpression l' l' f' f')
-> f (ConstExpression l' l' f' f')
-> Type l l' f' f
Abstract.subRange (forall a. Maybe a
Nothing :: Maybe (Abstract.QualIdent l)) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression
                            forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".." forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression),
   arrayType :: Parser g Text (Type l l NodeWrap NodeWrap)
arrayType =
      forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (Type l' l' f' f')] -> f (Type l' l' f' f') -> Type l l' f' f
Abstract.arrayType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ARRAY" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
simpleType) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OF" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod,
   recordType :: Parser g Text (Type l l NodeWrap NodeWrap)
recordType = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (FieldList l' l' f' f')] -> Type l l' f' f
Abstract.recordType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"RECORD" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
fieldListSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   fieldListSequence :: Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
fieldListSequence = forall a. [Maybe a] -> [a]
catMaybes forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (FieldList l l NodeWrap NodeWrap)
fieldList) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"),
   fieldList :: Parser g Text (FieldList l l NodeWrap NodeWrap)
fieldList = (forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
NonEmpty (IdentDef l')
-> f (Type l' l' f' f') -> FieldList l l' f' f
Abstract.fieldList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (IdentList l)
identList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod
                :: Parser g Text (Abstract.FieldList l l NodeWrap NodeWrap))
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Maybe Text
-> QualIdent l'
-> NonEmpty (f (Variant l' l' f' f'))
-> [f (FieldList l' l' f' f')]
-> FieldList l l' f' f
Abstract.caseFieldList forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"CASE" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (QualIdent l)
qualident
                                          forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OF" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Variant l l NodeWrap NodeWrap)
variant) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"|")
                                          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall {f :: * -> *} {a}.
(Alternative f, Monoid (f a)) =>
f a -> f a
moptional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ELSE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
fieldListSequence) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   variant :: Parser g Text (Variant l l NodeWrap NodeWrap)
variant = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
NonEmpty (f (CaseLabels l' l' f' f'))
-> [f (FieldList l' l' f' f')] -> Variant l l' f' f
Abstract.variant forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  g Text (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed
  (ParserT ((,) [[Lexeme]]))
  g
  Text
  [((Down Int, ParsedLexemes, Down Int),
    FieldList l l NodeWrap NodeWrap)]
fieldListSequence,
   caseLabelList :: Parser
  g Text (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList = forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (CaseLabels l l NodeWrap NodeWrap)
caseLabels) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
","),
   caseLabels :: Parser g Text (CaseLabels l l NodeWrap NodeWrap)
caseLabels = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ConstExpression l' l' f' f') -> CaseLabels l l' f' f
Abstract.singleLabel forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ConstExpression l' l' f' f')
-> f (ConstExpression l' l' f' f') -> CaseLabels l l' f' f
Abstract.labelRange forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".." forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   setType :: Parser g Text (Type l l NodeWrap NodeWrap)
setType = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (Type l' l' f' f') -> Type l l' f' f
Abstract.setType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"SET" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OF" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
simpleType,
   pointerType :: Parser g Text (Type l l NodeWrap NodeWrap)
pointerType = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Type l' l' f' f') -> Type l l' f' f
Abstract.pointerType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"POINTER" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"TO" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod,
   procedureType :: Parser g Text (Type l l NodeWrap NodeWrap)
procedureType = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Maybe (f (FormalParameters l' l' f' f')) -> Type l l' f' f
Abstract.procedureType forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"PROCEDURE" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (FormalParameters l l NodeWrap NodeWrap)
formalTypeList),
   formalTypeList :: Parser g Text (FormalParameters l l NodeWrap NodeWrap)
formalTypeList = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (FPSection l' l' f' f')]
-> Maybe (ReturnType l') -> FormalParameters l l' f' f
Abstract.formalParameters
                    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap forall a b. (a -> b) -> a -> b
$
                                       forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Bool -> [Text] -> f (Type l' l' f' f') -> FPSection l l' f' f
Abstract.fpSection forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"VAR" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure [] forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
formalType)
                                      (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
","))
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (QualIdent l)
qualident),
   variableDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
variableDeclaration = forall l l' (f :: * -> *) (f' :: * -> *).
Wirthy l =>
IdentList l' -> f (Type l' l' f' f') -> Declaration l l' f' f
Abstract.variableDeclaration forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (IdentList l)
identList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod,
   variableDefinition :: Parser g Text (Definition l l NodeWrap NodeWrap)
variableDefinition = forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
IdentList l' -> f (Type l' l' f' f') -> Definition l l' f' f
Abstract.variableDefinition forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (IdentList l)
identList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
type_prod,
   designator :: Parser g Text (Designator l l NodeWrap NodeWrap)
designator = forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Designator l l' f' f
Abstract.variable forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l. Wirthy l => Text -> QualIdent l
Abstract.nonQualIdent forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident -- qualident
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Text -> Designator l l' f' f
Abstract.field forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"." forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> NonEmpty (f (Expression l' l' f' f')) -> Designator l l' f' f
Abstract.index forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets Parser
  g Text (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
expList
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Designator l l' f' f
Abstract.dereference forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"^",
   expList :: Parser
  g Text (NonEmpty (NodeWrap (Expression l l NodeWrap NodeWrap)))
expList = forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
","),
   expression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression = Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall a b c. (a -> b -> c) -> b -> a -> c
flip forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
RelOp
-> f (Expression l' l' f' f')
-> f (Expression l' l' f' f')
-> Expression l l' f' f
Abstract.relation forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text RelOp
relation forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression)
                forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"expression",
   simpleExpression :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression =
      forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.positive forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"+" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.negative forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"-" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term)
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term
      forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
simpleExpression forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
addOperator forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term),
   term :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term = Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
factor forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
term forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> Parser
  g
  Text
  (NodeWrap (Expression l l NodeWrap NodeWrap)
   -> NodeWrap (Expression l l NodeWrap NodeWrap)
   -> Expression l l NodeWrap NodeWrap)
mulOperator forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
factor),
   factor :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
factor = forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Value l' l' f' f') -> Expression l l' f' f
Abstract.literal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (Parser g Text (Value l l NodeWrap NodeWrap)
number
                                             forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Text -> Value l l' f' f
Abstract.string forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
string_prod)
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Expression l l NodeWrap NodeWrap)
set
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f') -> Expression l l' f' f
Abstract.read forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> [f (Expression l' l' f' f')] -> Expression l l' f' f
Abstract.functionCall forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters
                  forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f') -> Expression l l' f' f
Abstract.not forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
"~" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"NOT") forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
factor
                       :: Parser g Text (Abstract.Expression l l NodeWrap NodeWrap)))
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   actualParameters :: Parser g Text [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters = forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",")),
   statement :: Parser g Text (Statement l l NodeWrap NodeWrap)
statement = Parser g Text (Statement l l NodeWrap NodeWrap)
assignment forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
procedureCall forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
ifStatement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
caseStatement 
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
whileStatement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
repeatStatement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
loopStatement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
forStatement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Statement l l NodeWrap NodeWrap)
withStatement 
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Statement l l' f' f
Abstract.exitStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"EXIT" 
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Maybe (f (Expression l' l' f' f')) -> Statement l l' f' f
Abstract.returnStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"RETURN" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
               forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
Statement l l' f' f
Abstract.emptyStatement
               forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"statement",
   assignment :: Parser g Text (Statement l l NodeWrap NodeWrap)
assignment  =  forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> f (Expression l' l' f' f') -> Statement l l' f' f
Abstract.assignment forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":=" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   procedureCall :: Parser g Text (Statement l l NodeWrap NodeWrap)
procedureCall = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Designator l' l' f' f')
-> Maybe [f (Expression l' l' f' f')] -> Statement l l' f' f
Abstract.procedureCall forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text [NodeWrap (Expression l l NodeWrap NodeWrap)]
actualParameters,
   statementSequence :: Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence = forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (Statement l' l' f' f')] -> StatementSequence l l' f' f
Abstract.statementSequence forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Statement l l NodeWrap NodeWrap)
statement) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")),
   ifStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
ifStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
NonEmpty (f (ConditionalBranch l' l' f' f'))
-> Maybe (f (StatementSequence l' l' f' f')) -> Statement l l' f' f
Abstract.ifStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"IF"
       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap forall a b. (a -> b) -> a -> b
$ forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (StatementSequence l' l' f' f') -> ConditionalBranch l l' f' f
Abstract.conditionalBranch forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"THEN" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence)
                         (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ELSIF")
       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ELSE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   caseStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
caseStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> [f (Case l' l' f' f')]
-> Maybe (f (StatementSequence l' l' f' f'))
-> Statement l l' f' f
Abstract.caseStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"CASE" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OF" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Case l l NodeWrap NodeWrap)
case_prod) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
"|")
       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ELSE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   case_prod :: Parser g Text (Case l l NodeWrap NodeWrap)
case_prod = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
NonEmpty (f (CaseLabels l' l' f' f'))
-> f (StatementSequence l' l' f' f') -> Case l l' f' f
Abstract.caseAlternative forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser
  g Text (NonEmpty (NodeWrap (CaseLabels l l NodeWrap NodeWrap)))
caseLabelList forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence,
   whileStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
whileStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (Expression l' l' f' f')
-> f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.whileStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"WHILE" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"DO"
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   repeatStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
repeatStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (StatementSequence l' l' f' f')
-> f (Expression l' l' f' f') -> Statement l l' f' f
Abstract.repeatStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"REPEAT"
                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"UNTIL" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression,
   forStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
forStatement = 
      forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Text
-> f (Expression l' l' f' f')
-> f (Expression l' l' f' f')
-> Maybe (f (Expression l' l' f' f'))
-> f (StatementSequence l' l' f' f')
-> Statement l l' f' f
Abstract.forStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"FOR" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":=" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"TO" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
expression forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"BY" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression)
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"DO" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   loopStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
loopStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.loopStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"LOOP" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   withStatement :: Parser g Text (Statement l l NodeWrap NodeWrap)
withStatement = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (Designator l' l' f' f')
-> f (StatementSequence l' l' f' f') -> Statement l l' f' f
Abstract.withStatement forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"WITH" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Designator l l NodeWrap NodeWrap)
designator forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"DO"
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   procedureDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
procedureDeclaration = do (Text
procedureName, ((Down Int, ParsedLexemes, Down Int),
 ProcedureHeading l l NodeWrap NodeWrap)
heading) <- forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Text, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading
                             forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"
                             NodeWrap (Block l l NodeWrap NodeWrap)
body <- forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Block l l NodeWrap NodeWrap)
block
                             forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
procedureName)
                             forall (m :: * -> *) a. Monad m => a -> m a
return (forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
f (ProcedureHeading l' l' f' f')
-> f (Block l' l' f' f') -> Declaration l l' f' f
Abstract.procedureDeclaration ((Down Int, ParsedLexemes, Down Int),
 ProcedureHeading l l NodeWrap NodeWrap)
heading NodeWrap (Block l l NodeWrap NodeWrap)
body),
   procedureHeading :: Parser g Text (Text, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Text
-> Maybe (f (FormalParameters l' l' f' f'))
-> ProcedureHeading l l' f' f
Abstract.procedureHeading forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"PROCEDURE"
                      forall (f :: * -> *) a b. Applicative f => f a -> f (a -> b) -> f b
<**> do Text
name <- Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident
                              Maybe (NodeWrap (FormalParameters l l NodeWrap NodeWrap))
params <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (FormalParameters l l NodeWrap NodeWrap)
formalParameters)
                              forall (m :: * -> *) a. Monad m => a -> m a
return (\Text
-> Maybe (NodeWrap (FormalParameters l l NodeWrap NodeWrap))
-> ProcedureHeading l l NodeWrap NodeWrap
proc-> (Text
name, Text
-> Maybe (NodeWrap (FormalParameters l l NodeWrap NodeWrap))
-> ProcedureHeading l l NodeWrap NodeWrap
proc Text
name Maybe (NodeWrap (FormalParameters l l NodeWrap NodeWrap))
params)),
   block :: Parser g Text (Block l l NodeWrap NodeWrap)
block = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (Declaration l' l' f' f')]
-> Maybe (f (StatementSequence l' l' f' f')) -> Block l l' f' f
Abstract.block forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text [NodeWrap (Declaration l l NodeWrap NodeWrap)]
declarationSequence forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"BEGIN" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (NodeWrap (StatementSequence l l NodeWrap NodeWrap))
statementSequence)
           forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END",
   declarationSequence :: Parser g Text [NodeWrap (Declaration l l NodeWrap NodeWrap)]
declarationSequence = forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"CONST" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Declaration l l NodeWrap NodeWrap)
constantDeclaration forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"TYPE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Declaration l l NodeWrap NodeWrap)
typeDeclaration forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"VAR" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Declaration l l NodeWrap NodeWrap)
variableDeclaration forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> [a] -> [a]
:[]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Declaration l l NodeWrap NodeWrap)
procedureDeclaration forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"
                                                    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Declaration l l NodeWrap NodeWrap)
moduleDeclaration forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"))
                         forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"declarations",
   formalParameters :: Parser g Text (FormalParameters l l NodeWrap NodeWrap)
formalParameters = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
[f (FPSection l' l' f' f')]
-> Maybe (ReturnType l') -> FormalParameters l l' f' f
Abstract.formalParameters forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. TokenParsing m => m a -> m a
parens (forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (FPSection l l NodeWrap NodeWrap)
fPSection) (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"))
                      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parser g Text (QualIdent l)
qualident),
   fPSection :: Parser g Text (FPSection l l NodeWrap NodeWrap)
fPSection = forall l (f :: * -> *) l' (f' :: * -> *).
Wirthy l =>
Bool -> [Text] -> f (Type l' l' f' f') -> FPSection l l' f' f
Abstract.fpSection forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"VAR" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) 
               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
sepBy1 Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
":" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
formalType,
   formalType :: Parser g Text (Type l l NodeWrap NodeWrap)
formalType = forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
[f (Type l' l' f' f')] -> f (Type l' l' f' f') -> Type l l' f' f
Abstract.arrayType [] forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"ARRAY" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"OF" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Type l l NodeWrap NodeWrap)
formalType 
                forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall l l' (f' :: * -> *) (f :: * -> *).
Wirthy l =>
QualIdent l' -> Type l l' f' f
Abstract.typeReference forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (QualIdent l)
qualident,
   moduleDeclaration :: Parser g Text (Declaration l l NodeWrap NodeWrap)
moduleDeclaration = do forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"MODULE"
                          Text
name <- Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident
                          forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Text
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> Maybe (Export l')
-> f (Block l' l' f' f')
-> Declaration l l' f' f
Abstract.moduleDeclaration Text
name forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
priority forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"
                             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Text (Import l)
import_prod forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (Export l)
export forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Block l l NodeWrap NodeWrap)
block forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
name),
   priority :: Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
priority = forall (m :: * -> *) a. TokenParsing m => m a -> m a
brackets Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
constExpression,
   export :: Parser g Text (Export l)
export = forall l. Modula2 l => Bool -> NonEmpty Text -> Export l
Abstract.moduleExport forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"EXPORT" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Bool
True forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"QUALIFIED" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";",
   import_prod :: Parser g Text (Import l)
import_prod = forall l. Modula2 l => Maybe Text -> NonEmpty Text -> Import l
Abstract.moduleImport forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"FROM" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident)
                 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"IMPORT" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a sep.
Alternative m =>
m a -> m sep -> m (NonEmpty a)
sepByNonEmpty Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident (forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
",") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";",
   definitionModule :: Parser g Text (Module l l NodeWrap NodeWrap)
definitionModule = forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"DEFINITION" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"MODULE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
                      do Text
name <- Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident
                         forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"
                         forall l l' (f :: * -> *) (f' :: * -> *).
Modula2 l =>
Text
-> [Import l']
-> Maybe (Export l')
-> [f (Definition l' l' f' f')]
-> Module l l' f' f
Abstract.definitionModule Text
name forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Text (Import l)
import_prod forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (Export l)
export forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser g Text [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionSequence
                                                   forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"END" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
name) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".",
   definitionSequence :: Parser g Text [NodeWrap (Definition l l NodeWrap NodeWrap)]
definitionSequence =  forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"CONST" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Definition l l NodeWrap NodeWrap)
constantDefinition forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"TYPE" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Definition l l NodeWrap NodeWrap)
typeDefinition forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"VAR" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Definition l l NodeWrap NodeWrap)
variableDefinition forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";")
                                     forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall a. a -> [a] -> [a]
:[]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
f (ProcedureHeading l' l' f' f') -> Definition l l' f' f
Abstract.procedureDefinition forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parser g Text (Text, ProcedureHeading l l NodeWrap NodeWrap)
procedureHeading))
                                                    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";"))
                         forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"definitions",
   programModule :: Parser g Text (Module l l NodeWrap NodeWrap)
programModule = do Text
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
con <- (forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Text
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> f (Block l' l' f' f')
-> Module l l' f' f
Abstract.implementationModule forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"IMPLEMENTATION"
                              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall l (f :: * -> *) l' (f' :: * -> *).
Modula2 l =>
Text
-> Maybe (f (Priority l' l' f' f'))
-> [Import l']
-> f (Block l' l' f' f')
-> Module l l' f' f
Abstract.programModule) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => ParserInput m -> m ()
keyword Text
"MODULE"
                      Text
name <- Fixed (ParserT ((,) [[Lexeme]])) g Text Text
ident
                      Text
-> Maybe (NodeWrap (Expression l l NodeWrap NodeWrap))
-> [Import l]
-> NodeWrap (Block l l NodeWrap NodeWrap)
-> Module l l NodeWrap NodeWrap
con Text
name forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional Parser g Text (NodeWrap (Expression l l NodeWrap NodeWrap))
priority forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
";" forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parser g Text (Import l)
import_prod
                               forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap Parser g Text (Block l l NodeWrap NodeWrap)
block forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
name) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
".",
   compilationUnit :: Parser g Text (NodeWrap (Module l l NodeWrap NodeWrap))
compilationUnit = forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap (forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (Parser g Text (Module l l NodeWrap NodeWrap)
definitionModule forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser g Text (Module l l NodeWrap NodeWrap)
programModule)) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) a. Parsing m => m a -> m ()
skipMany (forall (m :: * -> *). CharParsing m => Char -> m Char
char Char
'\x1a' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace)
   }

instance TokenParsing (Parser (Modula2Grammar l f) Text) where
   someSpace :: Parser (Modula2Grammar l f) Text ()
someSpace = forall (m :: * -> *). LexicalParsing m => m ()
someLexicalSpace
   token :: forall a.
Parser (Modula2Grammar l f) Text a
-> Parser (Modula2Grammar l f) Text a
token = forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken

instance LexicalParsing (Parser (Modula2Grammar l f) Text) where
   lexicalComment :: Parser (Modula2Grammar l f) Text ()
lexicalComment = do Text
c <- forall (g :: (* -> *) -> *). Apply g => Parser g Text Text
comment
                       forall (m :: * -> *) s a (g :: (* -> *) -> *).
(Applicative m, Ord s) =>
m a -> ParserT m g s a
lift ([[Text -> Lexeme
Comment Text
c]], ())
   lexicalWhiteSpace :: Parser (Modula2Grammar l f) Text ()
lexicalWhiteSpace = forall (g :: (* -> *) -> *).
(Apply g, LexicalParsing (Parser g Text)) =>
Parser g Text ()
whiteSpace
   isIdentifierStartChar :: Char -> Bool
isIdentifierStartChar = Char -> Bool
isLetter
   isIdentifierFollowChar :: Char -> Bool
isIdentifierFollowChar = Char -> Bool
isAlphaNum
   identifierToken :: Parser
  (Modula2Grammar l f)
  Text
  (ParserInput (Parser (Modula2Grammar l f) Text))
-> Parser
     (Modula2Grammar l f)
     Text
     (ParserInput (Parser (Modula2Grammar l f) Text))
identifierToken Parser
  (Modula2Grammar l f)
  Text
  (ParserInput (Parser (Modula2Grammar l f) Text))
word = forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (do Text
w <- Parser
  (Modula2Grammar l f)
  Text
  (ParserInput (Parser (Modula2Grammar l f) Text))
word
                                           forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Text
w forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Text]
reservedWords)
                                           forall (m :: * -> *) a. Monad m => a -> m a
return Text
w)
   lexicalToken :: forall a.
Parser (Modula2Grammar l f) Text a
-> Parser (Modula2Grammar l f) Text a
lexicalToken Parser (Modula2Grammar l f) Text a
p = forall a b. (a, b) -> b
snd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall b (m :: * -> *) a (g :: (* -> *) -> *) s.
AmbiguityDecidable b =>
(m a -> m b) -> ParserT m g s a -> ParserT m g s b
tmap forall {b}. ([[Lexeme]], (Text, b)) -> ([[Lexeme]], (Text, b))
addOtherToken (forall (m :: * -> *) a.
ConsumedInputParsing m =>
m a -> m (ParserInput m, a)
match Parser (Modula2Grammar l f) Text a
p) forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). LexicalParsing m => m ()
lexicalWhiteSpace
      where addOtherToken :: ([[Lexeme]], (Text, b)) -> ([[Lexeme]], (Text, b))
addOtherToken ([], (Text
i, b
x)) = ([[TokenType -> Text -> Lexeme
Token TokenType
Other Text
i]], (Text
i, b
x))
            addOtherToken ([[Lexeme]]
t, (Text
i, b
x)) = ([[Lexeme]]
t, (Text
i, b
x))
   keyword :: ParserInput (Parser (Modula2Grammar l f) Text)
-> Parser (Modula2Grammar l f) Text ()
keyword ParserInput (Parser (Modula2Grammar l f) Text)
s = forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string ParserInput (Parser (Modula2Grammar l f) Text)
s
                             forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). InputCharParsing m => (Char -> Bool) -> m ()
notSatisfyChar Char -> Bool
isAlphaNum
                             forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) s a (g :: (* -> *) -> *).
(Applicative m, Ord s) =>
m a -> ParserT m g s a
lift ([[TokenType -> Text -> Lexeme
Token TokenType
Keyword ParserInput (Parser (Modula2Grammar l f) Text)
s]], ()))
               forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"keyword " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show ParserInput (Parser (Modula2Grammar l f) Text)
s)

comment :: Rank2.Apply g => Parser g Text Text
comment :: forall (g :: (* -> *) -> *). Apply g => Parser g Text Text
comment = forall (m :: * -> *) a. Parsing m => m a -> m a
try (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"(*"
               forall a. Semigroup a => a -> a -> a
<> forall (p :: * -> *) a. (Alternative p, Monoid a) => p a -> p a
concatMany (forall (g :: (* -> *) -> *). Apply g => Parser g Text Text
comment forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> forall (m :: * -> *) a. (Parsing m, Show a) => m a -> m ()
notFollowedBy (forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"*)") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). InputParsing m => m (ParserInput m)
anyToken forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile Char -> Bool
isCommentChar)
               forall a. Semigroup a => a -> a -> a
<> forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
"*)")
   where isCommentChar :: Char -> Bool
isCommentChar Char
c = Char
c forall a. Eq a => a -> a -> Bool
/= Char
'*' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'('

whiteSpace :: Rank2.Apply g => LexicalParsing (Parser g Text) => Parser g Text ()
whiteSpace :: forall (g :: (* -> *) -> *).
(Apply g, LexicalParsing (Parser g Text)) =>
Parser g Text ()
whiteSpace = Fixed (ParserT ((,) [[Lexeme]])) g Text ()
spaceChars forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) a. Parsing m => m a -> m ()
skipMany (forall (m :: * -> *). LexicalParsing m => m ()
lexicalComment forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Fixed (ParserT ((,) [[Lexeme]])) g Text ()
spaceChars) forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> String
"whitespace"
   where spaceChars :: Fixed (ParserT ((,) [[Lexeme]])) g Text ()
spaceChars = (forall (m :: * -> *).
InputCharParsing m =>
(Char -> Bool) -> m (ParserInput m)
takeCharsWhile1 Char -> Bool
isSpace forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
ws-> forall (m :: * -> *) s a (g :: (* -> *) -> *).
(Applicative m, Ord s) =>
m a -> ParserT m g s a
lift ([[Text -> Lexeme
WhiteSpace Text
ws]], ())) forall (m :: * -> *) a. DeterministicParsing m => m a -> m a -> m a
<<|> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

wrap :: Rank2.Apply g => Parser g Text a -> Parser g Text (NodeWrap a)
wrap :: forall (g :: (* -> *) -> *) a.
Apply g =>
Parser g Text a -> Parser g Text (NodeWrap a)
wrap = (\Fixed (ParserT ((,) [[Lexeme]])) g Text (ParsedLexemes, a)
p-> forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 forall {a} {b} {b} {c}. a -> (b, b) -> c -> ((a, b, c), b)
surround forall (m :: * -> *). InputParsing m => m (ParserPosition m)
getSourcePos Fixed (ParserT ((,) [[Lexeme]])) g Text (ParsedLexemes, a)
p forall (m :: * -> *). InputParsing m => m (ParserPosition m)
getSourcePos) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b (m :: * -> *) a (g :: (* -> *) -> *) s.
AmbiguityDecidable b =>
(m a -> m b) -> ParserT m g s a -> ParserT m g s b
tmap forall {a} {t :: * -> *} {b}.
(Monoid a, Foldable t) =>
(t [Lexeme], (ParsedLexemes, b)) -> (a, (ParsedLexemes, b))
store forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((,) ([Lexeme] -> ParsedLexemes
Trailing []) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)
   where surround :: a -> (b, b) -> c -> ((a, b, c), b)
surround a
start (b
lexemes, b
p) c
end = ((a
start, b
lexemes, c
end), b
p)
         store :: (t [Lexeme], (ParsedLexemes, b)) -> (a, (ParsedLexemes, b))
store (t [Lexeme]
wss, (Trailing [Lexeme]
ws', b
a)) = (forall a. Monoid a => a
mempty, ([Lexeme] -> ParsedLexemes
Trailing forall a b. (a -> b) -> a -> b
$ [Lexeme]
ws' forall a. Semigroup a => a -> a -> a
<> forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat t [Lexeme]
wss, b
a))

moptional :: f a -> f a
moptional f a
p = f a
p forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. Monoid a => a
mempty

delimiter, operator :: (LexicalParsing (Parser g Text)) => Text -> Parser g Text ()

delimiter :: forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
delimiter Text
s = forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
s) forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"delimiter " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Text
s)
operator :: forall (g :: (* -> *) -> *).
LexicalParsing (Parser g Text) =>
Text -> Parser g Text ()
operator Text
s = forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall (m :: * -> *) a. LexicalParsing m => m a -> m a
lexicalToken forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
InputParsing m =>
ParserInput m -> m (ParserInput m)
string Text
s) forall (m :: * -> *) a. Parsing m => m a -> String -> m a
<?> (String
"operator " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Text
s)

reservedWords :: [Text]
reservedWords :: [Text]
reservedWords = [Text
"AND", Text
"ARRAY", Text
"BEGIN", Text
"BY",
                 Text
"CASE", Text
"CONST", Text
"DEFINITION", Text
"DIV", Text
"DO",
                 Text
"ELSE", Text
"ELSIF", Text
"END", Text
"EXIT", Text
"EXPORT", Text
"FOR", Text
"FROM",
                 Text
"IF", Text
"IMPLEMENTATION", Text
"IMPORT", Text
"IN", Text
"LOOP",
                 Text
"MOD", Text
"MODULE", Text
"NOT",
                 Text
"OF", Text
"OR", Text
"POINTER", Text
"PROCEDURE",
                 Text
"QUALIFIED", Text
"RECORD", Text
"REPEAT", Text
"RETURN",
                 Text
"SET", Text
"THEN", Text
"TO", Text
"TYPE",
                 Text
"UNTIL", Text
"VAR", Text
"WHILE", Text
"WITH"]