-- UUAGC 0.9.53 (src-ag/LOAG/Rep.ag)
module LOAG.Rep where

import CommonTypes
import AbstractSyntax
import LOAG.Common
import qualified Data.Array as A
import qualified Data.Map   as Map
import qualified Data.Set   as Set


import Data.List (intercalate, foldl', nub)
import Data.Tuple (swap)
import Control.Arrow
-- FieldAtt ----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         self                 : FieldAtt 
   alternatives:
      alternative FieldAtt:
         child t              : {MyType}
         child p              : {PLabel}
         child f              : {FLabel}
         child a              : {ALabel}
         visit 0:
            local self        : _
-}
data FieldAtt = FieldAtt {FieldAtt -> MyType
t_FieldAtt_FieldAtt :: MyType,FieldAtt -> PLabel
p_FieldAtt_FieldAtt :: PLabel,FieldAtt -> FLabel
f_FieldAtt_FieldAtt :: FLabel,FieldAtt -> ALabel
a_FieldAtt_FieldAtt :: ALabel}
-- FieldAtts ---------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         self                 : FieldAtts 
   alternatives:
      alternative Cons:
         child hd             : FieldAtt 
         child tl             : FieldAtts 
         visit 0:
            local self        : _
      alternative Nil:
         visit 0:
            local self        : _
-}
type FieldAtts = [FieldAtt]
-- LOAGRep -----------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         self                 : LOAGRep 
   alternatives:
      alternative LOAGRep:
         child ps             : {[PLabel]}
         child ap             : {A_P}
         child an             : {A_N}
         child ain            : {AI_N}
         child asn            : {AS_N}
         child sfp            : {SF_P}
         child pmp            : {PMP}
         child pmpr           : {PMP_R}
         child nmp            : {NMP}
         child nmpr           : {NMP_R}
         child gen            : {A.Array Int Int}
         child inss           : {A.Array Int [Int]}
         child ofld           : {A.Array Int Int}
         child fty            : {FTY}
         child fieldMap       : {FMap}
         child fsInP          : {Map.Map PLabel [(PLabel,FLabel)]}
         visit 0:
            local self        : _
-}
data LOAGRep = LOAGRep {LOAGRep -> [PLabel]
ps_LOAGRep_LOAGRep :: ([PLabel]),LOAGRep -> A_P
ap_LOAGRep_LOAGRep :: A_P,LOAGRep -> A_N
an_LOAGRep_LOAGRep :: A_N,LOAGRep -> A_N
ain_LOAGRep_LOAGRep :: AI_N,LOAGRep -> A_N
asn_LOAGRep_LOAGRep :: AS_N,LOAGRep -> SF_P
sfp_LOAGRep_LOAGRep :: SF_P,LOAGRep -> PMP
pmp_LOAGRep_LOAGRep :: PMP,LOAGRep -> PMP_R
pmpr_LOAGRep_LOAGRep :: PMP_R,LOAGRep -> NMP
nmp_LOAGRep_LOAGRep :: NMP,LOAGRep -> NMP_R
nmpr_LOAGRep_LOAGRep :: NMP_R,LOAGRep -> Array Int Int
gen_LOAGRep_LOAGRep :: (A.Array Int Int),LOAGRep -> Array Int [Int]
inss_LOAGRep_LOAGRep :: (A.Array Int [Int]),LOAGRep -> Array Int Int
ofld_LOAGRep_LOAGRep :: (A.Array Int Int),LOAGRep -> FTY
fty_LOAGRep_LOAGRep :: FTY,LOAGRep -> FMap
fieldMap_LOAGRep_LOAGRep :: FMap,LOAGRep -> Map PLabel [(PLabel, FLabel)]
fsInP_LOAGRep_LOAGRep :: (Map.Map PLabel [(PLabel,FLabel)])}
-- MySegment ---------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         self                 : MySegment 
   alternatives:
      alternative MySegment:
         child visnr          : {Int}
         child inhAttr        : {[Int]}
         child synAttr        : {[Int]}
         child inhOccs        : {Maybe [Int]}
         child synOccs        : {Maybe [Int]}
         visit 0:
            local self        : _
-}
data MySegment = MySegment {MySegment -> Int
visnr_MySegment_MySegment :: Int,MySegment -> [Int]
inhAttr_MySegment_MySegment :: ([Int]),MySegment -> [Int]
synAttr_MySegment_MySegment :: ([Int]),MySegment -> Maybe [Int]
inhOccs_MySegment_MySegment :: (Maybe [Int]),MySegment -> Maybe [Int]
synOccs_MySegment_MySegment :: (Maybe [Int])}
               deriving ( Int -> MySegment -> ShowS
[MySegment] -> ShowS
MySegment -> FLabel
(Int -> MySegment -> ShowS)
-> (MySegment -> FLabel)
-> ([MySegment] -> ShowS)
-> Show MySegment
forall a.
(Int -> a -> ShowS) -> (a -> FLabel) -> ([a] -> ShowS) -> Show a
showList :: [MySegment] -> ShowS
$cshowList :: [MySegment] -> ShowS
show :: MySegment -> FLabel
$cshow :: MySegment -> FLabel
showsPrec :: Int -> MySegment -> ShowS
$cshowsPrec :: Int -> MySegment -> ShowS
Show)
-- MySegments --------------------------------------------------
{-
   visit 0:
      synthesized attribute:
         self                 : MySegments 
   alternatives:
      alternative Cons:
         child hd             : MySegment 
         child tl             : MySegments 
         visit 0:
            local self        : _
      alternative Nil:
         visit 0:
            local self        : _
-}
type MySegments = [MySegment]