module LoadTree where
import "Utils"
import "XML"
import "N3Parser"
import "Array"
import "Observe"

-- this array contains all parameters
-- first parameter is inverseflag
-- second is ruleFlag
-- third is anonFlag
pa :: Array Int Int
-- all parameters are initially 0
pa = array (1,10) [ (i,0)| i <- [1 .. 10]]

-- constants
--------------------

-- the unloaded database
db = Tag ("DB", [], "")

-- the unloaded list of prefixes
prefixList = Tag ("prefixes", [], "")

-- definition of log:forAll
logForAll = "http://www.w3.org/2000/10/swap/log#forAll"
-- definition of log:forSome
logForSome = "http://www.w3.org/2000/10/swap/log#forSome"
-- definition of log:Truth
logTruth = "http://www.w3.org/2000/10/swap/log#Truth"
-- definition of log:implies
logImplies = "http://www.w3.org/2000/10/swap/log#implies"


-- read a parsed file, load it and print the result
saveEngine fileName = readExternN3 fileName (loadAndSave fileName)

-- loadFile loads a file into the data structures
-- loadString loads the database
loadAndSave :: String -> String -> IO ()
loadAndSave fileName parseString = stringToFile (printXml (thdQuad
             (loadString (parseString, prefixList, db, pa)))"")
               (fileName ++ ".ld")

thdQuad (a, b, c, d) = c

-- read a parsed file and load it
readEngine fileName  = readExternN3 fileName loadFile

testReadDB fileName =  readDB fileName (putStr)

-- read a parsed file and return the xml database
readDB :: String -> (String -> IO ()) -> IO ()
readDB fileName function = 
   do {s <- readFile fileName; function (printXml (loadDB (n3Parser s))"")}

-- read a parsed file and return the xml database
readDB1 :: String -> (String -> IO()) -> IO ()
readDB1 fileName function = 
   do {s <- readFile fileName; function (printXml (loadDB (n3Parser s))"")}

-- transform the parse string into the database
loadDB :: String -> XMLTree
loadDB parseString = db1
   where (s1, prefixList1, db, pa1) = loadString (parseString, prefixList,
                            Tag ("DB", [], ""), pa)
         db1 = addTree db prefixList1

addPrefixToTag tree tag = addTree tag tree

-- loadFile loads a file into the data structures
loadFile :: String -> IO ()
loadFile parseString = putStr (printXml (thdQuad (loadString
                         (parseString, prefixList, db, pa))) "")
  -- putStr (fstTriple (loadString (parseString, prefixList, db)))

testLoadString = putStr ("testLoadString\n" ++ printXml prefixList1 ""
                        ++ printXml db1 "")
                 where (rest, prefixList1, db1, pa1)
                           = loadString (ppa7, prefixList, db, pa)



-- this function creates the datastrucure.
loadString :: (String, XMLTree, XMLTree, Array Int Int)
              -> (String, XMLTree, XMLTree, Array Int Int)
loadString  ("", prefixList, db, pa) = ("", prefixList, db, pa1)
loadString  (s, prefixList, db, pa) 
        -- load prefix
        |bv1 = loadString (s2, prefixList1, db, pa1)

        -- load a triple or tripleset
        |bv2 = loadString (s3, prefixList, db1, pa2)

        |otherwise = (s, prefixList, db, pa1)

        where -- reset the rule flag
              pa1 = pa // [(2,0)]
              -- get first token
              (token, s1) = getNextToken ("", s)

              bv1 = token ==  "Prefix"
              (token1, s2) = getNextToken ("", s1)  -- get the prefix
              prefix = Tag("prefix", [], token1)
              prefixList1 = addTree prefixList prefix

              -- load the first triple
              bv2 =  token == "Subject" || token == "Set" || token == "AnonSet"
              (s3, db1, pa2) = loadTriple (s, db, pa1)

testLoadTerm = putStr ("testLoadTerm1\n" ++ printXml tree "")
    where (rest, tree, pa) =  loadTerm (ppa5, Tag("Term", [], ""), pa) 
        
-- load a term next token might be Set || AnonSet || Subject || EndOfSet
-- otherwise loadTriple
-- If Set then create a TermList.
loadTerm :: (String, XMLTree, Array Int Int)
                            -> (String, XMLTree, Array Int Int)
