diff --git a/Eval.hs b/Eval.hs index 8abd2948ae7220f8401b8870d0b1ebebb924003c..fed4608de8fed25645aded78ee27bd3b11133d83 100644 --- a/Eval.hs +++ b/Eval.hs @@ -19,7 +19,7 @@ eval env expr = let (eval', evalFull') = (eval env, evalFull env) in case expr o Filter -> let (Set inputRecords,predicate) = (eval' $ head inputSets, eval' $ head args) in Set $ filter ((==Boolean True).(\r -> eval' $ FuncCall predicate [] [r])) $ map eval' inputRecords - Map -> Set (map (\record -> FuncCall lambda [] [record]) records) + Map -> Set (map (\record -> eval' $ FuncCall lambda [] [record]) records) where (Set records:_) = inputSets (lambda:_) = args @@ -31,12 +31,12 @@ eval env expr = let (eval', evalFull') = (eval env, evalFull env) in case expr o Set $ [ x `concatRecord` y | x <- l1, y <- l2] RecordIndex -> let (Record recordData:Int index:_) = (map eval' args) in - recordData !! index + recordData !! (index - 1) - RecordSelect -> Record filteredList + RecordSelect -> debug (show expr) $ Record filteredList where - (Record recordData: indexes) = args - indexesRaw = map (\(Int i) -> i) indexes + (Record recordData: indexes) = map eval' args + indexesRaw = map (\(Int i) -> i - 1) indexes filteredList = map (recordData!!) indexesRaw @@ -49,7 +49,7 @@ eval env expr = let (eval', evalFull') = (eval env, evalFull env) in case expr o Contains -> case args of (mainString:containsWhat:_) -> case (eval' mainString , eval' containsWhat) of - (String a, String b) -> a `beginsWith` b + (String a, String b) -> b `sublist` a Plus -> let (e1:e2:_) = args in case (eval' e1, eval' e2) of (String a, String b) -> String (a ++ b) @@ -87,4 +87,5 @@ evalFull = eval --evalFull _ e = e --TODO implement properly concatRecord (Record r1) (Record r2) = Record (r1 ++ r2) -beginsWith = notImplemented \ No newline at end of file + +sublist = notImplemented \ No newline at end of file diff --git a/Interpreter.hs b/Interpreter.hs index 1b8ee24cfb27e02be165741e1596d2a0c45c6d69..6c4d9a6f1d114a65e218126c628c0953eec0a606 100644 --- a/Interpreter.hs +++ b/Interpreter.hs @@ -16,7 +16,7 @@ main = do args <- getArgs case args of (srcname:_) -> interpret srcname - _ -> interpret "solutions/pr1.cql" + _ -> interpret "solutions/pr2.cql" interpret :: FilePath -> IO () -- the main function, takes in file name, prints out result @@ -47,7 +47,7 @@ showFinal :: Expr -> IO () showFinal = (print2DList.sort2DListLex.setTo2DList) setTo2DList :: Expr -> [[String]] -setTo2DList (Set records) = map (map (\(String s) -> s).(\(Record list) -> list)) records +setTo2DList (Set records) = traceShow records $ map (map (\(String s) -> s).(\(Record list) -> list)) records -------------------------------------------- diff --git a/Lexer.x b/Lexer.x index 407bb44f6806a349c91aee2b3737cb0d3e938492..7dc070ef9d206945f2fae21371c245601a54b3e0 100644 --- a/Lexer.x +++ b/Lexer.x @@ -3,61 +3,113 @@ module Lexer where import Data.List } -%wrapper "basic" +%wrapper "posn" $digit = 0-9 +$posDigit = 1-9 $alpha = [a-zA-Z] $lower = [a-z] $upper = [A-Z] + +--\\map(\r -> r[1,2,3]) tokens :- $white+ ; -filter {\s -> TokenFilter } -true {\s -> TokenTrue } -false {\s -> TokenFalse } -\.in {\s -> TokenInSet } -\.out {\s -> TokenOutSet } -\[ {\s -> TokenLeftSqBracket } -\] {\s -> TokenRightSqBracket } -"->" {\s -> TokenArrow } -"==" {\s -> TokenisEqual } -"/=" {\s -> TokenisNotEqual } -\( {\s -> TokenLeftBracket } -\) {\s -> TokenRightBracket } -\; {\s -> TokenSemiCol } -\\ {\s -> TokenLambda } -\, {\s -> TokenComma } -\. {\s -> TokenFullStop } -x {\s -> TokenXProduct } -$lower [$lower $digit \_ \']* {\s -> TokenVarName s } -$upper[$alpha]* {\s -> TokenSetName s } -$digit+ {\s -> TokenNat (read s) } -\"[$alpha $digit]+\" {\s -> ((TokenString).init.tail) s } +\#.* ; +contains {\p s -> TokenContains p } +isEmpty {\p s -> TokenIsEmpty p } +filter {\p s -> TokenFilter p } +true {\p s -> TokenTrue p } +false {\p s -> TokenFalse p } +\.in {\p s -> TokenInSet p } +\.out {\p s -> TokenOutSet p } +\[ {\p s -> TokenLeftSqBracket p } +\] {\p s -> TokenRightSqBracket p } +"->" {\p s -> TokenArrow p } +"==" {\p s -> TokenisEqual p } +"/=" {\p s -> TokenisNotEqual p } +"+" {\p s -> TokenPlus p } +\( {\p s -> TokenLeftBracket p } +\) {\p s -> TokenRightBracket p } +\: {\p s -> TokenCol p } +\; {\p s -> TokenSemiCol p } +\\ {\p s -> TokenLambda p } +\, {\p s -> TokenComma p } +\. {\p s -> TokenFullStop p } +x {\p s -> TokenXProduct p } +xx {\p s -> TokenXXProduct p } +map {\p s -> TokenMap p } +$lower [$lower $digit \_ \']* {\p s -> TokenVarName p s } +$upper[$alpha]* {\p s -> TokenSetName p s } +--$posDigit$digit* {\p s -> TokenPosNat p (read s) } +$digit+ {\p s -> TokenNat p (read s) } +\"[$alpha $digit]+\" {\p s -> TokenString p (init.tail $ s) } + { --token type: -data Token = - TokenFilter | - TokenSetName String | - TokenFunc | - TokenNat Int | - TokenVarName String | - TokenTrue | - TokenFalse | - TokenString String | - TokenLeftSqBracket | - TokenRightSqBracket | - TokenArrow | - TokenisEqual | - TokenisNotEqual | - TokenLeftBracket | - TokenRightBracket | - TokenSemiCol | - TokenLambda | - TokenComma | - TokenFullStop | - TokenInSet | - TokenXProduct | - TokenOutSet +data Token = + TokenFilter AlexPosn | + TokenIsEmpty AlexPosn | + TokenContains AlexPosn | + TokenSetName AlexPosn String | + TokenNat AlexPosn Int | + TokenPosNat AlexPosn Int | + TokenVarName AlexPosn String | + TokenTrue AlexPosn | + TokenFalse AlexPosn | + TokenString AlexPosn String | + TokenLeftSqBracket AlexPosn | + TokenRightSqBracket AlexPosn | + TokenArrow AlexPosn | + TokenisEqual AlexPosn | + TokenisNotEqual AlexPosn | + TokenPlus AlexPosn | + TokenLeftBracket AlexPosn | + TokenRightBracket AlexPosn | + TokenSemiCol AlexPosn | + TokenCol AlexPosn | + TokenLambda AlexPosn | + TokenComma AlexPosn | + TokenFullStop AlexPosn | + TokenInSet AlexPosn | + TokenXProduct AlexPosn | + TokenXXProduct AlexPosn | + TokenOutSet AlexPosn | + TokenMap AlexPosn deriving (Eq, Show) -} + + +pos :: Token -> AlexPosn + +pos token = case token of + (TokenFilter p ) -> p + (TokenIsEmpty p ) -> p + (TokenContains p ) -> p + (TokenSetName p _) -> p + (TokenNat p _) -> p + (TokenPosNat p _) -> p + (TokenVarName p _) -> p + (TokenTrue p ) -> p + (TokenFalse p ) -> p + (TokenString p _) -> p + (TokenLeftSqBracket p ) -> p + (TokenRightSqBracket p ) -> p + (TokenArrow p ) -> p + (TokenisEqual p ) -> p + (TokenisNotEqual p ) -> p + (TokenPlus p ) -> p + (TokenLeftBracket p ) -> p + (TokenRightBracket p ) -> p + (TokenSemiCol p ) -> p + (TokenCol p ) -> p + (TokenLambda p ) -> p + (TokenComma p ) -> p + (TokenFullStop p ) -> p + (TokenInSet p ) -> p + (TokenXProduct p ) -> p + (TokenXXProduct p ) -> p + (TokenOutSet p ) -> p + (TokenMap p) -> p + +} \ No newline at end of file diff --git a/Parser.hs b/Parser.hs index c0bd9cc10606a5929f2ed9278bb2db15e0c7c398..181d17c18287e44ab1d5736e1099f727ca29f5cd 100644 --- a/Parser.hs +++ b/Parser.hs @@ -2,6 +2,7 @@ module Parser where import Lexer import Types +import CSV import qualified Data.Array as Happy_Data_Array import qualified Data.Bits as Bits import Control.Applicative(Applicative(..)) @@ -9,7 +10,7 @@ import Control.Monad (ap) -- parser produced by Happy Version 1.20.0 -data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 +data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15 t16 t17 = HappyTerminal (Token) | HappyErrorToken Prelude.Int | HappyAbsSyn4 t4 @@ -21,375 +22,614 @@ data HappyAbsSyn t4 t5 t6 t7 t8 t9 t10 t11 t12 | HappyAbsSyn10 t10 | HappyAbsSyn11 t11 | HappyAbsSyn12 t12 + | HappyAbsSyn13 t13 + | HappyAbsSyn14 t14 + | HappyAbsSyn15 t15 + | HappyAbsSyn16 t16 + | HappyAbsSyn17 t17 happyExpList :: Happy_Data_Array.Array Prelude.Int Prelude.Int -happyExpList = Happy_Data_Array.listArray (0,75) ([8192,0,16384,0,0,2,0,0,0,4,0,0,8,32,0,8,0,0,0,0,32,32768,0,0,0,2048,0,512,0,0,0,0,32,0,1024,0,16384,0,8192,0,8192,0,32,0,0,0,0,2,0,32,512,0,0,1,63488,0,0,0,0,18,0,0,0,0,0,0,0,0,0,0,0,248,0,2304,2,1024,0,32,0,3968,0,0,0,16384,0,0,0,63488,0,0,0,0,0,0 +happyExpList = Happy_Data_Array.listArray (0,118) ([0,4,0,0,1,0,0,1,0,0,0,0,0,0,0,512,2048,0,0,128,0,128,0,0,18,512,0,4,0,0,0,0,0,0,0,0,1024,0,0,66,0,0,4096,0,0,4,0,0,0,0,0,4,0,1,0,16384,0,0,0,4096,0,1152,32768,0,0,0,0,0,8,0,0,1,0,1024,0,0,0,0,0,2048,0,0,0,0,0,64,0,2048,0,0,0,0,0,0,2,0,0,8,0,0,1,0,2048,0,32768,0,0,0,8,0,63488,32768,1,0,0,0,0,0,0,4608,0,0,4096,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,992,1536,0,0,0,0,0,0,0,8264,0,0,4,0,63488,32768,1,128,0,0,3968,6144,0,0,0,0,256,2,0,2048,0,0,0,0,57344,3,6,0,0,0,0,0,0,0,0,0,8,0,0,256,0,0,32768,0,8192,0,0,0,0,0,0,0,0,0 ]) {-# NOINLINE happyExpListPerState #-} happyExpListPerState st = token_strs_expected - where token_strs = ["error","%dummy","%start_parseSource","Prog","SetNames","VarNames","SetFuncCalls","SetFuncCall","Func","Expr","Record","Exprs","filter","in","out","SetName","Nat","VarName","true","false","Str","'['","']'","\"->\"","\"==\"","\"/=\"","'('","')'","';'","'\\\\'","','","'.'","%eof"] - bit_start = st Prelude.* 33 - bit_end = (st Prelude.+ 1) Prelude.* 33 + where token_strs = ["error","%dummy","%start_parseSource","Prog","SetDecl","SetDecls","SetNames","VarNames","SetFuncCalls","SetFuncCall","Func","Expr","Function","PredefFunc","Record","Exprs","Nats","filter","in","out","SetName","Nat","PosNat","VarName","true","false","Str","'['","']'","\"->\"","\"==\"","\"/=\"","'('","')'","';'","':'","'\\\\'","','","'.'","'+'","x","map","xx","contains","isEmpty","%eof"] + bit_start = st Prelude.* 46 + bit_end = (st Prelude.+ 1) Prelude.* 46 read_bit = readArrayBit happyExpList bits = Prelude.map read_bit [bit_start..bit_end Prelude.- 1] - bits_indexed = Prelude.zip bits [0..32] + bits_indexed = Prelude.zip bits [0..45] token_strs_expected = Prelude.concatMap f bits_indexed f (Prelude.False, _) = [] f (Prelude.True, nr) = [token_strs Prelude.!! nr] -action_0 (14) = happyShift action_2 +action_0 (19) = happyShift action_2 action_0 (4) = happyGoto action_3 action_0 _ = happyFail (happyExpListPerState 0) -action_1 (14) = happyShift action_2 +action_1 (19) = happyShift action_2 action_1 _ = happyFail (happyExpListPerState 1) -action_2 (16) = happyShift action_5 +action_2 (21) = happyShift action_6 action_2 (5) = happyGoto action_4 +action_2 (6) = happyGoto action_5 action_2 _ = happyFail (happyExpListPerState 2) -action_3 (33) = happyAccept +action_3 (46) = happyAccept action_3 _ = happyFail (happyExpListPerState 3) -action_4 (15) = happyShift action_7 -action_4 _ = happyFail (happyExpListPerState 4) +action_4 _ = happyReduce_3 -action_5 (31) = happyShift action_6 -action_5 _ = happyReduce_2 +action_5 (20) = happyShift action_8 +action_5 (38) = happyShift action_9 +action_5 _ = happyFail (happyExpListPerState 5) -action_6 (16) = happyShift action_5 -action_6 (5) = happyGoto action_11 +action_6 (36) = happyShift action_7 action_6 _ = happyFail (happyExpListPerState 6) -action_7 (13) = happyShift action_10 -action_7 (7) = happyGoto action_8 -action_7 (8) = happyGoto action_9 +action_7 (22) = happyShift action_16 action_7 _ = happyFail (happyExpListPerState 7) -action_8 _ = happyReduce_1 +action_8 (18) = happyShift action_13 +action_8 (21) = happyShift action_14 +action_8 (42) = happyShift action_15 +action_8 (9) = happyGoto action_11 +action_8 (10) = happyGoto action_12 +action_8 _ = happyFail (happyExpListPerState 8) -action_9 (29) = happyShift action_13 -action_9 _ = happyReduce_6 +action_9 (21) = happyShift action_6 +action_9 (5) = happyGoto action_10 +action_9 _ = happyFail (happyExpListPerState 9) -action_10 (22) = happyShift action_12 -action_10 _ = happyFail (happyExpListPerState 10) +action_10 _ = happyReduce_4 -action_11 _ = happyReduce_3 +action_11 _ = happyReduce_1 -action_12 (16) = happyShift action_15 +action_12 (35) = happyShift action_21 action_12 _ = happyFail (happyExpListPerState 12) -action_13 (13) = happyShift action_10 -action_13 (7) = happyGoto action_14 -action_13 (8) = happyGoto action_9 +action_13 (28) = happyShift action_19 +action_13 (33) = happyShift action_20 action_13 _ = happyFail (happyExpListPerState 13) -action_14 _ = happyReduce_7 +action_14 (41) = happyShift action_18 +action_14 _ = happyFail (happyExpListPerState 14) -action_15 (23) = happyShift action_16 +action_15 (33) = happyShift action_17 action_15 _ = happyFail (happyExpListPerState 15) -action_16 (27) = happyShift action_17 -action_16 _ = happyFail (happyExpListPerState 16) +action_16 _ = happyReduce_2 -action_17 (30) = happyShift action_19 -action_17 (9) = happyGoto action_18 +action_17 (37) = happyShift action_24 +action_17 (11) = happyGoto action_27 action_17 _ = happyFail (happyExpListPerState 17) -action_18 (28) = happyShift action_21 +action_18 (21) = happyShift action_26 action_18 _ = happyFail (happyExpListPerState 18) -action_19 (27) = happyShift action_20 +action_19 (21) = happyShift action_25 action_19 _ = happyFail (happyExpListPerState 19) -action_20 (18) = happyShift action_23 -action_20 (6) = happyGoto action_22 +action_20 (37) = happyShift action_24 +action_20 (11) = happyGoto action_23 action_20 _ = happyFail (happyExpListPerState 20) -action_21 _ = happyReduce_8 +action_21 (18) = happyShift action_13 +action_21 (21) = happyShift action_14 +action_21 (42) = happyShift action_15 +action_21 (9) = happyGoto action_22 +action_21 (10) = happyGoto action_12 +action_21 _ = happyReduce_9 -action_22 (28) = happyShift action_25 -action_22 _ = happyFail (happyExpListPerState 22) +action_22 _ = happyReduce_10 -action_23 (31) = happyShift action_24 -action_23 _ = happyReduce_4 +action_23 (34) = happyShift action_31 +action_23 _ = happyFail (happyExpListPerState 23) -action_24 (18) = happyShift action_23 -action_24 (6) = happyGoto action_27 +action_24 (33) = happyShift action_30 action_24 _ = happyFail (happyExpListPerState 24) -action_25 (24) = happyShift action_26 +action_25 (29) = happyShift action_29 action_25 _ = happyFail (happyExpListPerState 25) -action_26 (18) = happyShift action_30 -action_26 (19) = happyShift action_31 -action_26 (20) = happyShift action_32 -action_26 (21) = happyShift action_33 -action_26 (22) = happyShift action_34 -action_26 (10) = happyGoto action_28 -action_26 (11) = happyGoto action_29 -action_26 _ = happyFail (happyExpListPerState 26) +action_26 _ = happyReduce_14 -action_27 _ = happyReduce_5 +action_27 (34) = happyShift action_28 +action_27 _ = happyFail (happyExpListPerState 27) -action_28 (22) = happyShift action_37 -action_28 (25) = happyShift action_38 -action_28 _ = happyReduce_9 +action_28 _ = happyReduce_13 -action_29 _ = happyReduce_14 +action_29 (33) = happyShift action_34 +action_29 _ = happyFail (happyExpListPerState 29) -action_30 _ = happyReduce_13 +action_30 (24) = happyShift action_33 +action_30 (8) = happyGoto action_32 +action_30 _ = happyFail (happyExpListPerState 30) -action_31 _ = happyReduce_15 +action_31 _ = happyReduce_12 -action_32 _ = happyReduce_16 +action_32 (34) = happyShift action_37 +action_32 _ = happyFail (happyExpListPerState 32) -action_33 _ = happyReduce_12 +action_33 (38) = happyShift action_36 +action_33 _ = happyReduce_7 -action_34 (18) = happyShift action_30 -action_34 (19) = happyShift action_31 -action_34 (20) = happyShift action_32 -action_34 (21) = happyShift action_33 -action_34 (22) = happyShift action_34 -action_34 (10) = happyGoto action_35 -action_34 (11) = happyGoto action_29 -action_34 (12) = happyGoto action_36 +action_34 (37) = happyShift action_24 +action_34 (11) = happyGoto action_35 action_34 _ = happyFail (happyExpListPerState 34) -action_35 (22) = happyShift action_37 -action_35 (25) = happyShift action_38 -action_35 (31) = happyShift action_42 -action_35 _ = happyReduce_18 +action_35 (34) = happyShift action_40 +action_35 _ = happyFail (happyExpListPerState 35) -action_36 (23) = happyShift action_41 +action_36 (24) = happyShift action_33 +action_36 (8) = happyGoto action_39 action_36 _ = happyFail (happyExpListPerState 36) -action_37 (17) = happyShift action_40 +action_37 (30) = happyShift action_38 action_37 _ = happyFail (happyExpListPerState 37) -action_38 (18) = happyShift action_30 -action_38 (19) = happyShift action_31 -action_38 (20) = happyShift action_32 -action_38 (21) = happyShift action_33 -action_38 (22) = happyShift action_34 -action_38 (10) = happyGoto action_39 -action_38 (11) = happyGoto action_29 +action_38 (24) = happyShift action_45 +action_38 (25) = happyShift action_46 +action_38 (26) = happyShift action_47 +action_38 (27) = happyShift action_48 +action_38 (28) = happyShift action_49 +action_38 (44) = happyShift action_50 +action_38 (45) = happyShift action_51 +action_38 (12) = happyGoto action_41 +action_38 (13) = happyGoto action_42 +action_38 (14) = happyGoto action_43 +action_38 (15) = happyGoto action_44 action_38 _ = happyFail (happyExpListPerState 38) -action_39 (22) = happyShift action_37 -action_39 _ = happyReduce_10 +action_39 _ = happyReduce_8 -action_40 (23) = happyShift action_44 -action_40 _ = happyFail (happyExpListPerState 40) +action_40 _ = happyReduce_11 -action_41 _ = happyReduce_17 +action_41 (28) = happyShift action_55 +action_41 (31) = happyShift action_56 +action_41 _ = happyReduce_15 -action_42 (18) = happyShift action_30 -action_42 (19) = happyShift action_31 -action_42 (20) = happyShift action_32 -action_42 (21) = happyShift action_33 -action_42 (22) = happyShift action_34 -action_42 (10) = happyGoto action_35 -action_42 (11) = happyGoto action_29 -action_42 (12) = happyGoto action_43 +action_42 (33) = happyShift action_54 action_42 _ = happyFail (happyExpListPerState 42) -action_43 _ = happyReduce_19 - -action_44 _ = happyReduce_11 +action_43 _ = happyReduce_25 + +action_44 _ = happyReduce_22 + +action_45 (33) = happyReduce_26 +action_45 _ = happyReduce_21 + +action_46 _ = happyReduce_23 + +action_47 _ = happyReduce_24 + +action_48 _ = happyReduce_20 + +action_49 (24) = happyShift action_45 +action_49 (25) = happyShift action_46 +action_49 (26) = happyShift action_47 +action_49 (27) = happyShift action_48 +action_49 (28) = happyShift action_49 +action_49 (44) = happyShift action_50 +action_49 (45) = happyShift action_51 +action_49 (12) = happyGoto action_52 +action_49 (13) = happyGoto action_42 +action_49 (14) = happyGoto action_43 +action_49 (15) = happyGoto action_44 +action_49 (16) = happyGoto action_53 +action_49 _ = happyFail (happyExpListPerState 49) + +action_50 _ = happyReduce_28 + +action_51 _ = happyReduce_27 + +action_52 (28) = happyShift action_55 +action_52 (31) = happyShift action_56 +action_52 (38) = happyShift action_61 +action_52 _ = happyReduce_30 + +action_53 (29) = happyShift action_60 +action_53 _ = happyFail (happyExpListPerState 53) + +action_54 (24) = happyShift action_45 +action_54 (25) = happyShift action_46 +action_54 (26) = happyShift action_47 +action_54 (27) = happyShift action_48 +action_54 (28) = happyShift action_49 +action_54 (44) = happyShift action_50 +action_54 (45) = happyShift action_51 +action_54 (12) = happyGoto action_52 +action_54 (13) = happyGoto action_42 +action_54 (14) = happyGoto action_43 +action_54 (15) = happyGoto action_44 +action_54 (16) = happyGoto action_59 +action_54 _ = happyFail (happyExpListPerState 54) + +action_55 (22) = happyShift action_58 +action_55 _ = happyFail (happyExpListPerState 55) + +action_56 (24) = happyShift action_45 +action_56 (25) = happyShift action_46 +action_56 (26) = happyShift action_47 +action_56 (27) = happyShift action_48 +action_56 (28) = happyShift action_49 +action_56 (44) = happyShift action_50 +action_56 (45) = happyShift action_51 +action_56 (12) = happyGoto action_57 +action_56 (13) = happyGoto action_42 +action_56 (14) = happyGoto action_43 +action_56 (15) = happyGoto action_44 +action_56 _ = happyFail (happyExpListPerState 56) + +action_57 (28) = happyShift action_55 +action_57 _ = happyReduce_16 + +action_58 (29) = happyShift action_64 +action_58 (38) = happyShift action_65 +action_58 _ = happyFail (happyExpListPerState 58) + +action_59 (34) = happyShift action_63 +action_59 _ = happyFail (happyExpListPerState 59) + +action_60 _ = happyReduce_29 + +action_61 (24) = happyShift action_45 +action_61 (25) = happyShift action_46 +action_61 (26) = happyShift action_47 +action_61 (27) = happyShift action_48 +action_61 (28) = happyShift action_49 +action_61 (44) = happyShift action_50 +action_61 (45) = happyShift action_51 +action_61 (12) = happyGoto action_52 +action_61 (13) = happyGoto action_42 +action_61 (14) = happyGoto action_43 +action_61 (15) = happyGoto action_44 +action_61 (16) = happyGoto action_62 +action_61 _ = happyFail (happyExpListPerState 61) + +action_62 _ = happyReduce_31 + +action_63 _ = happyReduce_19 + +action_64 _ = happyReduce_17 + +action_65 (22) = happyShift action_67 +action_65 (17) = happyGoto action_66 +action_65 _ = happyFail (happyExpListPerState 65) + +action_66 (29) = happyShift action_69 +action_66 _ = happyFail (happyExpListPerState 66) + +action_67 (38) = happyShift action_68 +action_67 _ = happyReduce_32 + +action_68 (22) = happyShift action_67 +action_68 (17) = happyGoto action_70 +action_68 _ = happyFail (happyExpListPerState 68) + +action_69 _ = happyReduce_18 + +action_70 _ = happyReduce_33 happyReduce_1 = happyReduce 4 4 happyReduction_1 -happyReduction_1 ((HappyAbsSyn7 happy_var_4) `HappyStk` +happyReduction_1 ((HappyAbsSyn9 happy_var_4) `HappyStk` _ `HappyStk` - (HappyAbsSyn5 happy_var_2) `HappyStk` + (HappyAbsSyn6 happy_var_2) `HappyStk` _ `HappyStk` happyRest) = HappyAbsSyn4 ((happy_var_2,happy_var_4) ) `HappyStk` happyRest -happyReduce_2 = happySpecReduce_1 5 happyReduction_2 -happyReduction_2 (HappyTerminal (TokenSetName happy_var_1)) +happyReduce_2 = happySpecReduce_3 5 happyReduction_2 +happyReduction_2 _ + _ + (HappyTerminal (TokenSetName _ happy_var_1)) = HappyAbsSyn5 + (happy_var_1 + ) +happyReduction_2 _ _ _ = notHappyAtAll + +happyReduce_3 = happySpecReduce_1 6 happyReduction_3 +happyReduction_3 (HappyAbsSyn5 happy_var_1) + = HappyAbsSyn6 ([happy_var_1] ) -happyReduction_2 _ = notHappyAtAll +happyReduction_3 _ = notHappyAtAll -happyReduce_3 = happySpecReduce_3 5 happyReduction_3 -happyReduction_3 (HappyAbsSyn5 happy_var_3) +happyReduce_4 = happySpecReduce_3 6 happyReduction_4 +happyReduction_4 (HappyAbsSyn5 happy_var_3) _ - (HappyTerminal (TokenSetName happy_var_1)) - = HappyAbsSyn5 + (HappyAbsSyn6 happy_var_1) + = HappyAbsSyn6 + (happy_var_3:happy_var_1 + ) +happyReduction_4 _ _ _ = notHappyAtAll + +happyReduce_5 = happySpecReduce_1 7 happyReduction_5 +happyReduction_5 (HappyTerminal (TokenSetName _ happy_var_1)) + = HappyAbsSyn7 + ([happy_var_1] + ) +happyReduction_5 _ = notHappyAtAll + +happyReduce_6 = happySpecReduce_3 7 happyReduction_6 +happyReduction_6 (HappyAbsSyn7 happy_var_3) + _ + (HappyTerminal (TokenSetName _ happy_var_1)) + = HappyAbsSyn7 (happy_var_1:happy_var_3 ) -happyReduction_3 _ _ _ = notHappyAtAll +happyReduction_6 _ _ _ = notHappyAtAll -happyReduce_4 = happySpecReduce_1 6 happyReduction_4 -happyReduction_4 (HappyTerminal (TokenVarName happy_var_1)) - = HappyAbsSyn6 +happyReduce_7 = happySpecReduce_1 8 happyReduction_7 +happyReduction_7 (HappyTerminal (TokenVarName _ happy_var_1)) + = HappyAbsSyn8 ([happy_var_1] ) -happyReduction_4 _ = notHappyAtAll +happyReduction_7 _ = notHappyAtAll -happyReduce_5 = happySpecReduce_3 6 happyReduction_5 -happyReduction_5 (HappyAbsSyn6 happy_var_3) +happyReduce_8 = happySpecReduce_3 8 happyReduction_8 +happyReduction_8 (HappyAbsSyn8 happy_var_3) _ - (HappyTerminal (TokenVarName happy_var_1)) - = HappyAbsSyn6 + (HappyTerminal (TokenVarName _ happy_var_1)) + = HappyAbsSyn8 (happy_var_1:happy_var_3 ) -happyReduction_5 _ _ _ = notHappyAtAll +happyReduction_8 _ _ _ = notHappyAtAll -happyReduce_6 = happySpecReduce_1 7 happyReduction_6 -happyReduction_6 (HappyAbsSyn8 happy_var_1) - = HappyAbsSyn7 +happyReduce_9 = happySpecReduce_2 9 happyReduction_9 +happyReduction_9 _ + (HappyAbsSyn10 happy_var_1) + = HappyAbsSyn9 ([happy_var_1] ) -happyReduction_6 _ = notHappyAtAll +happyReduction_9 _ _ = notHappyAtAll -happyReduce_7 = happySpecReduce_3 7 happyReduction_7 -happyReduction_7 (HappyAbsSyn7 happy_var_3) +happyReduce_10 = happySpecReduce_3 9 happyReduction_10 +happyReduction_10 (HappyAbsSyn9 happy_var_3) _ - (HappyAbsSyn8 happy_var_1) - = HappyAbsSyn7 + (HappyAbsSyn10 happy_var_1) + = HappyAbsSyn9 (happy_var_1:happy_var_3 ) -happyReduction_7 _ _ _ = notHappyAtAll +happyReduction_10 _ _ _ = notHappyAtAll -happyReduce_8 = happyReduce 7 8 happyReduction_8 -happyReduction_8 (_ `HappyStk` - (HappyAbsSyn9 happy_var_6) `HappyStk` +happyReduce_11 = happyReduce 7 10 happyReduction_11 +happyReduction_11 (_ `HappyStk` + (HappyAbsSyn11 happy_var_6) `HappyStk` _ `HappyStk` _ `HappyStk` - (HappyTerminal (TokenSetName happy_var_3)) `HappyStk` + (HappyTerminal (TokenSetName _ happy_var_3)) `HappyStk` _ `HappyStk` _ `HappyStk` happyRest) - = HappyAbsSyn8 + = HappyAbsSyn10 (FuncCall (PredefFunc Filter) [Var happy_var_3] [happy_var_6] ) `HappyStk` happyRest -happyReduce_9 = happyReduce 6 9 happyReduction_9 -happyReduction_9 ((HappyAbsSyn10 happy_var_6) `HappyStk` +happyReduce_12 = happyReduce 4 10 happyReduction_12 +happyReduction_12 (_ `HappyStk` + (HappyAbsSyn11 happy_var_3) `HappyStk` _ `HappyStk` _ `HappyStk` - (HappyAbsSyn6 happy_var_3) `HappyStk` + happyRest) + = HappyAbsSyn10 + (FuncCall (PredefFunc Filter) [] [happy_var_3] + ) `HappyStk` happyRest + +happyReduce_13 = happyReduce 4 10 happyReduction_13 +happyReduction_13 (_ `HappyStk` + (HappyAbsSyn11 happy_var_3) `HappyStk` _ `HappyStk` _ `HappyStk` happyRest) - = HappyAbsSyn9 - (FuncDef [] happy_var_3 happy_var_6 + = HappyAbsSyn10 + (FuncCall (PredefFunc Map) [] [happy_var_3] ) `HappyStk` happyRest -happyReduce_10 = happySpecReduce_3 10 happyReduction_10 -happyReduction_10 (HappyAbsSyn10 happy_var_3) +happyReduce_14 = happySpecReduce_3 10 happyReduction_14 +happyReduction_14 (HappyTerminal (TokenSetName _ happy_var_3)) _ - (HappyAbsSyn10 happy_var_1) + (HappyTerminal (TokenSetName _ happy_var_1)) = HappyAbsSyn10 + (FuncCall (PredefFunc XProduct) (map Var [happy_var_1, happy_var_3]) [] + ) +happyReduction_14 _ _ _ = notHappyAtAll + +happyReduce_15 = happyReduce 6 11 happyReduction_15 +happyReduction_15 ((HappyAbsSyn12 happy_var_6) `HappyStk` + _ `HappyStk` + _ `HappyStk` + (HappyAbsSyn8 happy_var_3) `HappyStk` + _ `HappyStk` + _ `HappyStk` + happyRest) + = HappyAbsSyn11 + (FuncDef [] happy_var_3 happy_var_6 + ) `HappyStk` happyRest + +happyReduce_16 = happySpecReduce_3 12 happyReduction_16 +happyReduction_16 (HappyAbsSyn12 happy_var_3) + _ + (HappyAbsSyn12 happy_var_1) + = HappyAbsSyn12 (FuncCall (PredefFunc IsEqual) [] [happy_var_1, happy_var_3] ) -happyReduction_10 _ _ _ = notHappyAtAll +happyReduction_16 _ _ _ = notHappyAtAll -happyReduce_11 = happyReduce 4 10 happyReduction_11 -happyReduction_11 (_ `HappyStk` - (HappyTerminal (TokenNat happy_var_3)) `HappyStk` +happyReduce_17 = happyReduce 4 12 happyReduction_17 +happyReduction_17 (_ `HappyStk` + (HappyTerminal (TokenNat _ happy_var_3)) `HappyStk` _ `HappyStk` - (HappyAbsSyn10 happy_var_1) `HappyStk` + (HappyAbsSyn12 happy_var_1) `HappyStk` happyRest) - = HappyAbsSyn10 + = HappyAbsSyn12 (FuncCall (PredefFunc RecordIndex) [] [happy_var_1, Types.Int happy_var_3] ) `HappyStk` happyRest -happyReduce_12 = happySpecReduce_1 10 happyReduction_12 -happyReduction_12 (HappyTerminal (TokenString happy_var_1)) - = HappyAbsSyn10 - (Types.String happy_var_1 +happyReduce_18 = happyReduce 6 12 happyReduction_18 +happyReduction_18 (_ `HappyStk` + (HappyAbsSyn17 happy_var_5) `HappyStk` + _ `HappyStk` + (HappyTerminal (TokenNat _ happy_var_3)) `HappyStk` + _ `HappyStk` + (HappyAbsSyn12 happy_var_1) `HappyStk` + happyRest) + = HappyAbsSyn12 + (FuncCall (PredefFunc RecordSelect) [] (happy_var_1:(map Types.Int (happy_var_3:happy_var_5))) + ) `HappyStk` happyRest + +happyReduce_19 = happyReduce 4 12 happyReduction_19 +happyReduction_19 (_ `HappyStk` + (HappyAbsSyn16 happy_var_3) `HappyStk` + _ `HappyStk` + (HappyAbsSyn13 happy_var_1) `HappyStk` + happyRest) + = HappyAbsSyn12 + (FuncCall happy_var_1 [] happy_var_3 + ) `HappyStk` happyRest + +happyReduce_20 = happySpecReduce_1 12 happyReduction_20 +happyReduction_20 (HappyTerminal (TokenString _ happy_var_1)) + = HappyAbsSyn12 + (Types.String $ stripWhitespace happy_var_1 ) -happyReduction_12 _ = notHappyAtAll +happyReduction_20 _ = notHappyAtAll -happyReduce_13 = happySpecReduce_1 10 happyReduction_13 -happyReduction_13 (HappyTerminal (TokenVarName happy_var_1)) - = HappyAbsSyn10 +happyReduce_21 = happySpecReduce_1 12 happyReduction_21 +happyReduction_21 (HappyTerminal (TokenVarName _ happy_var_1)) + = HappyAbsSyn12 (Var happy_var_1 ) -happyReduction_13 _ = notHappyAtAll +happyReduction_21 _ = notHappyAtAll -happyReduce_14 = happySpecReduce_1 10 happyReduction_14 -happyReduction_14 (HappyAbsSyn11 happy_var_1) - = HappyAbsSyn10 +happyReduce_22 = happySpecReduce_1 12 happyReduction_22 +happyReduction_22 (HappyAbsSyn15 happy_var_1) + = HappyAbsSyn12 (happy_var_1 ) -happyReduction_14 _ = notHappyAtAll +happyReduction_22 _ = notHappyAtAll -happyReduce_15 = happySpecReduce_1 10 happyReduction_15 -happyReduction_15 _ - = HappyAbsSyn10 +happyReduce_23 = happySpecReduce_1 12 happyReduction_23 +happyReduction_23 _ + = HappyAbsSyn12 (Boolean True ) -happyReduce_16 = happySpecReduce_1 10 happyReduction_16 -happyReduction_16 _ - = HappyAbsSyn10 +happyReduce_24 = happySpecReduce_1 12 happyReduction_24 +happyReduction_24 _ + = HappyAbsSyn12 (Boolean False ) -happyReduce_17 = happySpecReduce_3 11 happyReduction_17 -happyReduction_17 _ - (HappyAbsSyn12 happy_var_2) +happyReduce_25 = happySpecReduce_1 13 happyReduction_25 +happyReduction_25 (HappyAbsSyn14 happy_var_1) + = HappyAbsSyn13 + (PredefFunc happy_var_1 + ) +happyReduction_25 _ = notHappyAtAll + +happyReduce_26 = happySpecReduce_1 13 happyReduction_26 +happyReduction_26 (HappyTerminal (TokenVarName _ happy_var_1)) + = HappyAbsSyn13 + (Var happy_var_1 + ) +happyReduction_26 _ = notHappyAtAll + +happyReduce_27 = happySpecReduce_1 14 happyReduction_27 +happyReduction_27 _ + = HappyAbsSyn14 + (IsEmpty + ) + +happyReduce_28 = happySpecReduce_1 14 happyReduction_28 +happyReduction_28 _ + = HappyAbsSyn14 + (Contains + ) + +happyReduce_29 = happySpecReduce_3 15 happyReduction_29 +happyReduction_29 _ + (HappyAbsSyn16 happy_var_2) _ - = HappyAbsSyn11 + = HappyAbsSyn15 (Record happy_var_2 ) -happyReduction_17 _ _ _ = notHappyAtAll +happyReduction_29 _ _ _ = notHappyAtAll -happyReduce_18 = happySpecReduce_1 12 happyReduction_18 -happyReduction_18 (HappyAbsSyn10 happy_var_1) - = HappyAbsSyn12 +happyReduce_30 = happySpecReduce_1 16 happyReduction_30 +happyReduction_30 (HappyAbsSyn12 happy_var_1) + = HappyAbsSyn16 ([happy_var_1] ) -happyReduction_18 _ = notHappyAtAll +happyReduction_30 _ = notHappyAtAll -happyReduce_19 = happySpecReduce_3 12 happyReduction_19 -happyReduction_19 (HappyAbsSyn12 happy_var_3) +happyReduce_31 = happySpecReduce_3 16 happyReduction_31 +happyReduction_31 (HappyAbsSyn16 happy_var_3) _ - (HappyAbsSyn10 happy_var_1) - = HappyAbsSyn12 + (HappyAbsSyn12 happy_var_1) + = HappyAbsSyn16 + (happy_var_1:happy_var_3 + ) +happyReduction_31 _ _ _ = notHappyAtAll + +happyReduce_32 = happySpecReduce_1 17 happyReduction_32 +happyReduction_32 (HappyTerminal (TokenNat _ happy_var_1)) + = HappyAbsSyn17 + ([happy_var_1] + ) +happyReduction_32 _ = notHappyAtAll + +happyReduce_33 = happySpecReduce_3 17 happyReduction_33 +happyReduction_33 (HappyAbsSyn17 happy_var_3) + _ + (HappyTerminal (TokenNat _ happy_var_1)) + = HappyAbsSyn17 (happy_var_1:happy_var_3 ) -happyReduction_19 _ _ _ = notHappyAtAll +happyReduction_33 _ _ _ = notHappyAtAll happyNewToken action sts stk [] = - action 33 33 notHappyAtAll (HappyState action) sts stk [] + action 46 46 notHappyAtAll (HappyState action) sts stk [] happyNewToken action sts stk (tk:tks) = let cont i = action i i tk (HappyState action) sts stk tks in case tk of { - TokenFilter -> cont 13; - TokenInSet -> cont 14; - TokenOutSet -> cont 15; - TokenSetName happy_dollar_dollar -> cont 16; - TokenNat happy_dollar_dollar -> cont 17; - TokenVarName happy_dollar_dollar -> cont 18; - TokenTrue -> cont 19; - TokenFalse -> cont 20; - TokenString happy_dollar_dollar -> cont 21; - TokenLeftSqBracket -> cont 22; - TokenRightSqBracket -> cont 23; - TokenArrow -> cont 24; - TokenisEqual -> cont 25; - TokenisNotEqual -> cont 26; - TokenLeftBracket -> cont 27; - TokenRightBracket -> cont 28; - TokenSemiCol -> cont 29; - TokenLambda -> cont 30; - TokenComma -> cont 31; - TokenFullStop -> cont 32; + TokenFilter _ -> cont 18; + TokenInSet _ -> cont 19; + TokenOutSet _ -> cont 20; + TokenSetName _ happy_dollar_dollar -> cont 21; + TokenNat _ happy_dollar_dollar -> cont 22; + TokenPosNat _ happy_dollar_dollar -> cont 23; + TokenVarName _ happy_dollar_dollar -> cont 24; + TokenTrue _ -> cont 25; + TokenFalse _ -> cont 26; + TokenString _ happy_dollar_dollar -> cont 27; + TokenLeftSqBracket _ -> cont 28; + TokenRightSqBracket _ -> cont 29; + TokenArrow _ -> cont 30; + TokenisEqual _ -> cont 31; + TokenisNotEqual _ -> cont 32; + TokenLeftBracket _ -> cont 33; + TokenRightBracket _ -> cont 34; + TokenSemiCol _ -> cont 35; + TokenCol _ -> cont 36; + TokenLambda _ -> cont 37; + TokenComma _ -> cont 38; + TokenFullStop _ -> cont 39; + TokenPlus _ -> cont 40; + TokenXProduct _ -> cont 41; + TokenMap _ -> cont 42; + TokenXXProduct _ -> cont 43; + TokenContains _ -> cont 44; + TokenIsEmpty _ -> cont 45; _ -> happyError' ((tk:tks), []) } -happyError_ explist 33 tk tks = happyError' (tks, explist) +happyError_ explist 46 tk tks = happyError' (tks, explist) happyError_ explist _ tk tks = happyError' ((tk:tks), explist) newtype HappyIdentity a = HappyIdentity a @@ -422,7 +662,10 @@ happySeq = happyDontSeq parseError :: [Token] -> a -parseError _ = error "Parse error" +parseError tokens = error $ "Parse error: " ++ (show.pos.head) tokens + +tokenPosn :: Token -> String +tokenPosn t = let (AlexPn _ line col) = pos t in (show line) ++ ':' : (show col) {-# LINE 1 "templates/GenericTemplate.hs" #-} -- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $ diff --git a/Types.hs b/Types.hs index 366147ff2a8216e3deeb65e1ea76325bd7cf1d85..354c89ec64064687e25d8338965f81bbd1dc3f22 100644 --- a/Types.hs +++ b/Types.hs @@ -11,7 +11,7 @@ data PredefFunc = XProduct | XXProduct | IsEqual | IsNotEqual | Plus --operators | Map | Filter | RecordIndex -- [] operator | RecordSelect - | IsEmpty | NotEmpty | Contains | IsSubString -- string functions + | IsEmpty | NotEmpty | Contains -- string functions deriving (Show, Eq) diff --git a/solutions/pr2.cql b/solutions/pr2.cql index 8406adf37f2c403012678ffd61a6539df7291fcd..7411d3213e48552103ca4e9a2e5b7cda555ae982 100644 --- a/solutions/pr2.cql +++ b/solutions/pr2.cql @@ -2,4 +2,5 @@ A:3 .out -filter((r) -> isSubstring(r[1], r[2])); \ No newline at end of file +filter( \(r) -> r[1] == r[2]); +map (\(r) -> r[3,1]); \ No newline at end of file