uuagc-0.9.50: src-ag/ConcreteSyntax.ag

imports
{
import UU.Scanner.Position (Pos)
import Patterns   (Pattern)
import Expression (Expression)
import CommonTypes
import Macro --marcos
}


TYPE Elems     = [Elem]

TYPE Alts      = [Alt]

TYPE Fields    = [Field]

TYPE SemAlts   = [SemAlt]

TYPE SemDefs   = [SemDef]

DATA AG        | AG     elems  : Elems

DATA Elem      | Data   pos     : {Pos}
                        contype : {ConstructorType}
                        ctx     : {ClassContext}
                        names   : NontSet
                        params  : {[Identifier]}
                        attrs   : Attrs
                        alts    : Alts
                        ext     : {Bool}

               | Type   pos    : {Pos}
                        ctx    : {ClassContext}
                        name   : {NontermIdent}
                        params : {[Identifier]}
                        type   : {ComplexType}

               | Attr   pos    : {Pos}
                        ctx    : {ClassContext}
                        names  : NontSet
                        quants : {[String]}
                        attrs  : Attrs

               | Sem    pos    : {Pos}
                        ctx    : {ClassContext}
                        names  : NontSet
                        attrs  : Attrs
                        quants : {[String]}
                        alts   : SemAlts

               | Txt    pos    : {Pos}
                        kind   : {BlockKind}
                        mbNt   : {Maybe NontermIdent}
                        lines  : {[String]}

               | Set    pos    : {Pos}
                        name   : {NontermIdent}
                        merge  : Bool
                        set    : NontSet

               | Deriving pos  : {Pos}
                          set  : NontSet
                          classes : {[NontermIdent]}

               | Wrapper  pos  : {Pos}
                          set  : NontSet

               | Nocatas  pos  : {Pos}
                          set  : NontSet

               | Pragma   pos  : {Pos}
                          names: {[NontermIdent]}

               | Module   pos     : {Pos}
                          name    : {String}  -- name of the haskell module
                          exports : {String}  -- exports of the haskell module
                          imports : {String}  -- imports to replicate to generated haskell modules

DATA Attrs     | Attrs  pos    : {Pos}
                        inh,chn,syn : {AttrNames}

DATA Alt       | Alt    pos    : {Pos}
                        names  : ConstructorSet
                        tyvars : {[Identifier]}
                        fields : Fields
                        macro  : MaybeMacro --marcos: macro extension

DATA Field     | FChild  name : Identifier
                         tp   : Type
               | FCtx    tps  : {[Type]}

DATA SemAlt    | SemAlt pos    : {Pos}
                        constructorSet   : ConstructorSet
                        rules  : SemDefs

DATA SemDef    | Def    pos    : Pos
                        mbName : {Maybe Identifier}
                        pattern: Pattern
                        rhs    : {Expression}
                        owrt   : {Bool}
                        pure   : Bool
                        eager  : Bool
               | TypeDef pos   : {Pos}
                         ident : {Identifier}
                         tp    : Type
               | UniqueDef ident : {Identifier}
                           ref   : {Identifier}
               | AugmentDef ident : {Identifier}
                            rhs   : {Expression}
               | AroundDef ident : {Identifier}
                           rhs    : {Expression}
               | MergeDef  target  : {Identifier}
                           nt      : {Identifier}
                           sources : {[Identifier]}
                           rhs     : {Expression}
               | SemPragma  names : {[NontermIdent]}
               | AttrOrderBefore  before : {[Occurrence]}
                                  after  : {[Occurrence]}

DATA ConstructorSet | CName       name      : {ConstructorIdent}
                    | CUnion      set1,set2 : ConstructorSet
                    | CDifference set1,set2 : ConstructorSet
                    | CAll

DATA NontSet   | NamedSet   name      : {NontermIdent}
               | All
               | Union      set1,set2 : NontSet
               | Intersect  set1,set2 : NontSet
               | Difference set1,set2 : NontSet
               | Path       from,to   : {NontermIdent}