loadTerm ("", inTree, pa) = ("", inTree, pa)
loadTerm (s, inTree, pa)
       |bv1 = loadTerm (s3, outTree3, pa2)   -- token = set|anonset 
       |bv3 = (s1, inTree, pa)               -- token = endOfSet 
       |otherwise = (s, inTree, pa)
       where (token, s1) = getNextToken ("", s)

             -- token = set or token = anonset: load a triple
             bv1 = (token == "Set" || token == "AnonSet")
             (s3, outTree3, pa2) = loadTriples (s1, inTree, pa)

             -- token = "Subject"
             -- just load a triple
             bv2 = (token == "Subject")
             (s2, outTree1, pa1) = loadTriples (s, inTree, pa)                           

             -- token = "EndOfSet"
             -- return on EndOfSet
             bv3 = (token == "EndOfSet") 

-- load a series of triples; return when EndOfSet is met.
-- call with empty tree
loadTriples :: (String, XMLTree, Array Int Int)
                        -> (String, XMLTree, Array Int Int)
loadTriples ("", tree, pa) = ("", tree, pa)
loadTriples (s, tree, pa)
  |bv2 = (s, tree, pa)
  |bv3 = loadTriples (s1, treeOut, pa1)
  |otherwise = loadTriples (s1, treeOut, pa1)
  where (token, _) = getNextToken ("", s)
        (s1, treeOut, pa1) = loadTriple (s, tree, pa)
        (token1, s2) = getNextToken ("", s1)
        bv2 = token == "EndOfSet"

testLoadTriple = putStr ("testLoadTriple\n" ++ printXml tree "")
     where (rest, tree, pa1) = loadTriple (ppa1, Empty, pa)

testLoadAnonSet = putStr ("testLoadAnonSet" ++ printXml tree "")
    where (rest, tree, pa1) = loadTerm (ppa4, (Tag("Term", [], "")), pa)
  
testARule = putStr (printXml tree "")
          where (_, tree, _) = loadTriple (ppa7a, Empty, pa)

-- load a triple; load the subject and a propertylist.
loadTriple :: (String, XMLTree Array Int Int) -> (String, XMLTree, Array Int Int)
loadTriple ("", tree, pa) = ("", tree, pa)
loadTriple (s, tree, pa)
      |token == "EndOfSet" = (s, Empty, pa)
--      |bv1 && bv3 = (s2, sub1, pa1) 
      |bv1 && bv2 = (s3, p2, pa3)
      |bv1 && not bv4 = (s3, p3, pa2)
      |bv1 && bv4 = (s3, p, pa2) 
      |otherwise = (s, tree, pa)
      where (token, s1) = getNextToken("", s)
            bv1 = (token == "Subject" || token == "Set" || token == "AnonSet")
            (s2, sub, pa1) = loadSubject (s, tree, pa)
            (s3, p, pa2) = loadPropertyList (s2, sub, pa1)

            -- check if verb follows
            (token1, s4) = getNextToken ("", s2)
            bv3 = token1 /= "Verb"
            sub1 = getChildByName sub "Subject"

            -- check inverse detected; first parameter of array
            bv2 = (pa2!1) == 1
            -- reset the flag
            pa3 = pa2 // [(1,0)]
            verb = getChildByName p "Verb"
            p1 = deleteChildByName p "Verb"
            Tag (name, childrenSubject, content_) = p1
            object = getChildByName verb "Object"
            Tag (_, childrenObject, content) = object
            object1 = Tag("Object", childrenSubject, content)
            verb1 = deleteChildByName verb "Object"
            verb2 = addTree verb1 object1
            p4 = Tag (name, childrenObject, content)
            p2 = addTree p4 verb2

            -- (:s :p :o; :p1 :o1) ==> (:s :p :o. :s :p1 :o1)
            children = extendSubjects p
            bv4 = (length children) < 2
            -- return a tripleset
            p3 = Tag("TripleSet", children, "")

extendSubjectsTree [] = [] 
extendSubjectsTree t@(x:xs)
      |bv1 = extendSubjects x ++ extendSubjectsTree xs
      |otherwise = x:extendSubjectsTree xs
      where Tag(name, _, _) = x
            bv1 = name == "Subject"
            
