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

-- this string contains all parameters
-- char = '0': param not set; char = '1': param set.
-- first parameter is inverseflag 
-- second is ruleFlag = 
-- third is anonFlag
pa :: String
-- all parameters are initially 0
pa = "000000000"

getParamN :: String -> Int -> Int
getParamN ps@(x:xs) n
   | n>1 = getParamN xs (n-1)
   | bv1 = 0
   | bv2 = 1
   where bv1 = x == '0'
         bv2 = x == '1'

setParamN :: String -> Int -> String
setParamN ps@(x:xs) n
        |n>1 = x:setParamN xs (n-1)
        |otherwise = '1':xs

resetParamN :: String -> Int -> String
resetParamN ps@(x:xs) n
        |n>1 = x:resetParamN xs (n-1)
        |otherwise = '0':xs

-- 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: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))"")}

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

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 (ppa1, prefixList, db, pa)
        
-- this function creates the datastrucure.
loadString :: (String, XMLTree, XMLTree, String)
              -> (String, XMLTree, XMLTree, String)
loadString  ("", prefixList, db, pa) = ("", prefixList, db, pa1)
loadString  (s, prefixList, db, pa) 
        |bv1 = loadString (s2, prefixList1, db, pa1)
        |bv2 && not bv4 && bv5 && bv6 = loadString (s3, prefixList1, db1, pa2)
        |bv2 && not bv4 && bv5 && not bv6 =
                         loadString (s3, prefixList1, db2, pa2)
        |bv2 && not bv4 && not bv5  =
                         loadString (s3, prefixList1, db2, pa2)
        |bv2 &&  bv4 =
                         loadString (s3, prefixList1, db3, pa2)
        |otherwise = (s, prefixList1, db, pa1)
        where -- reset the rule flag
              pa1 = resetParamN pa 2
              -- 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, triple, pa2) = loadTriple (s, pa1)
              tripleSet = Tag("TripleSet", [], "")
              Tag (name, children, _) = triple
              bv4 = name == "TripleSet"
              bv5 = name == "Subject"
              child = getChildByName triple "Verb"
              bv6 = child == Empty
              tripleSet1 = addTreeList tripleSet children
              tripleSet2 = addTree tripleSet triple
              db1 = addTree db tripleSet1
              db2 = addTree db tripleSet2
              db3 = addTree db triple


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, String)
                            -> (String, XMLTree, String)
loadTerm ("", inTree, pa) = ("", inTree, pa)
loadTerm (s, inTree, pa)
       |bv1 && bv2 = (s3, t2, pa2)   -- token=set|anonset name=TripleSet
       |bv1 && bv3 = (s3a, t2a, pa3) -- token=set|anonset name!=TripleSet
       |bv4 && bv5 = (s5, t4, pa5)   -- token=subject name=TripleSet
       |bv4 && not bv5 = (s6, t5, pa6)   -- token=subject name!=TripleSet
       |bv6 = (s1, inTree, pa)           -- token=endOfSet 
       |otherwise = (s, inTree, pa)
       where (token, s1) = getNextToken ("", s)
             -- token = set or token = anonset
             bv1 = (token == "Set" || token == "AnonSet")
             (s4, t3, pa1) = loadTriple (s1, pa)
             -- name = "TripleSet"
             bv2 = name == "TripleSet"
             Tag(name, children, _) = t3
             inTree1 = addTreeList inTree children
             (s3, t2, pa2) = loadTerm (s4, inTree1, pa)  
             -- name is not "Term"
             bv3 = not (name == "TripleSet")
             inTree2 = addTree inTree t3
             (s3a, t2a, pa3) = loadTerm (s4, inTree2, pa)  
             -- token = "Subject"              
             bv4 = token == "Subject"                                      
             (s2, t1, pa4) = loadTriple (s, pa)                           
             Tag(name1, _, _) = t1
             -- name1 = "TripleSet"
             bv5 = name1 == "TripelSet"
             Tag(_, children1, _) = t1
             inTree3 = addTreeList inTree children1
             (s5, t4, pa5) = loadTerm (s2, inTree3, pa)                     
             -- name1 != "Term"
             inTree4 = addTreeList inTree children1
             (s6, t5, pa6) = loadTerm (s2, inTree4, pa)
             -- token = "EndOfSet"
             bv6 = token == "EndOfSet" -- return on EndOfSet

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

testLoadAnonSet = putStr ("testLoadAnonSet" ++ printXml tree "")
    where (rest, tree, pa1) = loadTerm (ppa4, (Tag("Term", [], "")), pa)
  
-- load a triple; load the subject and a propertylist.
loadTriple :: (String, String) -> (String, XMLTree, String)
loadTriple ("", pa) = ("", Empty, pa)
loadTriple (s, pa)
      |bv1 && bv2 = (s3, p2, pa3)
      |bv1 && bv3 = (s3, p, pa2)
      |bv1 && not bv4 = (s3, p3, pa2)
      |bv1 && bv4 = (s3, p, pa2) 
      |otherwise = (s, Tag("Subject", [], ""), pa)
      where (token, s1) = getNextToken("", s)
            bv1 = (token == "Subject" || token == "Set" || token == "AnonSet")
            (s2, sub, pa1) = loadSubject (s, pa)
            (s3, p, pa2) = loadPropertyList (s2, sub, pa1)
            -- check inverse detected; first parameter of array
            bv2 = (getParamN pa2 1 == 1)
            -- reset the flag
            pa3 = resetParamN pa2 1
            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
            -- rule is indicated by parameter 2 of array
            bv3 = (getParamN pa2 2 == 1)
            children = extendSubjects p
            bv4 = (length children) < 2
            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) = [tree]
        |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"
              noverbs = getNoVerbs ch
              getNoVerbs [] = []
              getNoVerbs (x@(Tag(name,_ , _)):xs) 
                  |name == "Verb" = getNoVerbs xs
                  |otherwise = x:getNoVerbs xs
              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
                           

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 = verbs ++ 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, prefixList1, 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, String)
                 -> (String, XMLTree, String)
loadPropertyList ("", p, pa) = ("", p, pa)
loadPropertyList (s, p, pa)
        |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 = name == "Empty"
              p2 = addTree p p1
              bv2 = token == "_subject"

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 -> String -> (String, XMLTree, String)
loadProperty "" pa = ("", Empty, pa)
loadProperty s 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 = setParamN pa 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)
      |bv1 = (rest3, subject, pa)
      |bv2 = (rest4, term, pa)
      |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, pa) = loadTerm (s, Tag("Subject", [], ""), pa)

-- load a verb.
-- the next token might be: Verb || _subject || Set || AnonSet
loadVerb ("", pa) = ("", Empty,pa)
loadVerb (s, 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 = setParamN pa 2
            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)
      |bv1 = (rest3, object, pa)
      |bv2 = (rest5, object1, pa1)
      |bv3 = (rest6, tree, pa)
      |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 = setParamN pa 3
            bv3 = (token1 == "Set" || token1 == "AnonSet")
            (rest6, term, pa) = 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>/@/")

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