Language.Oberon.AST

Oberon Abstract Syntax Tree definitions

Documentation

data Module f

Constructors

Module Ident [Import] [Declaration f] (Maybe (StatementSequence f)) Ident

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f)), Data (f (Statement f))) => Data (Module f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module f -> c (Module f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Module f)

toConstr :: Module f -> Constr

dataTypeOf :: Module f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Module f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module f))

gmapT :: (forall b. Data b => b -> b) -> Module f -> Module f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module f -> r

gmapQ :: (forall d. Data d => d -> u) -> Module f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module f -> m (Module f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module f -> m (Module f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module f -> m (Module f)

(Show (f (Designator f)), Show (f (Expression f)), Show (f (Statement f))) => Show (Module f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Module f -> ShowS

show :: Module f -> String

showList :: [Module f] -> ShowS

Pretty (Module Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Module Identity -> Doc ann

prettyList :: [Module Identity] -> Doc ann

type Ident = Text

type Import = (Maybe Ident, Ident)

data Declaration f

Constructors

ConstantDeclaration IdentDef (f (ConstExpression f))

TypeDeclaration IdentDef (Type f)

VariableDeclaration IdentList (Type f)

ProcedureDeclaration (ProcedureHeading f) (ProcedureBody f) Ident

ForwardDeclaration IdentDef (Maybe (FormalParameters f))

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f)), Data (f (Statement f))) => Data (Declaration f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Declaration f -> c (Declaration f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Declaration f)

toConstr :: Declaration f -> Constr

dataTypeOf :: Declaration f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Declaration f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Declaration f))

gmapT :: (forall b. Data b => b -> b) -> Declaration f -> Declaration f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Declaration f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Declaration f -> r

gmapQ :: (forall d. Data d => d -> u) -> Declaration f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Declaration f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Declaration f -> m (Declaration f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Declaration f -> m (Declaration f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Declaration f -> m (Declaration f)

(Show (f (Designator f)), Show (f (Expression f)), Show (f (Statement f))) => Show (Declaration f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Declaration f -> ShowS

show :: Declaration f -> String

showList :: [Declaration f] -> ShowS

Pretty (Declaration Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Declaration Identity -> Doc ann

prettyList :: [Declaration Identity] -> Doc ann

data IdentDef

Constructors

IdentDef Ident AccessMode

Instances

Eq IdentDef

Defined in Language.Oberon.AST

Methods

(==) :: IdentDef -> IdentDef -> Bool

(/=) :: IdentDef -> IdentDef -> Bool

Data IdentDef

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IdentDef -> c IdentDef

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IdentDef

toConstr :: IdentDef -> Constr

dataTypeOf :: IdentDef -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IdentDef)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IdentDef)

gmapT :: (forall b. Data b => b -> b) -> IdentDef -> IdentDef

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IdentDef -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IdentDef -> r

gmapQ :: (forall d. Data d => d -> u) -> IdentDef -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IdentDef -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IdentDef -> m IdentDef

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentDef -> m IdentDef

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IdentDef -> m IdentDef

Ord IdentDef

Defined in Language.Oberon.AST

Methods

compare :: IdentDef -> IdentDef -> Ordering

(<) :: IdentDef -> IdentDef -> Bool

(<=) :: IdentDef -> IdentDef -> Bool

(>) :: IdentDef -> IdentDef -> Bool

(>=) :: IdentDef -> IdentDef -> Bool

max :: IdentDef -> IdentDef -> IdentDef

min :: IdentDef -> IdentDef -> IdentDef

Show IdentDef

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> IdentDef -> ShowS

show :: IdentDef -> String

showList :: [IdentDef] -> ShowS

Pretty IdentDef

Defined in Language.Oberon.Pretty

Methods

pretty :: IdentDef -> Doc ann

prettyList :: [IdentDef] -> Doc ann

data AccessMode

Constructors

Exported

ReadOnly

PrivateOnly

Instances

Eq AccessMode

Defined in Language.Oberon.AST

Methods

(==) :: AccessMode -> AccessMode -> Bool

(/=) :: AccessMode -> AccessMode -> Bool

Data AccessMode

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AccessMode -> c AccessMode

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AccessMode

toConstr :: AccessMode -> Constr

dataTypeOf :: AccessMode -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AccessMode)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AccessMode)

gmapT :: (forall b. Data b => b -> b) -> AccessMode -> AccessMode

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AccessMode -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AccessMode -> r

gmapQ :: (forall d. Data d => d -> u) -> AccessMode -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AccessMode -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AccessMode -> m AccessMode

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AccessMode -> m AccessMode

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AccessMode -> m AccessMode