testExtendSubjects = putStr (printXml testComp "" ++  "!!!!!!!!!!!!"
                   ++ printTreeList list "")
   where list = extendSubjects testComp

-- this extends propertylists into separate triples.
-- returns a tree list
extendSubjects :: XMLTree -> [XMLTree]
extendSubjects Empty = []
extendSubjects tree
        |bv1 && (bv2 || bv3 || bv4) = [tree1a]
        |bv1 = createSubjects verbs
        |otherwise = [tree]
        where Tag(name, children, con1) = tree
              bv1 = name == "Subject"
              children1 = extendSubjectsTree children
              tree1a = Tag(name, children1, con1)
              tree1@(Tag(_, ch, content)) = extendVerbs tree1a
              verbs = getDirectChildrenByName tree1 "Verb"
              bv4 = ((any (\x -> getFullUriFromTree x == logForAll) verbs) ||
                    (any (\x -> getFullUriFromTree x == logForSome) verbs))
              noverbs = [t|t <- ch, getName t /= "Verb"]
              getName (t@(Tag(name,_ ,_ ))) = name
              i = length verbs
              bv2 = i == 0
              bv3 = i == 1
              createSubjects [] = []
              createSubjects (x:xs) =
                    subject1:createSubjects xs
                    where subject = Tag("Subject", [], content)
                          subject1 = addTree (addTreeList subject noverbs) x
                           
getFullUriFromTree t = r
   where Tag("URI", _, content) = getChildByName t "URI" 
         (bool, s, r) = parseUntil ' ' content

testExtendVerbs =
        putStr (printXml olist1 "" ++ "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" ++
                   printXml (extendVerbs olist1) "")
        where olist1 = Tag ("Top",[olist], "")

-- this extends objectlists into separate triples.
-- output is a tree.
extendVerbs :: XMLTree -> XMLTree
extendVerbs Empty = Empty
extendVerbs tree = tree1
      where Tag (name, children, content) = tree
            (verbs, noverbs) = funct children [] []
            tree1 = Tag(name, noverbs ++ verbs, content)
            funct [] _ _ = ([],[])
            funct (x@(Tag(name1, _, _)):xs) verbs noverbs
                |name1 == "Verb" = (verbs1 ++ verbs2, noverbs2)
                |otherwise = (verbs2, noverbs1 ++ noverbs2)
                where verbs1 = extendVerb x 
                      noverbs1 = noverbs ++ [x]
                      (verbs2, noverbs2) = funct xs verbs1 noverbs1

-- extend objectlists giving each object a verb.
-- returns a list of verbs.
extendVerb :: XMLTree -> [XMLTree]
extendVerb tree
     = funct objects   
     where objects = getDirectChildrenByName tree "Object"
           uri = getChildByName tree "URI"
           Tag (name, children, content) = tree
           funct [] = []
           funct (x:xs) = verb1:funct xs
               where verb = Tag("Verb", [], content)
                     verb1 = addTree (addTree verb uri) x
             	
-- definition of constants for testing
(r1, prefixList11, db1, pa1) = loadString (ppa10, prefixList, db, pa)
testComp = getChildByName db1 "TripleSet"
testComp1 = getChildByName testComp "Subject"
verbComp = getChildrenByName testComp "Verb"
verbComp1 = addTreeList (Tag("Subject", [], "")) verbComp
objectComp = addTree (addTree (Tag("Subject", [], "")) (Tag("Verb", [], ""))) (Tag("Object", [], ""))
      
testLoadPropertyList = putStr ("testLoadPropertyList\n" ++ printXml tree "")
    where (rest, tree, pa) = loadPropertyList (ppa3, Tag("Top", [], ""), pa)
        
-- load a propertylist.
loadPropertyList :: (String, XMLTree, Array Int Int)
                 -> (String, XMLTree, Array Int Int)
