-- UUAGC 0.9.10 (Ast.ag) module Database.HsSqlPpp.Ast( -- exports MySourcePos --ast nodes ,Statement (..) ,SelectExpression (..) ,FnBody (..) ,SetClause (..) ,TableRef (..) ,JoinExpression (..) ,JoinType (..) ,SelectList (..) ,SelectItem (..) ,CopySource (..) ,AttributeDef (..) ,RowConstraint (..) ,Constraint (..) ,TypeAttributeDef (..) ,ParamDef (..) ,VarDef (..) ,RaiseType (..) ,CombineType (..) ,Volatility (..) ,Language (..) ,TypeName (..) ,DropType (..) ,Cascade (..) ,Direction (..) ,Distinct (..) ,Natural (..) ,IfExists (..) ,RestartIdentity (..) ,Expression (..) ,OperatorType (..) ,getOperatorType ,InList (..) ,StatementList --checking stuff ,Message (..) ,MessageStuff (..) --types ,Type (..) ,PseudoType (..) ,TypeErrorInfo (..) ,StatementInfo (..) --scope ,Scope(..) ,defaultScope ,emptyScope --fns ,checkAst ,getExpressionType ,getStatementsType ,getStatementsTypeScope ,getStatementsInfo ,getStatementsInfoScope ,resetSps ,resetSp ,resetSp' ,resetSps' ,nsp --forward some defs ,typeSmallInt ,typeBigInt ,typeInt ,typeNumeric ,typeFloat4 ,typeFloat8 ,typeVarChar ,typeChar ,typeBool ) where import Data.Maybe import Data.List import Debug.Trace import Control.Monad.Error import Control.Arrow import Database.HsSqlPpp.TypeType import Database.HsSqlPpp.AstUtils import Database.HsSqlPpp.TypeConversion import Database.HsSqlPpp.TypeCheckingH import Database.HsSqlPpp.Scope import Database.HsSqlPpp.DefaultScope checkAst :: StatementList -> [Message] checkAst sts = let t = sem_Root (Root sts) in (messages_Syn_Root (wrap_Root t Inh_Root {scope_Inh_Root = defaultScope})) {- ================================================================================ = Types These are the utility functions which clients use to typecheck sql. -} getExpressionType :: Scope -> Expression -> Type getExpressionType scope ex = let t = sem_ExpressionRoot (ExpressionRoot ex) in (nodeType_Syn_ExpressionRoot (wrap_ExpressionRoot t Inh_ExpressionRoot {scope_Inh_ExpressionRoot = combineScopes defaultScope scope})) getStatementsType :: StatementList -> [Type] getStatementsType = getStatementsTypeScope emptyScope getStatementsTypeScope :: Scope -> StatementList -> [Type] getStatementsTypeScope scope st = let t = sem_Root (Root st) ta = wrap_Root t Inh_Root {scope_Inh_Root = combineScopes defaultScope scope} tl = nodeType_Syn_Root ta in (unwrapTypeList tl) getStatementsInfo :: StatementList -> [StatementInfo] getStatementsInfo = getStatementsInfoScope emptyScope getStatementsInfoScope :: Scope -> StatementList -> [StatementInfo] getStatementsInfoScope scope st = let t = sem_Root (Root st) ta = wrap_Root t Inh_Root {scope_Inh_Root = combineScopes defaultScope scope} t2 = statementInfo_Syn_Root ta in t2 --hack job, often not interested in the source positions when testing --the asts produced, so this function will reset all the source --positions to empty ("", 0, 0) so we can compare them for equality, etc. --without having to get the positions correct. resetSps :: [Statement] -> [Statement] resetSps = map resetSp resetSp :: Statement -> Statement resetSp (CreateFunction l n p r bq b v) = CreateFunction l n p r bq (case b of SqlFnBody stss -> SqlFnBody (map resetSp' stss) PlpgsqlFnBody vd stss -> PlpgsqlFnBody vd (map resetSp' stss)) v resetSp (ForSelectStatement v s stss) = ForSelectStatement v s (map resetSp' stss) resetSp (ForIntegerStatement v f t stss) = ForIntegerStatement v f t (map resetSp' stss) resetSp (CaseStatement v cs els) = CaseStatement v (map (second (map resetSp')) cs) (map resetSp' els) resetSp (If cs els) = If (map (second (map resetSp')) cs) (map resetSp' els) resetSp a = a resetSp' :: SourcePosStatement -> SourcePosStatement resetSp' (_,st) = (nsp,resetSp st) resetSps' :: StatementList -> StatementList resetSps' = map resetSp' nsp :: MySourcePos nsp = ("", 0,0) setUnknown :: Type -> Type -> Type setUnknown _ _ = UnknownType appendTypeList :: Type -> Type -> Type appendTypeList t1 (TypeList ts) = TypeList (t1:ts) appendTypeList t1 t2 = TypeList [t1,t2] data StatementInfo = DefaultStatementInfo Type | RelvarInfo CompositeDef | CreateFunctionInfo FunctionPrototype | SelectInfo Type | InsertInfo String Type | UpdateInfo String Type | DeleteInfo String | CreateDomainInfo String Type | DropInfo [(String,String)] | DropFunctionInfo [(String,[Type])] deriving (Eq,Show) --use this to make sure type errors are propagated into the statement --infos, temporary makeStatementInfo :: Type -> StatementInfo -> StatementInfo makeStatementInfo ty st = if isError ty then DefaultStatementInfo ty else st where isError t = case t of TypeError _ _ -> True TypeList ts -> any isError ts _ -> False -- i think this should be alright, an identifier referenced in an -- expression can only have zero or one dot in it. splitIdentifier :: String -> (String,String) splitIdentifier s = let (a,b) = span (/= '.') s in if b == "" then ("", a) else (a,tail b) --returns the type of the relation, and the system columns also getRelationType :: Scope -> MySourcePos -> String -> (Type,Type) getRelationType scope sp tbl = case getAttrs scope [TableComposite, ViewComposite] tbl of Just ((_,_,a@(UnnamedCompositeType _)) ,(_,_,s@(UnnamedCompositeType _)) ) -> (a,s) _ -> (TypeError sp (UnrecognisedRelation tbl), TypeList []) getFnType :: Scope -> MySourcePos -> String -> Expression -> Type -> Type getFnType scope sp alias fnVal fnType = checkErrors [fnType] $ snd $ getFunIdens scope sp alias fnVal fnType getFunIdens :: Scope -> MySourcePos -> String -> Expression -> Type -> (String, Type) getFunIdens scope sp alias fnVal fnType = case fnVal of FunCall f _ -> let correlationName = if alias /= "" then alias else f in (correlationName, case fnType of SetOfType (CompositeType t) -> getCompositeType t SetOfType x -> UnnamedCompositeType [(correlationName,x)] y -> UnnamedCompositeType [(correlationName,y)]) x -> ("", TypeError sp (ContextError "FunCall")) where getCompositeType t = case getAttrs scope [Composite ,TableComposite ,ViewComposite] t of Just ((_,_,a@(UnnamedCompositeType _)), _) -> a _ -> UnnamedCompositeType [] commonFieldNames t1 t2 = intersect (fn t1) (fn t2) where fn (UnnamedCompositeType s) = map fst s fn _ = [] both :: (a->b) -> (a,a) -> (b,b) both fn (x,y) = (fn x, fn y) fixedValue :: a -> a -> a -> a fixedValue a _ _ = a checkTableExists :: Scope -> MySourcePos -> String -> Type checkTableExists scope sp tbl = case getAttrs scope [TableComposite, ViewComposite] tbl of Just _ -> TypeList [] _ -> TypeError sp (UnrecognisedRelation tbl) checkColumnConsistency :: Scope -> MySourcePos -> String -> [String] -> [(String,Type)] -> Type checkColumnConsistency scope sp tbl cols' insNameTypePairs = let --todo: check the cols have no duplicates --todo: check the missing target cols have defaults targetTableType = fst $ getRelationType scope sp tbl targetTableCols = unwrapComposite targetTableType --check the num cols in the insdata match the number of cols cols = if null cols' then map fst targetTableCols else cols' wrongLengthError = if length insNameTypePairs /= length cols then TypeError sp WrongNumberOfColumns else TypeList [] --check the target cols appear in the target table and get their types nonMatchingColumns = cols \\ map fst targetTableCols nonMatchingErrors = case length nonMatchingColumns of 0 -> TypeList [] 1 -> makeUnknownColumnError $ head nonMatchingColumns _ -> TypeList $ map makeUnknownColumnError nonMatchingColumns targetNameTypePairs = map (\l -> (l, fromJust $ lookup l targetTableCols)) cols --check the types of the insdata match the column targets --name datatype columntype typeTriples = map (\((a,b),c) -> (a,b,c)) $ zip targetNameTypePairs $ map snd insNameTypePairs matchingTypeErrors = map (\(_,b,c) -> checkAssignmentValid scope sp c b) typeTriples in checkErrors [targetTableType ,wrongLengthError ,nonMatchingErrors ,TypeList matchingTypeErrors] $ TypeList [] where makeUnknownColumnError = TypeError sp . UnrecognisedIdentifier getColumnTypes :: Scope -> MySourcePos -> String -> [String] -> [(String,Type)] getColumnTypes scope sp tbl cols' = let targetTableType = fst $ getRelationType scope sp tbl targetTableCols = unwrapComposite targetTableType cols = if null cols' then map fst targetTableCols else cols' nonMatchingColumns = cols \\ map fst targetTableCols nonMatchingErrors = case length nonMatchingColumns of 0 -> TypeList [] 1 -> makeUnknownColumnError $ head nonMatchingColumns _ -> TypeList $ map makeUnknownColumnError nonMatchingColumns in map (\l -> (l, fromJust $ lookup l targetTableCols)) cols where makeUnknownColumnError = TypeError sp . UnrecognisedIdentifier getRowTypes :: Type -> [Type] getRowTypes (TypeList [(RowCtor ts)]) = ts getRowTypes (TypeList ts) = ts getRowTypes x = error $ "cannot get row types from " ++ show x -- AttributeDef ------------------------------------------------ data AttributeDef = AttributeDef (String) (TypeName) (Maybe Expression) (RowConstraintList) deriving ( Eq,Show) -- cata sem_AttributeDef :: AttributeDef -> T_AttributeDef sem_AttributeDef (AttributeDef _name _typ _check _cons ) = (sem_AttributeDef_AttributeDef _name (sem_TypeName _typ ) _check (sem_RowConstraintList _cons ) ) -- semantic domain type T_AttributeDef = Bool -> Scope -> MySourcePos -> ( AttributeDef,String,([Message]),Type) data Inh_AttributeDef = Inh_AttributeDef {inLoop_Inh_AttributeDef :: Bool,scope_Inh_AttributeDef :: Scope,sourcePos_Inh_AttributeDef :: MySourcePos} data Syn_AttributeDef = Syn_AttributeDef {actualValue_Syn_AttributeDef :: AttributeDef,attrName_Syn_AttributeDef :: String,messages_Syn_AttributeDef :: [Message],nodeType_Syn_AttributeDef :: Type} wrap_AttributeDef :: T_AttributeDef -> Inh_AttributeDef -> Syn_AttributeDef wrap_AttributeDef sem (Inh_AttributeDef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOattrName,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_AttributeDef _lhsOactualValue _lhsOattrName _lhsOmessages _lhsOnodeType )) sem_AttributeDef_AttributeDef :: String -> T_TypeName -> (Maybe Expression) -> T_RowConstraintList -> T_AttributeDef sem_AttributeDef_AttributeDef name_ typ_ check_ cons_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOattrName :: String _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: AttributeDef _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _consOinLoop :: Bool _consOscope :: Scope _consOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _consIactualValue :: RowConstraintList _consImessages :: ([Message]) _consInodeType :: Type _lhsOattrName = name_ _lhsOnodeType = _typInodeType _lhsOmessages = _typImessages ++ _consImessages _actualValue = AttributeDef name_ _typIactualValue check_ _consIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos _consOinLoop = _lhsIinLoop _consOscope = _lhsIscope _consOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) ( _consIactualValue,_consImessages,_consInodeType) = (cons_ _consOinLoop _consOscope _consOsourcePos ) in ( _lhsOactualValue,_lhsOattrName,_lhsOmessages,_lhsOnodeType))) -- AttributeDefList -------------------------------------------- type AttributeDefList = [(AttributeDef)] -- cata sem_AttributeDefList :: AttributeDefList -> T_AttributeDefList sem_AttributeDefList list = (Prelude.foldr sem_AttributeDefList_Cons sem_AttributeDefList_Nil (Prelude.map sem_AttributeDef list) ) -- semantic domain type T_AttributeDefList = Bool -> Scope -> MySourcePos -> ( AttributeDefList,([Message]),Type) data Inh_AttributeDefList = Inh_AttributeDefList {inLoop_Inh_AttributeDefList :: Bool,scope_Inh_AttributeDefList :: Scope,sourcePos_Inh_AttributeDefList :: MySourcePos} data Syn_AttributeDefList = Syn_AttributeDefList {actualValue_Syn_AttributeDefList :: AttributeDefList,messages_Syn_AttributeDefList :: [Message],nodeType_Syn_AttributeDefList :: Type} wrap_AttributeDefList :: T_AttributeDefList -> Inh_AttributeDefList -> Syn_AttributeDefList wrap_AttributeDefList sem (Inh_AttributeDefList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_AttributeDefList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_AttributeDefList_Cons :: T_AttributeDef -> T_AttributeDefList -> T_AttributeDefList sem_AttributeDefList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: AttributeDefList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: AttributeDef _hdIattrName :: String _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: AttributeDefList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOnodeType = checkErrors [_tlInodeType, _hdInodeType] $ consComposite (_hdIattrName, _hdInodeType) _tlInodeType _lhsOmessages = _hdImessages ++ _tlImessages _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdIattrName,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_AttributeDefList_Nil :: T_AttributeDefList sem_AttributeDefList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: AttributeDefList _lhsOnodeType = UnnamedCompositeType [] _lhsOmessages = [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Cascade ----------------------------------------------------- data Cascade = Cascade | Restrict deriving ( Eq,Show) -- cata sem_Cascade :: Cascade -> T_Cascade sem_Cascade (Cascade ) = (sem_Cascade_Cascade ) sem_Cascade (Restrict ) = (sem_Cascade_Restrict ) -- semantic domain type T_Cascade = Bool -> Scope -> MySourcePos -> ( Cascade,([Message]),Type) data Inh_Cascade = Inh_Cascade {inLoop_Inh_Cascade :: Bool,scope_Inh_Cascade :: Scope,sourcePos_Inh_Cascade :: MySourcePos} data Syn_Cascade = Syn_Cascade {actualValue_Syn_Cascade :: Cascade,messages_Syn_Cascade :: [Message],nodeType_Syn_Cascade :: Type} wrap_Cascade :: T_Cascade -> Inh_Cascade -> Syn_Cascade wrap_Cascade sem (Inh_Cascade _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Cascade _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Cascade_Cascade :: T_Cascade sem_Cascade_Cascade = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Cascade _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Cascade _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Cascade_Restrict :: T_Cascade sem_Cascade_Restrict = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Cascade _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Restrict _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- CaseExpressionList ------------------------------------------ type CaseExpressionList = [(Expression)] -- cata sem_CaseExpressionList :: CaseExpressionList -> T_CaseExpressionList sem_CaseExpressionList list = (Prelude.foldr sem_CaseExpressionList_Cons sem_CaseExpressionList_Nil (Prelude.map sem_Expression list) ) -- semantic domain type T_CaseExpressionList = Bool -> Scope -> MySourcePos -> ( CaseExpressionList,([Message]),Type) data Inh_CaseExpressionList = Inh_CaseExpressionList {inLoop_Inh_CaseExpressionList :: Bool,scope_Inh_CaseExpressionList :: Scope,sourcePos_Inh_CaseExpressionList :: MySourcePos} data Syn_CaseExpressionList = Syn_CaseExpressionList {actualValue_Syn_CaseExpressionList :: CaseExpressionList,messages_Syn_CaseExpressionList :: [Message],nodeType_Syn_CaseExpressionList :: Type} wrap_CaseExpressionList :: T_CaseExpressionList -> Inh_CaseExpressionList -> Syn_CaseExpressionList wrap_CaseExpressionList sem (Inh_CaseExpressionList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_CaseExpressionList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_CaseExpressionList_Cons :: T_Expression -> T_CaseExpressionList -> T_CaseExpressionList sem_CaseExpressionList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CaseExpressionList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: Expression _hdIliftedColumnName :: String _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: CaseExpressionList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdIliftedColumnName,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CaseExpressionList_Nil :: T_CaseExpressionList sem_CaseExpressionList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CaseExpressionList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- CaseExpressionListExpressionPair ---------------------------- type CaseExpressionListExpressionPair = ( (CaseExpressionList),(Expression)) -- cata sem_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair -> T_CaseExpressionListExpressionPair sem_CaseExpressionListExpressionPair ( x1,x2) = (sem_CaseExpressionListExpressionPair_Tuple (sem_CaseExpressionList x1 ) (sem_Expression x2 ) ) -- semantic domain type T_CaseExpressionListExpressionPair = Bool -> Scope -> MySourcePos -> ( CaseExpressionListExpressionPair,([Message]),Type) data Inh_CaseExpressionListExpressionPair = Inh_CaseExpressionListExpressionPair {inLoop_Inh_CaseExpressionListExpressionPair :: Bool,scope_Inh_CaseExpressionListExpressionPair :: Scope,sourcePos_Inh_CaseExpressionListExpressionPair :: MySourcePos} data Syn_CaseExpressionListExpressionPair = Syn_CaseExpressionListExpressionPair {actualValue_Syn_CaseExpressionListExpressionPair :: CaseExpressionListExpressionPair,messages_Syn_CaseExpressionListExpressionPair :: [Message],nodeType_Syn_CaseExpressionListExpressionPair :: Type} wrap_CaseExpressionListExpressionPair :: T_CaseExpressionListExpressionPair -> Inh_CaseExpressionListExpressionPair -> Syn_CaseExpressionListExpressionPair wrap_CaseExpressionListExpressionPair sem (Inh_CaseExpressionListExpressionPair _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_CaseExpressionListExpressionPair _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_CaseExpressionListExpressionPair_Tuple :: T_CaseExpressionList -> T_Expression -> T_CaseExpressionListExpressionPair sem_CaseExpressionListExpressionPair_Tuple x1_ x2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CaseExpressionListExpressionPair _x1OinLoop :: Bool _x1Oscope :: Scope _x1OsourcePos :: MySourcePos _x2OinLoop :: Bool _x2Oscope :: Scope _x2OsourcePos :: MySourcePos _x1IactualValue :: CaseExpressionList _x1Imessages :: ([Message]) _x1InodeType :: Type _x2IactualValue :: Expression _x2IliftedColumnName :: String _x2Imessages :: ([Message]) _x2InodeType :: Type _lhsOmessages = _x1Imessages ++ _x2Imessages _lhsOnodeType = _x1InodeType `appendTypeList` _x2InodeType _actualValue = (_x1IactualValue,_x2IactualValue) _lhsOactualValue = _actualValue _x1OinLoop = _lhsIinLoop _x1Oscope = _lhsIscope _x1OsourcePos = _lhsIsourcePos _x2OinLoop = _lhsIinLoop _x2Oscope = _lhsIscope _x2OsourcePos = _lhsIsourcePos ( _x1IactualValue,_x1Imessages,_x1InodeType) = (x1_ _x1OinLoop _x1Oscope _x1OsourcePos ) ( _x2IactualValue,_x2IliftedColumnName,_x2Imessages,_x2InodeType) = (x2_ _x2OinLoop _x2Oscope _x2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- CaseExpressionListExpressionPairList ------------------------ type CaseExpressionListExpressionPairList = [(CaseExpressionListExpressionPair)] -- cata sem_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList -> T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList list = (Prelude.foldr sem_CaseExpressionListExpressionPairList_Cons sem_CaseExpressionListExpressionPairList_Nil (Prelude.map sem_CaseExpressionListExpressionPair list) ) -- semantic domain type T_CaseExpressionListExpressionPairList = Bool -> Scope -> MySourcePos -> ( CaseExpressionListExpressionPairList,([Message]),Type) data Inh_CaseExpressionListExpressionPairList = Inh_CaseExpressionListExpressionPairList {inLoop_Inh_CaseExpressionListExpressionPairList :: Bool,scope_Inh_CaseExpressionListExpressionPairList :: Scope,sourcePos_Inh_CaseExpressionListExpressionPairList :: MySourcePos} data Syn_CaseExpressionListExpressionPairList = Syn_CaseExpressionListExpressionPairList {actualValue_Syn_CaseExpressionListExpressionPairList :: CaseExpressionListExpressionPairList,messages_Syn_CaseExpressionListExpressionPairList :: [Message],nodeType_Syn_CaseExpressionListExpressionPairList :: Type} wrap_CaseExpressionListExpressionPairList :: T_CaseExpressionListExpressionPairList -> Inh_CaseExpressionListExpressionPairList -> Syn_CaseExpressionListExpressionPairList wrap_CaseExpressionListExpressionPairList sem (Inh_CaseExpressionListExpressionPairList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_CaseExpressionListExpressionPairList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_CaseExpressionListExpressionPairList_Cons :: T_CaseExpressionListExpressionPair -> T_CaseExpressionListExpressionPairList -> T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CaseExpressionListExpressionPairList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: CaseExpressionListExpressionPair _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: CaseExpressionListExpressionPairList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CaseExpressionListExpressionPairList_Nil :: T_CaseExpressionListExpressionPairList sem_CaseExpressionListExpressionPairList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CaseExpressionListExpressionPairList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- CombineType ------------------------------------------------- data CombineType = Except | Intersect | Union | UnionAll deriving ( Eq,Show) -- cata sem_CombineType :: CombineType -> T_CombineType sem_CombineType (Except ) = (sem_CombineType_Except ) sem_CombineType (Intersect ) = (sem_CombineType_Intersect ) sem_CombineType (Union ) = (sem_CombineType_Union ) sem_CombineType (UnionAll ) = (sem_CombineType_UnionAll ) -- semantic domain type T_CombineType = Bool -> Scope -> MySourcePos -> ( CombineType,([Message]),Type) data Inh_CombineType = Inh_CombineType {inLoop_Inh_CombineType :: Bool,scope_Inh_CombineType :: Scope,sourcePos_Inh_CombineType :: MySourcePos} data Syn_CombineType = Syn_CombineType {actualValue_Syn_CombineType :: CombineType,messages_Syn_CombineType :: [Message],nodeType_Syn_CombineType :: Type} wrap_CombineType :: T_CombineType -> Inh_CombineType -> Syn_CombineType wrap_CombineType sem (Inh_CombineType _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_CombineType _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_CombineType_Except :: T_CombineType sem_CombineType_Except = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CombineType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Except _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CombineType_Intersect :: T_CombineType sem_CombineType_Intersect = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CombineType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Intersect _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CombineType_Union :: T_CombineType sem_CombineType_Union = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CombineType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Union _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CombineType_UnionAll :: T_CombineType sem_CombineType_UnionAll = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CombineType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = UnionAll _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Constraint -------------------------------------------------- data Constraint = CheckConstraint (Expression) | PrimaryKeyConstraint (StringList) | ReferenceConstraint (StringList) (String) (StringList) (Cascade) (Cascade) | UniqueConstraint (StringList) deriving ( Eq,Show) -- cata sem_Constraint :: Constraint -> T_Constraint sem_Constraint (CheckConstraint _expression ) = (sem_Constraint_CheckConstraint (sem_Expression _expression ) ) sem_Constraint (PrimaryKeyConstraint _stringList ) = (sem_Constraint_PrimaryKeyConstraint (sem_StringList _stringList ) ) sem_Constraint (ReferenceConstraint _atts _table _tableAtts _onUpdate _onDelete ) = (sem_Constraint_ReferenceConstraint (sem_StringList _atts ) _table (sem_StringList _tableAtts ) (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) ) sem_Constraint (UniqueConstraint _stringList ) = (sem_Constraint_UniqueConstraint (sem_StringList _stringList ) ) -- semantic domain type T_Constraint = Bool -> Scope -> MySourcePos -> ( Constraint,([Message]),Type) data Inh_Constraint = Inh_Constraint {inLoop_Inh_Constraint :: Bool,scope_Inh_Constraint :: Scope,sourcePos_Inh_Constraint :: MySourcePos} data Syn_Constraint = Syn_Constraint {actualValue_Syn_Constraint :: Constraint,messages_Syn_Constraint :: [Message],nodeType_Syn_Constraint :: Type} wrap_Constraint :: T_Constraint -> Inh_Constraint -> Syn_Constraint wrap_Constraint sem (Inh_Constraint _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Constraint _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Constraint_CheckConstraint :: T_Expression -> T_Constraint sem_Constraint_CheckConstraint expression_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Constraint _expressionOinLoop :: Bool _expressionOscope :: Scope _expressionOsourcePos :: MySourcePos _expressionIactualValue :: Expression _expressionIliftedColumnName :: String _expressionImessages :: ([Message]) _expressionInodeType :: Type _lhsOmessages = _expressionImessages _lhsOnodeType = _expressionInodeType _actualValue = CheckConstraint _expressionIactualValue _lhsOactualValue = _actualValue _expressionOinLoop = _lhsIinLoop _expressionOscope = _lhsIscope _expressionOsourcePos = _lhsIsourcePos ( _expressionIactualValue,_expressionIliftedColumnName,_expressionImessages,_expressionInodeType) = (expression_ _expressionOinLoop _expressionOscope _expressionOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Constraint_PrimaryKeyConstraint :: T_StringList -> T_Constraint sem_Constraint_PrimaryKeyConstraint stringList_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Constraint _stringListOinLoop :: Bool _stringListOscope :: Scope _stringListOsourcePos :: MySourcePos _stringListIactualValue :: StringList _stringListImessages :: ([Message]) _stringListInodeType :: Type _stringListIstrings :: ([String]) _lhsOmessages = _stringListImessages _lhsOnodeType = _stringListInodeType _actualValue = PrimaryKeyConstraint _stringListIactualValue _lhsOactualValue = _actualValue _stringListOinLoop = _lhsIinLoop _stringListOscope = _lhsIscope _stringListOsourcePos = _lhsIsourcePos ( _stringListIactualValue,_stringListImessages,_stringListInodeType,_stringListIstrings) = (stringList_ _stringListOinLoop _stringListOscope _stringListOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Constraint_ReferenceConstraint :: T_StringList -> String -> T_StringList -> T_Cascade -> T_Cascade -> T_Constraint sem_Constraint_ReferenceConstraint atts_ table_ tableAtts_ onUpdate_ onDelete_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Constraint _attsOinLoop :: Bool _attsOscope :: Scope _attsOsourcePos :: MySourcePos _tableAttsOinLoop :: Bool _tableAttsOscope :: Scope _tableAttsOsourcePos :: MySourcePos _onUpdateOinLoop :: Bool _onUpdateOscope :: Scope _onUpdateOsourcePos :: MySourcePos _onDeleteOinLoop :: Bool _onDeleteOscope :: Scope _onDeleteOsourcePos :: MySourcePos _attsIactualValue :: StringList _attsImessages :: ([Message]) _attsInodeType :: Type _attsIstrings :: ([String]) _tableAttsIactualValue :: StringList _tableAttsImessages :: ([Message]) _tableAttsInodeType :: Type _tableAttsIstrings :: ([String]) _onUpdateIactualValue :: Cascade _onUpdateImessages :: ([Message]) _onUpdateInodeType :: Type _onDeleteIactualValue :: Cascade _onDeleteImessages :: ([Message]) _onDeleteInodeType :: Type _lhsOmessages = _attsImessages ++ _tableAttsImessages ++ _onUpdateImessages ++ _onDeleteImessages _lhsOnodeType = _attsInodeType `setUnknown` _tableAttsInodeType `setUnknown` _onUpdateInodeType `setUnknown` _onDeleteInodeType _actualValue = ReferenceConstraint _attsIactualValue table_ _tableAttsIactualValue _onUpdateIactualValue _onDeleteIactualValue _lhsOactualValue = _actualValue _attsOinLoop = _lhsIinLoop _attsOscope = _lhsIscope _attsOsourcePos = _lhsIsourcePos _tableAttsOinLoop = _lhsIinLoop _tableAttsOscope = _lhsIscope _tableAttsOsourcePos = _lhsIsourcePos _onUpdateOinLoop = _lhsIinLoop _onUpdateOscope = _lhsIscope _onUpdateOsourcePos = _lhsIsourcePos _onDeleteOinLoop = _lhsIinLoop _onDeleteOscope = _lhsIscope _onDeleteOsourcePos = _lhsIsourcePos ( _attsIactualValue,_attsImessages,_attsInodeType,_attsIstrings) = (atts_ _attsOinLoop _attsOscope _attsOsourcePos ) ( _tableAttsIactualValue,_tableAttsImessages,_tableAttsInodeType,_tableAttsIstrings) = (tableAtts_ _tableAttsOinLoop _tableAttsOscope _tableAttsOsourcePos ) ( _onUpdateIactualValue,_onUpdateImessages,_onUpdateInodeType) = (onUpdate_ _onUpdateOinLoop _onUpdateOscope _onUpdateOsourcePos ) ( _onDeleteIactualValue,_onDeleteImessages,_onDeleteInodeType) = (onDelete_ _onDeleteOinLoop _onDeleteOscope _onDeleteOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Constraint_UniqueConstraint :: T_StringList -> T_Constraint sem_Constraint_UniqueConstraint stringList_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Constraint _stringListOinLoop :: Bool _stringListOscope :: Scope _stringListOsourcePos :: MySourcePos _stringListIactualValue :: StringList _stringListImessages :: ([Message]) _stringListInodeType :: Type _stringListIstrings :: ([String]) _lhsOmessages = _stringListImessages _lhsOnodeType = _stringListInodeType _actualValue = UniqueConstraint _stringListIactualValue _lhsOactualValue = _actualValue _stringListOinLoop = _lhsIinLoop _stringListOscope = _lhsIscope _stringListOsourcePos = _lhsIsourcePos ( _stringListIactualValue,_stringListImessages,_stringListInodeType,_stringListIstrings) = (stringList_ _stringListOinLoop _stringListOscope _stringListOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ConstraintList ---------------------------------------------- type ConstraintList = [(Constraint)] -- cata sem_ConstraintList :: ConstraintList -> T_ConstraintList sem_ConstraintList list = (Prelude.foldr sem_ConstraintList_Cons sem_ConstraintList_Nil (Prelude.map sem_Constraint list) ) -- semantic domain type T_ConstraintList = Bool -> Scope -> MySourcePos -> ( ConstraintList,([Message]),Type) data Inh_ConstraintList = Inh_ConstraintList {inLoop_Inh_ConstraintList :: Bool,scope_Inh_ConstraintList :: Scope,sourcePos_Inh_ConstraintList :: MySourcePos} data Syn_ConstraintList = Syn_ConstraintList {actualValue_Syn_ConstraintList :: ConstraintList,messages_Syn_ConstraintList :: [Message],nodeType_Syn_ConstraintList :: Type} wrap_ConstraintList :: T_ConstraintList -> Inh_ConstraintList -> Syn_ConstraintList wrap_ConstraintList sem (Inh_ConstraintList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ConstraintList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ConstraintList_Cons :: T_Constraint -> T_ConstraintList -> T_ConstraintList sem_ConstraintList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ConstraintList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: Constraint _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: ConstraintList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_ConstraintList_Nil :: T_ConstraintList sem_ConstraintList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ConstraintList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- CopySource -------------------------------------------------- data CopySource = CopyFilename (String) | Stdin deriving ( Eq,Show) -- cata sem_CopySource :: CopySource -> T_CopySource sem_CopySource (CopyFilename _string ) = (sem_CopySource_CopyFilename _string ) sem_CopySource (Stdin ) = (sem_CopySource_Stdin ) -- semantic domain type T_CopySource = Bool -> Scope -> MySourcePos -> ( CopySource,([Message]),Type) data Inh_CopySource = Inh_CopySource {inLoop_Inh_CopySource :: Bool,scope_Inh_CopySource :: Scope,sourcePos_Inh_CopySource :: MySourcePos} data Syn_CopySource = Syn_CopySource {actualValue_Syn_CopySource :: CopySource,messages_Syn_CopySource :: [Message],nodeType_Syn_CopySource :: Type} wrap_CopySource :: T_CopySource -> Inh_CopySource -> Syn_CopySource wrap_CopySource sem (Inh_CopySource _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_CopySource _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_CopySource_CopyFilename :: String -> T_CopySource sem_CopySource_CopyFilename string_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CopySource _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = CopyFilename string_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_CopySource_Stdin :: T_CopySource sem_CopySource_Stdin = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: CopySource _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Stdin _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Direction --------------------------------------------------- data Direction = Asc | Desc deriving ( Eq,Show) -- cata sem_Direction :: Direction -> T_Direction sem_Direction (Asc ) = (sem_Direction_Asc ) sem_Direction (Desc ) = (sem_Direction_Desc ) -- semantic domain type T_Direction = Bool -> Scope -> MySourcePos -> ( Direction,([Message]),Type) data Inh_Direction = Inh_Direction {inLoop_Inh_Direction :: Bool,scope_Inh_Direction :: Scope,sourcePos_Inh_Direction :: MySourcePos} data Syn_Direction = Syn_Direction {actualValue_Syn_Direction :: Direction,messages_Syn_Direction :: [Message],nodeType_Syn_Direction :: Type} wrap_Direction :: T_Direction -> Inh_Direction -> Syn_Direction wrap_Direction sem (Inh_Direction _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Direction _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Direction_Asc :: T_Direction sem_Direction_Asc = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Direction _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Asc _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Direction_Desc :: T_Direction sem_Direction_Desc = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Direction _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Desc _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Distinct ---------------------------------------------------- data Distinct = Distinct | Dupes deriving ( Eq,Show) -- cata sem_Distinct :: Distinct -> T_Distinct sem_Distinct (Distinct ) = (sem_Distinct_Distinct ) sem_Distinct (Dupes ) = (sem_Distinct_Dupes ) -- semantic domain type T_Distinct = Bool -> Scope -> MySourcePos -> ( Distinct,([Message]),Type) data Inh_Distinct = Inh_Distinct {inLoop_Inh_Distinct :: Bool,scope_Inh_Distinct :: Scope,sourcePos_Inh_Distinct :: MySourcePos} data Syn_Distinct = Syn_Distinct {actualValue_Syn_Distinct :: Distinct,messages_Syn_Distinct :: [Message],nodeType_Syn_Distinct :: Type} wrap_Distinct :: T_Distinct -> Inh_Distinct -> Syn_Distinct wrap_Distinct sem (Inh_Distinct _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Distinct _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Distinct_Distinct :: T_Distinct sem_Distinct_Distinct = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Distinct _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Distinct _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Distinct_Dupes :: T_Distinct sem_Distinct_Dupes = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Distinct _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Dupes _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- DropType ---------------------------------------------------- data DropType = Domain | Table | Type | View deriving ( Eq,Show) -- cata sem_DropType :: DropType -> T_DropType sem_DropType (Domain ) = (sem_DropType_Domain ) sem_DropType (Table ) = (sem_DropType_Table ) sem_DropType (Type ) = (sem_DropType_Type ) sem_DropType (View ) = (sem_DropType_View ) -- semantic domain type T_DropType = Bool -> Scope -> MySourcePos -> ( DropType,([Message]),Type) data Inh_DropType = Inh_DropType {inLoop_Inh_DropType :: Bool,scope_Inh_DropType :: Scope,sourcePos_Inh_DropType :: MySourcePos} data Syn_DropType = Syn_DropType {actualValue_Syn_DropType :: DropType,messages_Syn_DropType :: [Message],nodeType_Syn_DropType :: Type} wrap_DropType :: T_DropType -> Inh_DropType -> Syn_DropType wrap_DropType sem (Inh_DropType _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_DropType _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_DropType_Domain :: T_DropType sem_DropType_Domain = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: DropType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Domain _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_DropType_Table :: T_DropType sem_DropType_Table = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: DropType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Table _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_DropType_Type :: T_DropType sem_DropType_Type = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: DropType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Type _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_DropType_View :: T_DropType sem_DropType_View = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: DropType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = View _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Expression -------------------------------------------------- data Expression = BooleanLit (Bool) | Case (CaseExpressionListExpressionPairList) (MaybeExpression) | CaseSimple (Expression) (CaseExpressionListExpressionPairList) (MaybeExpression) | Cast (Expression) (TypeName) | Exists (SelectExpression) | FloatLit (Double) | FunCall (String) (ExpressionList) | Identifier (String) | InPredicate (Expression) (Bool) (InList) | IntegerLit (Integer) | NullLit | PositionalArg (Integer) | ScalarSubQuery (SelectExpression) | StringLit (String) (String) | WindowFn (Expression) (ExpressionList) (ExpressionList) (Direction) deriving ( Eq,Show) -- cata sem_Expression :: Expression -> T_Expression sem_Expression (BooleanLit _bool ) = (sem_Expression_BooleanLit _bool ) sem_Expression (Case _cases _els ) = (sem_Expression_Case (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) ) sem_Expression (CaseSimple _value _cases _els ) = (sem_Expression_CaseSimple (sem_Expression _value ) (sem_CaseExpressionListExpressionPairList _cases ) (sem_MaybeExpression _els ) ) sem_Expression (Cast _expr _tn ) = (sem_Expression_Cast (sem_Expression _expr ) (sem_TypeName _tn ) ) sem_Expression (Exists _sel ) = (sem_Expression_Exists (sem_SelectExpression _sel ) ) sem_Expression (FloatLit _double ) = (sem_Expression_FloatLit _double ) sem_Expression (FunCall _funName _args ) = (sem_Expression_FunCall _funName (sem_ExpressionList _args ) ) sem_Expression (Identifier _i ) = (sem_Expression_Identifier _i ) sem_Expression (InPredicate _expr _i _list ) = (sem_Expression_InPredicate (sem_Expression _expr ) _i (sem_InList _list ) ) sem_Expression (IntegerLit _integer ) = (sem_Expression_IntegerLit _integer ) sem_Expression (NullLit ) = (sem_Expression_NullLit ) sem_Expression (PositionalArg _integer ) = (sem_Expression_PositionalArg _integer ) sem_Expression (ScalarSubQuery _sel ) = (sem_Expression_ScalarSubQuery (sem_SelectExpression _sel ) ) sem_Expression (StringLit _quote _value ) = (sem_Expression_StringLit _quote _value ) sem_Expression (WindowFn _fn _partitionBy _orderBy _dir ) = (sem_Expression_WindowFn (sem_Expression _fn ) (sem_ExpressionList _partitionBy ) (sem_ExpressionList _orderBy ) (sem_Direction _dir ) ) -- semantic domain type T_Expression = Bool -> Scope -> MySourcePos -> ( Expression,String,([Message]),Type) data Inh_Expression = Inh_Expression {inLoop_Inh_Expression :: Bool,scope_Inh_Expression :: Scope,sourcePos_Inh_Expression :: MySourcePos} data Syn_Expression = Syn_Expression {actualValue_Syn_Expression :: Expression,liftedColumnName_Syn_Expression :: String,messages_Syn_Expression :: [Message],nodeType_Syn_Expression :: Type} wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression wrap_Expression sem (Inh_Expression _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Expression _lhsOactualValue _lhsOliftedColumnName _lhsOmessages _lhsOnodeType )) sem_Expression_BooleanLit :: Bool -> T_Expression sem_Expression_BooleanLit bool_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = typeBool _lhsOliftedColumnName = "" _lhsOmessages = [] _actualValue = BooleanLit bool_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_Case :: T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_Case cases_ els_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _casesOinLoop :: Bool _casesOscope :: Scope _casesOsourcePos :: MySourcePos _elsOinLoop :: Bool _elsOscope :: Scope _elsOsourcePos :: MySourcePos _casesIactualValue :: CaseExpressionListExpressionPairList _casesImessages :: ([Message]) _casesInodeType :: Type _elsIactualValue :: MaybeExpression _elsImessages :: ([Message]) _elsInodeType :: Type _lhsOnodeType = let elseThen = case _elsInodeType of TypeList [] -> [] t -> [t] unwrappedLists = map unwrapTypeList $ unwrapTypeList _casesInodeType whenTypes :: [Type] whenTypes = concat $ map unwrapTypeList $ map head unwrappedLists thenTypes :: [Type] thenTypes = map (head . tail) unwrappedLists ++ elseThen whensAllBool :: Type whensAllBool = if any (/= typeBool) whenTypes then TypeError _lhsIsourcePos (WrongTypes typeBool whenTypes) else TypeList [] in checkErrors (whenTypes ++ thenTypes ++ [whensAllBool]) $ resolveResultSetType _lhsIscope _lhsIsourcePos thenTypes _lhsOliftedColumnName = "" _lhsOmessages = _casesImessages ++ _elsImessages _actualValue = Case _casesIactualValue _elsIactualValue _lhsOactualValue = _actualValue _casesOinLoop = _lhsIinLoop _casesOscope = _lhsIscope _casesOsourcePos = _lhsIsourcePos _elsOinLoop = _lhsIinLoop _elsOscope = _lhsIscope _elsOsourcePos = _lhsIsourcePos ( _casesIactualValue,_casesImessages,_casesInodeType) = (cases_ _casesOinLoop _casesOscope _casesOsourcePos ) ( _elsIactualValue,_elsImessages,_elsInodeType) = (els_ _elsOinLoop _elsOscope _elsOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_CaseSimple :: T_Expression -> T_CaseExpressionListExpressionPairList -> T_MaybeExpression -> T_Expression sem_Expression_CaseSimple value_ cases_ els_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _valueOinLoop :: Bool _valueOscope :: Scope _valueOsourcePos :: MySourcePos _casesOinLoop :: Bool _casesOscope :: Scope _casesOsourcePos :: MySourcePos _elsOinLoop :: Bool _elsOscope :: Scope _elsOsourcePos :: MySourcePos _valueIactualValue :: Expression _valueIliftedColumnName :: String _valueImessages :: ([Message]) _valueInodeType :: Type _casesIactualValue :: CaseExpressionListExpressionPairList _casesImessages :: ([Message]) _casesInodeType :: Type _elsIactualValue :: MaybeExpression _elsImessages :: ([Message]) _elsInodeType :: Type _lhsOnodeType = let elseThen = case _elsInodeType of TypeList [] -> [] t -> [t] unwrappedLists = map unwrapTypeList $ unwrapTypeList _casesInodeType whenTypes :: [Type] whenTypes = concat $ map unwrapTypeList $ map head unwrappedLists thenTypes :: [Type] thenTypes = map (head . tail) unwrappedLists ++ elseThen checkWhenTypes = resolveResultSetType _lhsIscope _lhsIsourcePos (_valueInodeType:whenTypes) in checkErrors (whenTypes ++ thenTypes ++ [checkWhenTypes]) $ resolveResultSetType _lhsIscope _lhsIsourcePos thenTypes _lhsOliftedColumnName = _valueIliftedColumnName _lhsOmessages = _valueImessages ++ _casesImessages ++ _elsImessages _actualValue = CaseSimple _valueIactualValue _casesIactualValue _elsIactualValue _lhsOactualValue = _actualValue _valueOinLoop = _lhsIinLoop _valueOscope = _lhsIscope _valueOsourcePos = _lhsIsourcePos _casesOinLoop = _lhsIinLoop _casesOscope = _lhsIscope _casesOsourcePos = _lhsIsourcePos _elsOinLoop = _lhsIinLoop _elsOscope = _lhsIscope _elsOsourcePos = _lhsIsourcePos ( _valueIactualValue,_valueIliftedColumnName,_valueImessages,_valueInodeType) = (value_ _valueOinLoop _valueOscope _valueOsourcePos ) ( _casesIactualValue,_casesImessages,_casesInodeType) = (cases_ _casesOinLoop _casesOscope _casesOsourcePos ) ( _elsIactualValue,_elsImessages,_elsInodeType) = (els_ _elsOinLoop _elsOscope _elsOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_Cast :: T_Expression -> T_TypeName -> T_Expression sem_Expression_Cast expr_ tn_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _tnOinLoop :: Bool _tnOscope :: Scope _tnOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _tnIactualValue :: TypeName _tnImessages :: ([Message]) _tnInodeType :: Type _lhsOnodeType = checkErrors [_exprInodeType] _tnInodeType _lhsOliftedColumnName = case _tnIactualValue of SimpleTypeName tn -> tn _ -> "" _lhsOmessages = _exprImessages ++ _tnImessages _actualValue = Cast _exprIactualValue _tnIactualValue _lhsOactualValue = _actualValue _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos _tnOinLoop = _lhsIinLoop _tnOscope = _lhsIscope _tnOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) ( _tnIactualValue,_tnImessages,_tnInodeType) = (tn_ _tnOinLoop _tnOscope _tnOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_Exists :: T_SelectExpression -> T_Expression sem_Expression_Exists sel_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _lhsOnodeType = checkErrors [_selInodeType] typeBool _lhsOliftedColumnName = "" _lhsOmessages = _selImessages _actualValue = Exists _selIactualValue _lhsOactualValue = _actualValue _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_FloatLit :: Double -> T_Expression sem_Expression_FloatLit double_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = typeNumeric _lhsOliftedColumnName = "" _lhsOmessages = [] _actualValue = FloatLit double_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_FunCall :: String -> T_ExpressionList -> T_Expression sem_Expression_FunCall funName_ args_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _argsOinLoop :: Bool _argsOscope :: Scope _argsOsourcePos :: MySourcePos _argsIactualValue :: ExpressionList _argsImessages :: ([Message]) _argsInodeType :: Type _lhsOnodeType = checkErrors [_argsInodeType] $ typeCheckFunCall _lhsIscope _lhsIsourcePos funName_ _argsInodeType _lhsOliftedColumnName = if isOperator funName_ then "" else funName_ _lhsOmessages = _argsImessages _actualValue = FunCall funName_ _argsIactualValue _lhsOactualValue = _actualValue _argsOinLoop = _lhsIinLoop _argsOscope = _lhsIscope _argsOsourcePos = _lhsIsourcePos ( _argsIactualValue,_argsImessages,_argsInodeType) = (args_ _argsOinLoop _argsOscope _argsOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_Identifier :: String -> T_Expression sem_Expression_Identifier i_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = let (correlationName,iden) = splitIdentifier i_ in scopeLookupID _lhsIscope _lhsIsourcePos correlationName iden _lhsOliftedColumnName = i_ _lhsOmessages = [] _actualValue = Identifier i_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_InPredicate :: T_Expression -> Bool -> T_InList -> T_Expression sem_Expression_InPredicate expr_ i_ list_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _listOinLoop :: Bool _listOscope :: Scope _listOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _listIactualValue :: InList _listImessages :: ([Message]) _listInodeType :: Type _lhsOnodeType = let er = resolveResultSetType _lhsIscope _lhsIsourcePos [_exprInodeType, _listInodeType] in checkErrors [er] typeBool _lhsOliftedColumnName = _exprIliftedColumnName _lhsOmessages = _exprImessages ++ _listImessages _actualValue = InPredicate _exprIactualValue i_ _listIactualValue _lhsOactualValue = _actualValue _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos _listOinLoop = _lhsIinLoop _listOscope = _lhsIscope _listOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) ( _listIactualValue,_listImessages,_listInodeType) = (list_ _listOinLoop _listOscope _listOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_IntegerLit :: Integer -> T_Expression sem_Expression_IntegerLit integer_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = typeInt _lhsOliftedColumnName = "" _lhsOmessages = [] _actualValue = IntegerLit integer_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_NullLit :: T_Expression sem_Expression_NullLit = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = UnknownStringLit _lhsOliftedColumnName = "" _lhsOmessages = [] _actualValue = NullLit _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_PositionalArg :: Integer -> T_Expression sem_Expression_PositionalArg integer_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Expression _lhsOliftedColumnName = "" _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = PositionalArg integer_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_ScalarSubQuery :: T_SelectExpression -> T_Expression sem_Expression_ScalarSubQuery sel_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _lhsOnodeType = let f = map snd $ unwrapComposite $ unwrapSetOf _selInodeType in checkErrors [_selInodeType] $ case length f of 0 -> error "internal error: no columns in scalar subquery?" 1 -> head f _ -> RowCtor f _lhsOliftedColumnName = "" _lhsOmessages = _selImessages _actualValue = ScalarSubQuery _selIactualValue _lhsOactualValue = _actualValue _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_StringLit :: String -> String -> T_Expression sem_Expression_StringLit quote_ value_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: Expression _lhsOnodeType = UnknownStringLit _lhsOliftedColumnName = "" _lhsOmessages = [] _actualValue = StringLit quote_ value_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) sem_Expression_WindowFn :: T_Expression -> T_ExpressionList -> T_ExpressionList -> T_Direction -> T_Expression sem_Expression_WindowFn fn_ partitionBy_ orderBy_ dir_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOliftedColumnName :: String _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Expression _fnOinLoop :: Bool _fnOscope :: Scope _fnOsourcePos :: MySourcePos _partitionByOinLoop :: Bool _partitionByOscope :: Scope _partitionByOsourcePos :: MySourcePos _orderByOinLoop :: Bool _orderByOscope :: Scope _orderByOsourcePos :: MySourcePos _dirOinLoop :: Bool _dirOscope :: Scope _dirOsourcePos :: MySourcePos _fnIactualValue :: Expression _fnIliftedColumnName :: String _fnImessages :: ([Message]) _fnInodeType :: Type _partitionByIactualValue :: ExpressionList _partitionByImessages :: ([Message]) _partitionByInodeType :: Type _orderByIactualValue :: ExpressionList _orderByImessages :: ([Message]) _orderByInodeType :: Type _dirIactualValue :: Direction _dirImessages :: ([Message]) _dirInodeType :: Type _lhsOliftedColumnName = _fnIliftedColumnName _lhsOmessages = _fnImessages ++ _partitionByImessages ++ _orderByImessages ++ _dirImessages _lhsOnodeType = _fnInodeType `setUnknown` _partitionByInodeType `setUnknown` _orderByInodeType `setUnknown` _dirInodeType _actualValue = WindowFn _fnIactualValue _partitionByIactualValue _orderByIactualValue _dirIactualValue _lhsOactualValue = _actualValue _fnOinLoop = _lhsIinLoop _fnOscope = _lhsIscope _fnOsourcePos = _lhsIsourcePos _partitionByOinLoop = _lhsIinLoop _partitionByOscope = _lhsIscope _partitionByOsourcePos = _lhsIsourcePos _orderByOinLoop = _lhsIinLoop _orderByOscope = _lhsIscope _orderByOsourcePos = _lhsIsourcePos _dirOinLoop = _lhsIinLoop _dirOscope = _lhsIscope _dirOsourcePos = _lhsIsourcePos ( _fnIactualValue,_fnIliftedColumnName,_fnImessages,_fnInodeType) = (fn_ _fnOinLoop _fnOscope _fnOsourcePos ) ( _partitionByIactualValue,_partitionByImessages,_partitionByInodeType) = (partitionBy_ _partitionByOinLoop _partitionByOscope _partitionByOsourcePos ) ( _orderByIactualValue,_orderByImessages,_orderByInodeType) = (orderBy_ _orderByOinLoop _orderByOscope _orderByOsourcePos ) ( _dirIactualValue,_dirImessages,_dirInodeType) = (dir_ _dirOinLoop _dirOscope _dirOsourcePos ) in ( _lhsOactualValue,_lhsOliftedColumnName,_lhsOmessages,_lhsOnodeType))) -- ExpressionList ---------------------------------------------- type ExpressionList = [(Expression)] -- cata sem_ExpressionList :: ExpressionList -> T_ExpressionList sem_ExpressionList list = (Prelude.foldr sem_ExpressionList_Cons sem_ExpressionList_Nil (Prelude.map sem_Expression list) ) -- semantic domain type T_ExpressionList = Bool -> Scope -> MySourcePos -> ( ExpressionList,([Message]),Type) data Inh_ExpressionList = Inh_ExpressionList {inLoop_Inh_ExpressionList :: Bool,scope_Inh_ExpressionList :: Scope,sourcePos_Inh_ExpressionList :: MySourcePos} data Syn_ExpressionList = Syn_ExpressionList {actualValue_Syn_ExpressionList :: ExpressionList,messages_Syn_ExpressionList :: [Message],nodeType_Syn_ExpressionList :: Type} wrap_ExpressionList :: T_ExpressionList -> Inh_ExpressionList -> Syn_ExpressionList wrap_ExpressionList sem (Inh_ExpressionList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionList_Cons :: T_Expression -> T_ExpressionList -> T_ExpressionList sem_ExpressionList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: Expression _hdIliftedColumnName :: String _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: ExpressionList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdIliftedColumnName,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_ExpressionList_Nil :: T_ExpressionList sem_ExpressionList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionListList ------------------------------------------ type ExpressionListList = [(ExpressionList)] -- cata sem_ExpressionListList :: ExpressionListList -> T_ExpressionListList sem_ExpressionListList list = (Prelude.foldr sem_ExpressionListList_Cons sem_ExpressionListList_Nil (Prelude.map sem_ExpressionList list) ) -- semantic domain type T_ExpressionListList = Bool -> Scope -> MySourcePos -> ( ExpressionListList,([Message]),Type) data Inh_ExpressionListList = Inh_ExpressionListList {inLoop_Inh_ExpressionListList :: Bool,scope_Inh_ExpressionListList :: Scope,sourcePos_Inh_ExpressionListList :: MySourcePos} data Syn_ExpressionListList = Syn_ExpressionListList {actualValue_Syn_ExpressionListList :: ExpressionListList,messages_Syn_ExpressionListList :: [Message],nodeType_Syn_ExpressionListList :: Type} wrap_ExpressionListList :: T_ExpressionListList -> Inh_ExpressionListList -> Syn_ExpressionListList wrap_ExpressionListList sem (Inh_ExpressionListList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionListList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionListList_Cons :: T_ExpressionList -> T_ExpressionListList -> T_ExpressionListList sem_ExpressionListList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionListList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: ExpressionList _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: ExpressionListList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_ExpressionListList_Nil :: T_ExpressionListList sem_ExpressionListList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionListList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionListStatementListPair ----------------------------- type ExpressionListStatementListPair = ( (ExpressionList),(StatementList)) -- cata sem_ExpressionListStatementListPair :: ExpressionListStatementListPair -> T_ExpressionListStatementListPair sem_ExpressionListStatementListPair ( x1,x2) = (sem_ExpressionListStatementListPair_Tuple (sem_ExpressionList x1 ) (sem_StatementList x2 ) ) -- semantic domain type T_ExpressionListStatementListPair = Bool -> Scope -> MySourcePos -> ( ExpressionListStatementListPair,([Message]),Type) data Inh_ExpressionListStatementListPair = Inh_ExpressionListStatementListPair {inLoop_Inh_ExpressionListStatementListPair :: Bool,scope_Inh_ExpressionListStatementListPair :: Scope,sourcePos_Inh_ExpressionListStatementListPair :: MySourcePos} data Syn_ExpressionListStatementListPair = Syn_ExpressionListStatementListPair {actualValue_Syn_ExpressionListStatementListPair :: ExpressionListStatementListPair,messages_Syn_ExpressionListStatementListPair :: [Message],nodeType_Syn_ExpressionListStatementListPair :: Type} wrap_ExpressionListStatementListPair :: T_ExpressionListStatementListPair -> Inh_ExpressionListStatementListPair -> Syn_ExpressionListStatementListPair wrap_ExpressionListStatementListPair sem (Inh_ExpressionListStatementListPair _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionListStatementListPair _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionListStatementListPair_Tuple :: T_ExpressionList -> T_StatementList -> T_ExpressionListStatementListPair sem_ExpressionListStatementListPair_Tuple x1_ x2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionListStatementListPair _x1OinLoop :: Bool _x1Oscope :: Scope _x1OsourcePos :: MySourcePos _x2OinLoop :: Bool _x2Oscope :: Scope _x2OsourcePos :: MySourcePos _x1IactualValue :: ExpressionList _x1Imessages :: ([Message]) _x1InodeType :: Type _x2IactualValue :: StatementList _x2Imessages :: ([Message]) _x2InodeType :: Type _x2IstatementInfo :: ([StatementInfo]) _lhsOmessages = _x1Imessages ++ _x2Imessages _lhsOnodeType = _x1InodeType `setUnknown` _x2InodeType _actualValue = (_x1IactualValue,_x2IactualValue) _lhsOactualValue = _actualValue _x1OinLoop = _lhsIinLoop _x1Oscope = _lhsIscope _x1OsourcePos = _lhsIsourcePos _x2OinLoop = _lhsIinLoop _x2Oscope = _lhsIscope _x2OsourcePos = _lhsIsourcePos ( _x1IactualValue,_x1Imessages,_x1InodeType) = (x1_ _x1OinLoop _x1Oscope _x1OsourcePos ) ( _x2IactualValue,_x2Imessages,_x2InodeType,_x2IstatementInfo) = (x2_ _x2OinLoop _x2Oscope _x2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionListStatementListPairList ------------------------- type ExpressionListStatementListPairList = [(ExpressionListStatementListPair)] -- cata sem_ExpressionListStatementListPairList :: ExpressionListStatementListPairList -> T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList list = (Prelude.foldr sem_ExpressionListStatementListPairList_Cons sem_ExpressionListStatementListPairList_Nil (Prelude.map sem_ExpressionListStatementListPair list) ) -- semantic domain type T_ExpressionListStatementListPairList = Bool -> Scope -> MySourcePos -> ( ExpressionListStatementListPairList,([Message]),Type) data Inh_ExpressionListStatementListPairList = Inh_ExpressionListStatementListPairList {inLoop_Inh_ExpressionListStatementListPairList :: Bool,scope_Inh_ExpressionListStatementListPairList :: Scope,sourcePos_Inh_ExpressionListStatementListPairList :: MySourcePos} data Syn_ExpressionListStatementListPairList = Syn_ExpressionListStatementListPairList {actualValue_Syn_ExpressionListStatementListPairList :: ExpressionListStatementListPairList,messages_Syn_ExpressionListStatementListPairList :: [Message],nodeType_Syn_ExpressionListStatementListPairList :: Type} wrap_ExpressionListStatementListPairList :: T_ExpressionListStatementListPairList -> Inh_ExpressionListStatementListPairList -> Syn_ExpressionListStatementListPairList wrap_ExpressionListStatementListPairList sem (Inh_ExpressionListStatementListPairList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionListStatementListPairList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionListStatementListPairList_Cons :: T_ExpressionListStatementListPair -> T_ExpressionListStatementListPairList -> T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionListStatementListPairList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: ExpressionListStatementListPair _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: ExpressionListStatementListPairList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_ExpressionListStatementListPairList_Nil :: T_ExpressionListStatementListPairList sem_ExpressionListStatementListPairList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionListStatementListPairList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionRoot ---------------------------------------------- data ExpressionRoot = ExpressionRoot (Expression) deriving ( Show) -- cata sem_ExpressionRoot :: ExpressionRoot -> T_ExpressionRoot sem_ExpressionRoot (ExpressionRoot _expr ) = (sem_ExpressionRoot_ExpressionRoot (sem_Expression _expr ) ) -- semantic domain type T_ExpressionRoot = Scope -> ( ExpressionRoot,([Message]),Type) data Inh_ExpressionRoot = Inh_ExpressionRoot {scope_Inh_ExpressionRoot :: Scope} data Syn_ExpressionRoot = Syn_ExpressionRoot {actualValue_Syn_ExpressionRoot :: ExpressionRoot,messages_Syn_ExpressionRoot :: [Message],nodeType_Syn_ExpressionRoot :: Type} wrap_ExpressionRoot :: T_ExpressionRoot -> Inh_ExpressionRoot -> Syn_ExpressionRoot wrap_ExpressionRoot sem (Inh_ExpressionRoot _lhsIscope ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIscope ) in (Syn_ExpressionRoot _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionRoot_ExpressionRoot :: T_Expression -> T_ExpressionRoot sem_ExpressionRoot_ExpressionRoot expr_ = (\ _lhsIscope -> (let _exprOsourcePos :: MySourcePos _exprOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionRoot _exprOscope :: Scope _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _exprOsourcePos = ("",0,0) _exprOinLoop = False _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = ExpressionRoot _exprIactualValue _lhsOactualValue = _actualValue _exprOscope = _lhsIscope ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionStatementListPair --------------------------------- type ExpressionStatementListPair = ( (Expression),(StatementList)) -- cata sem_ExpressionStatementListPair :: ExpressionStatementListPair -> T_ExpressionStatementListPair sem_ExpressionStatementListPair ( x1,x2) = (sem_ExpressionStatementListPair_Tuple (sem_Expression x1 ) (sem_StatementList x2 ) ) -- semantic domain type T_ExpressionStatementListPair = Bool -> Scope -> MySourcePos -> ( ExpressionStatementListPair,([Message]),Type) data Inh_ExpressionStatementListPair = Inh_ExpressionStatementListPair {inLoop_Inh_ExpressionStatementListPair :: Bool,scope_Inh_ExpressionStatementListPair :: Scope,sourcePos_Inh_ExpressionStatementListPair :: MySourcePos} data Syn_ExpressionStatementListPair = Syn_ExpressionStatementListPair {actualValue_Syn_ExpressionStatementListPair :: ExpressionStatementListPair,messages_Syn_ExpressionStatementListPair :: [Message],nodeType_Syn_ExpressionStatementListPair :: Type} wrap_ExpressionStatementListPair :: T_ExpressionStatementListPair -> Inh_ExpressionStatementListPair -> Syn_ExpressionStatementListPair wrap_ExpressionStatementListPair sem (Inh_ExpressionStatementListPair _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionStatementListPair _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionStatementListPair_Tuple :: T_Expression -> T_StatementList -> T_ExpressionStatementListPair sem_ExpressionStatementListPair_Tuple x1_ x2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionStatementListPair _x1OinLoop :: Bool _x1Oscope :: Scope _x1OsourcePos :: MySourcePos _x2OinLoop :: Bool _x2Oscope :: Scope _x2OsourcePos :: MySourcePos _x1IactualValue :: Expression _x1IliftedColumnName :: String _x1Imessages :: ([Message]) _x1InodeType :: Type _x2IactualValue :: StatementList _x2Imessages :: ([Message]) _x2InodeType :: Type _x2IstatementInfo :: ([StatementInfo]) _lhsOmessages = _x1Imessages ++ _x2Imessages _lhsOnodeType = _x1InodeType `setUnknown` _x2InodeType _actualValue = (_x1IactualValue,_x2IactualValue) _lhsOactualValue = _actualValue _x1OinLoop = _lhsIinLoop _x1Oscope = _lhsIscope _x1OsourcePos = _lhsIsourcePos _x2OinLoop = _lhsIinLoop _x2Oscope = _lhsIscope _x2OsourcePos = _lhsIsourcePos ( _x1IactualValue,_x1IliftedColumnName,_x1Imessages,_x1InodeType) = (x1_ _x1OinLoop _x1Oscope _x1OsourcePos ) ( _x2IactualValue,_x2Imessages,_x2InodeType,_x2IstatementInfo) = (x2_ _x2OinLoop _x2Oscope _x2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ExpressionStatementListPairList ----------------------------- type ExpressionStatementListPairList = [(ExpressionStatementListPair)] -- cata sem_ExpressionStatementListPairList :: ExpressionStatementListPairList -> T_ExpressionStatementListPairList sem_ExpressionStatementListPairList list = (Prelude.foldr sem_ExpressionStatementListPairList_Cons sem_ExpressionStatementListPairList_Nil (Prelude.map sem_ExpressionStatementListPair list) ) -- semantic domain type T_ExpressionStatementListPairList = Bool -> Scope -> MySourcePos -> ( ExpressionStatementListPairList,([Message]),Type) data Inh_ExpressionStatementListPairList = Inh_ExpressionStatementListPairList {inLoop_Inh_ExpressionStatementListPairList :: Bool,scope_Inh_ExpressionStatementListPairList :: Scope,sourcePos_Inh_ExpressionStatementListPairList :: MySourcePos} data Syn_ExpressionStatementListPairList = Syn_ExpressionStatementListPairList {actualValue_Syn_ExpressionStatementListPairList :: ExpressionStatementListPairList,messages_Syn_ExpressionStatementListPairList :: [Message],nodeType_Syn_ExpressionStatementListPairList :: Type} wrap_ExpressionStatementListPairList :: T_ExpressionStatementListPairList -> Inh_ExpressionStatementListPairList -> Syn_ExpressionStatementListPairList wrap_ExpressionStatementListPairList sem (Inh_ExpressionStatementListPairList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ExpressionStatementListPairList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_ExpressionStatementListPairList_Cons :: T_ExpressionStatementListPair -> T_ExpressionStatementListPairList -> T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionStatementListPairList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: ExpressionStatementListPair _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: ExpressionStatementListPairList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_ExpressionStatementListPairList_Nil :: T_ExpressionStatementListPairList sem_ExpressionStatementListPairList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ExpressionStatementListPairList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- FnBody ------------------------------------------------------ data FnBody = PlpgsqlFnBody (VarDefList) (StatementList) | SqlFnBody (StatementList) deriving ( Eq,Show) -- cata sem_FnBody :: FnBody -> T_FnBody sem_FnBody (PlpgsqlFnBody _varDefList _sts ) = (sem_FnBody_PlpgsqlFnBody (sem_VarDefList _varDefList ) (sem_StatementList _sts ) ) sem_FnBody (SqlFnBody _sts ) = (sem_FnBody_SqlFnBody (sem_StatementList _sts ) ) -- semantic domain type T_FnBody = Bool -> Scope -> MySourcePos -> ( FnBody,([Message]),Type) data Inh_FnBody = Inh_FnBody {inLoop_Inh_FnBody :: Bool,scope_Inh_FnBody :: Scope,sourcePos_Inh_FnBody :: MySourcePos} data Syn_FnBody = Syn_FnBody {actualValue_Syn_FnBody :: FnBody,messages_Syn_FnBody :: [Message],nodeType_Syn_FnBody :: Type} wrap_FnBody :: T_FnBody -> Inh_FnBody -> Syn_FnBody wrap_FnBody sem (Inh_FnBody _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_FnBody _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_FnBody_PlpgsqlFnBody :: T_VarDefList -> T_StatementList -> T_FnBody sem_FnBody_PlpgsqlFnBody varDefList_ sts_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: FnBody _varDefListOinLoop :: Bool _varDefListOscope :: Scope _varDefListOsourcePos :: MySourcePos _stsOinLoop :: Bool _stsOscope :: Scope _stsOsourcePos :: MySourcePos _varDefListIactualValue :: VarDefList _varDefListImessages :: ([Message]) _varDefListInodeType :: Type _stsIactualValue :: StatementList _stsImessages :: ([Message]) _stsInodeType :: Type _stsIstatementInfo :: ([StatementInfo]) _lhsOmessages = _varDefListImessages ++ _stsImessages _lhsOnodeType = _varDefListInodeType `setUnknown` _stsInodeType _actualValue = PlpgsqlFnBody _varDefListIactualValue _stsIactualValue _lhsOactualValue = _actualValue _varDefListOinLoop = _lhsIinLoop _varDefListOscope = _lhsIscope _varDefListOsourcePos = _lhsIsourcePos _stsOinLoop = _lhsIinLoop _stsOscope = _lhsIscope _stsOsourcePos = _lhsIsourcePos ( _varDefListIactualValue,_varDefListImessages,_varDefListInodeType) = (varDefList_ _varDefListOinLoop _varDefListOscope _varDefListOsourcePos ) ( _stsIactualValue,_stsImessages,_stsInodeType,_stsIstatementInfo) = (sts_ _stsOinLoop _stsOscope _stsOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_FnBody_SqlFnBody :: T_StatementList -> T_FnBody sem_FnBody_SqlFnBody sts_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: FnBody _stsOinLoop :: Bool _stsOscope :: Scope _stsOsourcePos :: MySourcePos _stsIactualValue :: StatementList _stsImessages :: ([Message]) _stsInodeType :: Type _stsIstatementInfo :: ([StatementInfo]) _lhsOmessages = _stsImessages _lhsOnodeType = _stsInodeType _actualValue = SqlFnBody _stsIactualValue _lhsOactualValue = _actualValue _stsOinLoop = _lhsIinLoop _stsOscope = _lhsIscope _stsOsourcePos = _lhsIsourcePos ( _stsIactualValue,_stsImessages,_stsInodeType,_stsIstatementInfo) = (sts_ _stsOinLoop _stsOscope _stsOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- IfExists ---------------------------------------------------- data IfExists = IfExists | Require deriving ( Eq,Show) -- cata sem_IfExists :: IfExists -> T_IfExists sem_IfExists (IfExists ) = (sem_IfExists_IfExists ) sem_IfExists (Require ) = (sem_IfExists_Require ) -- semantic domain type T_IfExists = Bool -> Scope -> MySourcePos -> ( IfExists,([Message]),Type) data Inh_IfExists = Inh_IfExists {inLoop_Inh_IfExists :: Bool,scope_Inh_IfExists :: Scope,sourcePos_Inh_IfExists :: MySourcePos} data Syn_IfExists = Syn_IfExists {actualValue_Syn_IfExists :: IfExists,messages_Syn_IfExists :: [Message],nodeType_Syn_IfExists :: Type} wrap_IfExists :: T_IfExists -> Inh_IfExists -> Syn_IfExists wrap_IfExists sem (Inh_IfExists _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_IfExists _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_IfExists_IfExists :: T_IfExists sem_IfExists_IfExists = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: IfExists _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = IfExists _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_IfExists_Require :: T_IfExists sem_IfExists_Require = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: IfExists _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Require _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- InList ------------------------------------------------------ data InList = InList (ExpressionList) | InSelect (SelectExpression) deriving ( Eq,Show) -- cata sem_InList :: InList -> T_InList sem_InList (InList _exprs ) = (sem_InList_InList (sem_ExpressionList _exprs ) ) sem_InList (InSelect _sel ) = (sem_InList_InSelect (sem_SelectExpression _sel ) ) -- semantic domain type T_InList = Bool -> Scope -> MySourcePos -> ( InList,([Message]),Type) data Inh_InList = Inh_InList {inLoop_Inh_InList :: Bool,scope_Inh_InList :: Scope,sourcePos_Inh_InList :: MySourcePos} data Syn_InList = Syn_InList {actualValue_Syn_InList :: InList,messages_Syn_InList :: [Message],nodeType_Syn_InList :: Type} wrap_InList :: T_InList -> Inh_InList -> Syn_InList wrap_InList sem (Inh_InList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_InList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_InList_InList :: T_ExpressionList -> T_InList sem_InList_InList exprs_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: InList _exprsOinLoop :: Bool _exprsOscope :: Scope _exprsOsourcePos :: MySourcePos _exprsIactualValue :: ExpressionList _exprsImessages :: ([Message]) _exprsInodeType :: Type _lhsOnodeType = resolveResultSetType _lhsIscope _lhsIsourcePos $ unwrapTypeList _exprsInodeType _lhsOmessages = _exprsImessages _actualValue = InList _exprsIactualValue _lhsOactualValue = _actualValue _exprsOinLoop = _lhsIinLoop _exprsOscope = _lhsIscope _exprsOsourcePos = _lhsIsourcePos ( _exprsIactualValue,_exprsImessages,_exprsInodeType) = (exprs_ _exprsOinLoop _exprsOscope _exprsOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_InList_InSelect :: T_SelectExpression -> T_InList sem_InList_InSelect sel_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: InList _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _lhsOnodeType = let attrs = map snd $ unwrapComposite $ unwrapSetOf $ _selInodeType in case length attrs of 0 -> error "internal error - got subquery with no columns? in inselect" 1 -> head attrs _ -> RowCtor attrs _lhsOmessages = _selImessages _actualValue = InSelect _selIactualValue _lhsOactualValue = _actualValue _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- JoinExpression ---------------------------------------------- data JoinExpression = JoinOn (Expression) | JoinUsing (StringList) deriving ( Eq,Show) -- cata sem_JoinExpression :: JoinExpression -> T_JoinExpression sem_JoinExpression (JoinOn _expression ) = (sem_JoinExpression_JoinOn (sem_Expression _expression ) ) sem_JoinExpression (JoinUsing _stringList ) = (sem_JoinExpression_JoinUsing (sem_StringList _stringList ) ) -- semantic domain type T_JoinExpression = Bool -> Scope -> MySourcePos -> ( JoinExpression,([Message]),Type) data Inh_JoinExpression = Inh_JoinExpression {inLoop_Inh_JoinExpression :: Bool,scope_Inh_JoinExpression :: Scope,sourcePos_Inh_JoinExpression :: MySourcePos} data Syn_JoinExpression = Syn_JoinExpression {actualValue_Syn_JoinExpression :: JoinExpression,messages_Syn_JoinExpression :: [Message],nodeType_Syn_JoinExpression :: Type} wrap_JoinExpression :: T_JoinExpression -> Inh_JoinExpression -> Syn_JoinExpression wrap_JoinExpression sem (Inh_JoinExpression _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_JoinExpression _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_JoinExpression_JoinOn :: T_Expression -> T_JoinExpression sem_JoinExpression_JoinOn expression_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinExpression _expressionOinLoop :: Bool _expressionOscope :: Scope _expressionOsourcePos :: MySourcePos _expressionIactualValue :: Expression _expressionIliftedColumnName :: String _expressionImessages :: ([Message]) _expressionInodeType :: Type _lhsOmessages = _expressionImessages _lhsOnodeType = _expressionInodeType _actualValue = JoinOn _expressionIactualValue _lhsOactualValue = _actualValue _expressionOinLoop = _lhsIinLoop _expressionOscope = _lhsIscope _expressionOsourcePos = _lhsIsourcePos ( _expressionIactualValue,_expressionIliftedColumnName,_expressionImessages,_expressionInodeType) = (expression_ _expressionOinLoop _expressionOscope _expressionOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_JoinExpression_JoinUsing :: T_StringList -> T_JoinExpression sem_JoinExpression_JoinUsing stringList_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinExpression _stringListOinLoop :: Bool _stringListOscope :: Scope _stringListOsourcePos :: MySourcePos _stringListIactualValue :: StringList _stringListImessages :: ([Message]) _stringListInodeType :: Type _stringListIstrings :: ([String]) _lhsOmessages = _stringListImessages _lhsOnodeType = _stringListInodeType _actualValue = JoinUsing _stringListIactualValue _lhsOactualValue = _actualValue _stringListOinLoop = _lhsIinLoop _stringListOscope = _lhsIscope _stringListOsourcePos = _lhsIsourcePos ( _stringListIactualValue,_stringListImessages,_stringListInodeType,_stringListIstrings) = (stringList_ _stringListOinLoop _stringListOscope _stringListOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- JoinType ---------------------------------------------------- data JoinType = Cross | FullOuter | Inner | LeftOuter | RightOuter deriving ( Eq,Show) -- cata sem_JoinType :: JoinType -> T_JoinType sem_JoinType (Cross ) = (sem_JoinType_Cross ) sem_JoinType (FullOuter ) = (sem_JoinType_FullOuter ) sem_JoinType (Inner ) = (sem_JoinType_Inner ) sem_JoinType (LeftOuter ) = (sem_JoinType_LeftOuter ) sem_JoinType (RightOuter ) = (sem_JoinType_RightOuter ) -- semantic domain type T_JoinType = Bool -> Scope -> MySourcePos -> ( JoinType,([Message]),Type) data Inh_JoinType = Inh_JoinType {inLoop_Inh_JoinType :: Bool,scope_Inh_JoinType :: Scope,sourcePos_Inh_JoinType :: MySourcePos} data Syn_JoinType = Syn_JoinType {actualValue_Syn_JoinType :: JoinType,messages_Syn_JoinType :: [Message],nodeType_Syn_JoinType :: Type} wrap_JoinType :: T_JoinType -> Inh_JoinType -> Syn_JoinType wrap_JoinType sem (Inh_JoinType _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_JoinType _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_JoinType_Cross :: T_JoinType sem_JoinType_Cross = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Cross _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_JoinType_FullOuter :: T_JoinType sem_JoinType_FullOuter = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = FullOuter _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_JoinType_Inner :: T_JoinType sem_JoinType_Inner = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Inner _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_JoinType_LeftOuter :: T_JoinType sem_JoinType_LeftOuter = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = LeftOuter _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_JoinType_RightOuter :: T_JoinType sem_JoinType_RightOuter = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: JoinType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RightOuter _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Language ---------------------------------------------------- data Language = Plpgsql | Sql deriving ( Eq,Show) -- cata sem_Language :: Language -> T_Language sem_Language (Plpgsql ) = (sem_Language_Plpgsql ) sem_Language (Sql ) = (sem_Language_Sql ) -- semantic domain type T_Language = Bool -> Scope -> MySourcePos -> ( Language,([Message]),Type) data Inh_Language = Inh_Language {inLoop_Inh_Language :: Bool,scope_Inh_Language :: Scope,sourcePos_Inh_Language :: MySourcePos} data Syn_Language = Syn_Language {actualValue_Syn_Language :: Language,messages_Syn_Language :: [Message],nodeType_Syn_Language :: Type} wrap_Language :: T_Language -> Inh_Language -> Syn_Language wrap_Language sem (Inh_Language _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Language _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Language_Plpgsql :: T_Language sem_Language_Plpgsql = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Language _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Plpgsql _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Language_Sql :: T_Language sem_Language_Sql = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Language _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Sql _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- MTableRef --------------------------------------------------- type MTableRef = (Maybe (TableRef)) -- cata sem_MTableRef :: MTableRef -> T_MTableRef sem_MTableRef (Prelude.Just x ) = (sem_MTableRef_Just (sem_TableRef x ) ) sem_MTableRef Prelude.Nothing = sem_MTableRef_Nothing -- semantic domain type T_MTableRef = Bool -> Scope -> MySourcePos -> ( MTableRef,([QualifiedScope]),([String]),([Message]),Type) data Inh_MTableRef = Inh_MTableRef {inLoop_Inh_MTableRef :: Bool,scope_Inh_MTableRef :: Scope,sourcePos_Inh_MTableRef :: MySourcePos} data Syn_MTableRef = Syn_MTableRef {actualValue_Syn_MTableRef :: MTableRef,idens_Syn_MTableRef :: [QualifiedScope],joinIdens_Syn_MTableRef :: [String],messages_Syn_MTableRef :: [Message],nodeType_Syn_MTableRef :: Type} wrap_MTableRef :: T_MTableRef -> Inh_MTableRef -> Syn_MTableRef wrap_MTableRef sem (Inh_MTableRef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_MTableRef _lhsOactualValue _lhsOidens _lhsOjoinIdens _lhsOmessages _lhsOnodeType )) sem_MTableRef_Just :: T_TableRef -> T_MTableRef sem_MTableRef_Just just_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: MTableRef _lhsOidens :: ([QualifiedScope]) _lhsOjoinIdens :: ([String]) _justOinLoop :: Bool _justOscope :: Scope _justOsourcePos :: MySourcePos _justIactualValue :: TableRef _justIidens :: ([QualifiedScope]) _justIjoinIdens :: ([String]) _justImessages :: ([Message]) _justInodeType :: Type _lhsOnodeType = _justInodeType _lhsOmessages = _justImessages _actualValue = Just _justIactualValue _lhsOactualValue = _actualValue _lhsOidens = _justIidens _lhsOjoinIdens = _justIjoinIdens _justOinLoop = _lhsIinLoop _justOscope = _lhsIscope _justOsourcePos = _lhsIsourcePos ( _justIactualValue,_justIidens,_justIjoinIdens,_justImessages,_justInodeType) = (just_ _justOinLoop _justOscope _justOsourcePos ) in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_MTableRef_Nothing :: T_MTableRef sem_MTableRef_Nothing = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOidens :: ([QualifiedScope]) _lhsOjoinIdens :: ([String]) _lhsOmessages :: ([Message]) _lhsOactualValue :: MTableRef _lhsOnodeType = TypeList [] _lhsOidens = [] _lhsOjoinIdens = [] _lhsOmessages = [] _actualValue = Nothing _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) -- MaybeExpression --------------------------------------------- type MaybeExpression = (Maybe (Expression)) -- cata sem_MaybeExpression :: MaybeExpression -> T_MaybeExpression sem_MaybeExpression (Prelude.Just x ) = (sem_MaybeExpression_Just (sem_Expression x ) ) sem_MaybeExpression Prelude.Nothing = sem_MaybeExpression_Nothing -- semantic domain type T_MaybeExpression = Bool -> Scope -> MySourcePos -> ( MaybeExpression,([Message]),Type) data Inh_MaybeExpression = Inh_MaybeExpression {inLoop_Inh_MaybeExpression :: Bool,scope_Inh_MaybeExpression :: Scope,sourcePos_Inh_MaybeExpression :: MySourcePos} data Syn_MaybeExpression = Syn_MaybeExpression {actualValue_Syn_MaybeExpression :: MaybeExpression,messages_Syn_MaybeExpression :: [Message],nodeType_Syn_MaybeExpression :: Type} wrap_MaybeExpression :: T_MaybeExpression -> Inh_MaybeExpression -> Syn_MaybeExpression wrap_MaybeExpression sem (Inh_MaybeExpression _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_MaybeExpression _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_MaybeExpression_Just :: T_Expression -> T_MaybeExpression sem_MaybeExpression_Just just_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: MaybeExpression _justOinLoop :: Bool _justOscope :: Scope _justOsourcePos :: MySourcePos _justIactualValue :: Expression _justIliftedColumnName :: String _justImessages :: ([Message]) _justInodeType :: Type _lhsOnodeType = _justInodeType _lhsOmessages = _justImessages _actualValue = Just _justIactualValue _lhsOactualValue = _actualValue _justOinLoop = _lhsIinLoop _justOscope = _lhsIscope _justOsourcePos = _lhsIsourcePos ( _justIactualValue,_justIliftedColumnName,_justImessages,_justInodeType) = (just_ _justOinLoop _justOscope _justOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_MaybeExpression_Nothing :: T_MaybeExpression sem_MaybeExpression_Nothing = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: MaybeExpression _lhsOnodeType = TypeList [] _lhsOmessages = [] _actualValue = Nothing _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Natural ----------------------------------------------------- data Natural = Natural | Unnatural deriving ( Eq,Show) -- cata sem_Natural :: Natural -> T_Natural sem_Natural (Natural ) = (sem_Natural_Natural ) sem_Natural (Unnatural ) = (sem_Natural_Unnatural ) -- semantic domain type T_Natural = Bool -> Scope -> MySourcePos -> ( Natural,([Message]),Type) data Inh_Natural = Inh_Natural {inLoop_Inh_Natural :: Bool,scope_Inh_Natural :: Scope,sourcePos_Inh_Natural :: MySourcePos} data Syn_Natural = Syn_Natural {actualValue_Syn_Natural :: Natural,messages_Syn_Natural :: [Message],nodeType_Syn_Natural :: Type} wrap_Natural :: T_Natural -> Inh_Natural -> Syn_Natural wrap_Natural sem (Inh_Natural _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Natural _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Natural_Natural :: T_Natural sem_Natural_Natural = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Natural _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Natural _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Natural_Unnatural :: T_Natural sem_Natural_Unnatural = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Natural _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Unnatural _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- OnExpr ------------------------------------------------------ type OnExpr = (Maybe (JoinExpression)) -- cata sem_OnExpr :: OnExpr -> T_OnExpr sem_OnExpr (Prelude.Just x ) = (sem_OnExpr_Just (sem_JoinExpression x ) ) sem_OnExpr Prelude.Nothing = sem_OnExpr_Nothing -- semantic domain type T_OnExpr = Bool -> Scope -> MySourcePos -> ( OnExpr,([Message]),Type) data Inh_OnExpr = Inh_OnExpr {inLoop_Inh_OnExpr :: Bool,scope_Inh_OnExpr :: Scope,sourcePos_Inh_OnExpr :: MySourcePos} data Syn_OnExpr = Syn_OnExpr {actualValue_Syn_OnExpr :: OnExpr,messages_Syn_OnExpr :: [Message],nodeType_Syn_OnExpr :: Type} wrap_OnExpr :: T_OnExpr -> Inh_OnExpr -> Syn_OnExpr wrap_OnExpr sem (Inh_OnExpr _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_OnExpr _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_OnExpr_Just :: T_JoinExpression -> T_OnExpr sem_OnExpr_Just just_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: OnExpr _justOinLoop :: Bool _justOscope :: Scope _justOsourcePos :: MySourcePos _justIactualValue :: JoinExpression _justImessages :: ([Message]) _justInodeType :: Type _lhsOmessages = _justImessages _lhsOnodeType = _justInodeType _actualValue = Just _justIactualValue _lhsOactualValue = _actualValue _justOinLoop = _lhsIinLoop _justOscope = _lhsIscope _justOsourcePos = _lhsIsourcePos ( _justIactualValue,_justImessages,_justInodeType) = (just_ _justOinLoop _justOscope _justOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_OnExpr_Nothing :: T_OnExpr sem_OnExpr_Nothing = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: OnExpr _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Nothing _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- ParamDef ---------------------------------------------------- data ParamDef = ParamDef (String) (TypeName) | ParamDefTp (TypeName) deriving ( Eq,Show) -- cata sem_ParamDef :: ParamDef -> T_ParamDef sem_ParamDef (ParamDef _name _typ ) = (sem_ParamDef_ParamDef _name (sem_TypeName _typ ) ) sem_ParamDef (ParamDefTp _typ ) = (sem_ParamDef_ParamDefTp (sem_TypeName _typ ) ) -- semantic domain type T_ParamDef = Bool -> Scope -> MySourcePos -> ( ParamDef,([Message]),Type,String) data Inh_ParamDef = Inh_ParamDef {inLoop_Inh_ParamDef :: Bool,scope_Inh_ParamDef :: Scope,sourcePos_Inh_ParamDef :: MySourcePos} data Syn_ParamDef = Syn_ParamDef {actualValue_Syn_ParamDef :: ParamDef,messages_Syn_ParamDef :: [Message],nodeType_Syn_ParamDef :: Type,paramName_Syn_ParamDef :: String} wrap_ParamDef :: T_ParamDef -> Inh_ParamDef -> Syn_ParamDef wrap_ParamDef sem (Inh_ParamDef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparamName) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ParamDef _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOparamName )) sem_ParamDef_ParamDef :: String -> T_TypeName -> T_ParamDef sem_ParamDef_ParamDef name_ typ_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOparamName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: ParamDef _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOnodeType = _typInodeType _lhsOparamName = name_ _lhsOmessages = _typImessages _actualValue = ParamDef name_ _typIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparamName))) sem_ParamDef_ParamDefTp :: T_TypeName -> T_ParamDef sem_ParamDef_ParamDefTp typ_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOparamName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: ParamDef _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOnodeType = _typInodeType _lhsOparamName = "" _lhsOmessages = _typImessages _actualValue = ParamDefTp _typIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparamName))) -- ParamDefList ------------------------------------------------ type ParamDefList = [(ParamDef)] -- cata sem_ParamDefList :: ParamDefList -> T_ParamDefList sem_ParamDefList list = (Prelude.foldr sem_ParamDefList_Cons sem_ParamDefList_Nil (Prelude.map sem_ParamDef list) ) -- semantic domain type T_ParamDefList = Bool -> Scope -> MySourcePos -> ( ParamDefList,([Message]),Type,([(String,Type)])) data Inh_ParamDefList = Inh_ParamDefList {inLoop_Inh_ParamDefList :: Bool,scope_Inh_ParamDefList :: Scope,sourcePos_Inh_ParamDefList :: MySourcePos} data Syn_ParamDefList = Syn_ParamDefList {actualValue_Syn_ParamDefList :: ParamDefList,messages_Syn_ParamDefList :: [Message],nodeType_Syn_ParamDefList :: Type,params_Syn_ParamDefList :: [(String,Type)]} wrap_ParamDefList :: T_ParamDefList -> Inh_ParamDefList -> Syn_ParamDefList wrap_ParamDefList sem (Inh_ParamDefList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparams) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_ParamDefList _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOparams )) sem_ParamDefList_Cons :: T_ParamDef -> T_ParamDefList -> T_ParamDefList sem_ParamDefList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOparams :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ParamDefList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: ParamDef _hdImessages :: ([Message]) _hdInodeType :: Type _hdIparamName :: String _tlIactualValue :: ParamDefList _tlImessages :: ([Message]) _tlInodeType :: Type _tlIparams :: ([(String,Type)]) _lhsOparams = ((_hdIparamName, _hdInodeType) : _tlIparams) _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType,_hdIparamName) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType,_tlIparams) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparams))) sem_ParamDefList_Nil :: T_ParamDefList sem_ParamDefList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOparams :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: ParamDefList _lhsOparams = [] _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOparams))) -- RaiseType --------------------------------------------------- data RaiseType = RError | RException | RNotice deriving ( Eq,Show) -- cata sem_RaiseType :: RaiseType -> T_RaiseType sem_RaiseType (RError ) = (sem_RaiseType_RError ) sem_RaiseType (RException ) = (sem_RaiseType_RException ) sem_RaiseType (RNotice ) = (sem_RaiseType_RNotice ) -- semantic domain type T_RaiseType = Bool -> Scope -> MySourcePos -> ( RaiseType,([Message]),Type) data Inh_RaiseType = Inh_RaiseType {inLoop_Inh_RaiseType :: Bool,scope_Inh_RaiseType :: Scope,sourcePos_Inh_RaiseType :: MySourcePos} data Syn_RaiseType = Syn_RaiseType {actualValue_Syn_RaiseType :: RaiseType,messages_Syn_RaiseType :: [Message],nodeType_Syn_RaiseType :: Type} wrap_RaiseType :: T_RaiseType -> Inh_RaiseType -> Syn_RaiseType wrap_RaiseType sem (Inh_RaiseType _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_RaiseType _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_RaiseType_RError :: T_RaiseType sem_RaiseType_RError = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RaiseType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RError _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RaiseType_RException :: T_RaiseType sem_RaiseType_RException = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RaiseType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RException _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RaiseType_RNotice :: T_RaiseType sem_RaiseType_RNotice = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RaiseType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RNotice _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- RestartIdentity --------------------------------------------- data RestartIdentity = ContinueIdentity | RestartIdentity deriving ( Eq,Show) -- cata sem_RestartIdentity :: RestartIdentity -> T_RestartIdentity sem_RestartIdentity (ContinueIdentity ) = (sem_RestartIdentity_ContinueIdentity ) sem_RestartIdentity (RestartIdentity ) = (sem_RestartIdentity_RestartIdentity ) -- semantic domain type T_RestartIdentity = Bool -> Scope -> MySourcePos -> ( RestartIdentity,([Message]),Type) data Inh_RestartIdentity = Inh_RestartIdentity {inLoop_Inh_RestartIdentity :: Bool,scope_Inh_RestartIdentity :: Scope,sourcePos_Inh_RestartIdentity :: MySourcePos} data Syn_RestartIdentity = Syn_RestartIdentity {actualValue_Syn_RestartIdentity :: RestartIdentity,messages_Syn_RestartIdentity :: [Message],nodeType_Syn_RestartIdentity :: Type} wrap_RestartIdentity :: T_RestartIdentity -> Inh_RestartIdentity -> Syn_RestartIdentity wrap_RestartIdentity sem (Inh_RestartIdentity _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_RestartIdentity _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_RestartIdentity_ContinueIdentity :: T_RestartIdentity sem_RestartIdentity_ContinueIdentity = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RestartIdentity _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = ContinueIdentity _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RestartIdentity_RestartIdentity :: T_RestartIdentity sem_RestartIdentity_RestartIdentity = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RestartIdentity _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RestartIdentity _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Root -------------------------------------------------------- data Root = Root (StatementList) deriving ( Show) -- cata sem_Root :: Root -> T_Root sem_Root (Root _statements ) = (sem_Root_Root (sem_StatementList _statements ) ) -- semantic domain type T_Root = Scope -> ( Root,([Message]),Type,([StatementInfo])) data Inh_Root = Inh_Root {scope_Inh_Root :: Scope} data Syn_Root = Syn_Root {actualValue_Syn_Root :: Root,messages_Syn_Root :: [Message],nodeType_Syn_Root :: Type,statementInfo_Syn_Root :: [StatementInfo]} wrap_Root :: T_Root -> Inh_Root -> Syn_Root wrap_Root sem (Inh_Root _lhsIscope ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo) = (sem _lhsIscope ) in (Syn_Root _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOstatementInfo )) sem_Root_Root :: T_StatementList -> T_Root sem_Root_Root statements_ = (\ _lhsIscope -> (let _statementsOsourcePos :: MySourcePos _statementsOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Root _lhsOstatementInfo :: ([StatementInfo]) _statementsOscope :: Scope _statementsIactualValue :: StatementList _statementsImessages :: ([Message]) _statementsInodeType :: Type _statementsIstatementInfo :: ([StatementInfo]) _statementsOsourcePos = ("",0,0) _statementsOinLoop = False _lhsOmessages = _statementsImessages _lhsOnodeType = _statementsInodeType _actualValue = Root _statementsIactualValue _lhsOactualValue = _actualValue _lhsOstatementInfo = _statementsIstatementInfo _statementsOscope = _lhsIscope ( _statementsIactualValue,_statementsImessages,_statementsInodeType,_statementsIstatementInfo) = (statements_ _statementsOinLoop _statementsOscope _statementsOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) -- RowConstraint ----------------------------------------------- data RowConstraint = NotNullConstraint | NullConstraint | RowCheckConstraint (Expression) | RowPrimaryKeyConstraint | RowReferenceConstraint (String) (Maybe String) (Cascade) (Cascade) | RowUniqueConstraint deriving ( Eq,Show) -- cata sem_RowConstraint :: RowConstraint -> T_RowConstraint sem_RowConstraint (NotNullConstraint ) = (sem_RowConstraint_NotNullConstraint ) sem_RowConstraint (NullConstraint ) = (sem_RowConstraint_NullConstraint ) sem_RowConstraint (RowCheckConstraint _expression ) = (sem_RowConstraint_RowCheckConstraint (sem_Expression _expression ) ) sem_RowConstraint (RowPrimaryKeyConstraint ) = (sem_RowConstraint_RowPrimaryKeyConstraint ) sem_RowConstraint (RowReferenceConstraint _table _att _onUpdate _onDelete ) = (sem_RowConstraint_RowReferenceConstraint _table _att (sem_Cascade _onUpdate ) (sem_Cascade _onDelete ) ) sem_RowConstraint (RowUniqueConstraint ) = (sem_RowConstraint_RowUniqueConstraint ) -- semantic domain type T_RowConstraint = Bool -> Scope -> MySourcePos -> ( RowConstraint,([Message]),Type) data Inh_RowConstraint = Inh_RowConstraint {inLoop_Inh_RowConstraint :: Bool,scope_Inh_RowConstraint :: Scope,sourcePos_Inh_RowConstraint :: MySourcePos} data Syn_RowConstraint = Syn_RowConstraint {actualValue_Syn_RowConstraint :: RowConstraint,messages_Syn_RowConstraint :: [Message],nodeType_Syn_RowConstraint :: Type} wrap_RowConstraint :: T_RowConstraint -> Inh_RowConstraint -> Syn_RowConstraint wrap_RowConstraint sem (Inh_RowConstraint _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_RowConstraint _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_RowConstraint_NotNullConstraint :: T_RowConstraint sem_RowConstraint_NotNullConstraint = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = NotNullConstraint _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraint_NullConstraint :: T_RowConstraint sem_RowConstraint_NullConstraint = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = NullConstraint _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraint_RowCheckConstraint :: T_Expression -> T_RowConstraint sem_RowConstraint_RowCheckConstraint expression_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _expressionOinLoop :: Bool _expressionOscope :: Scope _expressionOsourcePos :: MySourcePos _expressionIactualValue :: Expression _expressionIliftedColumnName :: String _expressionImessages :: ([Message]) _expressionInodeType :: Type _lhsOmessages = _expressionImessages _lhsOnodeType = _expressionInodeType _actualValue = RowCheckConstraint _expressionIactualValue _lhsOactualValue = _actualValue _expressionOinLoop = _lhsIinLoop _expressionOscope = _lhsIscope _expressionOsourcePos = _lhsIsourcePos ( _expressionIactualValue,_expressionIliftedColumnName,_expressionImessages,_expressionInodeType) = (expression_ _expressionOinLoop _expressionOscope _expressionOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraint_RowPrimaryKeyConstraint :: T_RowConstraint sem_RowConstraint_RowPrimaryKeyConstraint = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RowPrimaryKeyConstraint _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraint_RowReferenceConstraint :: String -> (Maybe String) -> T_Cascade -> T_Cascade -> T_RowConstraint sem_RowConstraint_RowReferenceConstraint table_ att_ onUpdate_ onDelete_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _onUpdateOinLoop :: Bool _onUpdateOscope :: Scope _onUpdateOsourcePos :: MySourcePos _onDeleteOinLoop :: Bool _onDeleteOscope :: Scope _onDeleteOsourcePos :: MySourcePos _onUpdateIactualValue :: Cascade _onUpdateImessages :: ([Message]) _onUpdateInodeType :: Type _onDeleteIactualValue :: Cascade _onDeleteImessages :: ([Message]) _onDeleteInodeType :: Type _lhsOmessages = _onUpdateImessages ++ _onDeleteImessages _lhsOnodeType = _onUpdateInodeType `setUnknown` _onDeleteInodeType _actualValue = RowReferenceConstraint table_ att_ _onUpdateIactualValue _onDeleteIactualValue _lhsOactualValue = _actualValue _onUpdateOinLoop = _lhsIinLoop _onUpdateOscope = _lhsIscope _onUpdateOsourcePos = _lhsIsourcePos _onDeleteOinLoop = _lhsIinLoop _onDeleteOscope = _lhsIscope _onDeleteOsourcePos = _lhsIsourcePos ( _onUpdateIactualValue,_onUpdateImessages,_onUpdateInodeType) = (onUpdate_ _onUpdateOinLoop _onUpdateOscope _onUpdateOsourcePos ) ( _onDeleteIactualValue,_onDeleteImessages,_onDeleteInodeType) = (onDelete_ _onDeleteOinLoop _onDeleteOscope _onDeleteOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraint_RowUniqueConstraint :: T_RowConstraint sem_RowConstraint_RowUniqueConstraint = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraint _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = RowUniqueConstraint _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- RowConstraintList ------------------------------------------- type RowConstraintList = [(RowConstraint)] -- cata sem_RowConstraintList :: RowConstraintList -> T_RowConstraintList sem_RowConstraintList list = (Prelude.foldr sem_RowConstraintList_Cons sem_RowConstraintList_Nil (Prelude.map sem_RowConstraint list) ) -- semantic domain type T_RowConstraintList = Bool -> Scope -> MySourcePos -> ( RowConstraintList,([Message]),Type) data Inh_RowConstraintList = Inh_RowConstraintList {inLoop_Inh_RowConstraintList :: Bool,scope_Inh_RowConstraintList :: Scope,sourcePos_Inh_RowConstraintList :: MySourcePos} data Syn_RowConstraintList = Syn_RowConstraintList {actualValue_Syn_RowConstraintList :: RowConstraintList,messages_Syn_RowConstraintList :: [Message],nodeType_Syn_RowConstraintList :: Type} wrap_RowConstraintList :: T_RowConstraintList -> Inh_RowConstraintList -> Syn_RowConstraintList wrap_RowConstraintList sem (Inh_RowConstraintList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_RowConstraintList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_RowConstraintList_Cons :: T_RowConstraint -> T_RowConstraintList -> T_RowConstraintList sem_RowConstraintList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraintList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: RowConstraint _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: RowConstraintList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_RowConstraintList_Nil :: T_RowConstraintList sem_RowConstraintList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: RowConstraintList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- SelectExpression -------------------------------------------- data SelectExpression = CombineSelect (CombineType) (SelectExpression) (SelectExpression) | Select (Distinct) (SelectList) (MTableRef) (Where) (ExpressionList) (Maybe Expression) (ExpressionList) (Direction) (Maybe Expression) (Maybe Expression) | Values (ExpressionListList) deriving ( Eq,Show) -- cata sem_SelectExpression :: SelectExpression -> T_SelectExpression sem_SelectExpression (CombineSelect _ctype _sel1 _sel2 ) = (sem_SelectExpression_CombineSelect (sem_CombineType _ctype ) (sem_SelectExpression _sel1 ) (sem_SelectExpression _sel2 ) ) sem_SelectExpression (Select _selDistinct _selSelectList _selTref _selWhere _selGroupBy _selHaving _selOrderBy _selDir _selLimit _selOffset ) = (sem_SelectExpression_Select (sem_Distinct _selDistinct ) (sem_SelectList _selSelectList ) (sem_MTableRef _selTref ) (sem_Where _selWhere ) (sem_ExpressionList _selGroupBy ) _selHaving (sem_ExpressionList _selOrderBy ) (sem_Direction _selDir ) _selLimit _selOffset ) sem_SelectExpression (Values _vll ) = (sem_SelectExpression_Values (sem_ExpressionListList _vll ) ) -- semantic domain type T_SelectExpression = Bool -> Scope -> MySourcePos -> ( SelectExpression,([Message]),Type) data Inh_SelectExpression = Inh_SelectExpression {inLoop_Inh_SelectExpression :: Bool,scope_Inh_SelectExpression :: Scope,sourcePos_Inh_SelectExpression :: MySourcePos} data Syn_SelectExpression = Syn_SelectExpression {actualValue_Syn_SelectExpression :: SelectExpression,messages_Syn_SelectExpression :: [Message],nodeType_Syn_SelectExpression :: Type} wrap_SelectExpression :: T_SelectExpression -> Inh_SelectExpression -> Syn_SelectExpression wrap_SelectExpression sem (Inh_SelectExpression _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SelectExpression _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_SelectExpression_CombineSelect :: T_CombineType -> T_SelectExpression -> T_SelectExpression -> T_SelectExpression sem_SelectExpression_CombineSelect ctype_ sel1_ sel2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectExpression _ctypeOinLoop :: Bool _ctypeOscope :: Scope _ctypeOsourcePos :: MySourcePos _sel1OinLoop :: Bool _sel1Oscope :: Scope _sel1OsourcePos :: MySourcePos _sel2OinLoop :: Bool _sel2Oscope :: Scope _sel2OsourcePos :: MySourcePos _ctypeIactualValue :: CombineType _ctypeImessages :: ([Message]) _ctypeInodeType :: Type _sel1IactualValue :: SelectExpression _sel1Imessages :: ([Message]) _sel1InodeType :: Type _sel2IactualValue :: SelectExpression _sel2Imessages :: ([Message]) _sel2InodeType :: Type _lhsOnodeType = checkErrors [_sel1InodeType,_sel2InodeType] $ typeCheckCombineSelect _lhsIscope _lhsIsourcePos _sel1InodeType _sel2InodeType _lhsOmessages = _ctypeImessages ++ _sel1Imessages ++ _sel2Imessages _actualValue = CombineSelect _ctypeIactualValue _sel1IactualValue _sel2IactualValue _lhsOactualValue = _actualValue _ctypeOinLoop = _lhsIinLoop _ctypeOscope = _lhsIscope _ctypeOsourcePos = _lhsIsourcePos _sel1OinLoop = _lhsIinLoop _sel1Oscope = _lhsIscope _sel1OsourcePos = _lhsIsourcePos _sel2OinLoop = _lhsIinLoop _sel2Oscope = _lhsIscope _sel2OsourcePos = _lhsIsourcePos ( _ctypeIactualValue,_ctypeImessages,_ctypeInodeType) = (ctype_ _ctypeOinLoop _ctypeOscope _ctypeOsourcePos ) ( _sel1IactualValue,_sel1Imessages,_sel1InodeType) = (sel1_ _sel1OinLoop _sel1Oscope _sel1OsourcePos ) ( _sel2IactualValue,_sel2Imessages,_sel2InodeType) = (sel2_ _sel2OinLoop _sel2Oscope _sel2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_SelectExpression_Select :: T_Distinct -> T_SelectList -> T_MTableRef -> T_Where -> T_ExpressionList -> (Maybe Expression) -> T_ExpressionList -> T_Direction -> (Maybe Expression) -> (Maybe Expression) -> T_SelectExpression sem_SelectExpression_Select selDistinct_ selSelectList_ selTref_ selWhere_ selGroupBy_ selHaving_ selOrderBy_ selDir_ selLimit_ selOffset_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _selSelectListOscope :: Scope _selWhereOscope :: Scope _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectExpression _selDistinctOinLoop :: Bool _selDistinctOscope :: Scope _selDistinctOsourcePos :: MySourcePos _selSelectListOinLoop :: Bool _selSelectListOsourcePos :: MySourcePos _selTrefOinLoop :: Bool _selTrefOscope :: Scope _selTrefOsourcePos :: MySourcePos _selWhereOinLoop :: Bool _selWhereOsourcePos :: MySourcePos _selGroupByOinLoop :: Bool _selGroupByOscope :: Scope _selGroupByOsourcePos :: MySourcePos _selOrderByOinLoop :: Bool _selOrderByOscope :: Scope _selOrderByOsourcePos :: MySourcePos _selDirOinLoop :: Bool _selDirOscope :: Scope _selDirOsourcePos :: MySourcePos _selDistinctIactualValue :: Distinct _selDistinctImessages :: ([Message]) _selDistinctInodeType :: Type _selSelectListIactualValue :: SelectList _selSelectListImessages :: ([Message]) _selSelectListInodeType :: Type _selTrefIactualValue :: MTableRef _selTrefIidens :: ([QualifiedScope]) _selTrefIjoinIdens :: ([String]) _selTrefImessages :: ([Message]) _selTrefInodeType :: Type _selWhereIactualValue :: Where _selWhereImessages :: ([Message]) _selWhereInodeType :: Type _selGroupByIactualValue :: ExpressionList _selGroupByImessages :: ([Message]) _selGroupByInodeType :: Type _selOrderByIactualValue :: ExpressionList _selOrderByImessages :: ([Message]) _selOrderByInodeType :: Type _selDirIactualValue :: Direction _selDirImessages :: ([Message]) _selDirInodeType :: Type _lhsOnodeType = checkErrors [_selTrefInodeType ,_selSelectListInodeType ,_selWhereInodeType] (let t = _selSelectListInodeType in case t of UnnamedCompositeType [(_,Pseudo Void)] -> Pseudo Void _ -> SetOfType _selSelectListInodeType) _selSelectListOscope = scopeReplaceIds _lhsIscope _selTrefIidens _selTrefIjoinIdens _selWhereOscope = scopeReplaceIds _lhsIscope _selTrefIidens _selTrefIjoinIdens _lhsOmessages = _selDistinctImessages ++ _selSelectListImessages ++ _selTrefImessages ++ _selWhereImessages ++ _selGroupByImessages ++ _selOrderByImessages ++ _selDirImessages _actualValue = Select _selDistinctIactualValue _selSelectListIactualValue _selTrefIactualValue _selWhereIactualValue _selGroupByIactualValue selHaving_ _selOrderByIactualValue _selDirIactualValue selLimit_ selOffset_ _lhsOactualValue = _actualValue _selDistinctOinLoop = _lhsIinLoop _selDistinctOscope = _lhsIscope _selDistinctOsourcePos = _lhsIsourcePos _selSelectListOinLoop = _lhsIinLoop _selSelectListOsourcePos = _lhsIsourcePos _selTrefOinLoop = _lhsIinLoop _selTrefOscope = _lhsIscope _selTrefOsourcePos = _lhsIsourcePos _selWhereOinLoop = _lhsIinLoop _selWhereOsourcePos = _lhsIsourcePos _selGroupByOinLoop = _lhsIinLoop _selGroupByOscope = _lhsIscope _selGroupByOsourcePos = _lhsIsourcePos _selOrderByOinLoop = _lhsIinLoop _selOrderByOscope = _lhsIscope _selOrderByOsourcePos = _lhsIsourcePos _selDirOinLoop = _lhsIinLoop _selDirOscope = _lhsIscope _selDirOsourcePos = _lhsIsourcePos ( _selDistinctIactualValue,_selDistinctImessages,_selDistinctInodeType) = (selDistinct_ _selDistinctOinLoop _selDistinctOscope _selDistinctOsourcePos ) ( _selSelectListIactualValue,_selSelectListImessages,_selSelectListInodeType) = (selSelectList_ _selSelectListOinLoop _selSelectListOscope _selSelectListOsourcePos ) ( _selTrefIactualValue,_selTrefIidens,_selTrefIjoinIdens,_selTrefImessages,_selTrefInodeType) = (selTref_ _selTrefOinLoop _selTrefOscope _selTrefOsourcePos ) ( _selWhereIactualValue,_selWhereImessages,_selWhereInodeType) = (selWhere_ _selWhereOinLoop _selWhereOscope _selWhereOsourcePos ) ( _selGroupByIactualValue,_selGroupByImessages,_selGroupByInodeType) = (selGroupBy_ _selGroupByOinLoop _selGroupByOscope _selGroupByOsourcePos ) ( _selOrderByIactualValue,_selOrderByImessages,_selOrderByInodeType) = (selOrderBy_ _selOrderByOinLoop _selOrderByOscope _selOrderByOsourcePos ) ( _selDirIactualValue,_selDirImessages,_selDirInodeType) = (selDir_ _selDirOinLoop _selDirOscope _selDirOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_SelectExpression_Values :: T_ExpressionListList -> T_SelectExpression sem_SelectExpression_Values vll_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectExpression _vllOinLoop :: Bool _vllOscope :: Scope _vllOsourcePos :: MySourcePos _vllIactualValue :: ExpressionListList _vllImessages :: ([Message]) _vllInodeType :: Type _lhsOnodeType = checkErrors [_vllInodeType] $ typeCheckValuesExpr _lhsIscope _lhsIsourcePos _vllInodeType _lhsOmessages = _vllImessages _actualValue = Values _vllIactualValue _lhsOactualValue = _actualValue _vllOinLoop = _lhsIinLoop _vllOscope = _lhsIscope _vllOsourcePos = _lhsIsourcePos ( _vllIactualValue,_vllImessages,_vllInodeType) = (vll_ _vllOinLoop _vllOscope _vllOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- SelectItem -------------------------------------------------- data SelectItem = SelExp (Expression) | SelectItem (Expression) (String) deriving ( Eq,Show) -- cata sem_SelectItem :: SelectItem -> T_SelectItem sem_SelectItem (SelExp _ex ) = (sem_SelectItem_SelExp (sem_Expression _ex ) ) sem_SelectItem (SelectItem _ex _name ) = (sem_SelectItem_SelectItem (sem_Expression _ex ) _name ) -- semantic domain type T_SelectItem = Bool -> Scope -> MySourcePos -> ( SelectItem,String,([Message]),Type) data Inh_SelectItem = Inh_SelectItem {inLoop_Inh_SelectItem :: Bool,scope_Inh_SelectItem :: Scope,sourcePos_Inh_SelectItem :: MySourcePos} data Syn_SelectItem = Syn_SelectItem {actualValue_Syn_SelectItem :: SelectItem,columnName_Syn_SelectItem :: String,messages_Syn_SelectItem :: [Message],nodeType_Syn_SelectItem :: Type} wrap_SelectItem :: T_SelectItem -> Inh_SelectItem -> Syn_SelectItem wrap_SelectItem sem (Inh_SelectItem _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOcolumnName,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SelectItem _lhsOactualValue _lhsOcolumnName _lhsOmessages _lhsOnodeType )) sem_SelectItem_SelExp :: T_Expression -> T_SelectItem sem_SelectItem_SelExp ex_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOcolumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectItem _exOinLoop :: Bool _exOscope :: Scope _exOsourcePos :: MySourcePos _exIactualValue :: Expression _exIliftedColumnName :: String _exImessages :: ([Message]) _exInodeType :: Type _lhsOnodeType = _exInodeType _lhsOcolumnName = case _exIliftedColumnName of "" -> "?column?" s -> s _lhsOmessages = _exImessages _actualValue = SelExp _exIactualValue _lhsOactualValue = _actualValue _exOinLoop = _lhsIinLoop _exOscope = _lhsIscope _exOsourcePos = _lhsIsourcePos ( _exIactualValue,_exIliftedColumnName,_exImessages,_exInodeType) = (ex_ _exOinLoop _exOscope _exOsourcePos ) in ( _lhsOactualValue,_lhsOcolumnName,_lhsOmessages,_lhsOnodeType))) sem_SelectItem_SelectItem :: T_Expression -> String -> T_SelectItem sem_SelectItem_SelectItem ex_ name_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOcolumnName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectItem _exOinLoop :: Bool _exOscope :: Scope _exOsourcePos :: MySourcePos _exIactualValue :: Expression _exIliftedColumnName :: String _exImessages :: ([Message]) _exInodeType :: Type _lhsOnodeType = _exInodeType _lhsOcolumnName = name_ _lhsOmessages = _exImessages _actualValue = SelectItem _exIactualValue name_ _lhsOactualValue = _actualValue _exOinLoop = _lhsIinLoop _exOscope = _lhsIscope _exOsourcePos = _lhsIsourcePos ( _exIactualValue,_exIliftedColumnName,_exImessages,_exInodeType) = (ex_ _exOinLoop _exOscope _exOsourcePos ) in ( _lhsOactualValue,_lhsOcolumnName,_lhsOmessages,_lhsOnodeType))) -- SelectItemList ---------------------------------------------- type SelectItemList = [(SelectItem)] -- cata sem_SelectItemList :: SelectItemList -> T_SelectItemList sem_SelectItemList list = (Prelude.foldr sem_SelectItemList_Cons sem_SelectItemList_Nil (Prelude.map sem_SelectItem list) ) -- semantic domain type T_SelectItemList = Bool -> Scope -> MySourcePos -> ( SelectItemList,([Message]),Type) data Inh_SelectItemList = Inh_SelectItemList {inLoop_Inh_SelectItemList :: Bool,scope_Inh_SelectItemList :: Scope,sourcePos_Inh_SelectItemList :: MySourcePos} data Syn_SelectItemList = Syn_SelectItemList {actualValue_Syn_SelectItemList :: SelectItemList,messages_Syn_SelectItemList :: [Message],nodeType_Syn_SelectItemList :: Type} wrap_SelectItemList :: T_SelectItemList -> Inh_SelectItemList -> Syn_SelectItemList wrap_SelectItemList sem (Inh_SelectItemList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SelectItemList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_SelectItemList_Cons :: T_SelectItem -> T_SelectItemList -> T_SelectItemList sem_SelectItemList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectItemList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: SelectItem _hdIcolumnName :: String _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: SelectItemList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOnodeType = foldr consComposite _tlInodeType (let (correlationName,iden) = splitIdentifier _hdIcolumnName in if iden == "*" then scopeExpandStar _lhsIscope _lhsIsourcePos correlationName else [(iden, _hdInodeType)]) _lhsOmessages = _hdImessages ++ _tlImessages _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdIcolumnName,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_SelectItemList_Nil :: T_SelectItemList sem_SelectItemList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectItemList _lhsOnodeType = UnnamedCompositeType [] _lhsOmessages = [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- SelectList -------------------------------------------------- data SelectList = SelectList (SelectItemList) (StringList) deriving ( Eq,Show) -- cata sem_SelectList :: SelectList -> T_SelectList sem_SelectList (SelectList _items _stringList ) = (sem_SelectList_SelectList (sem_SelectItemList _items ) (sem_StringList _stringList ) ) -- semantic domain type T_SelectList = Bool -> Scope -> MySourcePos -> ( SelectList,([Message]),Type) data Inh_SelectList = Inh_SelectList {inLoop_Inh_SelectList :: Bool,scope_Inh_SelectList :: Scope,sourcePos_Inh_SelectList :: MySourcePos} data Syn_SelectList = Syn_SelectList {actualValue_Syn_SelectList :: SelectList,messages_Syn_SelectList :: [Message],nodeType_Syn_SelectList :: Type} wrap_SelectList :: T_SelectList -> Inh_SelectList -> Syn_SelectList wrap_SelectList sem (Inh_SelectList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SelectList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_SelectList_SelectList :: T_SelectItemList -> T_StringList -> T_SelectList sem_SelectList_SelectList items_ stringList_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: SelectList _itemsOinLoop :: Bool _itemsOscope :: Scope _itemsOsourcePos :: MySourcePos _stringListOinLoop :: Bool _stringListOscope :: Scope _stringListOsourcePos :: MySourcePos _itemsIactualValue :: SelectItemList _itemsImessages :: ([Message]) _itemsInodeType :: Type _stringListIactualValue :: StringList _stringListImessages :: ([Message]) _stringListInodeType :: Type _stringListIstrings :: ([String]) _lhsOnodeType = _itemsInodeType _lhsOmessages = _itemsImessages ++ _stringListImessages _actualValue = SelectList _itemsIactualValue _stringListIactualValue _lhsOactualValue = _actualValue _itemsOinLoop = _lhsIinLoop _itemsOscope = _lhsIscope _itemsOsourcePos = _lhsIsourcePos _stringListOinLoop = _lhsIinLoop _stringListOscope = _lhsIscope _stringListOsourcePos = _lhsIsourcePos ( _itemsIactualValue,_itemsImessages,_itemsInodeType) = (items_ _itemsOinLoop _itemsOscope _itemsOsourcePos ) ( _stringListIactualValue,_stringListImessages,_stringListInodeType,_stringListIstrings) = (stringList_ _stringListOinLoop _stringListOscope _stringListOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- SetClause --------------------------------------------------- data SetClause = RowSetClause (StringList) (ExpressionList) | SetClause (String) (Expression) deriving ( Eq,Show) -- cata sem_SetClause :: SetClause -> T_SetClause sem_SetClause (RowSetClause _atts _vals ) = (sem_SetClause_RowSetClause (sem_StringList _atts ) (sem_ExpressionList _vals ) ) sem_SetClause (SetClause _att _val ) = (sem_SetClause_SetClause _att (sem_Expression _val ) ) -- semantic domain type T_SetClause = Bool -> Scope -> MySourcePos -> ( SetClause,([Message]),Type,([(String,Type)])) data Inh_SetClause = Inh_SetClause {inLoop_Inh_SetClause :: Bool,scope_Inh_SetClause :: Scope,sourcePos_Inh_SetClause :: MySourcePos} data Syn_SetClause = Syn_SetClause {actualValue_Syn_SetClause :: SetClause,messages_Syn_SetClause :: [Message],nodeType_Syn_SetClause :: Type,pairs_Syn_SetClause :: [(String,Type)]} wrap_SetClause :: T_SetClause -> Inh_SetClause -> Syn_SetClause wrap_SetClause sem (Inh_SetClause _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SetClause _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOpairs )) sem_SetClause_RowSetClause :: T_StringList -> T_ExpressionList -> T_SetClause sem_SetClause_RowSetClause atts_ vals_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOpairs :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOactualValue :: SetClause _attsOinLoop :: Bool _attsOscope :: Scope _attsOsourcePos :: MySourcePos _valsOinLoop :: Bool _valsOscope :: Scope _valsOsourcePos :: MySourcePos _attsIactualValue :: StringList _attsImessages :: ([Message]) _attsInodeType :: Type _attsIstrings :: ([String]) _valsIactualValue :: ExpressionList _valsImessages :: ([Message]) _valsInodeType :: Type _lhsOnodeType = let atts = _attsIstrings types = getRowTypes _valsInodeType lengthError = if length atts /= length types then TypeError _lhsIsourcePos WrongNumberOfColumns else TypeList [] in checkErrors [lengthError] $ TypeList [] _lhsOpairs = zip _attsIstrings $ getRowTypes _valsInodeType _lhsOmessages = _attsImessages ++ _valsImessages _actualValue = RowSetClause _attsIactualValue _valsIactualValue _lhsOactualValue = _actualValue _attsOinLoop = _lhsIinLoop _attsOscope = _lhsIscope _attsOsourcePos = _lhsIsourcePos _valsOinLoop = _lhsIinLoop _valsOscope = _lhsIscope _valsOsourcePos = _lhsIsourcePos ( _attsIactualValue,_attsImessages,_attsInodeType,_attsIstrings) = (atts_ _attsOinLoop _attsOscope _attsOsourcePos ) ( _valsIactualValue,_valsImessages,_valsInodeType) = (vals_ _valsOinLoop _valsOscope _valsOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs))) sem_SetClause_SetClause :: String -> T_Expression -> T_SetClause sem_SetClause_SetClause att_ val_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOpairs :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOactualValue :: SetClause _valOinLoop :: Bool _valOscope :: Scope _valOsourcePos :: MySourcePos _valIactualValue :: Expression _valIliftedColumnName :: String _valImessages :: ([Message]) _valInodeType :: Type _lhsOnodeType = checkErrors [_valInodeType] $ TypeList [] _lhsOpairs = [(att_, _valInodeType)] _lhsOmessages = _valImessages _actualValue = SetClause att_ _valIactualValue _lhsOactualValue = _actualValue _valOinLoop = _lhsIinLoop _valOscope = _lhsIscope _valOsourcePos = _lhsIsourcePos ( _valIactualValue,_valIliftedColumnName,_valImessages,_valInodeType) = (val_ _valOinLoop _valOscope _valOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs))) -- SetClauseList ----------------------------------------------- type SetClauseList = [(SetClause)] -- cata sem_SetClauseList :: SetClauseList -> T_SetClauseList sem_SetClauseList list = (Prelude.foldr sem_SetClauseList_Cons sem_SetClauseList_Nil (Prelude.map sem_SetClause list) ) -- semantic domain type T_SetClauseList = Bool -> Scope -> MySourcePos -> ( SetClauseList,([Message]),Type,([(String,Type)])) data Inh_SetClauseList = Inh_SetClauseList {inLoop_Inh_SetClauseList :: Bool,scope_Inh_SetClauseList :: Scope,sourcePos_Inh_SetClauseList :: MySourcePos} data Syn_SetClauseList = Syn_SetClauseList {actualValue_Syn_SetClauseList :: SetClauseList,messages_Syn_SetClauseList :: [Message],nodeType_Syn_SetClauseList :: Type,pairs_Syn_SetClauseList :: [(String,Type)]} wrap_SetClauseList :: T_SetClauseList -> Inh_SetClauseList -> Syn_SetClauseList wrap_SetClauseList sem (Inh_SetClauseList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SetClauseList _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOpairs )) sem_SetClauseList_Cons :: T_SetClause -> T_SetClauseList -> T_SetClauseList sem_SetClauseList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOpairs :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: SetClauseList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: SetClause _hdImessages :: ([Message]) _hdInodeType :: Type _hdIpairs :: ([(String,Type)]) _tlIactualValue :: SetClauseList _tlImessages :: ([Message]) _tlInodeType :: Type _tlIpairs :: ([(String,Type)]) _lhsOpairs = _hdIpairs ++ _tlIpairs _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType,_hdIpairs) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType,_tlIpairs) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs))) sem_SetClauseList_Nil :: T_SetClauseList sem_SetClauseList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOpairs :: ([(String,Type)]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: SetClauseList _lhsOpairs = [] _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOpairs))) -- SourcePosStatement ------------------------------------------ type SourcePosStatement = ( (MySourcePos),(Statement)) -- cata sem_SourcePosStatement :: SourcePosStatement -> T_SourcePosStatement sem_SourcePosStatement ( x1,x2) = (sem_SourcePosStatement_Tuple x1 (sem_Statement x2 ) ) -- semantic domain type T_SourcePosStatement = Bool -> Scope -> MySourcePos -> ( SourcePosStatement,([Message]),Type,StatementInfo) data Inh_SourcePosStatement = Inh_SourcePosStatement {inLoop_Inh_SourcePosStatement :: Bool,scope_Inh_SourcePosStatement :: Scope,sourcePos_Inh_SourcePosStatement :: MySourcePos} data Syn_SourcePosStatement = Syn_SourcePosStatement {actualValue_Syn_SourcePosStatement :: SourcePosStatement,messages_Syn_SourcePosStatement :: [Message],nodeType_Syn_SourcePosStatement :: Type,statementInfo_Syn_SourcePosStatement :: StatementInfo} wrap_SourcePosStatement :: T_SourcePosStatement -> Inh_SourcePosStatement -> Syn_SourcePosStatement wrap_SourcePosStatement sem (Inh_SourcePosStatement _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_SourcePosStatement _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOstatementInfo )) sem_SourcePosStatement_Tuple :: MySourcePos -> T_Statement -> T_SourcePosStatement sem_SourcePosStatement_Tuple x1_ x2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _x2ObackType :: Type _x2OsourcePos :: MySourcePos _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: SourcePosStatement _lhsOstatementInfo :: StatementInfo _x2OinLoop :: Bool _x2Oscope :: Scope _x2IactualValue :: Statement _x2IbackType :: Type _x2Imessages :: ([Message]) _x2InodeType :: Type _x2IstatementInfo :: StatementInfo _x2ObackType = _x2InodeType _x2OsourcePos = x1_ _lhsOmessages = _x2Imessages _lhsOnodeType = _x2InodeType _actualValue = (x1_,_x2IactualValue) _lhsOactualValue = _actualValue _lhsOstatementInfo = _x2IstatementInfo _x2OinLoop = _lhsIinLoop _x2Oscope = _lhsIscope ( _x2IactualValue,_x2IbackType,_x2Imessages,_x2InodeType,_x2IstatementInfo) = (x2_ _x2ObackType _x2OinLoop _x2Oscope _x2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) -- Statement --------------------------------------------------- data Statement = Assignment (String) (Expression) | CaseStatement (Expression) (ExpressionListStatementListPairList) (StatementList) | ContinueStatement | Copy (String) (StringList) (CopySource) | CopyData (String) | CreateDomain (String) (TypeName) (Maybe Expression) | CreateFunction (Language) (String) (ParamDefList) (TypeName) (String) (FnBody) (Volatility) | CreateTable (String) (AttributeDefList) (ConstraintList) | CreateTableAs (String) (SelectExpression) | CreateType (String) (TypeAttributeDefList) | CreateView (String) (SelectExpression) | Delete (String) (Where) (Maybe SelectList) | DropFunction (IfExists) (StringStringListPairList) (Cascade) | DropSomething (DropType) (IfExists) (StringList) (Cascade) | Execute (Expression) | ExecuteInto (Expression) (StringList) | ForIntegerStatement (String) (Expression) (Expression) (StatementList) | ForSelectStatement (String) (SelectExpression) (StatementList) | If (ExpressionStatementListPairList) (StatementList) | Insert (String) (StringList) (SelectExpression) (Maybe SelectList) | NullStatement | Perform (Expression) | Raise (RaiseType) (String) (ExpressionList) | Return (Maybe Expression) | ReturnNext (Expression) | ReturnQuery (SelectExpression) | SelectStatement (SelectExpression) | Truncate (StringList) (RestartIdentity) (Cascade) | Update (String) (SetClauseList) (Where) (Maybe SelectList) | WhileStatement (Expression) (StatementList) deriving ( Eq,Show) -- cata sem_Statement :: Statement -> T_Statement sem_Statement (Assignment _target _value ) = (sem_Statement_Assignment _target (sem_Expression _value ) ) sem_Statement (CaseStatement _val _cases _els ) = (sem_Statement_CaseStatement (sem_Expression _val ) (sem_ExpressionListStatementListPairList _cases ) (sem_StatementList _els ) ) sem_Statement (ContinueStatement ) = (sem_Statement_ContinueStatement ) sem_Statement (Copy _table _targetCols _source ) = (sem_Statement_Copy _table (sem_StringList _targetCols ) (sem_CopySource _source ) ) sem_Statement (CopyData _insData ) = (sem_Statement_CopyData _insData ) sem_Statement (CreateDomain _name _typ _check ) = (sem_Statement_CreateDomain _name (sem_TypeName _typ ) _check ) sem_Statement (CreateFunction _lang _name _params _rettype _bodyQuote _body _vol ) = (sem_Statement_CreateFunction (sem_Language _lang ) _name (sem_ParamDefList _params ) (sem_TypeName _rettype ) _bodyQuote (sem_FnBody _body ) (sem_Volatility _vol ) ) sem_Statement (CreateTable _name _atts _cons ) = (sem_Statement_CreateTable _name (sem_AttributeDefList _atts ) (sem_ConstraintList _cons ) ) sem_Statement (CreateTableAs _name _expr ) = (sem_Statement_CreateTableAs _name (sem_SelectExpression _expr ) ) sem_Statement (CreateType _name _atts ) = (sem_Statement_CreateType _name (sem_TypeAttributeDefList _atts ) ) sem_Statement (CreateView _name _expr ) = (sem_Statement_CreateView _name (sem_SelectExpression _expr ) ) sem_Statement (Delete _table _whr _returning ) = (sem_Statement_Delete _table (sem_Where _whr ) _returning ) sem_Statement (DropFunction _ifE _sigs _cascade ) = (sem_Statement_DropFunction (sem_IfExists _ifE ) (sem_StringStringListPairList _sigs ) (sem_Cascade _cascade ) ) sem_Statement (DropSomething _dropType _ifE _names _cascade ) = (sem_Statement_DropSomething (sem_DropType _dropType ) (sem_IfExists _ifE ) (sem_StringList _names ) (sem_Cascade _cascade ) ) sem_Statement (Execute _expr ) = (sem_Statement_Execute (sem_Expression _expr ) ) sem_Statement (ExecuteInto _expr _targets ) = (sem_Statement_ExecuteInto (sem_Expression _expr ) (sem_StringList _targets ) ) sem_Statement (ForIntegerStatement _var _from _to _sts ) = (sem_Statement_ForIntegerStatement _var (sem_Expression _from ) (sem_Expression _to ) (sem_StatementList _sts ) ) sem_Statement (ForSelectStatement _var _sel _sts ) = (sem_Statement_ForSelectStatement _var (sem_SelectExpression _sel ) (sem_StatementList _sts ) ) sem_Statement (If _cases _els ) = (sem_Statement_If (sem_ExpressionStatementListPairList _cases ) (sem_StatementList _els ) ) sem_Statement (Insert _table _targetCols _insData _returning ) = (sem_Statement_Insert _table (sem_StringList _targetCols ) (sem_SelectExpression _insData ) _returning ) sem_Statement (NullStatement ) = (sem_Statement_NullStatement ) sem_Statement (Perform _expr ) = (sem_Statement_Perform (sem_Expression _expr ) ) sem_Statement (Raise _level _message _args ) = (sem_Statement_Raise (sem_RaiseType _level ) _message (sem_ExpressionList _args ) ) sem_Statement (Return _value ) = (sem_Statement_Return _value ) sem_Statement (ReturnNext _expr ) = (sem_Statement_ReturnNext (sem_Expression _expr ) ) sem_Statement (ReturnQuery _sel ) = (sem_Statement_ReturnQuery (sem_SelectExpression _sel ) ) sem_Statement (SelectStatement _ex ) = (sem_Statement_SelectStatement (sem_SelectExpression _ex ) ) sem_Statement (Truncate _tables _restartIdentity _cascade ) = (sem_Statement_Truncate (sem_StringList _tables ) (sem_RestartIdentity _restartIdentity ) (sem_Cascade _cascade ) ) sem_Statement (Update _table _assigns _whr _returning ) = (sem_Statement_Update _table (sem_SetClauseList _assigns ) (sem_Where _whr ) _returning ) sem_Statement (WhileStatement _expr _sts ) = (sem_Statement_WhileStatement (sem_Expression _expr ) (sem_StatementList _sts ) ) -- semantic domain type T_Statement = Type -> Bool -> Scope -> MySourcePos -> ( Statement,Type,([Message]),Type,StatementInfo) data Inh_Statement = Inh_Statement {backType_Inh_Statement :: Type,inLoop_Inh_Statement :: Bool,scope_Inh_Statement :: Scope,sourcePos_Inh_Statement :: MySourcePos} data Syn_Statement = Syn_Statement {actualValue_Syn_Statement :: Statement,backType_Syn_Statement :: Type,messages_Syn_Statement :: [Message],nodeType_Syn_Statement :: Type,statementInfo_Syn_Statement :: StatementInfo} wrap_Statement :: T_Statement -> Inh_Statement -> Syn_Statement wrap_Statement sem (Inh_Statement _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo) = (sem _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Statement _lhsOactualValue _lhsObackType _lhsOmessages _lhsOnodeType _lhsOstatementInfo )) sem_Statement_Assignment :: String -> T_Expression -> T_Statement sem_Statement_Assignment target_ value_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _valueOinLoop :: Bool _valueOscope :: Scope _valueOsourcePos :: MySourcePos _valueIactualValue :: Expression _valueIliftedColumnName :: String _valueImessages :: ([Message]) _valueInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _valueImessages _lhsOnodeType = _valueInodeType _actualValue = Assignment target_ _valueIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _valueOinLoop = _lhsIinLoop _valueOscope = _lhsIscope _valueOsourcePos = _lhsIsourcePos ( _valueIactualValue,_valueIliftedColumnName,_valueImessages,_valueInodeType) = (value_ _valueOinLoop _valueOscope _valueOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CaseStatement :: T_Expression -> T_ExpressionListStatementListPairList -> T_StatementList -> T_Statement sem_Statement_CaseStatement val_ cases_ els_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _valOinLoop :: Bool _valOscope :: Scope _valOsourcePos :: MySourcePos _casesOinLoop :: Bool _casesOscope :: Scope _casesOsourcePos :: MySourcePos _elsOinLoop :: Bool _elsOscope :: Scope _elsOsourcePos :: MySourcePos _valIactualValue :: Expression _valIliftedColumnName :: String _valImessages :: ([Message]) _valInodeType :: Type _casesIactualValue :: ExpressionListStatementListPairList _casesImessages :: ([Message]) _casesInodeType :: Type _elsIactualValue :: StatementList _elsImessages :: ([Message]) _elsInodeType :: Type _elsIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _valImessages ++ _casesImessages ++ _elsImessages _lhsOnodeType = _valInodeType `setUnknown` _casesInodeType `setUnknown` _elsInodeType _actualValue = CaseStatement _valIactualValue _casesIactualValue _elsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _valOinLoop = _lhsIinLoop _valOscope = _lhsIscope _valOsourcePos = _lhsIsourcePos _casesOinLoop = _lhsIinLoop _casesOscope = _lhsIscope _casesOsourcePos = _lhsIsourcePos _elsOinLoop = _lhsIinLoop _elsOscope = _lhsIscope _elsOsourcePos = _lhsIsourcePos ( _valIactualValue,_valIliftedColumnName,_valImessages,_valInodeType) = (val_ _valOinLoop _valOscope _valOsourcePos ) ( _casesIactualValue,_casesImessages,_casesInodeType) = (cases_ _casesOinLoop _casesOscope _casesOsourcePos ) ( _elsIactualValue,_elsImessages,_elsInodeType,_elsIstatementInfo) = (els_ _elsOinLoop _elsOscope _elsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ContinueStatement :: T_Statement sem_Statement_ContinueStatement = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = if not _lhsIinLoop then [Error _lhsIsourcePos ContinueNotInLoop] else [] _lhsOnodeType = UnknownType _actualValue = ContinueStatement _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Copy :: String -> T_StringList -> T_CopySource -> T_Statement sem_Statement_Copy table_ targetCols_ source_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _targetColsOinLoop :: Bool _targetColsOscope :: Scope _targetColsOsourcePos :: MySourcePos _sourceOinLoop :: Bool _sourceOscope :: Scope _sourceOsourcePos :: MySourcePos _targetColsIactualValue :: StringList _targetColsImessages :: ([Message]) _targetColsInodeType :: Type _targetColsIstrings :: ([String]) _sourceIactualValue :: CopySource _sourceImessages :: ([Message]) _sourceInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _targetColsImessages ++ _sourceImessages _lhsOnodeType = _targetColsInodeType `setUnknown` _sourceInodeType _actualValue = Copy table_ _targetColsIactualValue _sourceIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _targetColsOinLoop = _lhsIinLoop _targetColsOscope = _lhsIscope _targetColsOsourcePos = _lhsIsourcePos _sourceOinLoop = _lhsIinLoop _sourceOscope = _lhsIscope _sourceOsourcePos = _lhsIsourcePos ( _targetColsIactualValue,_targetColsImessages,_targetColsInodeType,_targetColsIstrings) = (targetCols_ _targetColsOinLoop _targetColsOscope _targetColsOsourcePos ) ( _sourceIactualValue,_sourceImessages,_sourceInodeType) = (source_ _sourceOinLoop _sourceOscope _sourceOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CopyData :: String -> T_Statement sem_Statement_CopyData insData_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = CopyData insData_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateDomain :: String -> T_TypeName -> (Maybe Expression) -> T_Statement sem_Statement_CreateDomain name_ typ_ check_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ CreateDomainInfo name_ _typInodeType _lhsOmessages = _typImessages _lhsOnodeType = _typInodeType _actualValue = CreateDomain name_ _typIactualValue check_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateFunction :: T_Language -> String -> T_ParamDefList -> T_TypeName -> String -> T_FnBody -> T_Volatility -> T_Statement sem_Statement_CreateFunction lang_ name_ params_ rettype_ bodyQuote_ body_ vol_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _bodyOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _langOinLoop :: Bool _langOscope :: Scope _langOsourcePos :: MySourcePos _paramsOinLoop :: Bool _paramsOscope :: Scope _paramsOsourcePos :: MySourcePos _rettypeOinLoop :: Bool _rettypeOscope :: Scope _rettypeOsourcePos :: MySourcePos _bodyOscope :: Scope _bodyOsourcePos :: MySourcePos _volOinLoop :: Bool _volOscope :: Scope _volOsourcePos :: MySourcePos _langIactualValue :: Language _langImessages :: ([Message]) _langInodeType :: Type _paramsIactualValue :: ParamDefList _paramsImessages :: ([Message]) _paramsInodeType :: Type _paramsIparams :: ([(String,Type)]) _rettypeIactualValue :: TypeName _rettypeImessages :: ([Message]) _rettypeInodeType :: Type _bodyIactualValue :: FnBody _bodyImessages :: ([Message]) _bodyInodeType :: Type _volIactualValue :: Volatility _volImessages :: ([Message]) _volInodeType :: Type _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ CreateFunctionInfo (name_,map snd _paramsIparams,_rettypeInodeType) _bodyOinLoop = False _lhsOmessages = _langImessages ++ _paramsImessages ++ _rettypeImessages ++ _bodyImessages ++ _volImessages _lhsOnodeType = _langInodeType `setUnknown` _paramsInodeType `setUnknown` _rettypeInodeType `setUnknown` _bodyInodeType `setUnknown` _volInodeType _actualValue = CreateFunction _langIactualValue name_ _paramsIactualValue _rettypeIactualValue bodyQuote_ _bodyIactualValue _volIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _langOinLoop = _lhsIinLoop _langOscope = _lhsIscope _langOsourcePos = _lhsIsourcePos _paramsOinLoop = _lhsIinLoop _paramsOscope = _lhsIscope _paramsOsourcePos = _lhsIsourcePos _rettypeOinLoop = _lhsIinLoop _rettypeOscope = _lhsIscope _rettypeOsourcePos = _lhsIsourcePos _bodyOscope = _lhsIscope _bodyOsourcePos = _lhsIsourcePos _volOinLoop = _lhsIinLoop _volOscope = _lhsIscope _volOsourcePos = _lhsIsourcePos ( _langIactualValue,_langImessages,_langInodeType) = (lang_ _langOinLoop _langOscope _langOsourcePos ) ( _paramsIactualValue,_paramsImessages,_paramsInodeType,_paramsIparams) = (params_ _paramsOinLoop _paramsOscope _paramsOsourcePos ) ( _rettypeIactualValue,_rettypeImessages,_rettypeInodeType) = (rettype_ _rettypeOinLoop _rettypeOscope _rettypeOsourcePos ) ( _bodyIactualValue,_bodyImessages,_bodyInodeType) = (body_ _bodyOinLoop _bodyOscope _bodyOsourcePos ) ( _volIactualValue,_volImessages,_volInodeType) = (vol_ _volOinLoop _volOscope _volOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateTable :: String -> T_AttributeDefList -> T_ConstraintList -> T_Statement sem_Statement_CreateTable name_ atts_ cons_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOactualValue :: Statement _lhsObackType :: Type _attsOinLoop :: Bool _attsOscope :: Scope _attsOsourcePos :: MySourcePos _consOinLoop :: Bool _consOscope :: Scope _consOsourcePos :: MySourcePos _attsIactualValue :: AttributeDefList _attsImessages :: ([Message]) _attsInodeType :: Type _consIactualValue :: ConstraintList _consImessages :: ([Message]) _consInodeType :: Type _lhsOnodeType = _attsInodeType _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ RelvarInfo (name_, TableComposite, _attsInodeType) _lhsOmessages = _attsImessages ++ _consImessages _actualValue = CreateTable name_ _attsIactualValue _consIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _attsOinLoop = _lhsIinLoop _attsOscope = _lhsIscope _attsOsourcePos = _lhsIsourcePos _consOinLoop = _lhsIinLoop _consOscope = _lhsIscope _consOsourcePos = _lhsIsourcePos ( _attsIactualValue,_attsImessages,_attsInodeType) = (atts_ _attsOinLoop _attsOscope _attsOsourcePos ) ( _consIactualValue,_consImessages,_consInodeType) = (cons_ _consOinLoop _consOscope _consOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateTableAs :: String -> T_SelectExpression -> T_Statement sem_Statement_CreateTableAs name_ expr_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _exprIactualValue :: SelectExpression _exprImessages :: ([Message]) _exprInodeType :: Type _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ RelvarInfo (name_, TableComposite, _exprInodeType) _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = CreateTableAs name_ _exprIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateType :: String -> T_TypeAttributeDefList -> T_Statement sem_Statement_CreateType name_ atts_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _attsOinLoop :: Bool _attsOscope :: Scope _attsOsourcePos :: MySourcePos _attsIactualValue :: TypeAttributeDefList _attsImessages :: ([Message]) _attsInodeType :: Type _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ RelvarInfo (name_, Composite, _attsInodeType) _lhsOmessages = _attsImessages _lhsOnodeType = _attsInodeType _actualValue = CreateType name_ _attsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _attsOinLoop = _lhsIinLoop _attsOscope = _lhsIscope _attsOsourcePos = _lhsIsourcePos ( _attsIactualValue,_attsImessages,_attsInodeType) = (atts_ _attsOinLoop _attsOscope _attsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_CreateView :: String -> T_SelectExpression -> T_Statement sem_Statement_CreateView name_ expr_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _exprIactualValue :: SelectExpression _exprImessages :: ([Message]) _exprInodeType :: Type _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ RelvarInfo (name_, ViewComposite, _exprInodeType) _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = CreateView name_ _exprIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Delete :: String -> T_Where -> (Maybe SelectList) -> T_Statement sem_Statement_Delete table_ whr_ returning_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOactualValue :: Statement _lhsObackType :: Type _whrOinLoop :: Bool _whrOscope :: Scope _whrOsourcePos :: MySourcePos _whrIactualValue :: Where _whrImessages :: ([Message]) _whrInodeType :: Type _lhsOnodeType = checkErrors [checkTableExists _lhsIscope _lhsIsourcePos table_ ,_whrInodeType] $ TypeList [] _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ DeleteInfo table_ _lhsOmessages = _whrImessages _actualValue = Delete table_ _whrIactualValue returning_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _whrOinLoop = _lhsIinLoop _whrOscope = _lhsIscope _whrOsourcePos = _lhsIsourcePos ( _whrIactualValue,_whrImessages,_whrInodeType) = (whr_ _whrOinLoop _whrOscope _whrOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_DropFunction :: T_IfExists -> T_StringStringListPairList -> T_Cascade -> T_Statement sem_Statement_DropFunction ifE_ sigs_ cascade_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _ifEOinLoop :: Bool _ifEOscope :: Scope _ifEOsourcePos :: MySourcePos _sigsOinLoop :: Bool _sigsOscope :: Scope _sigsOsourcePos :: MySourcePos _cascadeOinLoop :: Bool _cascadeOscope :: Scope _cascadeOsourcePos :: MySourcePos _ifEIactualValue :: IfExists _ifEImessages :: ([Message]) _ifEInodeType :: Type _sigsIactualValue :: StringStringListPairList _sigsImessages :: ([Message]) _sigsInodeType :: Type _cascadeIactualValue :: Cascade _cascadeImessages :: ([Message]) _cascadeInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _ifEImessages ++ _sigsImessages ++ _cascadeImessages _lhsOnodeType = _ifEInodeType `setUnknown` _sigsInodeType `setUnknown` _cascadeInodeType _actualValue = DropFunction _ifEIactualValue _sigsIactualValue _cascadeIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _ifEOinLoop = _lhsIinLoop _ifEOscope = _lhsIscope _ifEOsourcePos = _lhsIsourcePos _sigsOinLoop = _lhsIinLoop _sigsOscope = _lhsIscope _sigsOsourcePos = _lhsIsourcePos _cascadeOinLoop = _lhsIinLoop _cascadeOscope = _lhsIscope _cascadeOsourcePos = _lhsIsourcePos ( _ifEIactualValue,_ifEImessages,_ifEInodeType) = (ifE_ _ifEOinLoop _ifEOscope _ifEOsourcePos ) ( _sigsIactualValue,_sigsImessages,_sigsInodeType) = (sigs_ _sigsOinLoop _sigsOscope _sigsOsourcePos ) ( _cascadeIactualValue,_cascadeImessages,_cascadeInodeType) = (cascade_ _cascadeOinLoop _cascadeOscope _cascadeOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_DropSomething :: T_DropType -> T_IfExists -> T_StringList -> T_Cascade -> T_Statement sem_Statement_DropSomething dropType_ ifE_ names_ cascade_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _dropTypeOinLoop :: Bool _dropTypeOscope :: Scope _dropTypeOsourcePos :: MySourcePos _ifEOinLoop :: Bool _ifEOscope :: Scope _ifEOsourcePos :: MySourcePos _namesOinLoop :: Bool _namesOscope :: Scope _namesOsourcePos :: MySourcePos _cascadeOinLoop :: Bool _cascadeOscope :: Scope _cascadeOsourcePos :: MySourcePos _dropTypeIactualValue :: DropType _dropTypeImessages :: ([Message]) _dropTypeInodeType :: Type _ifEIactualValue :: IfExists _ifEImessages :: ([Message]) _ifEInodeType :: Type _namesIactualValue :: StringList _namesImessages :: ([Message]) _namesInodeType :: Type _namesIstrings :: ([String]) _cascadeIactualValue :: Cascade _cascadeImessages :: ([Message]) _cascadeInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _dropTypeImessages ++ _ifEImessages ++ _namesImessages ++ _cascadeImessages _lhsOnodeType = _dropTypeInodeType `setUnknown` _ifEInodeType `setUnknown` _namesInodeType `setUnknown` _cascadeInodeType _actualValue = DropSomething _dropTypeIactualValue _ifEIactualValue _namesIactualValue _cascadeIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _dropTypeOinLoop = _lhsIinLoop _dropTypeOscope = _lhsIscope _dropTypeOsourcePos = _lhsIsourcePos _ifEOinLoop = _lhsIinLoop _ifEOscope = _lhsIscope _ifEOsourcePos = _lhsIsourcePos _namesOinLoop = _lhsIinLoop _namesOscope = _lhsIscope _namesOsourcePos = _lhsIsourcePos _cascadeOinLoop = _lhsIinLoop _cascadeOscope = _lhsIscope _cascadeOsourcePos = _lhsIsourcePos ( _dropTypeIactualValue,_dropTypeImessages,_dropTypeInodeType) = (dropType_ _dropTypeOinLoop _dropTypeOscope _dropTypeOsourcePos ) ( _ifEIactualValue,_ifEImessages,_ifEInodeType) = (ifE_ _ifEOinLoop _ifEOscope _ifEOsourcePos ) ( _namesIactualValue,_namesImessages,_namesInodeType,_namesIstrings) = (names_ _namesOinLoop _namesOscope _namesOsourcePos ) ( _cascadeIactualValue,_cascadeImessages,_cascadeInodeType) = (cascade_ _cascadeOinLoop _cascadeOscope _cascadeOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Execute :: T_Expression -> T_Statement sem_Statement_Execute expr_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = Execute _exprIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ExecuteInto :: T_Expression -> T_StringList -> T_Statement sem_Statement_ExecuteInto expr_ targets_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _targetsOinLoop :: Bool _targetsOscope :: Scope _targetsOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _targetsIactualValue :: StringList _targetsImessages :: ([Message]) _targetsInodeType :: Type _targetsIstrings :: ([String]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _exprImessages ++ _targetsImessages _lhsOnodeType = _exprInodeType `setUnknown` _targetsInodeType _actualValue = ExecuteInto _exprIactualValue _targetsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos _targetsOinLoop = _lhsIinLoop _targetsOscope = _lhsIscope _targetsOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) ( _targetsIactualValue,_targetsImessages,_targetsInodeType,_targetsIstrings) = (targets_ _targetsOinLoop _targetsOscope _targetsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ForIntegerStatement :: String -> T_Expression -> T_Expression -> T_StatementList -> T_Statement sem_Statement_ForIntegerStatement var_ from_ to_ sts_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _stsOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _fromOinLoop :: Bool _fromOscope :: Scope _fromOsourcePos :: MySourcePos _toOinLoop :: Bool _toOscope :: Scope _toOsourcePos :: MySourcePos _stsOscope :: Scope _stsOsourcePos :: MySourcePos _fromIactualValue :: Expression _fromIliftedColumnName :: String _fromImessages :: ([Message]) _fromInodeType :: Type _toIactualValue :: Expression _toIliftedColumnName :: String _toImessages :: ([Message]) _toInodeType :: Type _stsIactualValue :: StatementList _stsImessages :: ([Message]) _stsInodeType :: Type _stsIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _stsOinLoop = True _lhsOmessages = _fromImessages ++ _toImessages ++ _stsImessages _lhsOnodeType = _fromInodeType `setUnknown` _toInodeType `setUnknown` _stsInodeType _actualValue = ForIntegerStatement var_ _fromIactualValue _toIactualValue _stsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _fromOinLoop = _lhsIinLoop _fromOscope = _lhsIscope _fromOsourcePos = _lhsIsourcePos _toOinLoop = _lhsIinLoop _toOscope = _lhsIscope _toOsourcePos = _lhsIsourcePos _stsOscope = _lhsIscope _stsOsourcePos = _lhsIsourcePos ( _fromIactualValue,_fromIliftedColumnName,_fromImessages,_fromInodeType) = (from_ _fromOinLoop _fromOscope _fromOsourcePos ) ( _toIactualValue,_toIliftedColumnName,_toImessages,_toInodeType) = (to_ _toOinLoop _toOscope _toOsourcePos ) ( _stsIactualValue,_stsImessages,_stsInodeType,_stsIstatementInfo) = (sts_ _stsOinLoop _stsOscope _stsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ForSelectStatement :: String -> T_SelectExpression -> T_StatementList -> T_Statement sem_Statement_ForSelectStatement var_ sel_ sts_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _stsOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _stsOscope :: Scope _stsOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _stsIactualValue :: StatementList _stsImessages :: ([Message]) _stsInodeType :: Type _stsIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _stsOinLoop = True _lhsOmessages = _selImessages ++ _stsImessages _lhsOnodeType = _selInodeType `setUnknown` _stsInodeType _actualValue = ForSelectStatement var_ _selIactualValue _stsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos _stsOscope = _lhsIscope _stsOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) ( _stsIactualValue,_stsImessages,_stsInodeType,_stsIstatementInfo) = (sts_ _stsOinLoop _stsOscope _stsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_If :: T_ExpressionStatementListPairList -> T_StatementList -> T_Statement sem_Statement_If cases_ els_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _casesOinLoop :: Bool _casesOscope :: Scope _casesOsourcePos :: MySourcePos _elsOinLoop :: Bool _elsOscope :: Scope _elsOsourcePos :: MySourcePos _casesIactualValue :: ExpressionStatementListPairList _casesImessages :: ([Message]) _casesInodeType :: Type _elsIactualValue :: StatementList _elsImessages :: ([Message]) _elsInodeType :: Type _elsIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _casesImessages ++ _elsImessages _lhsOnodeType = _casesInodeType `setUnknown` _elsInodeType _actualValue = If _casesIactualValue _elsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _casesOinLoop = _lhsIinLoop _casesOscope = _lhsIscope _casesOsourcePos = _lhsIsourcePos _elsOinLoop = _lhsIinLoop _elsOscope = _lhsIscope _elsOsourcePos = _lhsIsourcePos ( _casesIactualValue,_casesImessages,_casesInodeType) = (cases_ _casesOinLoop _casesOscope _casesOsourcePos ) ( _elsIactualValue,_elsImessages,_elsInodeType,_elsIstatementInfo) = (els_ _elsOinLoop _elsOscope _elsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Insert :: String -> T_StringList -> T_SelectExpression -> (Maybe SelectList) -> T_Statement sem_Statement_Insert table_ targetCols_ insData_ returning_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOactualValue :: Statement _lhsObackType :: Type _targetColsOinLoop :: Bool _targetColsOscope :: Scope _targetColsOsourcePos :: MySourcePos _insDataOinLoop :: Bool _insDataOscope :: Scope _insDataOsourcePos :: MySourcePos _targetColsIactualValue :: StringList _targetColsImessages :: ([Message]) _targetColsInodeType :: Type _targetColsIstrings :: ([String]) _insDataIactualValue :: SelectExpression _insDataImessages :: ([Message]) _insDataInodeType :: Type _lhsOnodeType = checkErrors [checkTableExists _lhsIscope _lhsIsourcePos table_ ,_insDataInodeType ,checkColumnConsistency _lhsIscope _lhsIsourcePos table_ _targetColsIstrings (unwrapComposite $ unwrapSetOf _insDataInodeType)] _insDataInodeType _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ InsertInfo table_ $ UnnamedCompositeType $ getColumnTypes _lhsIscope _lhsIsourcePos table_ _targetColsIstrings _lhsOmessages = _targetColsImessages ++ _insDataImessages _actualValue = Insert table_ _targetColsIactualValue _insDataIactualValue returning_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _targetColsOinLoop = _lhsIinLoop _targetColsOscope = _lhsIscope _targetColsOsourcePos = _lhsIsourcePos _insDataOinLoop = _lhsIinLoop _insDataOscope = _lhsIscope _insDataOsourcePos = _lhsIsourcePos ( _targetColsIactualValue,_targetColsImessages,_targetColsInodeType,_targetColsIstrings) = (targetCols_ _targetColsOinLoop _targetColsOscope _targetColsOsourcePos ) ( _insDataIactualValue,_insDataImessages,_insDataInodeType) = (insData_ _insDataOinLoop _insDataOscope _insDataOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_NullStatement :: T_Statement sem_Statement_NullStatement = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = NullStatement _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Perform :: T_Expression -> T_Statement sem_Statement_Perform expr_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = Perform _exprIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Raise :: T_RaiseType -> String -> T_ExpressionList -> T_Statement sem_Statement_Raise level_ message_ args_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _levelOinLoop :: Bool _levelOscope :: Scope _levelOsourcePos :: MySourcePos _argsOinLoop :: Bool _argsOscope :: Scope _argsOsourcePos :: MySourcePos _levelIactualValue :: RaiseType _levelImessages :: ([Message]) _levelInodeType :: Type _argsIactualValue :: ExpressionList _argsImessages :: ([Message]) _argsInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _levelImessages ++ _argsImessages _lhsOnodeType = _levelInodeType `setUnknown` _argsInodeType _actualValue = Raise _levelIactualValue message_ _argsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _levelOinLoop = _lhsIinLoop _levelOscope = _lhsIscope _levelOsourcePos = _lhsIsourcePos _argsOinLoop = _lhsIinLoop _argsOscope = _lhsIscope _argsOsourcePos = _lhsIsourcePos ( _levelIactualValue,_levelImessages,_levelInodeType) = (level_ _levelOinLoop _levelOscope _levelOsourcePos ) ( _argsIactualValue,_argsImessages,_argsInodeType) = (args_ _argsOinLoop _argsOscope _argsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Return :: (Maybe Expression) -> T_Statement sem_Statement_Return value_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Return value_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ReturnNext :: T_Expression -> T_Statement sem_Statement_ReturnNext expr_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _exprImessages _lhsOnodeType = _exprInodeType _actualValue = ReturnNext _exprIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_ReturnQuery :: T_SelectExpression -> T_Statement sem_Statement_ReturnQuery sel_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _selImessages _lhsOnodeType = _selInodeType _actualValue = ReturnQuery _selIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_SelectStatement :: T_SelectExpression -> T_Statement sem_Statement_SelectStatement ex_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOactualValue :: Statement _lhsObackType :: Type _exOinLoop :: Bool _exOscope :: Scope _exOsourcePos :: MySourcePos _exIactualValue :: SelectExpression _exImessages :: ([Message]) _exInodeType :: Type _lhsOnodeType = _exInodeType _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ SelectInfo _exInodeType _lhsOmessages = _exImessages _actualValue = SelectStatement _exIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exOinLoop = _lhsIinLoop _exOscope = _lhsIscope _exOsourcePos = _lhsIsourcePos ( _exIactualValue,_exImessages,_exInodeType) = (ex_ _exOinLoop _exOscope _exOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Truncate :: T_StringList -> T_RestartIdentity -> T_Cascade -> T_Statement sem_Statement_Truncate tables_ restartIdentity_ cascade_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _tablesOinLoop :: Bool _tablesOscope :: Scope _tablesOsourcePos :: MySourcePos _restartIdentityOinLoop :: Bool _restartIdentityOscope :: Scope _restartIdentityOsourcePos :: MySourcePos _cascadeOinLoop :: Bool _cascadeOscope :: Scope _cascadeOsourcePos :: MySourcePos _tablesIactualValue :: StringList _tablesImessages :: ([Message]) _tablesInodeType :: Type _tablesIstrings :: ([String]) _restartIdentityIactualValue :: RestartIdentity _restartIdentityImessages :: ([Message]) _restartIdentityInodeType :: Type _cascadeIactualValue :: Cascade _cascadeImessages :: ([Message]) _cascadeInodeType :: Type _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _lhsOmessages = _tablesImessages ++ _restartIdentityImessages ++ _cascadeImessages _lhsOnodeType = _tablesInodeType `setUnknown` _restartIdentityInodeType `setUnknown` _cascadeInodeType _actualValue = Truncate _tablesIactualValue _restartIdentityIactualValue _cascadeIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _tablesOinLoop = _lhsIinLoop _tablesOscope = _lhsIscope _tablesOsourcePos = _lhsIsourcePos _restartIdentityOinLoop = _lhsIinLoop _restartIdentityOscope = _lhsIscope _restartIdentityOsourcePos = _lhsIsourcePos _cascadeOinLoop = _lhsIinLoop _cascadeOscope = _lhsIscope _cascadeOsourcePos = _lhsIsourcePos ( _tablesIactualValue,_tablesImessages,_tablesInodeType,_tablesIstrings) = (tables_ _tablesOinLoop _tablesOscope _tablesOsourcePos ) ( _restartIdentityIactualValue,_restartIdentityImessages,_restartIdentityInodeType) = (restartIdentity_ _restartIdentityOinLoop _restartIdentityOscope _restartIdentityOsourcePos ) ( _cascadeIactualValue,_cascadeImessages,_cascadeInodeType) = (cascade_ _cascadeOinLoop _cascadeOscope _cascadeOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_Update :: String -> T_SetClauseList -> T_Where -> (Maybe SelectList) -> T_Statement sem_Statement_Update table_ assigns_ whr_ returning_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOstatementInfo :: StatementInfo _lhsOmessages :: ([Message]) _lhsOactualValue :: Statement _lhsObackType :: Type _assignsOinLoop :: Bool _assignsOscope :: Scope _assignsOsourcePos :: MySourcePos _whrOinLoop :: Bool _whrOscope :: Scope _whrOsourcePos :: MySourcePos _assignsIactualValue :: SetClauseList _assignsImessages :: ([Message]) _assignsInodeType :: Type _assignsIpairs :: ([(String,Type)]) _whrIactualValue :: Where _whrImessages :: ([Message]) _whrInodeType :: Type _lhsOnodeType = checkErrors [checkTableExists _lhsIscope _lhsIsourcePos table_ ,_whrInodeType ,_assignsInodeType ,checkColumnConsistency _lhsIscope _lhsIsourcePos table_ colNames colTypes] _assignsInodeType where colNames = map fst _assignsIpairs colTypes = _assignsIpairs _lhsOstatementInfo = makeStatementInfo _lhsIbackType $ UpdateInfo table_ $ UnnamedCompositeType $ getColumnTypes _lhsIscope _lhsIsourcePos table_ $ map fst _assignsIpairs _lhsOmessages = _assignsImessages ++ _whrImessages _actualValue = Update table_ _assignsIactualValue _whrIactualValue returning_ _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _assignsOinLoop = _lhsIinLoop _assignsOscope = _lhsIscope _assignsOsourcePos = _lhsIsourcePos _whrOinLoop = _lhsIinLoop _whrOscope = _lhsIscope _whrOsourcePos = _lhsIsourcePos ( _assignsIactualValue,_assignsImessages,_assignsInodeType,_assignsIpairs) = (assigns_ _assignsOinLoop _assignsOscope _assignsOsourcePos ) ( _whrIactualValue,_whrImessages,_whrInodeType) = (whr_ _whrOinLoop _whrOscope _whrOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_Statement_WhileStatement :: T_Expression -> T_StatementList -> T_Statement sem_Statement_WhileStatement expr_ sts_ = (\ _lhsIbackType _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: StatementInfo _stsOinLoop :: Bool _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Statement _lhsObackType :: Type _exprOinLoop :: Bool _exprOscope :: Scope _exprOsourcePos :: MySourcePos _stsOscope :: Scope _stsOsourcePos :: MySourcePos _exprIactualValue :: Expression _exprIliftedColumnName :: String _exprImessages :: ([Message]) _exprInodeType :: Type _stsIactualValue :: StatementList _stsImessages :: ([Message]) _stsInodeType :: Type _stsIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = DefaultStatementInfo _lhsIbackType _stsOinLoop = True _lhsOmessages = _exprImessages ++ _stsImessages _lhsOnodeType = _exprInodeType `setUnknown` _stsInodeType _actualValue = WhileStatement _exprIactualValue _stsIactualValue _lhsOactualValue = _actualValue _lhsObackType = _lhsIbackType _exprOinLoop = _lhsIinLoop _exprOscope = _lhsIscope _exprOsourcePos = _lhsIsourcePos _stsOscope = _lhsIscope _stsOsourcePos = _lhsIsourcePos ( _exprIactualValue,_exprIliftedColumnName,_exprImessages,_exprInodeType) = (expr_ _exprOinLoop _exprOscope _exprOsourcePos ) ( _stsIactualValue,_stsImessages,_stsInodeType,_stsIstatementInfo) = (sts_ _stsOinLoop _stsOscope _stsOsourcePos ) in ( _lhsOactualValue,_lhsObackType,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) -- StatementList ----------------------------------------------- type StatementList = [(SourcePosStatement)] -- cata sem_StatementList :: StatementList -> T_StatementList sem_StatementList list = (Prelude.foldr sem_StatementList_Cons sem_StatementList_Nil (Prelude.map sem_SourcePosStatement list) ) -- semantic domain type T_StatementList = Bool -> Scope -> MySourcePos -> ( StatementList,([Message]),Type,([StatementInfo])) data Inh_StatementList = Inh_StatementList {inLoop_Inh_StatementList :: Bool,scope_Inh_StatementList :: Scope,sourcePos_Inh_StatementList :: MySourcePos} data Syn_StatementList = Syn_StatementList {actualValue_Syn_StatementList :: StatementList,messages_Syn_StatementList :: [Message],nodeType_Syn_StatementList :: Type,statementInfo_Syn_StatementList :: [StatementInfo]} wrap_StatementList :: T_StatementList -> Inh_StatementList -> Syn_StatementList wrap_StatementList sem (Inh_StatementList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_StatementList _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOstatementInfo )) sem_StatementList_Cons :: T_SourcePosStatement -> T_StatementList -> T_StatementList sem_StatementList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: ([StatementInfo]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StatementList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: SourcePosStatement _hdImessages :: ([Message]) _hdInodeType :: Type _hdIstatementInfo :: StatementInfo _tlIactualValue :: StatementList _tlImessages :: ([Message]) _tlInodeType :: Type _tlIstatementInfo :: ([StatementInfo]) _lhsOstatementInfo = _hdIstatementInfo : _tlIstatementInfo _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType,_hdIstatementInfo) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType,_tlIstatementInfo) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) sem_StatementList_Nil :: T_StatementList sem_StatementList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstatementInfo :: ([StatementInfo]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StatementList _lhsOstatementInfo = [] _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstatementInfo))) -- StringList -------------------------------------------------- type StringList = [(String)] -- cata sem_StringList :: StringList -> T_StringList sem_StringList list = (Prelude.foldr sem_StringList_Cons sem_StringList_Nil list ) -- semantic domain type T_StringList = Bool -> Scope -> MySourcePos -> ( StringList,([Message]),Type,([String])) data Inh_StringList = Inh_StringList {inLoop_Inh_StringList :: Bool,scope_Inh_StringList :: Scope,sourcePos_Inh_StringList :: MySourcePos} data Syn_StringList = Syn_StringList {actualValue_Syn_StringList :: StringList,messages_Syn_StringList :: [Message],nodeType_Syn_StringList :: Type,strings_Syn_StringList :: [String]} wrap_StringList :: T_StringList -> Inh_StringList -> Syn_StringList wrap_StringList sem (Inh_StringList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstrings) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_StringList _lhsOactualValue _lhsOmessages _lhsOnodeType _lhsOstrings )) sem_StringList_Cons :: String -> T_StringList -> T_StringList sem_StringList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstrings :: ([String]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StringList _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _tlIactualValue :: StringList _tlImessages :: ([Message]) _tlInodeType :: Type _tlIstrings :: ([String]) _lhsOstrings = hd_ : _tlIstrings _lhsOmessages = _tlImessages _lhsOnodeType = _tlInodeType _actualValue = (:) hd_ _tlIactualValue _lhsOactualValue = _actualValue _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _tlIactualValue,_tlImessages,_tlInodeType,_tlIstrings) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstrings))) sem_StringList_Nil :: T_StringList sem_StringList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOstrings :: ([String]) _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StringList _lhsOstrings = [] _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType,_lhsOstrings))) -- StringStringListPair ---------------------------------------- type StringStringListPair = ( (String),(StringList)) -- cata sem_StringStringListPair :: StringStringListPair -> T_StringStringListPair sem_StringStringListPair ( x1,x2) = (sem_StringStringListPair_Tuple x1 (sem_StringList x2 ) ) -- semantic domain type T_StringStringListPair = Bool -> Scope -> MySourcePos -> ( StringStringListPair,([Message]),Type) data Inh_StringStringListPair = Inh_StringStringListPair {inLoop_Inh_StringStringListPair :: Bool,scope_Inh_StringStringListPair :: Scope,sourcePos_Inh_StringStringListPair :: MySourcePos} data Syn_StringStringListPair = Syn_StringStringListPair {actualValue_Syn_StringStringListPair :: StringStringListPair,messages_Syn_StringStringListPair :: [Message],nodeType_Syn_StringStringListPair :: Type} wrap_StringStringListPair :: T_StringStringListPair -> Inh_StringStringListPair -> Syn_StringStringListPair wrap_StringStringListPair sem (Inh_StringStringListPair _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_StringStringListPair _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_StringStringListPair_Tuple :: String -> T_StringList -> T_StringStringListPair sem_StringStringListPair_Tuple x1_ x2_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StringStringListPair _x2OinLoop :: Bool _x2Oscope :: Scope _x2OsourcePos :: MySourcePos _x2IactualValue :: StringList _x2Imessages :: ([Message]) _x2InodeType :: Type _x2Istrings :: ([String]) _lhsOmessages = _x2Imessages _lhsOnodeType = _x2InodeType _actualValue = (x1_,_x2IactualValue) _lhsOactualValue = _actualValue _x2OinLoop = _lhsIinLoop _x2Oscope = _lhsIscope _x2OsourcePos = _lhsIsourcePos ( _x2IactualValue,_x2Imessages,_x2InodeType,_x2Istrings) = (x2_ _x2OinLoop _x2Oscope _x2OsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- StringStringListPairList ------------------------------------ type StringStringListPairList = [(StringStringListPair)] -- cata sem_StringStringListPairList :: StringStringListPairList -> T_StringStringListPairList sem_StringStringListPairList list = (Prelude.foldr sem_StringStringListPairList_Cons sem_StringStringListPairList_Nil (Prelude.map sem_StringStringListPair list) ) -- semantic domain type T_StringStringListPairList = Bool -> Scope -> MySourcePos -> ( StringStringListPairList,([Message]),Type) data Inh_StringStringListPairList = Inh_StringStringListPairList {inLoop_Inh_StringStringListPairList :: Bool,scope_Inh_StringStringListPairList :: Scope,sourcePos_Inh_StringStringListPairList :: MySourcePos} data Syn_StringStringListPairList = Syn_StringStringListPairList {actualValue_Syn_StringStringListPairList :: StringStringListPairList,messages_Syn_StringStringListPairList :: [Message],nodeType_Syn_StringStringListPairList :: Type} wrap_StringStringListPairList :: T_StringStringListPairList -> Inh_StringStringListPairList -> Syn_StringStringListPairList wrap_StringStringListPairList sem (Inh_StringStringListPairList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_StringStringListPairList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_StringStringListPairList_Cons :: T_StringStringListPair -> T_StringStringListPairList -> T_StringStringListPairList sem_StringStringListPairList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StringStringListPairList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: StringStringListPair _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: StringStringListPairList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_StringStringListPairList_Nil :: T_StringStringListPairList sem_StringStringListPairList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: StringStringListPairList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- TableRef ---------------------------------------------------- data TableRef = JoinedTref (TableRef) (Natural) (JoinType) (TableRef) (OnExpr) | SubTref (SelectExpression) (String) | Tref (String) | TrefAlias (String) (String) | TrefFun (Expression) | TrefFunAlias (Expression) (String) deriving ( Eq,Show) -- cata sem_TableRef :: TableRef -> T_TableRef sem_TableRef (JoinedTref _tbl _nat _joinType _tbl1 _onExpr ) = (sem_TableRef_JoinedTref (sem_TableRef _tbl ) (sem_Natural _nat ) (sem_JoinType _joinType ) (sem_TableRef _tbl1 ) (sem_OnExpr _onExpr ) ) sem_TableRef (SubTref _sel _alias ) = (sem_TableRef_SubTref (sem_SelectExpression _sel ) _alias ) sem_TableRef (Tref _tbl ) = (sem_TableRef_Tref _tbl ) sem_TableRef (TrefAlias _tbl _alias ) = (sem_TableRef_TrefAlias _tbl _alias ) sem_TableRef (TrefFun _fn ) = (sem_TableRef_TrefFun (sem_Expression _fn ) ) sem_TableRef (TrefFunAlias _fn _alias ) = (sem_TableRef_TrefFunAlias (sem_Expression _fn ) _alias ) -- semantic domain type T_TableRef = Bool -> Scope -> MySourcePos -> ( TableRef,([QualifiedScope]),([String]),([Message]),Type) data Inh_TableRef = Inh_TableRef {inLoop_Inh_TableRef :: Bool,scope_Inh_TableRef :: Scope,sourcePos_Inh_TableRef :: MySourcePos} data Syn_TableRef = Syn_TableRef {actualValue_Syn_TableRef :: TableRef,idens_Syn_TableRef :: [QualifiedScope],joinIdens_Syn_TableRef :: [String],messages_Syn_TableRef :: [Message],nodeType_Syn_TableRef :: Type} wrap_TableRef :: T_TableRef -> Inh_TableRef -> Syn_TableRef wrap_TableRef sem (Inh_TableRef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_TableRef _lhsOactualValue _lhsOidens _lhsOjoinIdens _lhsOmessages _lhsOnodeType )) sem_TableRef_JoinedTref :: T_TableRef -> T_Natural -> T_JoinType -> T_TableRef -> T_OnExpr -> T_TableRef sem_TableRef_JoinedTref tbl_ nat_ joinType_ tbl1_ onExpr_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOidens :: ([QualifiedScope]) _lhsOjoinIdens :: ([String]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _tblOinLoop :: Bool _tblOscope :: Scope _tblOsourcePos :: MySourcePos _natOinLoop :: Bool _natOscope :: Scope _natOsourcePos :: MySourcePos _joinTypeOinLoop :: Bool _joinTypeOscope :: Scope _joinTypeOsourcePos :: MySourcePos _tbl1OinLoop :: Bool _tbl1Oscope :: Scope _tbl1OsourcePos :: MySourcePos _onExprOinLoop :: Bool _onExprOscope :: Scope _onExprOsourcePos :: MySourcePos _tblIactualValue :: TableRef _tblIidens :: ([QualifiedScope]) _tblIjoinIdens :: ([String]) _tblImessages :: ([Message]) _tblInodeType :: Type _natIactualValue :: Natural _natImessages :: ([Message]) _natInodeType :: Type _joinTypeIactualValue :: JoinType _joinTypeImessages :: ([Message]) _joinTypeInodeType :: Type _tbl1IactualValue :: TableRef _tbl1Iidens :: ([QualifiedScope]) _tbl1IjoinIdens :: ([String]) _tbl1Imessages :: ([Message]) _tbl1InodeType :: Type _onExprIactualValue :: OnExpr _onExprImessages :: ([Message]) _onExprInodeType :: Type _lhsOnodeType = checkErrors [_tblInodeType ,_tbl1InodeType] ret where ret = case (_natIactualValue, _onExprIactualValue) of (Natural, _) -> unionJoinList $ commonFieldNames _tblInodeType _tbl1InodeType (_,Just (JoinUsing s)) -> unionJoinList s _ -> unionJoinList [] unionJoinList s = combineTableTypesWithUsingList _lhsIscope _lhsIsourcePos s _tblInodeType _tbl1InodeType _lhsOidens = _tblIidens ++ _tbl1Iidens _lhsOjoinIdens = commonFieldNames _tblInodeType _tbl1InodeType _lhsOmessages = _tblImessages ++ _natImessages ++ _joinTypeImessages ++ _tbl1Imessages ++ _onExprImessages _actualValue = JoinedTref _tblIactualValue _natIactualValue _joinTypeIactualValue _tbl1IactualValue _onExprIactualValue _lhsOactualValue = _actualValue _tblOinLoop = _lhsIinLoop _tblOscope = _lhsIscope _tblOsourcePos = _lhsIsourcePos _natOinLoop = _lhsIinLoop _natOscope = _lhsIscope _natOsourcePos = _lhsIsourcePos _joinTypeOinLoop = _lhsIinLoop _joinTypeOscope = _lhsIscope _joinTypeOsourcePos = _lhsIsourcePos _tbl1OinLoop = _lhsIinLoop _tbl1Oscope = _lhsIscope _tbl1OsourcePos = _lhsIsourcePos _onExprOinLoop = _lhsIinLoop _onExprOscope = _lhsIscope _onExprOsourcePos = _lhsIsourcePos ( _tblIactualValue,_tblIidens,_tblIjoinIdens,_tblImessages,_tblInodeType) = (tbl_ _tblOinLoop _tblOscope _tblOsourcePos ) ( _natIactualValue,_natImessages,_natInodeType) = (nat_ _natOinLoop _natOscope _natOsourcePos ) ( _joinTypeIactualValue,_joinTypeImessages,_joinTypeInodeType) = (joinType_ _joinTypeOinLoop _joinTypeOscope _joinTypeOsourcePos ) ( _tbl1IactualValue,_tbl1Iidens,_tbl1IjoinIdens,_tbl1Imessages,_tbl1InodeType) = (tbl1_ _tbl1OinLoop _tbl1Oscope _tbl1OsourcePos ) ( _onExprIactualValue,_onExprImessages,_onExprInodeType) = (onExpr_ _onExprOinLoop _onExprOscope _onExprOsourcePos ) in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_TableRef_SubTref :: T_SelectExpression -> String -> T_TableRef sem_TableRef_SubTref sel_ alias_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOidens :: ([QualifiedScope]) _lhsOjoinIdens :: ([String]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _selOinLoop :: Bool _selOscope :: Scope _selOsourcePos :: MySourcePos _selIactualValue :: SelectExpression _selImessages :: ([Message]) _selInodeType :: Type _lhsOnodeType = checkErrors [_selInodeType] $ unwrapSetOfComposite _selInodeType _lhsOidens = [(alias_, (unwrapComposite $ unwrapSetOf _selInodeType, []))] _lhsOjoinIdens = [] _lhsOmessages = _selImessages _actualValue = SubTref _selIactualValue alias_ _lhsOactualValue = _actualValue _selOinLoop = _lhsIinLoop _selOscope = _lhsIscope _selOsourcePos = _lhsIsourcePos ( _selIactualValue,_selImessages,_selInodeType) = (sel_ _selOinLoop _selOscope _selOsourcePos ) in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_TableRef_Tref :: String -> T_TableRef sem_TableRef_Tref tbl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOjoinIdens :: ([String]) _lhsOidens :: ([QualifiedScope]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _lhsOnodeType = fst $ getRelationType _lhsIscope _lhsIsourcePos tbl_ _lhsOjoinIdens = [] _lhsOidens = [(tbl_, both unwrapComposite $ getRelationType _lhsIscope _lhsIsourcePos tbl_)] _lhsOmessages = [] _actualValue = Tref tbl_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_TableRef_TrefAlias :: String -> String -> T_TableRef sem_TableRef_TrefAlias tbl_ alias_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOjoinIdens :: ([String]) _lhsOidens :: ([QualifiedScope]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _lhsOnodeType = fst $ getRelationType _lhsIscope _lhsIsourcePos tbl_ _lhsOjoinIdens = [] _lhsOidens = [(alias_, both unwrapComposite $ getRelationType _lhsIscope _lhsIsourcePos tbl_)] _lhsOmessages = [] _actualValue = TrefAlias tbl_ alias_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_TableRef_TrefFun :: T_Expression -> T_TableRef sem_TableRef_TrefFun fn_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOjoinIdens :: ([String]) _lhsOidens :: ([QualifiedScope]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _fnOinLoop :: Bool _fnOscope :: Scope _fnOsourcePos :: MySourcePos _fnIactualValue :: Expression _fnIliftedColumnName :: String _fnImessages :: ([Message]) _fnInodeType :: Type _lhsOnodeType = getFnType _lhsIscope _lhsIsourcePos "" _fnIactualValue _fnInodeType _lhsOjoinIdens = [] _lhsOidens = [second (\l -> (unwrapComposite l, [])) $ getFunIdens _lhsIscope _lhsIsourcePos "" _fnIactualValue _fnInodeType] _lhsOmessages = _fnImessages _actualValue = TrefFun _fnIactualValue _lhsOactualValue = _actualValue _fnOinLoop = _lhsIinLoop _fnOscope = _lhsIscope _fnOsourcePos = _lhsIsourcePos ( _fnIactualValue,_fnIliftedColumnName,_fnImessages,_fnInodeType) = (fn_ _fnOinLoop _fnOscope _fnOsourcePos ) in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) sem_TableRef_TrefFunAlias :: T_Expression -> String -> T_TableRef sem_TableRef_TrefFunAlias fn_ alias_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOjoinIdens :: ([String]) _lhsOidens :: ([QualifiedScope]) _lhsOmessages :: ([Message]) _lhsOactualValue :: TableRef _fnOinLoop :: Bool _fnOscope :: Scope _fnOsourcePos :: MySourcePos _fnIactualValue :: Expression _fnIliftedColumnName :: String _fnImessages :: ([Message]) _fnInodeType :: Type _lhsOnodeType = getFnType _lhsIscope _lhsIsourcePos alias_ _fnIactualValue _fnInodeType _lhsOjoinIdens = [] _lhsOidens = [second (\l -> (unwrapComposite l, [])) $ getFunIdens _lhsIscope _lhsIsourcePos alias_ _fnIactualValue _fnInodeType] _lhsOmessages = _fnImessages _actualValue = TrefFunAlias _fnIactualValue alias_ _lhsOactualValue = _actualValue _fnOinLoop = _lhsIinLoop _fnOscope = _lhsIscope _fnOsourcePos = _lhsIsourcePos ( _fnIactualValue,_fnIliftedColumnName,_fnImessages,_fnInodeType) = (fn_ _fnOinLoop _fnOscope _fnOsourcePos ) in ( _lhsOactualValue,_lhsOidens,_lhsOjoinIdens,_lhsOmessages,_lhsOnodeType))) -- TypeAttributeDef -------------------------------------------- data TypeAttributeDef = TypeAttDef (String) (TypeName) deriving ( Eq,Show) -- cata sem_TypeAttributeDef :: TypeAttributeDef -> T_TypeAttributeDef sem_TypeAttributeDef (TypeAttDef _name _typ ) = (sem_TypeAttributeDef_TypeAttDef _name (sem_TypeName _typ ) ) -- semantic domain type T_TypeAttributeDef = Bool -> Scope -> MySourcePos -> ( TypeAttributeDef,String,([Message]),Type) data Inh_TypeAttributeDef = Inh_TypeAttributeDef {inLoop_Inh_TypeAttributeDef :: Bool,scope_Inh_TypeAttributeDef :: Scope,sourcePos_Inh_TypeAttributeDef :: MySourcePos} data Syn_TypeAttributeDef = Syn_TypeAttributeDef {actualValue_Syn_TypeAttributeDef :: TypeAttributeDef,attrName_Syn_TypeAttributeDef :: String,messages_Syn_TypeAttributeDef :: [Message],nodeType_Syn_TypeAttributeDef :: Type} wrap_TypeAttributeDef :: T_TypeAttributeDef -> Inh_TypeAttributeDef -> Syn_TypeAttributeDef wrap_TypeAttributeDef sem (Inh_TypeAttributeDef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOattrName,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_TypeAttributeDef _lhsOactualValue _lhsOattrName _lhsOmessages _lhsOnodeType )) sem_TypeAttributeDef_TypeAttDef :: String -> T_TypeName -> T_TypeAttributeDef sem_TypeAttributeDef_TypeAttDef name_ typ_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOattrName :: String _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeAttributeDef _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOnodeType = _typInodeType _lhsOattrName = name_ _lhsOmessages = _typImessages _actualValue = TypeAttDef name_ _typIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOattrName,_lhsOmessages,_lhsOnodeType))) -- TypeAttributeDefList ---------------------------------------- type TypeAttributeDefList = [(TypeAttributeDef)] -- cata sem_TypeAttributeDefList :: TypeAttributeDefList -> T_TypeAttributeDefList sem_TypeAttributeDefList list = (Prelude.foldr sem_TypeAttributeDefList_Cons sem_TypeAttributeDefList_Nil (Prelude.map sem_TypeAttributeDef list) ) -- semantic domain type T_TypeAttributeDefList = Bool -> Scope -> MySourcePos -> ( TypeAttributeDefList,([Message]),Type) data Inh_TypeAttributeDefList = Inh_TypeAttributeDefList {inLoop_Inh_TypeAttributeDefList :: Bool,scope_Inh_TypeAttributeDefList :: Scope,sourcePos_Inh_TypeAttributeDefList :: MySourcePos} data Syn_TypeAttributeDefList = Syn_TypeAttributeDefList {actualValue_Syn_TypeAttributeDefList :: TypeAttributeDefList,messages_Syn_TypeAttributeDefList :: [Message],nodeType_Syn_TypeAttributeDefList :: Type} wrap_TypeAttributeDefList :: T_TypeAttributeDefList -> Inh_TypeAttributeDefList -> Syn_TypeAttributeDefList wrap_TypeAttributeDefList sem (Inh_TypeAttributeDefList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_TypeAttributeDefList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_TypeAttributeDefList_Cons :: T_TypeAttributeDef -> T_TypeAttributeDefList -> T_TypeAttributeDefList sem_TypeAttributeDefList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeAttributeDefList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: TypeAttributeDef _hdIattrName :: String _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: TypeAttributeDefList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOnodeType = checkErrors [_tlInodeType, _hdInodeType] $ consComposite (_hdIattrName, _hdInodeType) _tlInodeType _lhsOmessages = _hdImessages ++ _tlImessages _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdIattrName,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_TypeAttributeDefList_Nil :: T_TypeAttributeDefList sem_TypeAttributeDefList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeAttributeDefList _lhsOnodeType = UnnamedCompositeType [] _lhsOmessages = [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- TypeName ---------------------------------------------------- data TypeName = ArrayTypeName (TypeName) | PrecTypeName (String) (Integer) | SetOfTypeName (TypeName) | SimpleTypeName (String) deriving ( Eq,Show) -- cata sem_TypeName :: TypeName -> T_TypeName sem_TypeName (ArrayTypeName _typ ) = (sem_TypeName_ArrayTypeName (sem_TypeName _typ ) ) sem_TypeName (PrecTypeName _tn _prec ) = (sem_TypeName_PrecTypeName _tn _prec ) sem_TypeName (SetOfTypeName _typ ) = (sem_TypeName_SetOfTypeName (sem_TypeName _typ ) ) sem_TypeName (SimpleTypeName _tn ) = (sem_TypeName_SimpleTypeName _tn ) -- semantic domain type T_TypeName = Bool -> Scope -> MySourcePos -> ( TypeName,([Message]),Type) data Inh_TypeName = Inh_TypeName {inLoop_Inh_TypeName :: Bool,scope_Inh_TypeName :: Scope,sourcePos_Inh_TypeName :: MySourcePos} data Syn_TypeName = Syn_TypeName {actualValue_Syn_TypeName :: TypeName,messages_Syn_TypeName :: [Message],nodeType_Syn_TypeName :: Type} wrap_TypeName :: T_TypeName -> Inh_TypeName -> Syn_TypeName wrap_TypeName sem (Inh_TypeName _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_TypeName _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_TypeName_ArrayTypeName :: T_TypeName -> T_TypeName sem_TypeName_ArrayTypeName typ_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeName _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOnodeType = let t = ArrayType _typInodeType in checkErrors [_typInodeType ,checkTypeExists _lhsIscope _lhsIsourcePos t] t _lhsOmessages = _typImessages _actualValue = ArrayTypeName _typIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_TypeName_PrecTypeName :: String -> Integer -> T_TypeName sem_TypeName_PrecTypeName tn_ prec_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: TypeName _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = PrecTypeName tn_ prec_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_TypeName_SetOfTypeName :: T_TypeName -> T_TypeName sem_TypeName_SetOfTypeName typ_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeName _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOnodeType = checkErrors [_typInodeType] (SetOfType _typInodeType) _lhsOmessages = _typImessages _actualValue = SetOfTypeName _typIactualValue _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_TypeName_SimpleTypeName :: String -> T_TypeName sem_TypeName_SimpleTypeName tn_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: TypeName _lhsOnodeType = lookupTypeByName _lhsIscope _lhsIsourcePos $ canonicalizeTypeName tn_ _lhsOmessages = [] _actualValue = SimpleTypeName tn_ _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- VarDef ------------------------------------------------------ data VarDef = VarDef (String) (TypeName) (Maybe Expression) deriving ( Eq,Show) -- cata sem_VarDef :: VarDef -> T_VarDef sem_VarDef (VarDef _name _typ _value ) = (sem_VarDef_VarDef _name (sem_TypeName _typ ) _value ) -- semantic domain type T_VarDef = Bool -> Scope -> MySourcePos -> ( VarDef,([Message]),Type) data Inh_VarDef = Inh_VarDef {inLoop_Inh_VarDef :: Bool,scope_Inh_VarDef :: Scope,sourcePos_Inh_VarDef :: MySourcePos} data Syn_VarDef = Syn_VarDef {actualValue_Syn_VarDef :: VarDef,messages_Syn_VarDef :: [Message],nodeType_Syn_VarDef :: Type} wrap_VarDef :: T_VarDef -> Inh_VarDef -> Syn_VarDef wrap_VarDef sem (Inh_VarDef _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_VarDef _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_VarDef_VarDef :: String -> T_TypeName -> (Maybe Expression) -> T_VarDef sem_VarDef_VarDef name_ typ_ value_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: VarDef _typOinLoop :: Bool _typOscope :: Scope _typOsourcePos :: MySourcePos _typIactualValue :: TypeName _typImessages :: ([Message]) _typInodeType :: Type _lhsOmessages = _typImessages _lhsOnodeType = _typInodeType _actualValue = VarDef name_ _typIactualValue value_ _lhsOactualValue = _actualValue _typOinLoop = _lhsIinLoop _typOscope = _lhsIscope _typOsourcePos = _lhsIsourcePos ( _typIactualValue,_typImessages,_typInodeType) = (typ_ _typOinLoop _typOscope _typOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- VarDefList -------------------------------------------------- type VarDefList = [(VarDef)] -- cata sem_VarDefList :: VarDefList -> T_VarDefList sem_VarDefList list = (Prelude.foldr sem_VarDefList_Cons sem_VarDefList_Nil (Prelude.map sem_VarDef list) ) -- semantic domain type T_VarDefList = Bool -> Scope -> MySourcePos -> ( VarDefList,([Message]),Type) data Inh_VarDefList = Inh_VarDefList {inLoop_Inh_VarDefList :: Bool,scope_Inh_VarDefList :: Scope,sourcePos_Inh_VarDefList :: MySourcePos} data Syn_VarDefList = Syn_VarDefList {actualValue_Syn_VarDefList :: VarDefList,messages_Syn_VarDefList :: [Message],nodeType_Syn_VarDefList :: Type} wrap_VarDefList :: T_VarDefList -> Inh_VarDefList -> Syn_VarDefList wrap_VarDefList sem (Inh_VarDefList _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_VarDefList _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_VarDefList_Cons :: T_VarDef -> T_VarDefList -> T_VarDefList sem_VarDefList_Cons hd_ tl_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: VarDefList _hdOinLoop :: Bool _hdOscope :: Scope _hdOsourcePos :: MySourcePos _tlOinLoop :: Bool _tlOscope :: Scope _tlOsourcePos :: MySourcePos _hdIactualValue :: VarDef _hdImessages :: ([Message]) _hdInodeType :: Type _tlIactualValue :: VarDefList _tlImessages :: ([Message]) _tlInodeType :: Type _lhsOmessages = _hdImessages ++ _tlImessages _lhsOnodeType = _hdInodeType `appendTypeList` _tlInodeType _actualValue = (:) _hdIactualValue _tlIactualValue _lhsOactualValue = _actualValue _hdOinLoop = _lhsIinLoop _hdOscope = _lhsIscope _hdOsourcePos = _lhsIsourcePos _tlOinLoop = _lhsIinLoop _tlOscope = _lhsIscope _tlOsourcePos = _lhsIsourcePos ( _hdIactualValue,_hdImessages,_hdInodeType) = (hd_ _hdOinLoop _hdOscope _hdOsourcePos ) ( _tlIactualValue,_tlImessages,_tlInodeType) = (tl_ _tlOinLoop _tlOscope _tlOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_VarDefList_Nil :: T_VarDefList sem_VarDefList_Nil = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: VarDefList _lhsOmessages = [] _lhsOnodeType = TypeList [] _actualValue = [] _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Volatility -------------------------------------------------- data Volatility = Immutable | Stable | Volatile deriving ( Eq,Show) -- cata sem_Volatility :: Volatility -> T_Volatility sem_Volatility (Immutable ) = (sem_Volatility_Immutable ) sem_Volatility (Stable ) = (sem_Volatility_Stable ) sem_Volatility (Volatile ) = (sem_Volatility_Volatile ) -- semantic domain type T_Volatility = Bool -> Scope -> MySourcePos -> ( Volatility,([Message]),Type) data Inh_Volatility = Inh_Volatility {inLoop_Inh_Volatility :: Bool,scope_Inh_Volatility :: Scope,sourcePos_Inh_Volatility :: MySourcePos} data Syn_Volatility = Syn_Volatility {actualValue_Syn_Volatility :: Volatility,messages_Syn_Volatility :: [Message],nodeType_Syn_Volatility :: Type} wrap_Volatility :: T_Volatility -> Inh_Volatility -> Syn_Volatility wrap_Volatility sem (Inh_Volatility _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Volatility _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Volatility_Immutable :: T_Volatility sem_Volatility_Immutable = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Volatility _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Immutable _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Volatility_Stable :: T_Volatility sem_Volatility_Stable = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Volatility _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Stable _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Volatility_Volatile :: T_Volatility sem_Volatility_Volatile = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOmessages :: ([Message]) _lhsOnodeType :: Type _lhsOactualValue :: Volatility _lhsOmessages = [] _lhsOnodeType = UnknownType _actualValue = Volatile _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) -- Where ------------------------------------------------------- type Where = (Maybe (Expression)) -- cata sem_Where :: Where -> T_Where sem_Where (Prelude.Just x ) = (sem_Where_Just (sem_Expression x ) ) sem_Where Prelude.Nothing = sem_Where_Nothing -- semantic domain type T_Where = Bool -> Scope -> MySourcePos -> ( Where,([Message]),Type) data Inh_Where = Inh_Where {inLoop_Inh_Where :: Bool,scope_Inh_Where :: Scope,sourcePos_Inh_Where :: MySourcePos} data Syn_Where = Syn_Where {actualValue_Syn_Where :: Where,messages_Syn_Where :: [Message],nodeType_Syn_Where :: Type} wrap_Where :: T_Where -> Inh_Where -> Syn_Where wrap_Where sem (Inh_Where _lhsIinLoop _lhsIscope _lhsIsourcePos ) = (let ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType) = (sem _lhsIinLoop _lhsIscope _lhsIsourcePos ) in (Syn_Where _lhsOactualValue _lhsOmessages _lhsOnodeType )) sem_Where_Just :: T_Expression -> T_Where sem_Where_Just just_ = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: Where _justOinLoop :: Bool _justOscope :: Scope _justOsourcePos :: MySourcePos _justIactualValue :: Expression _justIliftedColumnName :: String _justImessages :: ([Message]) _justInodeType :: Type _lhsOnodeType = checkErrors [_justInodeType] (if _justInodeType /= typeBool then TypeError _lhsIsourcePos ExpressionMustBeBool else typeBool) _lhsOmessages = _justImessages _actualValue = Just _justIactualValue _lhsOactualValue = _actualValue _justOinLoop = _lhsIinLoop _justOscope = _lhsIscope _justOsourcePos = _lhsIsourcePos ( _justIactualValue,_justIliftedColumnName,_justImessages,_justInodeType) = (just_ _justOinLoop _justOscope _justOsourcePos ) in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType))) sem_Where_Nothing :: T_Where sem_Where_Nothing = (\ _lhsIinLoop _lhsIscope _lhsIsourcePos -> (let _lhsOnodeType :: Type _lhsOmessages :: ([Message]) _lhsOactualValue :: Where _lhsOnodeType = typeBool _lhsOmessages = [] _actualValue = Nothing _lhsOactualValue = _actualValue in ( _lhsOactualValue,_lhsOmessages,_lhsOnodeType)))