Ord AccessMode

Defined in Language.Oberon.AST

Methods

compare :: AccessMode -> AccessMode -> Ordering

(<) :: AccessMode -> AccessMode -> Bool

(<=) :: AccessMode -> AccessMode -> Bool

(>) :: AccessMode -> AccessMode -> Bool

(>=) :: AccessMode -> AccessMode -> Bool

max :: AccessMode -> AccessMode -> AccessMode

min :: AccessMode -> AccessMode -> AccessMode

Show AccessMode

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> AccessMode -> ShowS

show :: AccessMode -> String

showList :: [AccessMode] -> ShowS

type ConstExpression = Expression

data Expression f

Constructors

Relation RelOp (Expression f) (Expression f)

Positive (Expression f)

Negative (Expression f)

Add (Expression f) (Expression f)

Subtract (Expression f) (Expression f)

Or (Expression f) (Expression f)

Multiply (Expression f) (Expression f)

Divide (Expression f) (Expression f)

IntegerDivide (Expression f) (Expression f)

Modulo (Expression f) (Expression f)

And (Expression f) (Expression f)

Integer Text

Real Text

CharConstant Char

CharCode Int

String Text

Nil

Set [Element f]

Read (AmbDesignator f)

FunctionCall (AmbDesignator f) (ActualParameters f)

Not (Expression f)

Instances

(Typeable f, Data (f (Designator f))) => Data (Expression f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Expression f -> c (Expression f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Expression f)

toConstr :: Expression f -> Constr

dataTypeOf :: Expression f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Expression f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expression f))

gmapT :: (forall b. Data b => b -> b) -> Expression f -> Expression f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expression f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expression f -> r