loadPropertyList ("", p, pa) = ("", p, pa)
loadPropertyList (s, p, pa)
        |bv3 = (s, p, pa) -- loadPropertyList (s3, p, pa) -- error (s3 ++ printXml p "")
        |bv1 = (s, p, pa1)
        |bv2 = loadPropertyList (s2, p2, pa1)       -- token = "_subject"
        |otherwise = (s1, p2, pa1)                  -- is single verb
        where (s1, p1, pa1) = loadProperty s pa
              (token, s2) = getNextToken ("", s1)
              Tag(name, children, content) = p1
              bv1 = p1 == Empty
              p2 = addTree p p1
              bv2 = token == "_subject"
              (token1, s3) = getNextToken ("",s)
              bv3 = token1 == "EndOfSet"

testLoadProperty = putStr ("testLoadProperty\n" ++ printXml tree "")
    where (rest, tree, pa) = loadProperty ppa3 pa

-- load a property.
-- the next token might be: Verb || _subject.
loadProperty :: String -> Array Int Int -> (String, XMLTree, Array Int Int)
loadProperty "" pa = ("", Empty, pa)
loadProperty s pa
      |token == "EndOfSet" = (s, Empty, pa)
      |bv1 = (s5, ol, pa2)         -- token = "Verb"
      |bv2 = (s6, ol1, pa4)        -- token = "_subject"
      |bv3 = loadProperty s1 pa5   -- "Inverse" detected; skip token
      |otherwise = (s, Empty, pa)
      where (token, s1) = getNextToken ("",s)
            (s3, v1, pa1) = loadVerb (s, pa)
            bv1 = token == "Verb"
            (s5, ol, pa2) = loadObjectList (s3, v1, pa1)
            bv2 = token == "_subject"
            (s4, v2, pa3) = loadVerb (s1, pa)
            (s6, ol1, pa4) = loadObjectList (s4, v2, pa3)
            bv3 =  (token == "Inverse")
            -- token is inverse; set the inverse flag
            pa5 = pa // [(1,1)]

-- constant for test extendVerbs
olist = oList
   where (rest, oList, pa1) = loadObjectList(ppa2, verb, pa2)
         (rest1, verb, pa2) = loadVerb (ss2, pa)

testLoadSubject = putStr ("Rest: " ++ rest ++ "\n" ++ printXml subject "")
    where (rest, subject, pa1) = loadSubject (ppa1, pa)
        
testLoadVerb = putStr ("Rest: " ++ rest ++ "\n" ++ printXml verb "")
    where (rest, verb, pa1) = loadVerb (ss2, pa)

testLoadObjectList = putStr ("testLoadObjectList:\n" ++ printXml oList "")
    where (rest,oList, pa1) = loadObjectList (ppa2, (Tag("Top", [], "")), pa)

-- load an objectlist.
loadObjectList ("", o, pa) = ("", o, pa)
loadObjectList (s, o, pa)
      |bv1 = loadObjectList (rest3, o1, pa)
      |otherwise = (rest1, o1, pa)
      where (rest1, object, pa1) = loadObject (s, pa)
            (token1, rest2) = getNextToken ("", rest1)
            (token2, rest3) = getNextToken ("", rest2)
            o1 = addTree o object
            bv1 = (token1 == "_subject") && (token2 == "_verb")
            
-- load a subject.
-- the next token might be: Subject || Set || AnonSet
loadSubject ("", pa) = ("", Empty, pa)
loadSubject (s, pa)
      |token1 == "EndOfSet" = (s, Empty, pa)
      |bv1 = (rest3, subject, pa)
      -- Set or AnonSet
      |bv2 = (rest4, term, pa1)
      |otherwise = (s, Empty, pa)
      where (token1, rest1) = getNextToken ("",s)
            (token2, rest2) = getNextToken ("", rest1)
            (token3, rest3) = getNextToken ("", rest2)

            bv1 = (token1 == "Subject")
            uri = Tag("URI", [], token2 ++ " " ++ token3)
            subject = addTree (Tag("Subject", [], "")) uri

            bv2 = (token1 == "Set" || token1 == "AnonSet")
            (rest4, term, pa1) = loadTerm (s, Tag("Subject", [], ""), pa)

