home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / modules / rdf / src / query.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  22.4 KB  |  648 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* 
  20.    This file implements query support for the rdf data model.
  21.    For more information on this file, contact rjc or guha 
  22.    For more information on RDF, look at the RDF section of www.mozilla.org
  23. */
  24.  
  25. #include "query.h"
  26. #include "rdf-int.h"
  27.  
  28. /* prototypes */
  29. PRBool variableTermp(TermStruc term);
  30. PRBool resourceTermp(TermStruc term);
  31. PRBool constantTermp(TermStruc term);
  32. RDF_Error addVariableToList(RDF_Variable variable, RDF_VariableList *list);
  33. void destroyVariableList(RDF_VariableList list, PRBool destroyVariables);
  34. void destroyLiteralList(RDF_LiteralList list, PRBool destroyLiterals);
  35. PRBool comparisonp(RDF_Resource r);
  36. PRBool specialResourcePredicate(RDF_Resource r);
  37. PRBool findLiteral(RDF_Literal target, RDF_LiteralList list);
  38. RDF_Literal getNthLiteral(RDF_Query q, uint16 index);
  39. PRBool constantp(TermStruc term, RDF_VariableList knownVars);
  40. RDF_Literal oneUnknownAs(RDF_Query q, RDF_LiteralList orderedLiterals, RDF_VariableList knownVars);
  41. RDF_Literal noUnknownAs(RDF_Query q, RDF_LiteralList orderedLiterals, RDF_VariableList knownVars);
  42. PRBool orderConjuncts(RDF_Query q);
  43. PRBool processNextLiteral(RDF_Query q, RDF_Literal literal);
  44. void addLiteral(RDF_Query q, RDF_Literal literal);
  45.  
  46. /* Variable API */
  47. PR_PUBLIC_API(PRBool) RDF_IsResultVariable(RDF_Variable var) {
  48.     return var->isResult;
  49. }
  50.  
  51. PR_PUBLIC_API(void) RDF_SetResultVariable(RDF_Variable var, PRBool isResult) {
  52.     var->isResult = isResult;
  53. }
  54.  
  55. PR_PUBLIC_API(void*) RDF_GetVariableValue(RDF_Variable var) {
  56.     if (var->query->queryRunning)
  57.         return var->value;
  58.     else return NULL;
  59. }
  60.  
  61. PR_PUBLIC_API(void) RDF_SetVariableValue(RDF_Variable var, void* value, RDF_ValueType type) {
  62.     if (!var->query->queryRunning) var->query->conjunctsOrdered = false;
  63.     var->value = value;
  64.     var->type = type;
  65. }
  66.  
  67. PRBool variableTermp(TermStruc term) {
  68.     return term.type == RDF_VARIABLE_TERM_TYPE;
  69. }
  70.  
  71. PRBool resourceTermp(TermStruc term) {
  72.     return term.type == RDF_RESOURCE_TERM_TYPE;
  73. }
  74.  
  75. PRBool constantTermp(TermStruc term) {
  76.     return term.type == RDF_CONSTANT_TERM_TYPE;
  77. }
  78.  
  79. /* Adds the variable to the variable list if it isn't already on the list. */
  80. RDF_Error addVariableToList(RDF_Variable variable, RDF_VariableList *list) {
  81.     PRBool found = false;
  82.     RDF_VariableList current = *list;
  83.     while (current != NULL) {
  84.         if (current->element == variable) {
  85.             found = true;
  86.             break;
  87.         }
  88.         current = current->next;
  89.     }
  90.     if (!found) {
  91.         RDF_VariableList newlist = (RDF_VariableList)getMem(sizeof(RDF_VariableListStruc));
  92.         if (newlist == NULL) return RDF_NO_MEMORY;
  93.         newlist->element = variable;
  94.         newlist->next = *list;
  95.         *list = newlist;
  96.     }
  97.     return noRDFErr;
  98. }
  99.  
  100. void destroyVariableList(RDF_VariableList list, PRBool destroyVariables) {
  101.     if (list != NULL) {
  102.         destroyVariableList(list->next, destroyVariables);
  103.         if (destroyVariables) freeMem(list->element);    /* free the variable */
  104.         freeMem(list);                                    /* free the list structure */
  105.     }
  106. }
  107.  
  108. void destroyLiteralList(RDF_LiteralList list, PRBool destroyLiterals) {
  109.     if (list != NULL) {
  110.         destroyLiteralList(list->next, destroyLiterals);
  111.         if (destroyLiterals) {
  112.             RDF_Literal literal = list->element;
  113.             if (literal->c != NULL) RDF_DisposeCursor(literal->c);
  114.             if (literal->valueType == RDF_STRING_TYPE) {
  115.                 int i;
  116.                 for (i = 0; i < literal->valueCount; i++) {
  117.                     TermStruc term = *(literal->v + i);
  118.                     if (constantTermp(term)) freeMem(term.value);
  119.                 }
  120.             }
  121.             freeMem(literal->v);
  122.             freeMem(list->element);    /* free the literal */
  123.         }
  124.         freeMem(list);                                    /* free the list structure */
  125.     }
  126. }
  127.  
  128. PRBool comparisonp(RDF_Resource r) {
  129.     return (r == gCoreVocab->RDF_substring || 
  130.             r == gCoreVocab->RDF_notSubstring ||
  131.             r == gCoreVocab->RDF_lessThan || 
  132.             r == gCoreVocab->RDF_greaterThan ||
  133.             r == gCoreVocab->RDF_lessThanOrEqual ||
  134.             r == gCoreVocab->RDF_greaterThanOrEqual ||
  135.             r == gCoreVocab->RDF_equals ||
  136.             r == gCoreVocab->RDF_notEquals ||
  137.             r == gCoreVocab->RDF_stringEquals ||
  138.             r == gCoreVocab->RDF_notStringEquals);
  139. }
  140.  
  141. PRBool specialResourcePredicate(RDF_Resource r) {
  142.     return (r == gCoreVocab->RDF_notInstanceOf || r == gCoreVocab->RDF_notParent);
  143. }
  144.  
  145. /* Creates and initializes a query. Returns NULL if not enough memory. */
  146. PR_PUBLIC_API(RDF_Query) RDF_CreateQuery(RDF rdf) {
  147.     RDF_Query q = (RDF_Query)getMem(sizeof(RDF_QueryStruc));
  148.     if (q == NULL) return q;
  149.     q->variables = NULL;
  150.     q->literals = NULL;
  151.     q->numLiterals = 0;
  152.     q->index = 0;
  153.     q->conjunctsOrdered = false;
  154.     q->queryRunning = false;
  155.     q->rdf = rdf;
  156.     return q;
  157. }
  158.  
  159. /* Destroys a query. */
  160. PR_PUBLIC_API(void) RDF_DestroyQuery(RDF_Query q) {
  161.     destroyLiteralList(q->literals, true);        /* free the literals */
  162.     q->literals = NULL;
  163.     destroyVariableList(q->variables, true);    /* free the variables */
  164.     q->variables = NULL;
  165.     freeMem(q);                                    /* free the query */
  166.     q = NULL;
  167. }
  168.  
  169. /* Returns the variable with the given name in the query.
  170.    If not found:
  171.        if the query is running, return NULL
  172.        otherwise create a new variable with the given name.
  173.        if there isn't enough memory, return NULL.
  174. */
  175. PR_PUBLIC_API(RDF_Variable) RDF_GetVariable(RDF_Query q, char* name) {
  176.     RDF_Variable newvar;
  177.     RDF_VariableList newlist;
  178.     RDF_VariableList current = q->variables;
  179.     while (current != NULL) {
  180.         if (stringEquals(current->element->id, name)) return current->element;
  181.         if (current->next == NULL) break;
  182.         else current = current->next;
  183.     }
  184.     if (q->queryRunning) return NULL;
  185.     newvar = (RDF_Variable)getMem(sizeof(RDF_VariableStruc));
  186.     if (newvar == NULL) return NULL;
  187.     newvar->id = copyString(name);
  188.     newvar->query = q;
  189.     /* create a list containing the variable and append it to the front of the variable list */
  190.     newlist = (RDF_VariableList)getMem(sizeof(RDF_VariableListStruc));
  191.     if (newlist == NULL) {
  192.         freeMem(newvar);
  193.         return NULL;
  194.     }
  195.     newlist->element = newvar;
  196.     newlist->next = q->variables;
  197.     q->variables = newlist;
  198.     return newvar;
  199. }
  200.  
  201. /* Returns the number of variables in the query. */
  202. PR_PUBLIC_API(uint16) RDF_GetVariableListCount(RDF_Query q) {
  203.     RDF_VariableList current = q->variables;
  204.     uint16 count = 0;
  205.     while (current != NULL) {
  206.         current = current->next;
  207.         count++;
  208.     }
  209.     return count;
  210. }
  211.  
  212. /* Returns the variables belonging to the query at the given index. */
  213. PR_PUBLIC_API(RDF_Variable) RDF_GetNthVariable(RDF_Query q, uint16 index) {
  214.     RDF_VariableList current = q->variables;
  215.     uint16 count = 0;
  216.     while (current != NULL) {
  217.         if (count == index)
  218.             return current->element;
  219.         else {
  220.             current = current->next;
  221.             count++;
  222.         }
  223.     }
  224.     return NULL;
  225. }
  226.  
  227. /* Returns true if target is found in literal */
  228. PRBool findLiteral(RDF_Literal target, RDF_LiteralList list) {
  229.     while (list != NULL) {
  230.         if (list->element == target) return true;
  231.         else list = list->next;
  232.     }
  233.     return false;
  234. }
  235.  
  236. /* Returns the literal belonging to the query at the given index. */
  237. RDF_Literal getNthLiteral(RDF_Query q, uint16 index) {
  238.     RDF_LiteralList current = q->literals;
  239.     uint16 count = 0;
  240.     while (current != NULL) {
  241.         if (count == index)
  242.             return current->element;
  243.         else {
  244.             current = current->next;
  245.             count++;
  246.         }
  247.     }
  248.     return NULL;
  249. }
  250.  
  251. /* A term is constant if it is not a variable, if it is a variable with
  252.    a non-null value, or if it is a known variable.
  253. */
  254. PRBool constantp(TermStruc term, RDF_VariableList knownVars) {
  255.     if (term.type != RDF_VARIABLE_TERM_TYPE) return true;
  256.     else {
  257.         RDF_Variable var = (RDF_Variable)term.value;
  258.         if (var->value != NULL) return true;
  259.         else {
  260.             while (knownVars != NULL) {
  261.                 if (knownVars->element == var) return true;
  262.                 knownVars = knownVars->next;
  263.             }
  264.             return false;
  265.         }
  266.     }
  267. }
  268.  
  269. /* Returns a literal with a constant term which has not been ordered yet. */
  270. RDF_Literal oneUnknownAs(RDF_Query q, RDF_LiteralList orderedLiterals, RDF_VariableList knownVars) {
  271.     RDF_LiteralList list = q->literals;
  272.     RDF_Literal answer = NULL;
  273.     while (list != NULL) {
  274.         RDF_Literal current = list->element;
  275.         if (!findLiteral(current, orderedLiterals)) { 
  276.             if (((constantp(current->u, knownVars)) || (constantp(*current->v, knownVars))) && 
  277.                 current->valueCount == 1 && /* no disjunctions */
  278.                 !comparisonp(current->s) && /* comparisons must have constant terms */
  279.                 !specialResourcePredicate(current->s) /* notTypeOf and notParent must have constant terms */
  280.                 /* && current->tv == true */) {
  281.                 if (answer == NULL) {
  282.                     answer = current;
  283.                 } else {
  284.                     /* fix me - deal with branching factor */
  285.                     answer = current;
  286.                 }
  287.             }
  288.         } 
  289.         list = list->next;
  290.     }
  291.     return answer;
  292. }
  293.  
  294. /* Returns a literal with both terms constant which has not been ordered yet. */
  295. RDF_Literal noUnknownAs(RDF_Query q, RDF_LiteralList orderedLiterals, RDF_VariableList knownVars) {
  296.     RDF_LiteralList list = q->literals;
  297.     while (list != NULL) {
  298.         RDF_Literal current = list->element;
  299.         if (!findLiteral(current, orderedLiterals) &&
  300.             constantp(current->u, knownVars)) {
  301.             int i;
  302.             PRBool foundNonConstant = false;
  303.             for (i = 0; i < current->valueCount; i++) { /* all values constant? */
  304.                 TermStruc term = *(current->v + i);
  305.                 if (!constantp(term, knownVars)) foundNonConstant = true;
  306.             }
  307.             if (foundNonConstant) list = list->next;
  308.             else return current;
  309.         }
  310.         else list = list->next;
  311.     }
  312.     return NULL;
  313. }
  314.  
  315. /* Returns true if the conjuncts were ordered succesfully.
  316. */
  317. PRBool orderConjuncts(RDF_Query q) {
  318.     uint16 numOrdered = 0;
  319.     RDF_Error err = noRDFErr;
  320.     RDF_LiteralList orderedLiterals = NULL;
  321.     RDF_LiteralList orderedLiteralsTail = orderedLiterals;
  322.     RDF_VariableList knownVars = NULL;
  323.  
  324.     if (q->conjunctsOrdered) return true;
  325.     
  326.     while (numOrdered < q->numLiterals) {
  327.         RDF_Literal lit1 = noUnknownAs(q, orderedLiterals, knownVars);
  328.         if (lit1 != NULL) {
  329.             /* add literal to ordered list */
  330.             RDF_LiteralList newlist = (RDF_LiteralList)getMem(sizeof(RDF_LiteralListStruc));
  331.             if (newlist == NULL) break;
  332.             newlist->element = lit1;
  333.             newlist->next = NULL;
  334.             if (orderedLiterals == NULL)
  335.                 orderedLiterals = orderedLiteralsTail = newlist;
  336.             else {
  337.                 orderedLiteralsTail->next = newlist;
  338.                 orderedLiteralsTail = orderedLiteralsTail->next;
  339.             }
  340.             numOrdered++;
  341.         } else {
  342.             RDF_Literal lit2 = oneUnknownAs(q, orderedLiterals, knownVars);
  343.             if (lit2 != NULL) {
  344.                 RDF_LiteralList newlist = (RDF_LiteralList)getMem(sizeof(RDF_LiteralListStruc));
  345.                 if (newlist == NULL) break;
  346.                 /* add unit and value as known variables */
  347.                 lit2->variable = (RDF_Variable) (constantp(lit2->u, knownVars) ? lit2->v->value : lit2->u.value);
  348.                 if (variableTermp(lit2->u)) {
  349.                     err = addVariableToList((RDF_Variable)lit2->u.value, &knownVars);
  350.                     if (err != noRDFErr) break;
  351.                 }
  352.                 if (variableTermp(*lit2->v)) {
  353.                     err = addVariableToList((RDF_Variable)lit2->v->value, &knownVars);
  354.                     if (err != noRDFErr) break;
  355.                 }
  356.                 /* add literal to ordered list */
  357.                 newlist->element = lit2;
  358.                 newlist->next = NULL;
  359.                 if (orderedLiterals == NULL)
  360.                     orderedLiterals = orderedLiteralsTail = newlist;
  361.                 else {
  362.                     orderedLiteralsTail->next = newlist;
  363.                     orderedLiteralsTail = orderedLiteralsTail->next;
  364.                 }
  365.                 numOrdered++;
  366.             } else break;
  367.         } 
  368.     }
  369.     if (numOrdered == q->numLiterals) {    /* ordered all succesfully so replace literals */
  370.         RDF_LiteralList old = q->literals;
  371.         q->literals = orderedLiterals;
  372.         destroyLiteralList(old, false);
  373.         q->conjunctsOrdered = true;
  374.     } else {                            /* unsuccessful so destroy ordered list structure */
  375.         destroyLiteralList(orderedLiterals, false);
  376.         q->conjunctsOrdered = false;
  377.     }
  378.     destroyVariableList(knownVars, false); /* free the knownVars list structure */
  379.     return q->conjunctsOrdered;
  380. }
  381.  
  382. PRBool processNextLiteral(RDF_Query q, RDF_Literal literal) {
  383.     if (literal->c != NULL) {
  384.         RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
  385.         return (RDF_GetVariableValue(literal->variable) != NULL);
  386.     } else {
  387.         RDF_Resource u; /* unit is a resource except for the comparison case so don't set it yet. */
  388.         RDF_Resource s = literal->s;
  389.         void* v;
  390.         if (literal->variable == NULL) {
  391.             PRBool result = false;
  392.             PRBool ans = false;
  393.             int i;
  394.             if (literal->bt) return false;
  395.             /* find a value that satisfies predicate */
  396.             for (i = 0; i < literal->valueCount; i++) {
  397.                 TermStruc valueTerm = *(literal->v + i);
  398.                 if (comparisonp(s)) {
  399.                     /* unit is a variable in all comparisons.
  400.                        value may be a variable or a constant.
  401.                     */
  402.                     switch (literal->valueType) {
  403.                         char *str, *pattern;
  404.                         int i, j;
  405.                     case RDF_STRING_TYPE:
  406.                         if (literal->u.type != RDF_VARIABLE_TERM_TYPE) return false; /* error */
  407.                         if (((RDF_Variable)literal->u.value)->type != RDF_STRING_TYPE) return false;
  408.                         str = (char*)RDF_GetVariableValue((RDF_Variable)literal->u.value);
  409.                         switch (valueTerm.type) {
  410.                         case RDF_VARIABLE_TERM_TYPE:
  411.                             pattern = (char*)RDF_GetVariableValue((RDF_Variable)valueTerm.value);
  412.                             break;
  413.                         case RDF_CONSTANT_TERM_TYPE:
  414.                             pattern = (char*)valueTerm.value;
  415.                             break;
  416.                         default:
  417.                             /* should blow up */
  418.                             return false;
  419.                             break;
  420.                         }
  421.                         if (s == gCoreVocab->RDF_stringEquals) {
  422.                             ans = stringEquals(pattern, str);
  423.                         } else if (s == gCoreVocab->RDF_substring) {
  424.                             ans = substring(pattern, str);
  425.                         } else if (s == gCoreVocab->RDF_notStringEquals) {
  426.                             ans = !stringEquals(pattern, str);
  427.                         } else if (s == gCoreVocab->RDF_notSubstring) {
  428.                             ans = !substring(pattern, str);
  429.                         } else return false; /* error */
  430.                         break;
  431.                     case RDF_INT_TYPE:
  432.                         if (literal->u.type != RDF_VARIABLE_TERM_TYPE) return false; /* error */
  433.                         if (((RDF_Variable)literal->u.value)->type != RDF_INT_TYPE) return false;
  434.                         i = (int)RDF_GetVariableValue((RDF_Variable)literal->u.value);
  435.                         switch (valueTerm.type) {
  436.                         case RDF_VARIABLE_TERM_TYPE:
  437.                             j = (int)RDF_GetVariableValue((RDF_Variable)valueTerm.value);
  438.                             break;
  439.                         case RDF_CONSTANT_TERM_TYPE:
  440.                             j = (int)valueTerm.value;
  441.                             break;
  442.                         default:
  443.                             /* should blow up */
  444.                             return false;
  445.                             break;
  446.                         }
  447.                         if (s == gCoreVocab->RDF_equals) {
  448.                             ans = (i == j);
  449.                         } else if (s == gCoreVocab->RDF_notEquals) {
  450.                             ans = (i != j);
  451.                         } else if (s == gCoreVocab->RDF_lessThan) {
  452.                             ans = (i < j);
  453.                         } else if (s == gCoreVocab->RDF_greaterThan) {
  454.                             ans = (i > j);
  455.                         } else if (s == gCoreVocab->RDF_lessThanOrEqual) {
  456.                             ans = (i <= j);
  457.                         } else if (s == gCoreVocab->RDF_greaterThanOrEqual) {
  458.                             ans = (i >= j);
  459.                         } else return false;
  460.                         break;
  461.                     default:
  462.                         return false;
  463.                         break;
  464.                     }
  465.                 }
  466.                 else {
  467.                     u = (RDF_Resource)((variableTermp(literal->u)) ? ((RDF_Variable)literal->u.value)->value : literal->u.value);
  468.                     /* special predicates */
  469.                     if (s == gCoreVocab->RDF_notInstanceOf) {
  470.                         ans = !RDF_HasAssertion(q->rdf, u, gCoreVocab->RDF_instanceOf, valueTerm.value, literal->valueType, true);
  471.                     } else if (s == gCoreVocab->RDF_notParent) {
  472.                         ans = !RDF_HasAssertion(q->rdf, u, gCoreVocab->RDF_parent, valueTerm.value, literal->valueType, true);
  473.                     } else ans = RDF_HasAssertion(q->rdf, u, s, valueTerm.value, literal->valueType, true);
  474.                 }
  475.                 literal->bt = true;
  476.                 /* result = ((literal->tv == true) ? ans : !ans); */
  477.                 result = ans;
  478.                 if (result) return result; /* otherwise try next value */
  479.             }
  480.             return result;
  481.         } 
  482.         u = (RDF_Resource)((variableTermp(literal->u)) ? ((RDF_Variable)literal->u.value)->value : literal->u.value);
  483.         v = (variableTermp(*literal->v)) ? ((RDF_Variable)literal->v->value)->value : literal->v->value;
  484.         if ((u == NULL) && variableTermp(literal->u) && resourceTermp(*literal->v)) {
  485.             literal->c = RDF_GetSources(q->rdf, (RDF_Resource)v, s, literal->valueType,  true);
  486.             if (literal->c == NULL) return false;
  487.             RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
  488.             return (RDF_GetVariableValue(literal->variable) != NULL);
  489.         } else if ((v == NULL) && variableTermp(*literal->v) && (u != NULL)) {
  490.             literal->c = RDF_GetTargets(q->rdf, u, s, literal->valueType,  true); /* note arg order differs from java implementation */
  491.             if (literal->c == NULL) return false;
  492.             RDF_SetVariableValue(literal->variable, RDF_NextValue(literal->c), literal->valueType);
  493.             return (RDF_GetVariableValue(literal->variable) != NULL);
  494.         } else return false;            
  495.     }
  496. }
  497.  
  498. PR_PUBLIC_API(PRBool) RDF_RunQuery (RDF_Query q) {
  499.     q->queryRunning = true;
  500.     orderConjuncts(q);
  501.     if (q->conjunctsOrdered)
  502.         return true;
  503.     else return false;
  504. }
  505.  
  506. PR_PUBLIC_API(PRBool) RDF_GetNextElement(RDF_Query q) {
  507.     if (!q->queryRunning) RDF_RunQuery(q);
  508.     if (q->index == q->numLiterals) q->index--;
  509.     while (q->index < q->numLiterals) {
  510.         RDF_Literal lit = getNthLiteral(q, q->index); /* we know it's it range so don't have to check for NULL */
  511.         if (!processNextLiteral(q, lit)) {
  512.             if (q->index == 0) return false;
  513.             lit->c = NULL;
  514.             if (lit->variable != NULL) RDF_SetVariableValue(lit->variable, (void*)NULL, RDF_RESOURCE_TYPE);
  515.             lit->bt = false;
  516.             q->index--;
  517.         } else {
  518.             q->index++;
  519.         }
  520.     }
  521.     return true;
  522. }
  523.  
  524. PR_PUBLIC_API(void) RDF_EndQuery (RDF_Query q) {
  525.     q->queryRunning = false;
  526. }
  527.  
  528. PR_PUBLIC_API(RDF_VariableList) RDF_GetVariableList(RDF_Query q) {
  529.     return q->variables;
  530. }
  531.  
  532. /* Note: should put a test for overflow of numLiterals */
  533.  
  534. /* Adds a literal to the query. */
  535. void addLiteral(RDF_Query q, RDF_Literal literal) {
  536.     RDF_LiteralList newlist = (RDF_LiteralList)getMem(sizeof(RDF_LiteralListStruc));
  537.     if (newlist == NULL) return;
  538.     newlist->element = literal;
  539.     newlist->next = q->literals;
  540.     q->literals = newlist;
  541.     q->numLiterals++;
  542. }
  543.  
  544. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctVRV(RDF_Query q, RDF_Variable arg1, RDF_Resource s, RDF_Variable arg2, RDF_ValueType type) {
  545.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  546.     if (literal == NULL) return RDF_NO_MEMORY;
  547.     literal->u.value = (void*)arg1;
  548.     literal->u.type = RDF_VARIABLE_TERM_TYPE;
  549.     ((RDF_Variable)literal->u.value)->type = RDF_RESOURCE_TYPE;
  550.     literal->s = s;
  551.     literal->valueCount = 1;
  552.     literal->v = (TermStruc*)getMem(sizeof(TermStruc));
  553.     literal->v->value = (void*)arg2;
  554.     literal->v->type = RDF_VARIABLE_TERM_TYPE;
  555.     ((RDF_Variable)literal->v->value)->type = literal->valueType = type;
  556.     literal->tv = true;
  557.     addLiteral(q, literal);    
  558.     q->conjunctsOrdered = false;
  559.     return noRDFErr;
  560. }
  561.  
  562. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctVRO(RDF_Query q, RDF_Variable arg1, RDF_Resource s, void* arg2, RDF_ValueType type) {
  563.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  564.     if (literal == NULL) return RDF_NO_MEMORY;
  565.     literal->u.value = (void*)arg1;
  566.     literal->u.type = RDF_VARIABLE_TERM_TYPE;
  567.     ((RDF_Variable)literal->u.value)->type = type;
  568.     literal->s = s;
  569.     literal->valueCount = 1;
  570.     literal->v = (TermStruc*)getMem(sizeof(TermStruc));
  571.     literal->v->value = (type == RDF_STRING_TYPE) ? (void*)copyString((char*)arg2) : (void*)arg2;
  572.     literal->v->type = RDF_CONSTANT_TERM_TYPE;
  573.     literal->valueType = type;
  574.     literal->tv = true;
  575.     addLiteral(q, literal);    
  576.     q->conjunctsOrdered = false;        
  577.     return noRDFErr;
  578. }
  579.  
  580. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctRRO(RDF_Query q, RDF_Resource arg1, RDF_Resource s, void* arg2, RDF_ValueType type) {
  581.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  582.     if (literal == NULL) return RDF_NO_MEMORY;
  583.     literal->u.value = (void*)arg1;
  584.     literal->u.type = RDF_RESOURCE_TERM_TYPE;
  585.     literal->s = s;
  586.     literal->valueCount = 1;
  587.     literal->v = (TermStruc*)getMem(sizeof(TermStruc));
  588.     literal->v->value = (type == RDF_STRING_TYPE) ? (void*)copyString((char*)arg2) : (void*)arg2;
  589.     literal->v->type = RDF_CONSTANT_TERM_TYPE;
  590.     literal->valueType = type;
  591.     literal->tv = true;
  592.     addLiteral(q, literal);    
  593.     q->conjunctsOrdered = false;        
  594.     return noRDFErr;
  595. }
  596.  
  597. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctVRR(RDF_Query q, RDF_Variable arg1, RDF_Resource s, RDF_Resource arg2) {
  598.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  599.     if (literal == NULL) return RDF_NO_MEMORY;
  600.     literal->u.value = (void*)arg1;
  601.     literal->u.type = RDF_VARIABLE_TERM_TYPE;
  602.     ((RDF_Variable)literal->u.value)->type = RDF_RESOURCE_TYPE;
  603.     literal->s = s;
  604.     literal->valueCount = 1;
  605.     literal->v = (TermStruc*)getMem(sizeof(TermStruc));
  606.     literal->v->value = (void*)arg2;
  607.     literal->v->type = RDF_RESOURCE_TERM_TYPE;
  608.     literal->valueType = RDF_RESOURCE_TYPE;
  609.     literal->tv = true;
  610.     addLiteral(q, literal);    
  611.     q->conjunctsOrdered = false;
  612.     return noRDFErr;
  613. }
  614.  
  615. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctRRV(RDF_Query q, RDF_Resource arg1, RDF_Resource s, RDF_Variable arg2, RDF_ValueType type) {
  616.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  617.     if (literal == NULL) return RDF_NO_MEMORY;
  618.     literal->u.value = arg1;
  619.     literal->u.type = RDF_RESOURCE_TERM_TYPE;
  620.     literal->s = s;
  621.     literal->valueCount = 1;
  622.     literal->v = (TermStruc*)getMem(sizeof(TermStruc));
  623.     literal->v->value = (void*)arg2;
  624.     literal->v->type = RDF_VARIABLE_TERM_TYPE;
  625.     ((RDF_Variable)literal->v->value)->type = literal->valueType = type;
  626.     literal->tv = true;
  627.     addLiteral(q, literal);    
  628.     q->conjunctsOrdered = false;
  629.     return noRDFErr;
  630. }
  631.  
  632. PR_PUBLIC_API(RDF_Error) RDF_AddConjunctVRL(RDF_Query q, RDF_Variable arg1, RDF_Resource s, RDF_Term arg2, RDF_ValueType type, uint8 count) {
  633.     RDF_Literal literal = (RDF_Literal)getMem(sizeof(LiteralStruc));
  634.     if (literal == NULL) return RDF_NO_MEMORY;
  635.     literal->u.value = (void*)arg1;
  636.     literal->u.type = RDF_VARIABLE_TERM_TYPE;
  637.     ((RDF_Variable)literal->u.value)->type = type;
  638.     literal->s = s;
  639.     literal->valueCount = count;
  640.     literal->v = (void*)arg2;
  641.     /* value and type of each term already assigned */
  642.     literal->valueType = type;
  643.     literal->tv = true;
  644.     addLiteral(q, literal);    
  645.     q->conjunctsOrdered = false;        
  646.     return noRDFErr;
  647. }
  648.