gmapQ :: (forall d. Data d => d -> u) -> Expression f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Expression f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Expression f -> m (Expression f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression f -> m (Expression f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Expression f -> m (Expression f)

Show (f (Designator f)) => Show (Expression f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Expression f -> ShowS

show :: Expression f -> String

showList :: [Expression f] -> ShowS

Pretty (Expression Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Expression Identity -> Doc ann

prettyList :: [Expression Identity] -> Doc ann

data RelOp

Constructors

Equal

Unequal

Less

LessOrEqual

Greater

GreaterOrEqual

In

Is

Instances

Data RelOp

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RelOp -> c RelOp

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RelOp

toConstr :: RelOp -> Constr

dataTypeOf :: RelOp -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RelOp)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RelOp)

gmapT :: (forall b. Data b => b -> b) -> RelOp -> RelOp

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RelOp -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RelOp -> r

gmapQ :: (forall d. Data d => d -> u) -> RelOp -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RelOp -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RelOp -> m RelOp

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RelOp -> m RelOp

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RelOp -> m RelOp

Show RelOp

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> RelOp -> ShowS

show :: RelOp -> String

showList :: [RelOp] -> ShowS

Pretty RelOp

Defined in Language.Oberon.Pretty

Methods

pretty :: RelOp -> Doc ann

prettyList :: [RelOp] -> Doc ann

data Element f

Constructors

Element (Expression f)

Range (Expression f) (Expression f)

Instances

(Typeable f, Data (f (Designator f))) => Data (Element f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Element f -> c (Element f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Element f)

toConstr :: Element f -> Constr

dataTypeOf :: Element f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Element f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Element f))

gmapT :: (forall b. Data b => b -> b) -> Element f -> Element f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Element f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Element f -> r

gmapQ :: (forall d. Data d => d -> u) -> Element f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Element f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Element f -> m (Element f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Element f -> m (Element f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Element f -> m (Element f)

Show (f (Designator f)) => Show (Element f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Element f -> ShowS

show :: Element f -> String

showList :: [Element f] -> ShowS

Pretty (Element Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Element Identity -> Doc ann

prettyList :: [Element Identity] -> Doc ann

type AmbDesignator f = f (Designator f)

data Designator f

Constructors

Variable QualIdent

Field (Designator f) Ident

Index (Designator f) (NonEmpty (Expression f))

TypeGuard (Designator f) QualIdent

Dereference (Designator f)

Instances

(Typeable f, Data (f (Designator f))) => Data (Designator f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Designator f -> c (Designator f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Designator f)

toConstr :: Designator f -> Constr

dataTypeOf :: Designator f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Designator f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Designator f))

gmapT :: (forall b. Data b => b -> b) -> Designator f -> Designator f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Designator f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Designator f -> r

gmapQ :: (forall d. Data d => d -> u) -> Designator f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Designator f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Designator f -> m (Designator f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Designator f -> m (Designator f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Designator f -> m (Designator f)

Show (f (Designator f)) => Show (Designator f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Designator f -> ShowS

show :: Designator f -> String

showList :: [Designator f] -> ShowS

Pretty (Designator Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Designator Identity -> Doc ann

prettyList :: [Designator Identity] -> Doc ann

type ActualParameters f = [Expression f]

data Type f

Constructors

TypeReference QualIdent

ArrayType [f (ConstExpression f)] (Type f)

RecordType (Maybe BaseType) (FieldListSequence f)

PointerType (Type f)

ProcedureType (Maybe (FormalParameters f))

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f))) => Data (Type f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type f -> c (Type f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type f)

toConstr :: Type f -> Constr

dataTypeOf :: Type f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type f))

gmapT :: (forall b. Data b => b -> b) -> Type f -> Type f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type f -> r

gmapQ :: (forall d. Data d => d -> u) -> Type f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type f -> m (Type f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type f -> m (Type f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type f -> m (Type f)

(Show (f (Designator f)), Show (f (Expression f))) => Show (Type f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Type f -> ShowS

show :: Type f -> String

showList :: [Type f] -> ShowS

Pretty (Type Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Type Identity -> Doc ann

prettyList :: [Type Identity] -> Doc ann

data QualIdent

Constructors

QualIdent Ident Ident

NonQualIdent Ident

Instances

Eq QualIdent

Defined in Language.Oberon.AST

Methods

(==) :: QualIdent -> QualIdent -> Bool

(/=) :: QualIdent -> QualIdent -> Bool

Data QualIdent

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualIdent -> c QualIdent

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QualIdent

toConstr :: QualIdent -> Constr

dataTypeOf :: QualIdent -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QualIdent)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualIdent)

gmapT :: (forall b. Data b => b -> b) -> QualIdent -> QualIdent

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualIdent -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualIdent -> r

gmapQ :: (forall d. Data d => d -> u) -> QualIdent -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualIdent -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualIdent -> m QualIdent

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualIdent -> m QualIdent

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualIdent -> m QualIdent

Ord QualIdent

Defined in Language.Oberon.AST

Methods

compare :: QualIdent -> QualIdent -> Ordering

(<) :: QualIdent -> QualIdent -> Bool

(<=) :: QualIdent -> QualIdent -> Bool

(>) :: QualIdent -> QualIdent -> Bool

(>=) :: QualIdent -> QualIdent -> Bool

max :: QualIdent -> QualIdent -> QualIdent

min :: QualIdent -> QualIdent -> QualIdent

Show QualIdent

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> QualIdent -> ShowS

show :: QualIdent -> String

showList :: [QualIdent] -> ShowS

Pretty QualIdent

Defined in Language.Oberon.Pretty

Methods

pretty :: QualIdent -> Doc ann

prettyList :: [QualIdent] -> Doc ann

type BaseType = QualIdent

type FieldListSequence f = NonEmpty (FieldList f)

data FieldList f

Constructors

FieldList IdentList (Type f)

EmptyFieldList

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f))) => Data (FieldList f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldList f -> c (FieldList f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldList f)

toConstr :: FieldList f -> Constr

dataTypeOf :: FieldList f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldList f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldList f))

gmapT :: (forall b. Data b => b -> b) -> FieldList f -> FieldList f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldList f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldList f -> r

gmapQ :: (forall d. Data d => d -> u) -> FieldList f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldList f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldList f -> m (FieldList f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldList f -> m (FieldList f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldList f -> m (FieldList f)

(Show (f (Designator f)), Show (f (Expression f))) => Show (FieldList f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> FieldList f -> ShowS

show :: FieldList f -> String

showList :: [FieldList f] -> ShowS

Pretty (FieldList Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: FieldList Identity -> Doc ann

prettyList :: [FieldList Identity] -> Doc ann

type IdentList = NonEmpty IdentDef

data ProcedureHeading f

Constructors

ProcedureHeading (Maybe (Bool, Ident, Ident)) Bool IdentDef (Maybe (FormalParameters f))

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f))) => Data (ProcedureHeading f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProcedureHeading f -> c (ProcedureHeading f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ProcedureHeading f)

toConstr :: ProcedureHeading f -> Constr

dataTypeOf :: ProcedureHeading f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ProcedureHeading f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ProcedureHeading f))

gmapT :: (forall b. Data b => b -> b) -> ProcedureHeading f -> ProcedureHeading f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProcedureHeading f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProcedureHeading f -> r

gmapQ :: (forall d. Data d => d -> u) -> ProcedureHeading f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProcedureHeading f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProcedureHeading f -> m (ProcedureHeading f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcedureHeading f -> m (ProcedureHeading f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcedureHeading f -> m (ProcedureHeading f)

(Show (f (Designator f)), Show (f (Expression f))) => Show (ProcedureHeading f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> ProcedureHeading f -> ShowS

show :: ProcedureHeading f -> String

showList :: [ProcedureHeading f] -> ShowS

Pretty (ProcedureHeading Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: ProcedureHeading Identity -> Doc ann

prettyList :: [ProcedureHeading Identity] -> Doc ann

data FormalParameters f

Constructors

FormalParameters [FPSection f] (Maybe QualIdent)

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f))) => Data (FormalParameters f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FormalParameters f -> c (FormalParameters f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FormalParameters f)

toConstr :: FormalParameters f -> Constr

dataTypeOf :: FormalParameters f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FormalParameters f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FormalParameters f))

gmapT :: (forall b. Data b => b -> b) -> FormalParameters f -> FormalParameters f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FormalParameters f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FormalParameters f -> r

gmapQ :: (forall d. Data d => d -> u) -> FormalParameters f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FormalParameters f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FormalParameters f -> m (FormalParameters f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FormalParameters f -> m (FormalParameters f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FormalParameters f -> m (FormalParameters f)

(Show (f (Designator f)), Show (f (Expression f))) => Show (FormalParameters f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> FormalParameters f -> ShowS

show :: FormalParameters f -> String

showList :: [FormalParameters f] -> ShowS

Pretty (FormalParameters Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: FormalParameters Identity -> Doc ann

prettyList :: [FormalParameters Identity] -> Doc ann

data FPSection f

Constructors

FPSection Bool (NonEmpty Ident) (Type f)

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f))) => Data (FPSection f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FPSection f -> c (FPSection f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FPSection f)

toConstr :: FPSection f -> Constr

dataTypeOf :: FPSection f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FPSection f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FPSection f))

gmapT :: (forall b. Data b => b -> b) -> FPSection f -> FPSection f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FPSection f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FPSection f -> r

gmapQ :: (forall d. Data d => d -> u) -> FPSection f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FPSection f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FPSection f -> m (FPSection f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FPSection f -> m (FPSection f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FPSection f -> m (FPSection f)

(Show (f (Designator f)), Show (f (Expression f))) => Show (FPSection f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> FPSection f -> ShowS

show :: FPSection f -> String

showList :: [FPSection f] -> ShowS

Pretty (FPSection Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: FPSection Identity -> Doc ann

prettyList :: [FPSection Identity] -> Doc ann

data ProcedureBody f

Constructors

ProcedureBody [Declaration f] (Maybe (StatementSequence f))

Instances

(Typeable f, Data (f (Designator f)), Data (f (Expression f)), Data (f (Statement f))) => Data (ProcedureBody f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ProcedureBody f -> c (ProcedureBody f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ProcedureBody f)

toConstr :: ProcedureBody f -> Constr

dataTypeOf :: ProcedureBody f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ProcedureBody f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ProcedureBody f))

gmapT :: (forall b. Data b => b -> b) -> ProcedureBody f -> ProcedureBody f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ProcedureBody f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ProcedureBody f -> r

gmapQ :: (forall d. Data d => d -> u) -> ProcedureBody f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ProcedureBody f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ProcedureBody f -> m (ProcedureBody f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcedureBody f -> m (ProcedureBody f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ProcedureBody f -> m (ProcedureBody f)

(Show (f (Designator f)), Show (f (Expression f)), Show (f (Statement f))) => Show (ProcedureBody f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> ProcedureBody f -> ShowS

show :: ProcedureBody f -> String

showList :: [ProcedureBody f] -> ShowS

Pretty (ProcedureBody Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: ProcedureBody Identity -> Doc ann

prettyList :: [ProcedureBody Identity] -> Doc ann

type StatementSequence f = NonEmpty (f (Statement f))

data Statement f

Constructors

EmptyStatement

Assignment (AmbDesignator f) (Expression f)

ProcedureCall (AmbDesignator f) (Maybe (ActualParameters f))

If (NonEmpty (Expression f, StatementSequence f)) (Maybe (StatementSequence f))

CaseStatement (Expression f) (NonEmpty (Case f)) (Maybe (StatementSequence f))

While (Expression f) (StatementSequence f)

Repeat (StatementSequence f) (Expression f)

For Ident (Expression f) (Expression f) (Maybe (Expression f)) (StatementSequence f)

Loop (StatementSequence f)

With (NonEmpty (WithAlternative f)) (Maybe (StatementSequence f))

Exit

Return (Maybe (Expression f))

Instances

(Typeable f, Data (f (Designator f)), Data (f (Statement f))) => Data (Statement f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Statement f -> c (Statement f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Statement f)

toConstr :: Statement f -> Constr

dataTypeOf :: Statement f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Statement f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Statement f))

gmapT :: (forall b. Data b => b -> b) -> Statement f -> Statement f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Statement f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Statement f -> r

gmapQ :: (forall d. Data d => d -> u) -> Statement f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Statement f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Statement f -> m (Statement f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement f -> m (Statement f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Statement f -> m (Statement f)

(Show (f (Designator f)), Show (f (Statement f))) => Show (Statement f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Statement f -> ShowS

show :: Statement f -> String

showList :: [Statement f] -> ShowS

Pretty (Statement Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Statement Identity -> Doc ann

prettyList :: [Statement Identity] -> Doc ann

data WithAlternative f

Constructors

WithAlternative QualIdent QualIdent (StatementSequence f)

Instances

(Typeable f, Data (f (Designator f)), Data (f (Statement f))) => Data (WithAlternative f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WithAlternative f -> c (WithAlternative f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WithAlternative f)

toConstr :: WithAlternative f -> Constr

dataTypeOf :: WithAlternative f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WithAlternative f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WithAlternative f))

gmapT :: (forall b. Data b => b -> b) -> WithAlternative f -> WithAlternative f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WithAlternative f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WithAlternative f -> r

gmapQ :: (forall d. Data d => d -> u) -> WithAlternative f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WithAlternative f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WithAlternative f -> m (WithAlternative f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WithAlternative f -> m (WithAlternative f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WithAlternative f -> m (WithAlternative f)

(Show (f (Designator f)), Show (f (Statement f))) => Show (WithAlternative f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> WithAlternative f -> ShowS

show :: WithAlternative f -> String

showList :: [WithAlternative f] -> ShowS

Pretty (WithAlternative Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: WithAlternative Identity -> Doc ann

prettyList :: [WithAlternative Identity] -> Doc ann

data Case f

Constructors

Case (NonEmpty (CaseLabels f)) (StatementSequence f)

EmptyCase

Instances

(Typeable f, Data (f (Designator f)), Data (f (Statement f))) => Data (Case f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Case f -> c (Case f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Case f)

toConstr :: Case f -> Constr

dataTypeOf :: Case f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Case f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Case f))

gmapT :: (forall b. Data b => b -> b) -> Case f -> Case f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Case f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Case f -> r

gmapQ :: (forall d. Data d => d -> u) -> Case f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Case f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Case f -> m (Case f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Case f -> m (Case f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Case f -> m (Case f)

(Show (f (Designator f)), Show (f (Statement f))) => Show (Case f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> Case f -> ShowS

show :: Case f -> String

showList :: [Case f] -> ShowS

Pretty (Case Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: Case Identity -> Doc ann

prettyList :: [Case Identity] -> Doc ann

data CaseLabels f

Constructors

SingleLabel (ConstExpression f)

LabelRange (ConstExpression f) (ConstExpression f)

Instances

(Typeable f, Data (f (Designator f))) => Data (CaseLabels f)

Defined in Language.Oberon.AST

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CaseLabels f -> c (CaseLabels f)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CaseLabels f)

toConstr :: CaseLabels f -> Constr

dataTypeOf :: CaseLabels f -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CaseLabels f))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CaseLabels f))

gmapT :: (forall b. Data b => b -> b) -> CaseLabels f -> CaseLabels f

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CaseLabels f -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CaseLabels f -> r

gmapQ :: (forall d. Data d => d -> u) -> CaseLabels f -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> CaseLabels f -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CaseLabels f -> m (CaseLabels f)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseLabels f -> m (CaseLabels f)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CaseLabels f -> m (CaseLabels f)

Show (f (Designator f)) => Show (CaseLabels f)

Defined in Language.Oberon.AST

Methods

showsPrec :: Int -> CaseLabels f -> ShowS

show :: CaseLabels f -> String

showList :: [CaseLabels f] -> ShowS

Pretty (CaseLabels Identity)

Defined in Language.Oberon.Pretty

Methods

pretty :: CaseLabels Identity -> Doc ann

prettyList :: [CaseLabels Identity] -> Doc ann