-- load a verb.
-- the next token might be: Verb || _subject || Set || AnonSet
loadVerb ("", pa) = ("", Empty,pa)
loadVerb (s, pa)
      |token1 == "EndOfSet" = (s, Empty, pa)
      |bv1 && bv2 = (rest3, verb, pa1)
      |bv1 =  (rest3, verb, pa)
      |bv3 = (rest4, verb1, pa)
      |bv4 = (rest5, tree, pa2)
      |otherwise = (s, Empty, pa)
      where (token1, rest1) = getNextToken ("",s)
            (token2, rest2) = getNextToken ("", rest1)
            (token3, rest3) = getNextToken ("", rest2)
            bv1 = token1 == "Verb"
            uri = Tag("URI", [], token2 ++ " " ++ token3)
            bv2 = (token3 == logImplies)
            -- set the rule flag
            pa1 = pa // [(2,1)]
            verb = addTree (Tag("Verb", [], "")) uri
            bv3 = (token1 == "_subject")
            (token4, rest4) = getNextToken ("", rest3)
            uri1 = Tag("URI", [], token3 ++ " " ++ token4)
            verb1 = addTree (Tag("Verb", [], "")) uri1
            bv4 = (token1 == "Set" || token1 == "AnonSet")
            (rest5, term, pa2) = loadTerm (s, Tag("Term", [], ""), pa)
            Tag (_, children, _) = term
            tree = addTreeList (Tag("Verb", [], "")) children 

testLoadObject = putStr ("Rest: " ++ rest ++ "\n" ++ printXml object "")
    where (rest, object, pa1) = loadObject (ss1, pa)
        
-- load an object.
-- the next token might be: Object || _subject || Set || AnonSet
loadObject ("", pa) = ("", Empty, pa)
loadObject (s, pa)
      |token1 == "EndOfSet" = (s, Empty, pa)
      |bv1 = (rest3, object, pa)
      |bv2 = (rest5, object1, pa1)
      |bv3 = (rest6, tree, pa2)
      |otherwise = (s, Empty, pa)
      where (token1, rest1) = getNextToken ("",s)
            (token2, rest2) = getNextToken ("", rest1)
            (token3, rest3) = getNextToken ("", rest2)

            bv1 = (token1 == "Object")
            uri = Tag("URI", [], token2 ++ " " ++ token3)
            object = addTree (Tag("Object", [], "")) uri

            bv2 = (token1 == "_subject" || token2 == "_verb")
            (token4, rest4) = getNextToken ("", rest3)
            (token5, rest5) = getNextToken ("", rest4)
            uri1 = Tag("URI", [], token4 ++ " " ++ token5)
            object1 = addTree (Tag("Object", [], "")) uri1
            -- set anonflag
            pa1 = pa // [(3,1)]

            bv3 = (token1 == "Set" || token1 == "AnonSet")
--            (rest6, term, pa2) = loadTriple (s, pa)
            (rest6, term, pa2) = loadTerm (s, Tag("Term", [], ""), pa)
            Tag(_, children, _) = term
            tree = Tag("Object", children, "") 

-- getNextToken returns the next token and the rest string
-- is normally called with first string empty
getNextToken :: (String, String) -> (String, String)
getNextToken ([], []) = ([], [])
getNextToken (s, []) = (s, [])
getNextToken (s1, s2@(x:xs))
   | startsWith s2 "/@/" = (s1, drop 3 s2)
   | otherwise = getNextToken (s1 ++ [x], xs)
            
--  Test data
------------------

-- testLoadObject
ss1 = "Object/@/<http://www.agfa.com>" ++ "/@/http://www.agfa.com/@/"

-- testLoadVerb
ss2 = ("Verb/@/:member/@/" ++
         "<http://www/w3.org#member>/@/Object/@/<http://www.agfa.com>" ++
         "/@/http://www.agfa.com/@/")

ppa1 = ("Subject/@/<mailto:jos.deroo.jd@belgium.agfa.com>/@/" ++
          "mailto:jos.deroo.jd@belgium.agfa.com/@/Verb/@/:member/@/" ++
          "<http://www/w3.org#member>/@/Object/@/<http://www.agfa.com>" ++
          "/@/http://www.agfa.com/@/")

-- test loadObjectList
ppa2 = ("Object/@/<http://www.agfa.com>/@/http://www.agfa.com/@/_subject" ++
           "/@/_verb/@/Object/@/<http://gn>/@/http://gn/@/Subject/@/")

