{-# LANGUAGE DeriveDataTypeable #-}

module Language.Grammars.ZipperAG.Examples.LET.Let_No_Blocks where

import Data.Generics.Zipper
import Language.Grammars.ZipperAG.Examples.LET.Let_DataTypes_Boilerplate
import Language.Grammars.ZipperAG.Examples.LET.Let_Bidi
import Language.Grammars.ZipperAG

---- Synthesized Attributes ----
dclo :: Zipper RootA -> [String]
dclo ag = case (constructor ag) of
           "RootA"       -> dclo $ ag.$1
           "LetA"        -> dclo $ ag.$1
           "ConsAssignA" -> dclo $ ag.$3
           "EmptyListA"  -> dcli ag

errs :: Zipper RootA -> [String]
errs ag = case (constructor ag) of
           "RootA"       -> errs $ ag.$1
           "LetA"        -> (errs $ ag.$1) ++ (errs $ ag.$2)
           "InA"         -> (errs $ ag.$1)
           "ConsAssignA" -> mNBIn (lexeme_ConsAssignA_1 ag) (dcli ag) ++ (errs $ ag.$2) ++ (errs $ ag.$3)
           "EmptyListA"  -> []
           "Plus"        -> (errs $ ag.$1) ++ (errs $ ag.$2)
           "Divide"      -> (errs $ ag.$1) ++ (errs $ ag.$2)
           "Minus"       -> (errs $ ag.$1) ++ (errs $ ag.$2)
           "Time"        -> (errs $ ag.$1) ++ (errs $ ag.$2)
           "Variable"    -> mBIn (lexeme_Variable ag) (env ag)
           "Constant"    -> []

---- Inheritted Attributes ----
dcli :: Zipper RootA -> [String]
dcli ag = case (constructor ag) of
           "RootA" -> []
           _       -> case (constructor $ parent ag) of
                             "ConsAssignA" -> (dcli $ parent ag) ++ [lexeme_ConsAssignA_1 $ parent ag]
                             _             -> dcli $ parent ag

env :: Zipper RootA -> [String]
env ag = case (constructor ag) of
           "RootA"       -> dclo ag
           _             -> env $ parent ag

{- Environment lookup functions -}
mBIn :: String -> [String] -> [String]
mBIn name [] = [name]
mBIn name (n:es) = if (n==name) then [] else mBIn name es

mNBIn :: String -> [String] -> [String]
mNBIn tuple [] = [] 
mNBIn a1 (a2:es) = if (a1==a2) then [a1] else mNBIn a1 es

test_scope_no_block_rules p = errs $ toZipper (getRootC_RootA $ toZipper p)