home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / modules / rdf / src / mcff2mcf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  10.0 KB  |  388 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. #include "mcff2mcf.h"
  20.  
  21.  
  22.  
  23. int
  24. parseNextMCFBlob(NET_StreamClass *stream, char* blob, int32 size)
  25. {
  26.   RDFFile f;
  27.   int32 n, last, m;
  28.   n = last = 0;
  29.  
  30.   f = (RDFFile)stream->data_object;
  31.   if ((f == NULL) || (size < 0)) {
  32.     return MK_INTERRUPTED;
  33.   }
  34.  
  35.   while (n < size) {
  36.     char c = blob[n];
  37.     m = 0;
  38.     memset(f->line, '\0', f->lineSize);
  39.     if (f->holdOver[0] != '\0') {
  40.       memcpy(f->line, f->holdOver, strlen(f->holdOver));
  41.       m = strlen(f->holdOver);
  42.       memset(f->holdOver, '\0', RDF_BUF_SIZE);
  43.     }
  44.     while ((m < f->lineSize) && (c != '\r') && (c != '\n') && (n < size)) {
  45.       f->line[m] = c;
  46.       m++;
  47.       n++;
  48.       c = blob[n];
  49.     }
  50.     n++;
  51.     if (m > 0) {
  52.       if ((c == '\n') || (c == '\r')) {
  53.     last = n;
  54.     parseNextMCFLine(f, f->line);
  55.       } else if (size > last) {
  56.     memcpy(f->holdOver, f->line, m);
  57.       }
  58.     }
  59.   }
  60.   return(size);
  61. }
  62.  
  63.  
  64.  
  65. void
  66. parseNextMCFLine (RDFFile f, char* line)
  67. {
  68.   char* nextToken ;
  69.   int16 offset = 0;
  70.   RDF_Error err;
  71.   
  72.   if ((nullp(line)) || (line[0] == '\0'))return; 
  73.   nextToken = getMem(MAX_URL_SIZE);
  74.   err = getFirstToken(line, nextToken, &offset);
  75.   
  76.   offset++; 
  77.   if ((err != noRDFErr) &&  (nextToken[0] == ';')) {
  78.     freeMem(nextToken);
  79.     return;
  80.   }
  81.   if (startsWith("begin-headers", nextToken)) {
  82.     f->status = HEADERS;
  83.   } else if (startsWith("end-headers", nextToken)) {
  84.     f->status = BODY;
  85.   } else if (startsWith("unit", nextToken)) {
  86.     f->status = BODY; 
  87.     if (!(nullp(f->currentResource))) resourceTransition(f);
  88.     getFirstToken(&line[offset], nextToken, &offset);
  89.     f->currentResource = resolveReference(nextToken, f); 
  90.   } else if (nextToken[strlen(nextToken)-1] == ':') {
  91.     memset(f->currentSlot, '\0', 100);
  92.     memcpy(f->currentSlot, nextToken, strlen(nextToken)-1);
  93.     while (getFirstToken(&line[offset], nextToken, &offset) == noRDFErr) {
  94.       if (f->status == HEADERS) {
  95.     assignHeaderSlot(f, f->currentSlot, nextToken);
  96.       } else if (f->currentResource) {
  97.     assignSlot(f->currentResource, f->currentSlot, nextToken, f); 
  98.       }
  99.       offset++;
  100.     }
  101.   }
  102.   freeMem(nextToken);
  103. }
  104.  
  105.  
  106.  
  107. void
  108. finishMCFParse (RDFFile f)
  109. {
  110.   parseNextMCFLine(f, f->storeAway);
  111.   resourceTransition(f); 
  112. } 
  113.  
  114.  
  115.  
  116. void
  117. resourceTransition (RDFFile f)
  118. {
  119.   if ((f->currentResource)  && (!f->genlAdded))
  120.     addSlotValue(f, f->currentResource, gCoreVocab->RDF_parent, f->rtop, 
  121.          RDF_RESOURCE_TYPE, true); 
  122.   f->genlAdded = false;
  123. }
  124.  
  125.  
  126.  
  127. void
  128. assignHeaderSlot (RDFFile f, char* slot, char* value)
  129. {
  130.   if (startsWith(slot, "expiresOn")) {
  131.     if (f->expiryTime == NULL)  f->expiryTime = (PRTime*)getMem(sizeof(PRTime));
  132.     if (PR_ParseTimeString (value, 0, f->expiryTime) !=  PR_SUCCESS) {
  133.       freeMem(f->expiryTime);
  134.       f->expiryTime = NULL;
  135.     }
  136.   } else if (!(startsWith(slot, "RDFVersion"))) {
  137.     assignSlot(f->top, slot, value, f);
  138.   }    
  139. }
  140.  
  141.  
  142.  
  143. RDF_Error
  144. getFirstToken (char* line, char* nextToken, int16* l)
  145. {
  146.   PRBool in_paren = 0;
  147.   PRBool in_string = 0;
  148.   PRBool in_bracket = 0;
  149.   PRBool something_seen = 0;
  150.   uint16 front_spaces = 0;
  151.   uint16 index;
  152.   RDF_Error ans = -1;
  153.   
  154.   memset(nextToken, '\0', 200);
  155.   
  156.   for (index = 0; index < strlen(line); index++) {
  157.     char c = line[index];
  158.     
  159.     if ((c == '\n') || (c == '\0') || (c == '\r')) {
  160.       *l = index + *l  ;
  161.       return ans;
  162.     }
  163.     
  164.     if ((c == ':') && ((index == 0) || (line[index-1] == ' ')) && 
  165.     ((line[index+1] == ' ')    || (line[index+1] == '\0'))) c = ' ';
  166.     
  167.     if (c != ' ') something_seen = 1;
  168.     
  169.     if (in_paren) {
  170.       if (c == ')') {
  171.     nextToken[index-front_spaces] = c;
  172.     ans = noRDFErr;
  173.     *l = index + *l ;
  174.     return ans;
  175.       } else {
  176.     ans = noRDFErr;
  177.     nextToken[index-front_spaces] = c;
  178.       }
  179.     } else if (in_string) {
  180.       if (c == '"') {
  181.     nextToken[index-front_spaces] = c;
  182.     ans = noRDFErr;
  183.     *l = index + *l ;
  184.     return ans;
  185.       } else {
  186.     ans = noRDFErr;
  187.     nextToken[index-front_spaces] = c;
  188.       }
  189.     } else if (in_bracket) {
  190.       if (c == ']') {
  191.     nextToken[index-front_spaces] = c; 
  192.     *l = index + *l ;
  193.     ans = noRDFErr;
  194.     return ans;
  195.       } else {
  196.     ans = noRDFErr;
  197.     nextToken[index-front_spaces] = c;
  198.       }
  199.     } else if (c == '"') {
  200.       ans = noRDFErr;
  201.       nextToken[index-front_spaces] = c;
  202.       in_string = 1;
  203.     } else if (c == '[') {
  204.       ans = noRDFErr;
  205.       nextToken[index-front_spaces] = c;
  206.       in_bracket = 1;
  207.     } else if (c == '(') {
  208.       ans = noRDFErr;
  209.       nextToken[index-front_spaces] = c;
  210.       in_paren = 1;
  211.     } else if (c == ' '){
  212.       if (something_seen) { 
  213.     *l = index + *l ;
  214.     return ans;
  215.       } else {
  216.     front_spaces++;
  217.       }
  218.     } else {
  219.       ans = noRDFErr;
  220.       nextToken[index-front_spaces] = c;
  221.     }
  222.   }
  223.   *l = index + *l ;
  224.   return ans;
  225. }    
  226.  
  227.  
  228.  
  229. void
  230. addSlotValue (RDFFile f, RDF_Resource u, RDF_Resource s, void* v,
  231.         RDF_ValueType type, PRBool tv)
  232. {
  233.    if (f == NULL || u == NULL || s == NULL || v == NULL)    return;
  234.    if (s == gCoreVocab->RDF_child) {
  235.      RDF_Resource temp = (RDF_Resource)v;
  236.      s = gCoreVocab->RDF_parent;
  237.      v = u;
  238.      u = temp;
  239.    }
  240.    if (s == gCoreVocab->RDF_parent) f->genlAdded = true; 
  241.    (*f->assert)(f, f->db, u, s, v, type, tv);
  242.    if (s == gCoreVocab->RDF_parent) setContainerp((RDF_Resource)v, 1);
  243. }
  244.  
  245.  
  246.  
  247. void
  248. assignSlot (RDF_Resource u, char* slot, char* value, RDFFile f)
  249. {
  250.   PRBool tv = true;
  251.   if (value[0] == '(') {
  252.     tv = false;
  253.     value = &value[1];
  254.     value[strlen(value)-1] = '\0';
  255.   } 
  256.   if (startsWith("default_genl", slot)) return;
  257.   
  258.   if (startsWith("name", slot) || (startsWith("local-name", slot))) { 
  259.     value[strlen(value)-1] = '\0';
  260.     addSlotValue(f, u, gCoreVocab->RDF_name, copyString(&value[1]), RDF_STRING_TYPE, tv);  
  261.   }  else if (startsWith("specs", slot) || (startsWith("child", slot))) {
  262.     RDF_Resource spec = resolveReference(value, f);  
  263.     if (!nullp(spec)) addSlotValue(f, spec, gCoreVocab->RDF_parent, u, RDF_RESOURCE_TYPE, tv); 
  264.   }  else if (startsWith("genls_pos", slot)) {
  265.     RDF_Resource genl = resolveGenlPosReference(value, f);  
  266.     if (!nullp(genl)) addSlotValue(f, u, gCoreVocab->RDF_parent, genl, RDF_RESOURCE_TYPE, tv);
  267.   }  else if ((startsWith("genls", slot)) || (startsWith("parent", slot))) {
  268.     RDF_Resource genl = resolveReference(value, f);
  269.     if (!nullp(genl)) addSlotValue(f, u, gCoreVocab->RDF_parent, genl, RDF_RESOURCE_TYPE, tv);
  270.   } else {
  271.     void* parsed_value;
  272.     RDF_ValueType data_type;
  273.     RDF_Resource s = RDF_GetResource(NULL, slot, true);
  274.     RDF_Error err = parseSlotValue(f, s, value, &parsed_value, &data_type); 
  275.     if ((err == noRDFErr) && (!nullp(parsed_value)))   
  276.       addSlotValue(f, u, s, parsed_value, data_type, tv);
  277.   } 
  278. }
  279.  
  280.  
  281.  
  282. RDF_Error
  283. parseSlotValue (RDFFile f, RDF_Resource s, char* value, void** parsed_value, RDF_ValueType* data_type)
  284. {
  285.   if (value[0] == '"') {
  286.     int32 size = strlen(value)-1;
  287.     *parsed_value = getMem(size);
  288.     value[size]  = '\0';
  289.     *parsed_value = &value[1];
  290.     *data_type = RDF_STRING_TYPE;
  291.     return noRDFErr;
  292.   } else if (value[0] == '#') {
  293.     if (value[1] == '"') {
  294.       value[strlen(value)-1] = '\0';
  295.       value = &value[2];
  296.     } else {
  297.       value = &value[1];
  298.     }
  299.     *parsed_value = resolveReference(value, f);
  300.     return noRDFErr;
  301.   } else if (charSearch('.', value) == -1) {
  302.     int16 ans = 0;
  303.     /* XXX        sscanf(value, "%ld", &ans); */
  304.     *data_type = RDF_INT_TYPE;
  305.     return noRDFErr;
  306.   } else {
  307.     return -1;
  308.   }
  309. }
  310.  
  311.  
  312.  
  313. void
  314. derelativizeURL (char* tok, char* url, RDFFile f)
  315. {
  316.   if ((tok[0] == '/') && (endsWith(".mco", tok))) {
  317.     void stringAppendBase (char* dest, char* addition) ;
  318.     stringAppendBase(url, f->url); 
  319.     stringAppend(url, "#");
  320.     stringAppend(url, tok);
  321.   } else if  ((endsWith(".mco", tok)) && (charSearch('#', tok) == -1)) {
  322.     void stringAppendBase (char* dest, char* addition) ;
  323.     stringAppendBase(url, f->url);
  324.     stringAppend(url, "#");
  325.     stringAppend(url, tok);
  326.   } else {
  327.     memcpy(url, tok, strlen(tok));
  328.   }
  329. }
  330.  
  331.  
  332.  
  333. RDF_Resource
  334. resolveReference (char *tok, RDFFile f)
  335. {
  336.   RDF_Resource existing;
  337.   char* url = getMem(MAX_URL_SIZE);
  338.   if (tok[0] == '#') tok = &tok[1];
  339.   if (tok[strlen(tok)-1] == '"') tok[strlen(tok)-1] = '\0';
  340.   if (tok[0] == '"') tok = &tok[1];
  341.   memset(url, '\0', 200);
  342.   if (charSearch(':', tok) == -1) { 
  343.     derelativizeURL(tok, url, f);
  344.   } else {
  345.     memcpy(url, tok, strlen(tok));
  346.   }
  347.   if (strcmp(url,"this") == 0) {
  348.     existing = f->top;
  349.   } else {
  350.     existing = RDF_GetResource(NULL, url, false);
  351.   }
  352.   if (existing != null) return existing;
  353.   existing = RDF_GetResource(NULL, url, true);
  354.   addToResourceList(f, existing);
  355.   freeMem(url);
  356.   return existing;
  357. }
  358.  
  359.  
  360.  
  361. RDF_Resource
  362. resolveGenlPosReference(char* tok,  RDFFile f)
  363. {
  364.   RDF_Resource ans;
  365.   char* url = (char*)getMem(MAX_URL_SIZE);
  366.   long i1, i2;
  367.   i1 = charSearch('"', tok);
  368.   i2 = revCharSearch('"', tok);
  369.   memcpy(url, &tok[i1], i2-i1+1);
  370.   ans = resolveReference(url, f);
  371.   freeMem(url);
  372.   return ans;
  373. }
  374.  
  375.  
  376.  
  377. char *
  378. getRelURL (RDF_Resource u, RDF_Resource top)
  379. {
  380.   char* uID = resourceID(u);
  381.   char* topID = resourceID(top);
  382.   if (startsWith(topID, uID)) {
  383.     int16 n = charSearch('#', uID);
  384.     if (n == -1) return uID;
  385.     return &(uID)[n+1];
  386.   } else return uID;
  387. }
  388.