-- test loadPropertyList
ppa3 = ("Verb/@/:member/@/" ++
     "<http://www/w3.org#member>/@/Object/@/<http://www.agfa.com>" ++
     "/@/http://www.agfa.com/@/" ++ "_subject/@/Verb/@/:test/@/hp:test/@/" ++
     "Object/@/:ok/@/ok:ok/@/")

-- test AnonSet
ppa4 = ("AnonSet/@/Subject/@/_T$$$1/@/_T$$$1/@/Verb/@/a/@/rdf:type/@/Object/@/agg:Company"
      ++ "/@/http://example.com/xmlns/aggregation-demo#Company/@/" 
      ++ "_subject/@/Verb/@/agg:corporateHomepage/@/" ++
      "http://example.com/xmlns/aggregation-demo#corporateHomepage/@/" ++
      "Object/@/<http://megacorp.example.com/>/@/" ++
      "http://megacorp.example.com//@/_subject/@/Verb/@/agg:name/@/" ++
      "http://example.com/xmlns/aggregation-demo#name/@/Object/@/" ++
      "MegaCorp Inc./@/MegaCorp Inc./@/_subject/@/Verb/@/agg:owner/@/" ++
      "http://example.com/xmlns/aggregation-demo#owner/@/Object/@/agg:gn" ++
      "/@/agg:gn/@/EndOfSet/@/")

-- test embedded sets
ppa5 = ("Set/@/Set/@/Subject/@/:t/@/:t/@/Verb/@/:v/@/:v/@/Object/@/:o/@/:o" ++
      "/@/Subject/@/:t1/@/:t1/@/Verb/@/:v1/@/:v1/@/Object/@/:o1/@/:o1/@/" ++
      "EndOfSet/@/Verb/@/:v2/@/:v2/@/Object/@/:o2/@/:o2/@/EndOfSet/@/")

-- test prefix loading
ppa6 = ["@prefix log: <http://www.w3.org/2000/10/swap/log#>.",
      "@prefix : <authen#>."]

-- test of rule  ("authen.axiom.n3")
ppa7 = ("Prefix/@/@prefix log: <http://www.w3.org/2000/10/swap/log#>./@/" ++
      "Prefix/@/@prefix : <authen#>./@/Subject/@/<mailto:jos.deroo.jd@belgium.agfa.com>" ++
      "/@/mailto:jos.deroo.jd@belgium.agfa.com/@/Verb/@/:member/@/" ++
      "<authen#member>/@/Object/@/<http://www.agfa.com>/@/" ++
      "http://www.agfa.com/@/Subject/@/<http://www.agfa.com>/@/" ++
      "http://www.agfa.com/@/Verb/@/:w3cmember/@/<authen#w3cmember>" ++
      "/@/Object/@/<http://www.w3.org>/@/http://www.w3.org/@/Subject" ++
      "/@/<http://www.agfa.com>/@/http://www.agfa.com/@/Verb/@/" ++
      ":subscribed/@/<authen#subscribed>/@/Object/@/" ++
      "<mailto:w3c-ac-forum@w3.org/>/@/mailto:w3c-ac-forum@w3.org//@/" ++
      "Set/@/Set/@/Subject/@/:person/@/<authen#person>/@/Verb/@/:member" ++
      "/@/<authen#member>/@/Object/@/:institution/@/<authen#institution>" ++
      "/@/Subject/@/:institution/@/<authen#institution>/@/" ++
      "Verb/@/:w3cmember/@/<authen#w3cmember>/@/Object/@/" ++
      "<http://www.w3.org>/@/http://www.w3.org/@/" ++
      "Subject/@/:institution/@/<authen#institution>/@/Verb" ++
      "/@/:subscribed/@/<authen#subscribed>/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/EndOfSet/@/Verb/@/" ++
      "log:implies/@/http://www.w3.org/2000/10/swap/log#implies/@/" ++
      "Set/@/Subject/@/:person/@/<authen#person>/@/Verb/@/" ++
      ":authenticated/@/<authen#authenticated>/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/EndOfSet/@/EndOfSet" ++
      "/@/Verb/@/a/@/http://www.w3.org/1999/02/22-rdf-syntax-ns#type" ++
      "/@/Object/@/log:Truth/@/http://www.w3.org/2000/10/swap/log#Truth" ++
      "/@/_subject/@/Verb/@/log:forAll/@/" ++
      "http://www.w3.org/2000/10/swap/log#forAll/@/Object/@/" ++
      ":person/@/<authen#person>/@/_subject/@/_verb/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/_subject/@/_verb/@/" ++
      "Object/@/:institution/@/<authen#institution>/@/")

ppa7a =(
      "Set/@/Set/@/Subject/@/:person/@/<authen#person>/@/Verb/@/:member" ++
      "/@/<authen#member>/@/Object/@/:institution/@/<authen#institution>" ++
      "/@/Subject/@/:institution/@/<authen#institution>/@/" ++
      "Verb/@/:w3cmember/@/<authen#w3cmember>/@/Object/@/" ++
      "<http://www.w3.org>/@/http://www.w3.org/@/" ++
      "Subject/@/:institution/@/<authen#institution>/@/Verb" ++
      "/@/:subscribed/@/<authen#subscribed>/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/EndOfSet/@/Verb/@/" ++
      "log:implies/@/http://www.w3.org/2000/10/swap/log#implies/@/" ++
      "Set/@/Subject/@/:person/@/<authen#person>/@/Verb/@/" ++
      ":authenticated/@/<authen#authenticated>/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/EndOfSet/@/EndOfSet" ++
      "/@/Verb/@/a/@/http://www.w3.org/1999/02/22-rdf-syntax-ns#type" ++
      "/@/Object/@/log:Truth/@/http://www.w3.org/2000/10/swap/log#Truth" ++
      "/@/_subject/@/Verb/@/log:forAll/@/" ++
      "http://www.w3.org/2000/10/swap/log#forAll/@/Object/@/" ++
      ":person/@/<authen#person>/@/_subject/@/_verb/@/Object/@/" ++
      ":mailinglist/@/<authen#mailinglist>/@/_subject/@/_verb/@/" ++
      "Object/@/:institution/@/<authen#institution>/@/")

-- test of a query ("authen.lemma.n3")
ppa8 = ("Prefix/@/@prefix log: <http://www.w3.org/2000/10/swap/log#>." ++
      "/@/Prefix/@/@prefix : <authen#>./@/Subject/@/_:who/@/_:who/@/" ++
      "Verb/@/:authenticated/@/<authen#authenticated>/@/Object/@/" ++
      "<mailto:w3c-ac-forum@w3.org/>/@/mailto:w3c-ac-forum@w3.org//@/")
     
ppa9 = ("Subject/@/:a/@/<a>/@/Verb/@/:b/@/<b>/@/Set/@/Subject/@/:c/@/<c>" ++
      "/@/Verb/@/:d/@/<d>/@/Object/@/:e/@/<e>/@/Subject/@/:f/@/<f>/@/Verb" ++
      "/@/:g/@/<g>/@/Object/@/:h/@/<h>/@/Subject/@/:i/@/<i>/@/Verb" ++
      "/@/:j/@/<j>/@/Object/@/:k/@/<k>/@/EndOfSet/@/")

ppa10 = ("Subject/@/:a/@/http://www.test#a/@/Verb/@/:b/@/http://www.test#b" ++
            "/@/Object/@/:c/@/http://www.test#c/@/_subject/@/_verb/@/" ++
            "Object/@/:d/@/http://www.test#d/@/_subject/@/_verb/@/" ++
            "Object/@/:e/@/http://www.test#e/@/")


tl2 = testReadDB"animal-result.n3"           -- ok              
tl3 = testReadDB"animal-simple.n3"           -- ok        
tl4 = testReadDB"animal.n3"                  -- ok        
tl5 = testReadDB "authen.axiom.n3"           -- ok        
tl6 = testReadDB "authen.lemma.n3"           -- ok        
tl7 = testReadDB"authen.proof.n3"            -- ok       
tl8 = testReadDB "danb-query.n3"             -- ok
tl9 = testReadDB "danb-result.n3"            -- ok
tl10 = testReadDB "danb.n3"                  -- ok        
tl11 = testReadDB "danc-query.n3"            -- ok
tl12 = testReadDB "danc-result.n3"           -- ok
tl13 = testReadDB "danc.n3"                  -- ok        
tl14 = testReadDB "etc.n3"                   -- ok
tl15 = testReadDB "gedcom-facts.n3"          -- ok
tl16 = testReadDB "gedcom-proof.n3"          -- syntax error but response
tl17 = testReadDB "gedcom-query.n3"          -- ok
tl18 = testReadDB "gedcom-relations-result.n3" -- ok
tl19 = testReadDB "gedcom-relations-test.n3"   -- ok
tl20 = testReadDB "gedcom-relations.n3"        -- ok
tl21 = testReadDB "graph.axiom.n3"             -- ok
tl22 = testReadDB "graph.lemma.n3"             -- ok
tl23 = testReadDB "graph.proof.n3"             -- ok
tl24 = testReadDB "janet-result.n3"            -- ok
tl25 = testReadDB "janet-test.n3"              -- ok
tl26 = testReadDB "janet.n3"                   -- ok
tl27 = testReadDB "lists-query.n3"             -- ok
tl28 = testReadDB "lists-result.n3"            -- ok
tl29 = testReadDB "lists.n3"                   -- ok
tl30 = testReadDB "vogel.q.n3"                 -- ok
tl40 = testReadDB "rdf-facts.n3"               -- ok
tl41 = testReadDB "rdf-query.n3"               -- ok
tl42 = testReadDB "rdf-result.n3"              -- ok
tl43 = testReadDB "rdf-rules.n3"               -- ok
tl44 = testReadDB "rdfc25May-result.n3"        -- ok
tl45 = testReadDB "rdfc25May-test.n3"          -- ok
tl46 = testReadDB "rdfc25May.n3"               -- ok
tl47 = testReadDB "rdfs-query.n3"              -- ok
tl48 = testReadDB "rdfs-result.n3"             -- ok
tl49 = testReadDB "rdfs-rules.n3"              -- ok
tl50 = testReadDB "russell.axiom.n3"           -- ok
tl51 = testReadDB "russell.lemma.n3"           -- ok
tl52 = testReadDB "russell.proof.n3"           -- syntax error
tl53 = testReadDB "subclass-query.n3"          -- ok 
tl54 = testReadDB "subclass-result.n3"         -- ok
tl55 = testReadDB "subclass.n3"                -- ok
tl56 = testReadDB "subprop-query.n3"           -- ok
tl57 = testReadDB "subprop-result.n3"          -- ok
tl58 = testReadDB "subprop.n3"                 -- ok
tl59 = testReadDB "test-result.n3"             -- ok
tl60 = testReadDB "test-test.n3"               -- ok
tl61 = testReadDB "test.n3"                    -- ok
tl62 = testReadDB "tpoint-all.n3"              -- ok
tl63 = testReadDB "tpoint-facts.n3"            -- ok
tl64 = testReadDB "tpoint-query.n3"            -- ok
tl65 = testReadDB "tpoint-result.n3"
tl66 = testReadDB "tpoint.n3"                  -- ok
tl67 = testReadDB "varprop-query.n3"           -- ok
tl68 = testReadDB "varprop-result.n3"          -- ok
tl69 = testReadDB "varprop.n3"                 -- ok
tl70 = testReadDB "ziv-query.n3"               -- ok
tl71 = testReadDB "ziv-result.n3"              -- ok
tl72 = testReadDB "ziv.n3"                     -- ok
tl73 = testReadDB "wol-facts.n3"               -- ok
tl74 = testReadDB "wol-query.n3"               -- ok
tl75 = testReadDB "wol-rules.n3"               -- ok
tl76 = testReadDB "VOGEL.N3"                   -- ok
tl77 = testReadDB "vogel.l.n3"                 -- ok
tl78 = testReadDB "boole.lemma.n3"             -- ok
tl79 = testReadDB "boole.axiom.n3"             -- ok
tl80 = testReadDB "induction.axiom.n3"         -- ok
tl81 = testReadDB "induction.query.n3"         -- ok
tl82 = testReadDB "allValuesFrom.n3"           -- ok
tl83 = testReadDB "Owls.n3"                    -- ok
tl84 = testReadDB "gedcom-simple.n3"
tl85 = testReadDB "gedcom-qsimple.n3"  
tl86 = testReadDB "ontology2.axiom.n3"
tl87 = testReadDB "eq.a.n3"
tl88 = testReadDB "eq.q.n3"