Adding rdf files into raptor

rdf/include/makefile.win

@@ -0,0 +1,37 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+
+MODULE = rdf
+
+DEPTH = ..\..\..
+
+EXPORTS	= rdf.h \
+	rdfc.h \
+	nsIRDFService.h \
+	nsIRDFDataSource.h \
+	nsIRDFDataBase.h \
+	nsIRDFObserver.h \
+	nsIRDFCursor.h \
+	htrdf.h \
+	vocab.h \
+	jsec2rdf.h \
+	$(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+

rdf/include/nsIRDFCursor.h

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsIRDFCursor_h__
+#define nsIRDFCursor_h__
+
+/*
+
+  nsIRDFCursor:
+
+  An iterator for RDF data sources.
+
+*/
+
+#include "nsISupports.h"
+#include "rdf.h"
+
+
+// 1c2abdb0-4cef-11d2-bc16-00805f912fe7
+#define NS_IRDFCURSOR_IID \
+{ \
+    0x1c2abdb0, \
+    0x4cef, \
+    0x11d2, \
+  { 0xbc, 0x16, 0x00, 0x80, 0x5f, 0x91, 0x2f, 0xe7 } \
+}
+
+
+class nsIRDFCursor : public nsISupports {
+public:
+
+  //  NS_IMETHOD HasElements(PRBool& hasElements) = 0;
+
+  NS_IMETHOD Next(RDF_NodeStruct& next /* in/out */) = 0;
+
+};
+
+#endif /* nsIRDFCursor_h__ */

rdf/include/nsIRDFDataBase.h

@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsIRDFDataBase_h__
+#define nsIRDFDataBase_h__
+
+/*
+  This file contains the interface definition for an RDF database.
+
+  RDF databases aggregate RDF data sources (see nsIRDFDataSource.h)
+*/
+
+#include "nsISupports.h"
+#include "nsIRDFDataSource.h"
+#include "rdf.h"
+
+
+// 96343820-307c-11d2-bc15-00805f912fe7
+#define NS_IRDFDATABASE_IID \
+{ \
+  0x96343820, \
+  0x307c, \
+  0x11d2, \
+  { 0xb, 0xc15, 0x00, 0x80, 0x5f, 0x91, 0x2f, 0xe7 } \
+}
+
+
+class nsIRDFDataBase : public nsIRDFDataSource {
+public:
+
+#ifdef RDF_NOT_IMPLEMENTED
+  NS_IMETHOD Initialize(nsIRDFResourceManager* r) = 0;
+#endif
+
+
+#ifdef RDF_NOT_IMPLEMENTED
+  /*
+    Add a data source for the specified URL to the database.
+
+    Parameters:
+      dataSource -- a ptr to the data source to add
+
+    Returns:
+  */
+  NS_IMETHOD AddDataSource(nsIRDFDataSource* dataSource) = 0;
+
+  NS_IMETHOD RemoveDataSource(nsIRDFDataSource* dataSource) = 0;
+
+  NS_IMETHOD GetDataSource(RDF_String url,
+                           nsIRDFDataSource **source /* out */ ) = 0;
+#endif
+
+  // XXX move these to datasource?
+  NS_IMETHOD DeleteAllArcs(RDF_Resource resource) = 0;
+
+};
+
+
+#endif /* nsIRDFDataBase_h__ */

rdf/include/nsIRDFDataSource.h

@@ -0,0 +1,223 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsIRDFDataSource_h__
+#define nsIRDFDataSource_h__
+
+/*
+  This file contains the interface definition for an RDF data source.
+
+  Classes which implement this interface for a particular type of URL
+  are registered with the RDF singleton via nsIRDF::RegisterHandler(...)
+*/
+
+#include "nsISupports.h"
+#include "rdf.h"
+
+// 852666b0-2cce-11d2-bc14-00805f912fe7
+#define NS_IRDFDATASOURCE_IID \
+{ \
+  0x852666b0, \
+  0x2cce, \
+  0x11d2, \
+  { 0xb, 0xc14,0x00, 0x80, 0x5f, 0x91 0x2f, 0xe7 } \
+}
+
+class nsIRDFCursor;
+class nsIRDFObserver;
+class nsIRDFDataBase;
+
+class nsIRDFDataSource : public nsISupports {
+public:
+
+#ifdef RDF_NOT_IMPLEMENTED
+  /**
+   * Initialize this data source
+   */
+  NS_IMETHOD Initialize(RDF_String url,
+                        nsIRDFResourceManager* m);
+#endif
+
+  /**
+   * Get the name of this data source.
+   *
+   * For regular data sources, this will be the URL of the source.
+   *
+   * For aggregated sources, it generally will not be a valid RDF URL.
+   */
+  NS_IMETHOD GetName(const RDF_String* name /* out */ ) = 0;
+
+  /**
+   * Find an RDF resource that points to a given node over the
+   * specified arc & truth value (defaults to "PR_TRUE").
+   */
+  NS_IMETHOD GetSource(RDF_Node target,
+                       RDF_Resource arcLabel,
+                       RDF_Resource *source /* out */) = 0;
+
+  NS_IMETHOD GetSource(RDF_Node target,
+                       RDF_Resource arcLabel,
+                       PRBool tv,
+                       RDF_Resource *source /* out */) = 0;
+
+  /**
+   * Find all RDF resources that point to a given node over the
+   * specified arc & truth value (defaults to "PR_TRUE").
+   */
+  NS_IMETHOD GetSources(RDF_Node target,
+                        RDF_Resource arcLabel,
+                        nsIRDFCursor **sources /* out */) = 0;
+
+  NS_IMETHOD GetSources(RDF_Node target,
+                        RDF_Resource arcLabel,
+                        PRBool tv,
+                        nsIRDFCursor **sources /* out */) = 0;
+
+  /**
+   * Find a child of that is related to the source by the given arc
+   * arc and truth value (defaults to PR_TRUE).
+   */
+  NS_IMETHOD GetTarget(RDF_Resource source,
+                       RDF_Resource arcLabel,
+                       RDF_ValueType targetType,
+                       RDF_NodeStruct& target /* in/out */) = 0;
+
+  NS_IMETHOD GetTarget(RDF_Resource source,
+                       RDF_Resource arcLabel,
+                       RDF_ValueType targetType,
+                       PRBool tv,
+                       RDF_NodeStruct& target /* in/out */) = 0;
+
+  /**
+   * Find all children of that are related to the source by the given arc
+   * arc and truth value (defaults to PR_TRUE).
+   */
+  NS_IMETHOD GetTargets(RDF_Resource source,
+                        RDF_Resource arcLabel,
+                        RDF_ValueType targetType,
+                        nsIRDFCursor **targets /* out */) = 0;
+
+  NS_IMETHOD GetTargets(RDF_Resource source,
+                        RDF_Resource arcLabel,
+                        PRBool tv,
+                        RDF_ValueType targetType,
+                        nsIRDFCursor **targets /* out */) = 0;
+
+#ifdef RDF_NOT_IMPLEMENTED
+  /**
+   * Find all parents that point to a node over a given arc label,
+   * regardless of truth value.
+   */
+  NS_IMETHOD GetAllSources(RDF_Node target,
+                           RDF_Resource arcLabel,
+                           nsIRDFCursor2 **sources /* out */) = 0;
+
+  /**
+   * Find all children of a resource that are related by the 
+   * given arc label, regardless of the truth value.
+   */ 
+  NS_IMETHOD GetAllTargets(RDF_Resource source,
+                           RDF_Resource arcLabel,
+                           RDF_ValueType targetType,
+                           nsIRDFCursor2 **targets /* out */);
+#endif /* RDF_NOT_IMPLEMENTED */
+
+
+  /**
+   * Add an assertion to the graph.
+   */
+  NS_IMETHOD Assert(RDF_Resource source, 
+                    RDF_Resource arcLabel, 
+                    RDF_Node target,
+                    PRBool tv = PR_TRUE) = 0;
+
+  /**
+   * Remove an assertion from the graph.
+   */
+  NS_IMETHOD Unassert(RDF_Resource source,
+                      RDF_Resource arcLabel,
+                      RDF_Node target) = 0;
+
+  /**
+   * Query whether an assertion exists in this graph.
+   *
+   */
+  NS_IMETHOD HasAssertion(RDF_Resource source,
+                          RDF_Resource arcLabel,
+                          RDF_Node target,
+                          PRBool truthValue,
+                          PRBool* hasAssertion /* out */) = 0;
+
+  /**
+   * Add an observer to this data source.
+   */
+  NS_IMETHOD AddObserver(nsIRDFObserver *n,
+                         RDF_EventMask type = RDF_ANY_NOTIFY) = 0;
+
+  /**
+   * Remove an observer from this data source
+   */
+  NS_IMETHOD RemoveObserver(nsIRDFObserver *n,
+                            RDF_EventMask = RDF_ANY_NOTIFY) = 0;
+
+  /**
+   * Get a cursor to iterate over all the arcs that point into a node.
+   */
+  NS_IMETHOD ArcLabelsIn(RDF_Node node,
+                         nsIRDFCursor **labels /* out */) = 0;
+
+  /**
+   * Get a cursor to iterate over all the arcs that originate in
+   * a resource.
+   */
+  NS_IMETHOD ArcLabelsOut(RDF_Resource source,
+                          nsIRDFCursor **labels /* out */) = 0;
+
+#ifdef RDF_NOT_IMPLEMENTED
+  /**
+   * Notify this data source that it is a child of a database.
+   *
+   * The datasource must send notifications to the parent when 
+   * changes to it's graph are made, in case the parent has observers
+   * interested in the events generated.
+   */
+  NS_IMETHOD AddParent(nsIRDFDataBase* parent) = 0;
+
+  /**
+   * Notify this data source that it has been disconnected from a
+   * parent.
+   */
+  NS_IMETHOD RemoveParent(nsIRDFDataBase* parent) = 0;
+
+  /**
+   * Request that a data source obtain updates if applicable.
+   */
+  // XXX move this to an nsIRDFRemoteDataStore interface?
+  NS_IMETHOD Update(RDF_Resource hint) = 0;
+#endif /* RDF_NOT_IMPLEMENTED */
+
+  /**
+   * Request that a data source write it's contents out to 
+   * permanent storage if applicable.
+   */
+  NS_IMETHOD Flush() = 0;
+
+};
+
+
+#endif /* nsIRDFDataSource_h__ */

rdf/include/nsIRDFObserver.h

@@ -0,0 +1,51 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/*
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsIRDFObserver_h__
+#define nsIRDFObserver_h__
+
+/*
+  This file defines the interface for RDF observers.
+*/
+
+#include "nsISupports.h"
+#include "rdf.h"
+
+
+// 3cc75360-484a-11d2-bc16-00805f912fe7
+#define NS_IRDFOBSERVER_IID \
+{ \
+    0x3cc75360, \
+    0x484a, \
+    0x11d2, \
+  { 0xbc, 0x16, 0x00, 0x80, 0x5f, 0x91, 0x2f, 0xe7 } \
+}
+
+class nsIRDFDataSource;      
+
+class nsIRDFObserver : public nsISupports
+{
+public:
+
+  NS_IMETHOD HandleEvent(nsIRDFDataSource *source,
+                         RDF_Event event) = 0;
+
+};
+
+
+#endif /* nsIRDFObserver_h__ */

rdf/include/nsIRDFService.h

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef nsIRDFService_h__
+#define nsIRDFService_h__
+
+/*
+  This file defines the interface for the RDF singleton,
+  which maintains various pieces of pieces of information global
+  to all RDF data sources.
+
+  In particular, it provides the interface for mapping rdf URL types
+  to nsIRDFDataSource implementors for that type of content.
+*/
+
+#include "nsISupports.h"
+#include "nsIFactory.h" /* nsCID typedef, for consistency */
+#include "rdf.h"
+
+class nsIRDFDataSource;
+class nsIRDFDataBase;
+
+// 6edf3660-32f0-11d2-9abe-00600866748f
+#define NS_IRDFSERVICE_IID \
+{ \
+  0x6edf3660, \
+  0x32f0, \
+  0x11d2, \
+  { 0x9a, 0xbe, 0x00, 0x60, 0x08, 0x66, 0x74, 0x8f } \
+}
+
+
+class nsIRDFService : public nsISupports {
+public:
+
+  NS_IMETHOD Initialize();
+
+#ifdef RDF_NOT_IMPLEMENTED
+  NS_IMETHOD RegisterHandler(RDF_String url_selector, const nsCID& clsid) = 0;
+
+  NS_IMETHOD RemoveHandler(RDF_String url_selector, const nsCID& clsid) = 0;
+
+  NS_IMETHOD CreateDataSource(RDF_String url,
+                              nsIRDFDataSource **source /* out */) = 0;
+#endif /* RDF_NOT_IMPLEMENTED */
+
+  NS_IMETHOD CreateDatabase(const RDF_String* url_ary,
+                            nsIRDFDataBase **db /* out */) = 0;
+
+};
+
+
+#endif /* nsIRDFService_h__ */

rdf/include/rdf.h

@@ -0,0 +1,120 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+#ifndef rdf_h___
+#define rdf_h___
+
+#include "nspr.h"
+#include "nsError.h"
+
+typedef int RDF_Error;
+
+#define RDF_ERROR_ILLEGAL_ASSERT 1 /* NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF,1) */
+#define RDF_ERROR_ILLEGAL_KILL   2 /* NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF,2) */
+#define RDF_ERROR_UNABLE_TO_CREATE 3 /*NS_ERROR_GENERATE_FAILURE( NS_ERROR_MODULE_RDF,3) */
+
+#define RDF_ERROR_NO_MEMORY NS_ERROR_OUT_OF_MEMORY /* XXX remove this */
+
+NSPR_BEGIN_EXTERN_C
+
+typedef struct RDF_ResourceStruct* RDF_Resource;
+typedef struct RDF_CursorStruct* RDF_Cursor;
+typedef struct RDF_DBStruct* RDF;
+typedef struct RDF_TranslatorStruct *RDFT;
+
+typedef char* RDF_String;
+
+typedef enum { 
+  RDF_ANY_TYPE,
+  RDF_RESOURCE_TYPE,
+  RDF_INT_TYPE,
+  RDF_STRING_TYPE,
+#ifdef RDF_BLOB
+  RDF_BLOB_TYPE
+#endif
+} RDF_ValueType;
+
+
+#ifdef RDF_BLOB
+typedef struct RDF_BlobStruct {
+  PRUint32 size;
+  void* data;
+} *RDF_Blob;
+#endif
+
+typedef struct RDF_NodeStruct {
+  RDF_ValueType type;
+  union {
+    RDF_Resource r;
+    RDF_String s;
+#ifdef RDF_BLOB
+    RDF_Blob b;
+#endif
+  } value;
+} *RDF_Node;
+
+typedef PRUint32 RDF_EventType;
+#define RDF_ASSERT_NOTIFY	((RDF_EventType)0x00000001)
+#define RDF_DELETE_NOTIFY	((RDF_EventType)0x00000002)
+#define RDF_KILL_NOTIFY		((RDF_EventType)0x00000004)
+#define RDF_CREATE_NOTIFY	((RDF_EventType)0x00000008)
+#define RDF_RESOURCE_GC_NOTIFY	((RDF_EventType)0x00000010)
+#define RDF_INSERT_NOTIFY	((RDF_EventType)0x00000020)
+
+typedef PRUint32 RDF_EventMask;
+#define RDF_ANY_NOTIFY      ((RDF_EventMask)0xFFFFFFFF)
+
+typedef struct  RDF_AssertEventStruct {
+  RDF_Resource u;
+  RDF_Resource s;
+  void*        v;
+  RDF_ValueType type;
+  PRBool       tv;
+  char*        dataSource;
+} *RDF_AssertEvent;
+
+
+typedef struct RDF_UnassertEventStruct {
+  RDF_Resource u;
+  RDF_Resource s;
+  void*        v;
+  RDF_ValueType type;
+  char*        dataSource;
+} *RDF_UnassertEvent;
+
+typedef struct RDF_KillEventStruct {
+  RDF_Resource u;
+} *RDF_KillEvent;
+
+
+typedef struct RDF_EventStruct {
+  RDF_EventType eventType;
+  union ev {
+    struct RDF_AssertEventStruct assert;
+    struct RDF_UnassertEventStruct unassert;
+    struct RDF_KillEventStruct    kill;
+  } event;
+} *RDF_Event;
+
+#include "vocab.h"
+#include "rdfc.h"
+
+NSPR_END_EXTERN_C
+
+#endif /* rdf_h___ */

rdf/src/bmk2rdf.c

@@ -0,0 +1,602 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/* Reading bookmarks.htm into rdf.
+   tags in the bookmark file.
+   <TITLE>
+   <H1>
+   <H3>
+   <DL></DL>
+   <DT>
+   <P>
+
+  <DT> indicates that an item is coming. 
+	   If the next item is an <a then we have a url
+	   If the next item is a h3, we have a folder.
+  <DL> indicates that the previous item (which should have been a folder)
+	    is the parent of the next set.
+  </DL> indicates pop out a level
+  <P> ignore this on reading, but write out one after each <DL>
+  <DD> the description for the previous <DT>
+
+  Category urls. Make it up out of the add dates. */
+
+
+/* 
+   This file translates netscape bookmarks into the rdf data model.
+   For more information on this file, contact rjc or guha 
+   For more information on RDF, look at the RDF section of www.mozilla.org
+*/
+
+
+#include "bmk2rdf.h"
+#include "utils.h"
+#include "time.h"
+#ifdef MOZILLA_CLIENT
+
+	/* extern declarations */
+PR_PUBLIC_API(void) HT_WriteOutAsBookmarks (RDF r, PRFileDesc *fp, RDF_Resource u);	/* XXX this should be elsewhere */
+extern	char	*gBookmarkURL;
+RDF	gNCDB;
+
+	/* globals */
+uint16 separatorCounter = 0;
+static char* gBkFolderDate;
+static RDFT gBMKStore = 0;
+extern	int		RDF_PERSONAL_TOOLBAR_NAME;
+
+RDF_Resource
+createSeparator(void)
+{
+  char url[50];
+  RDF_Resource sep;
+  PR_snprintf(url, 50, "separator%i", separatorCounter++);
+  sep = RDF_GetResource(NULL, url, 1);
+  return sep;
+}
+
+#endif
+
+RDF_Resource
+createContainer (char* id)
+{
+  RDF_Resource r = RDF_GetResource(NULL, id, true);
+  setContainerp(r, 1);
+  return r;
+}
+
+
+
+#ifdef MOZILLA_CLIENT
+
+char *
+resourceDescription (RDF rdf, RDF_Resource r)
+{
+  return (char*)RDF_GetSlotValue(rdf, r, gWebData->RDF_description, RDF_STRING_TYPE, false, true);
+}
+
+
+
+char *
+resourceLastVisitDate (RDF rdf, RDF_Resource r)
+{
+  return (char*)RDF_GetSlotValue(rdf, r, gWebData->RDF_lastVisitDate, RDF_STRING_TYPE, false, true);
+}
+
+
+
+char *
+resourceLastModifiedDate (RDF rdf, RDF_Resource r)
+{
+  return (char*)RDF_GetSlotValue(rdf, r, gWebData->RDF_lastModifiedDate, RDF_STRING_TYPE, false, true);
+}
+
+
+
+void
+parseNextBkBlob (RDFFile f, char* blob, int32 size)
+{
+  int32 n, last, m;
+  PRBool somethingseenp = false;
+  n = last = 0;
+  
+  while (n < size) {
+    char c = blob[n];
+    m = 0;
+    somethingseenp = false;
+    memset(f->line, '\0', f->lineSize);
+    if (f->holdOver[0] != '\0') {
+      memcpy(f->line, f->holdOver, RDF_STRLEN(f->holdOver));
+      m = RDF_STRLEN(f->holdOver);
+      somethingseenp = true;
+      memset(f->holdOver, '\0', RDF_BUF_SIZE);
+    }
+    while ((m < 300) && (c != '<') && (c != '>') && (n < size)) {
+      f->line[m] = c;
+      m++;
+      somethingseenp = (somethingseenp || ((c != ' ') && (c != '\r') && (c != '\n')));
+      n++;
+      c = blob[n];
+    }
+    if (c == '>') f->line[m] = c;
+    n++;
+    if (m > 0) {
+      if ((c == '<') || (c == '>')) {
+	last = n;
+	if (c == '<') f->holdOver[0] = '<'; 
+	if (somethingseenp == true) parseNextBkToken(f, f->line);
+      } else if (size > last) {
+	memcpy(f->holdOver, f->line, m);
+      }
+    } else if (c == '<') f->holdOver[0] = '<';
+  }
+}
+
+
+ 
+void
+parseNextBkToken (RDFFile f, char* token)
+{
+ /*	printf(token); */
+  if (token[0] == '<') {
+    bkStateTransition(f, token);
+  } else {
+    /* ok, we have a piece of content.
+       can be the title, or a description or */
+    if ((f->status == IN_TITLE) || (f->status == IN_H3) || 
+	(f->status == IN_ITEM_TITLE)) {
+      if (IN_H3 && gBkFolderDate) {
+	char *url;
+	RDF_Resource newFolder;
+	url = PR_smprintf("%s%s.rdf", gBkFolderDate, token);
+	newFolder = createContainer(url);
+	free(url);
+	addSlotValue(f,newFolder, gCoreVocab->RDF_parent, f->stack[f->depth-1], 
+		     RDF_RESOURCE_TYPE, NULL);
+	freeMem(gBkFolderDate);
+	gBkFolderDate = NULL;
+	f->lastItem = newFolder;
+      }
+      if ((f->db == gLocalStore) || (f->status != IN_TITLE))
+	{
+	      addSlotValue(f, f->lastItem, gCoreVocab->RDF_name, 
+			   copyString(token), RDF_STRING_TYPE, NULL);
+	}
+
+	if (startsWith("Personal Toolbar", token) && (containerp(f->lastItem))) 
+		addSlotValue(f, f->lastItem, gCoreVocab->RDF_instanceOf,	
+			  gNavCenter->RDF_PersonalToolbarFolderCategory, 
+			  RDF_RESOURCE_TYPE, "true");
+
+    } else if (f->status == IN_ITEM_DESCRIPTION) {
+      addDescription(f, f->lastItem, token);
+    }
+  }
+}
+
+
+
+void
+addDescription (RDFFile f, RDF_Resource r, char* token)
+{
+  char* desc = (char*)  remoteStoreGetSlotValue(gLocalStore, r, gWebData->RDF_description, 
+				       RDF_STRING_TYPE, false, true);
+  if (desc == NULL) {
+    addSlotValue(f, f->lastItem, gWebData->RDF_description, 
+                 copyString(token),
+		 RDF_STRING_TYPE, NULL);
+  } else {
+   addSlotValue(f, f->lastItem, gWebData->RDF_description, 
+		 append2Strings(desc, token), RDF_STRING_TYPE, NULL); 
+    remoteUnassert(gLocalStore, f->lastItem, gWebData->RDF_description, desc, RDF_STRING_TYPE);
+  }
+}
+
+
+
+void
+bkStateTransition (RDFFile f, char* token)
+{
+  if (startsWith("<A", token)) {
+    newLeafBkItem(f, token);
+    f->status = IN_ITEM_TITLE;
+  } else if (startsWith(OPEN_H3_STRING, token)) {
+    newFolderBkItem(f, token);
+    f->status = IN_H3;
+  } else if (startsWith(OPEN_TITLE_STRING, token)) {
+    f->status = IN_TITLE;
+  } else if (startsWith(OPEN_H3_STRING, token)) {
+    f->status = IN_H3;
+  } else if (startsWith(DD_STRING, token)) {
+    if (remoteStoreGetSlotValue(gLocalStore, f->lastItem, gWebData->RDF_description, 
+				RDF_STRING_TYPE, false, true) 
+		== NULL) f->status = IN_ITEM_DESCRIPTION;
+  } else if (startsWith(OPEN_DL_STRING, token)) {
+    f->stack[f->depth++] = f->lastItem;
+  } else if (startsWith(CLOSE_DL_STRING, token)) {
+    f->depth--;
+  } else if (startsWith("<HR>", token)) {
+    addSlotValue(f, createSeparator(), gCoreVocab->RDF_parent, f->stack[f->depth-1], 
+		 RDF_RESOURCE_TYPE, NULL);
+    f->status = 0;
+  } else if ((f->status == IN_ITEM_DESCRIPTION) && (startsWith("<BR>", token))) {
+    addDescription(f, f->lastItem, token);
+  } else f->status = 0;
+}
+
+
+
+void
+newFolderBkItem(RDFFile f, char* token)
+{
+  int16 start, end;
+  start = charSearch('"', token);
+  end   = revCharSearch('"', token);
+  token[end] = '\0';
+  gBkFolderDate = copyString(&token[start+1]);
+}
+
+
+
+void
+newLeafBkItem (RDFFile f, char* token)
+{
+  char			buffer[128];
+  struct tm		*time;
+  uint32		dateVal;
+  char* url = NULL;
+  char* addDate = NULL;
+  char* lastVisit = NULL;
+  char* lastModified = NULL;
+  uint8 current = 0;
+  int32 len = RDF_STRLEN(token); 
+  int32 n = 0;
+  char c = token[n++];
+  PRBool inString = false;
+  RDF_Resource newR;
+  
+  while (n < len) {
+    if (c == '"') {
+      if (inString) {
+	token[n-1] = '\0';
+	inString = false;
+      } else {
+	inString = true;
+	if (current == 0) {
+	  url = &token[n];
+	} else if (current == 1) {
+	  addDate = &token[n];
+	} else if (current == 2) {
+	  lastVisit = &token[n];
+	} else if (current == 3) {
+	  lastModified = &token[n];
+	}
+	current++;
+      }
+    }
+    c = token[n++];
+  }
+  if (url == NULL) return;
+  newR = RDF_GetResource(NULL, url, true);
+  addSlotValue(f, newR, gCoreVocab->RDF_parent, f->stack[f->depth-1],  
+	       RDF_RESOURCE_TYPE, NULL);
+  /* addSlotValue(f, newR, gWebData->RDF_URL, (void*)copyString(url), 
+	       RDF_STRING_TYPE, true); */
+  if (addDate != NULL)
+    {
+	dateVal = atol(addDate);
+	if ((time = localtime((time_t *) &dateVal)) != NULL)
+	{
+      /* xxx
+#ifdef	XP_MAC
+		time->tm_year += 4;
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#elif	XP_UNIX
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#else
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_WINDATE),time);
+#endif
+
+		addSlotValue(f, newR, gNavCenter->RDF_bookmarkAddDate,
+			(void*)copyString(buffer), RDF_STRING_TYPE, NULL);
+            */
+	}
+    }
+  if (lastVisit != NULL)
+    {
+	dateVal = atol(lastVisit);
+	if ((time = localtime((time_t *) &dateVal)) != NULL)
+	{
+      /* xxx
+#ifdef	XP_MAC
+		time->tm_year += 4;
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#elif	XP_UNIX
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#else
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_WINDATE),time);
+#endif
+		addSlotValue(f, newR, gWebData->RDF_lastVisitDate,
+			(void*)copyString(buffer), RDF_STRING_TYPE, NULL);
+            */
+	}
+    }
+  if (lastModified != NULL)
+    {
+	dateVal = atol(lastModified);
+	if ((time = localtime((time_t *) &dateVal)) != NULL)
+	{
+      /* xxx
+#ifdef	XP_MAC
+		time->tm_year += 4;
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#elif	XP_UNIX
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_MACDATE),time);
+#else
+		strftime(buffer,sizeof(buffer),XP_GetString(RDF_HTML_WINDATE),time);
+#endif
+		addSlotValue(f, newR, gWebData->RDF_lastModifiedDate,
+			(void*)copyString(buffer), RDF_STRING_TYPE, NULL);
+            */
+	}
+    }
+  f->lastItem = newR;
+}
+
+
+
+char *
+numericDate(char *url)
+{
+	char		*date = NULL;
+	int		len=0;
+
+	if (!url) return NULL;
+	while (url[len])
+	{
+		if (!isdigit(url[len]))	break;
+		++len;
+	}
+	if (len > 0)
+	{
+		if ((date = getMem(len+1)) != NULL)
+		{
+			strncpy(date, url, len);
+		}
+	}
+	return(date);
+}
+
+
+
+PRBool
+bookmarkSlotp (RDF_Resource s)
+{
+  return ((s == gCoreVocab->RDF_parent) || (s == gWebData->RDF_lastVisitDate) || (s == gWebData->RDF_description) ||
+	  (s == gNavCenter->RDF_bookmarkAddDate) || (s == gWebData->RDF_lastModifiedDate) || 
+	  (s == gCoreVocab->RDF_name));
+}
+
+
+void
+HT_WriteOutAsBookmarks1 (RDF rdf, PRFileDesc *fp, RDF_Resource u, RDF_Resource top, int indent)
+{
+    RDF_Cursor c = RDF_GetSources(rdf, u, gCoreVocab->RDF_parent, RDF_RESOURCE_TYPE, true);
+    RDF_Resource next;
+    char *date, *name, *url;
+    int loop;
+
+    if (c == NULL) return;
+    if (u == top) {
+      name = RDF_GetResourceName(rdf, u);
+      ht_rjcprintf(fp, "<!DOCTYPE NETSCAPE-Bookmark-file-1>\n", NULL);
+      ht_rjcprintf(fp, "<!-- This is an automatically generated file.\n", NULL);
+      ht_rjcprintf(fp, "It will be read and overwritten.\n", NULL);
+      ht_rjcprintf(fp, "Do Not Edit! -->\n", NULL);
+
+      ht_rjcprintf(fp, "<TITLE>%s</TITLE>\n", (name) ? name:"");
+      ht_rjcprintf(fp, "<H1>%s</H1>\n<DL><p>\n", (name) ? name:"");
+    }
+    while ((next = RDF_NextValue(c)) != NULL) {
+
+      url = resourceID(next);
+      if (containerp(next) && (!startsWith("ftp:",url)) && (!startsWith("file:",url))
+	    && (!startsWith("IMAP:", url)) && (!startsWith("nes:", url))
+	    && (!startsWith("mail:", url)) && (!startsWith("cache:", url))
+	    && (!startsWith("ldap:", url))) {
+		for (loop=0; loop<indent; loop++)	ht_rjcprintf(fp, "    ", NULL);
+
+		date = numericDate(resourceID(next));
+		ht_rjcprintf(fp, "<DT><H3 ADD_DATE=\"%s\">", (date) ? date:"");
+		if (date) freeMem(date);
+		name = RDF_GetResourceName(rdf, next);
+		ht_rjcprintf(fp, "%s</H3>\n", name);
+
+		for (loop=0; loop<indent; loop++)	ht_rjcprintf(fp, "    ", NULL);
+		ht_rjcprintf(fp, "<DL><p>\n", NULL);
+		HT_WriteOutAsBookmarks1(rdf, fp, next, top, indent+1);
+
+		for (loop=0; loop<indent; loop++)	ht_rjcprintf(fp, "    ", NULL);
+
+		ht_rjcprintf(fp, "</DL><p>\n", NULL);
+      }
+      else if (isSeparator(next)) {
+	for (loop=0; loop<indent; loop++)	ht_rjcprintf(fp, "    ", NULL);
+	ht_rjcprintf(fp, "<HR>\n", NULL);
+      }
+      else {
+	char* bkAddDate = (char*)RDF_GetSlotValue(rdf, next, 
+						  gNavCenter->RDF_bookmarkAddDate, 
+						  RDF_STRING_TYPE, false, true);
+
+        for (loop=0; loop<indent; loop++)	ht_rjcprintf(fp, "    ", NULL);
+
+	ht_rjcprintf(fp, "<DT><A HREF=\"%s\" ", resourceID(next));
+	date = numericDate(bkAddDate);
+	ht_rjcprintf(fp, "ADD_DATE=\"%s\" ", (date) ? date: "");
+	if (date) freeMem(date);
+	ht_rjcprintf(fp, "LAST_VISIT=\"%s\" ", resourceLastVisitDate(rdf, next));
+	ht_rjcprintf(fp, "LAST_MODIFIED=\"%s\">", resourceLastModifiedDate(rdf, next));
+	ht_rjcprintf(fp, "%s</A>\n", RDF_GetResourceName(rdf, next));
+
+	if (resourceDescription(rdf, next) != NULL) {
+	  ht_rjcprintf(fp, "<DD>%s\n", resourceDescription(rdf, next));
+	}
+      }
+    }
+    RDF_DisposeCursor(c);
+    if (u == top) {
+      ht_rjcprintf(fp, "</DL>\n", NULL);
+    }
+}
+
+
+
+PR_PUBLIC_API(void)
+HT_WriteOutAsBookmarks (RDF r, PRFileDesc *fp, RDF_Resource u)
+{
+	HT_WriteOutAsBookmarks1 (r, fp, u, u, 1);
+}
+
+
+
+void
+flushBookmarks()
+{
+	PRFileDesc		*bkfp;
+
+	if (gBookmarkURL != NULL)
+	{
+		/*
+		  delete bookmark.htm as PROpen() with PR_TRUNCATE appears broken (at least on Mac)
+		*/
+		CallPRDeleteFileUsingFileURL(gBookmarkURL);
+
+		if ((bkfp = CallPROpenUsingFileURL(gBookmarkURL, (PR_WRONLY|PR_CREATE_FILE|PR_TRUNCATE),
+						0644)) != NULL)
+		{
+			HT_WriteOutAsBookmarks(gNCDB, bkfp, gNavCenter->RDF_BookmarkFolderCategory);
+			PR_Close(bkfp);
+		}
+	}
+}
+
+
+PRBool 
+ResourceBelongsToBookmarksp (RDF_Resource r, int32 depth) {
+  if (depth > 20) {
+    return false;
+  } else if (r == gNavCenter->RDF_BookmarkFolderCategory) {
+    return 1;
+  } else if (containerp(r)) {
+    Assertion as = r->rarg1;
+    while (as) {
+      if ((as->db == gBMKStore) &&
+          (as->s == gCoreVocab->RDF_parent) &&
+          (as->tv == 1) &&
+          (ResourceBelongsToBookmarksp((RDF_Resource)as->value, depth+1))) return 1;
+      as = as->next;
+    }
+    return 0;
+  } else return 0;
+}
+
+
+
+PRBool remoteAssert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv);
+PRBool remoteUnassert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type);
+
+
+PRBool 
+bmkUnassert  (RDFT mcf, RDF_Resource u, RDF_Resource s,
+              void* v, RDF_ValueType type) {
+  if (ResourceBelongsToBookmarksp(u, 0)) {
+    return (remoteStoreRemove(mcf, u, s, v, type) != NULL);
+  } else return 0;
+}
+
+
+PRBool
+bmkAssert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+                RDF_ValueType type, PRBool tv) {
+  if (ResourceBelongsToBookmarksp(u, 0)) {
+    return (remoteStoreAdd(mcf, u, s, v, type, tv) != NULL);
+  } else return 0;
+}
+        
+extern RDF_Resource gPTFolder;
+void
+readInBookmarks()
+{
+  /* RDF_Resource ptFolder; */
+    RDF_Resource bmk = RDF_GetResource(NULL, "NC:Bookmarks", true);
+    RDFFile f = makeRDFFile(gBookmarkURL, bmk, true);
+    PRFileDesc *fp;
+    int32 len;
+    char buf[512]; 
+    f->fileType = RDF_BOOKMARKS;
+    f->db = gBMKStore;
+    f->assert = remoteAssert3;
+ 
+    fp = CallPROpenUsingFileURL(f->url, PR_RDONLY|PR_CREATE_FILE, 0644);
+    if (fp == NULL) return;
+    while((len=PR_Read(fp, buf, sizeof(buf))) >0) {
+      parseNextBkBlob(f, buf, len);
+    }
+
+	gPTFolder = remoteStoreGetSlotValue(f->db, 
+                                            gNavCenter->RDF_PersonalToolbarFolderCategory,
+                                            gCoreVocab->RDF_instanceOf, RDF_RESOURCE_TYPE, true, true);
+
+	if (gPTFolder == NULL) {
+      if ((gPTFolder = createContainer("personaltoolbar.rdf")) != NULL) {
+        addSlotValue(f, gPTFolder, gCoreVocab->RDF_instanceOf,
+                     gNavCenter->RDF_PersonalToolbarFolderCategory,
+                     RDF_RESOURCE_TYPE, "true");
+        addSlotValue(f, gPTFolder, gCoreVocab->RDF_name,
+                     copyString("Personal Toolbar"),
+                     RDF_STRING_TYPE, "true");
+        RDFUtil_SetPTFolder(gPTFolder);
+      }
+	}
+	
+    PR_Close(fp);
+    freeMem(f->line);
+    freeMem(f->currentSlot);
+    freeMem(f->holdOver);
+}
+
+
+RDFT
+MakeBMKStore (char* url)
+{
+  if (startsWith("rdf:bookmarks", url)) {
+    if (gBMKStore == 0) {
+      RDFT ntr = gBMKStore = NewRemoteStore(url);
+      ntr->assert = bmkAssert;
+      ntr->unassert = bmkUnassert;
+      readInBookmarks();
+      return ntr;
+    } else return gBMKStore;
+  } else return NULL;
+}
+
+
+#endif

rdf/src/bmk2rdf.h

@@ -0,0 +1,72 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef	_RDF_BMK2MCF_H_
+#define	_RDF_BMK2MCF_H_
+
+
+#include "rdf.h"
+#include "rdf-int.h"
+#include "vocab.h"
+#include "stdio.h"
+#include "ctype.h"
+
+
+/* bmk2mcf.c data structures and defines */
+
+#define OPEN_TITLE_STRING  "<TITLE>"
+#define CLOSE_TITLE_STRING "</TITLE>"
+#define OPEN_H1_STRING     "<H1>"
+#define CLOSE_H1_STRING    "</H1>"
+#define OPEN_H3_STRING     "<H3"
+#define CLOSE_H3_STRING    "</H3>"
+#define OPEN_DL_STRING     "<DL>"
+#define CLOSE_DL_STRING    "</DL>"
+#define DT_STRING	   "<DT>"
+#define PAR_STRING	   "<P>"
+#define DD_STRING	   "<DD>"
+
+#define IN_TITLE		1
+#define IN_H3			5
+#define IN_ITEM_TITLE		7
+#define IN_ITEM_DESCRIPTION	9
+
+
+
+/* bmk2mcf.c function prototypes */
+
+
+
+RDF_Resource		createSeparator(void);
+RDF_Resource		createContainer (char* id);
+char *			resourceDescription (RDF rdf, RDF_Resource r);
+char *			resourceLastVisitDate (RDF rdf, RDF_Resource r);
+char *			resourceLastModifiedDate (RDF rdf, RDF_Resource r);
+void			parseNextBkBlob (RDFFile f, char* blob, int32 size);
+void			parseNextBkToken (RDFFile f, char* token);
+void			addDescription (RDFFile f, RDF_Resource r, char* token);
+void			bkStateTransition (RDFFile f, char* token);
+void			newFolderBkItem(RDFFile f, char* token);
+void			newLeafBkItem (RDFFile f, char* token);
+char *			numericDate(char *url);
+void			HT_WriteOutAsBookmarks1 (RDF rdf, PRFileDesc *fp, RDF_Resource u, RDF_Resource top, int indent);
+void			flushBookmarks();
+
+
+
+#endif

rdf/src/comwrap.cpp

@@ -0,0 +1,577 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "rdf.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFDataBase.h"
+#include "nsIRDFObserver.h"
+#include "nsIRDFService.h"
+#include "nsIRDFCursor.h"
+
+#include "nspr.h"
+#include "plhash.h"
+
+PR_BEGIN_EXTERN_C
+PR_PUBLIC_API(void) _comwrap_NotificationCB(RDF_Event event, void* pdata);
+PR_END_EXTERN_C
+
+class rdfDataBaseWrapper;
+class rdfCursorWrapper;
+class rdfServiceWrapper;
+class rdfServiceFactory;
+
+class rdfDatabaseWrapper : public nsIRDFDataBase {
+public:
+  NS_DECL_ISUPPORTS
+
+  rdfDatabaseWrapper(RDF r);
+  virtual ~rdfDatabaseWrapper();
+
+  /* nsIRDFDataSource methods:  */
+
+  NS_METHOD GetName(const RDF_String* name /* out */ );
+
+  NS_METHOD GetSource(RDF_Node target,
+                      RDF_Resource arcLabel,
+                      RDF_Resource *source /* out */);
+
+  NS_METHOD GetSource(RDF_Node target,
+                      RDF_Resource arcLabel,
+                      PRBool tv,
+                      RDF_Resource *source /* out */);
+
+  NS_METHOD GetSources(RDF_Node target,
+                       RDF_Resource arcLabel,
+                       nsIRDFCursor **sources /* out */);
+
+  NS_METHOD GetSources(RDF_Node target,
+                       RDF_Resource arcLabel,
+                       PRBool tv,
+                       nsIRDFCursor **sources /* out */);
+
+  NS_METHOD GetTarget(RDF_Resource source,
+                      RDF_Resource arcLabel,
+                      RDF_ValueType targetType,
+                      RDF_NodeStruct& target /* in/out */);
+
+  NS_METHOD GetTarget(RDF_Resource source,
+                      RDF_Resource arcLabel,
+                      RDF_ValueType targetType,
+                      PRBool tv,
+                      RDF_NodeStruct& target /* in/out */);
+
+  NS_METHOD GetTargets(RDF_Resource source,
+                       RDF_Resource arcLabel,
+                       RDF_ValueType targetType,
+                       nsIRDFCursor **targets /* out */);
+
+  NS_METHOD GetTargets(RDF_Resource source,
+                       RDF_Resource arcLabel,
+                       PRBool tv,
+                       RDF_ValueType targetType,
+                       nsIRDFCursor **targets /* out */);
+
+  NS_METHOD Assert(RDF_Resource source, 
+                   RDF_Resource arcLabel, 
+                   RDF_Node target,
+                   PRBool tv = PR_TRUE);
+
+  NS_METHOD Unassert(RDF_Resource source,
+                     RDF_Resource arcLabel,
+                     RDF_Node target);
+
+  NS_METHOD HasAssertion(RDF_Resource source,
+                         RDF_Resource arcLabel,
+                         RDF_Node target,
+                         PRBool tv,
+                         PRBool* hasAssertion /* out */);
+
+  NS_METHOD AddObserver(nsIRDFObserver *n,
+                        RDF_EventMask type = RDF_ANY_NOTIFY);
+
+  NS_METHOD RemoveObserver(nsIRDFObserver *n,
+                           RDF_EventMask = RDF_ANY_NOTIFY);
+
+  NS_METHOD ArcLabelsIn(RDF_Node node,
+                        nsIRDFCursor **labels /* out */);
+
+  NS_METHOD ArcLabelsOut(RDF_Resource source,
+                         nsIRDFCursor **labels /* out */);
+
+  NS_METHOD Flush();
+
+  /* nsIRDFDataBase methods:   */
+  NS_METHOD AddDataSource(nsIRDFDataSource* dataSource);
+
+  NS_METHOD RemoveDataSource(nsIRDFDataSource* dataSource);
+
+  NS_METHOD GetDataSource(RDF_String url,
+                          nsIRDFDataSource **source /* out */ );
+
+  NS_METHOD DeleteAllArcs(RDF_Resource resource);
+
+private:
+  RDF mRDF;
+
+  PLHashTable* mpObserverMap;
+};
+
+class rdfCursorWrapper : public nsIRDFCursor {
+public:
+  NS_DECL_ISUPPORTS
+  
+  rdfCursorWrapper(RDF_Cursor c);
+  virtual ~rdfCursorWrapper();
+
+  /*   NS_METHOD HasElements(PRBool& hasElements); */
+
+  NS_METHOD Next(RDF_NodeStruct& n);
+
+private:
+  RDF_Cursor mCursor;
+};
+
+class rdfServiceWrapper : public nsIRDFService {
+public:
+  NS_DECL_ISUPPORTS
+
+  NS_METHOD CreateDatabase(const RDF_String* url,
+                           nsIRDFDataBase** db);
+
+};
+
+
+class rdfServiceFactory : public nsIFactory {
+public:
+  NS_DECL_ISUPPORTS
+
+  rdfServiceFactory();
+  virtual ~rdfServiceFactory();
+
+  NS_METHOD CreateInstance(nsISupports *aOuter,
+                           REFNSIID anIID,
+                           void **aResult);
+
+  NS_METHOD LockFactory(PRBool aLock);
+
+};
+
+/*
+  
+  rdfDataBaseWrapper:
+
+*/
+
+NS_IMPL_ISUPPORTS( rdfDatabaseWrapper, NS_IRDFDATABASE_IID )
+
+rdfDatabaseWrapper::rdfDatabaseWrapper(RDF r) : mRDF(r)
+{
+  mpObserverMap = PL_NewHashTable( 100,
+                                   NULL, // XXX isn't there are hash fn for pointers???
+                                   PL_CompareValues,
+                                   PL_CompareValues,
+                                   0,
+                                   0 );
+
+  PR_ASSERT( mpObserverMap );
+#ifdef XXX
+  if( !mpObserverMap ) // XXX just like 'new' failing on this object?
+    throw bad_alloc("rdf: unable to allocate observer map" );
+#endif
+
+}
+
+rdfDatabaseWrapper::~rdfDatabaseWrapper()
+{
+  PL_HashTableDestroy( mpObserverMap );
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetName(const RDF_String* name /* out */ )
+{
+  PR_ASSERT( PR_FALSE );
+  return NS_ERROR_NOT_IMPLEMENTED; // XXX
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetSource(RDF_Node target,
+                              RDF_Resource arcLabel,
+                              RDF_Resource *source /* out */)
+{
+  PR_ASSERT( target && source );
+  *source = (RDF_Resource) RDF_GetSlotValue( mRDF,
+                                             target->value.r,
+                                             arcLabel,
+                                             RDF_RESOURCE_TYPE, // anything else makes no sense
+                                             PR_TRUE,
+                                             PR_TRUE );
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetSource(RDF_Node target,
+                              RDF_Resource arcLabel,
+                              PRBool tv,
+                              RDF_Resource *source /* out */)
+{
+  *source = (RDF_Resource) RDF_GetSlotValue( mRDF,
+                                             target->value.r,
+                                             arcLabel,
+                                             RDF_RESOURCE_TYPE, // anything else makes no sense
+                                             PR_TRUE,
+                                             tv );
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetSources(RDF_Node target,
+                               RDF_Resource arcLabel,
+                               nsIRDFCursor **sources /* out */)
+{
+  return GetSources(target,arcLabel,PR_TRUE,sources);
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetSources(RDF_Node target,
+                               RDF_Resource arcLabel,
+                               PRBool tv,
+                               nsIRDFCursor **sources /* out */)
+{
+  PR_ASSERT( sources );
+  if( 0 == sources )
+    return NS_ERROR_NULL_POINTER;
+
+  *sources = 0;
+
+  RDF_Cursor c = RDF_GetSources( mRDF,
+                                 target->value.r,
+                                 arcLabel,
+                                 RDF_RESOURCE_TYPE, // anything else makes no sense
+                                 tv );
+
+  if( c ) {
+    *sources = new rdfCursorWrapper( c );
+    (*sources)->AddRef();
+  }
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetTarget(RDF_Resource source,
+                              RDF_Resource arcLabel,
+                              RDF_ValueType targetType,
+                              RDF_NodeStruct& target /* in/out */)
+{
+  return GetTarget(source,arcLabel,targetType,PR_TRUE,target);
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetTarget(RDF_Resource source,
+                              RDF_Resource arcLabel,
+                              RDF_ValueType targetType,
+                              PRBool tv,
+                              RDF_NodeStruct& target /* in/out */)
+{
+  PR_ASSERT( targetType != RDF_ANY_TYPE ); // not ready to support this yet
+
+  void* value  = RDF_GetSlotValue( mRDF,
+                                   target.value.r,
+                                   arcLabel,
+                                   targetType, // anything else makes no sense
+                                   PR_FALSE,
+                                   tv );
+
+  target.type = targetType;
+  target.value.r = (RDF_Resource) value; // reasonable? XXX
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetTargets(RDF_Resource source,
+                               RDF_Resource arcLabel,
+                               RDF_ValueType targetType,
+                               nsIRDFCursor **targets /* out */)
+{
+  return GetTargets(source,arcLabel,PR_TRUE,targetType,targets);
+}
+
+NS_METHOD
+rdfDatabaseWrapper::GetTargets(RDF_Resource source,
+                               RDF_Resource arcLabel,
+                               PRBool tv,
+                               RDF_ValueType targetType,
+                               nsIRDFCursor **targets /* out */)
+{
+  PR_ASSERT( targets );
+  if( 0 == targets )
+    return NS_ERROR_NULL_POINTER;
+
+  *targets = 0;
+
+  RDF_Cursor c = RDF_GetTargets( mRDF,
+                                 source,
+                                 arcLabel,
+                                 targetType,
+                                 tv );
+
+  if( c ) {
+    *targets = new rdfCursorWrapper( c );
+    (*targets)->AddRef();
+  }
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::Assert(RDF_Resource source, 
+                           RDF_Resource arcLabel, 
+                           RDF_Node target,
+                           PRBool tv)
+{
+  PRBool b = tv ? RDF_Assert( mRDF, source, arcLabel, (void*)target->value.r, target->type ) :
+    RDF_AssertFalse( mRDF, source, arcLabel, (void*)target->value.r, target->type );
+
+  // XXX
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::Unassert(RDF_Resource source,
+                             RDF_Resource arcLabel,
+                             RDF_Node target)
+{
+  PRBool b = RDF_Unassert( mRDF, 
+                           source, 
+                           arcLabel, 
+                           target->value.r, 
+                           target->type ); // XXX
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::HasAssertion(RDF_Resource source,
+                                 RDF_Resource arcLabel,
+                                 RDF_Node target,
+                                 PRBool truthValue,
+                                 PRBool* hasAssertion /* out */)
+{
+  *hasAssertion = RDF_HasAssertion( mRDF,
+                                    source,
+                                    arcLabel,
+                                    target->value.r,
+                                    target->type,
+                                    truthValue );
+  
+  return NS_OK;
+}
+
+PR_IMPLEMENT(void)
+  _comwrap_NotificationCB(RDF_Event event, void* pdata)
+{
+  nsIRDFObserver* observer = (nsIRDFObserver*) pdata;
+  // XXX QueryInterface & release??
+  observer->HandleEvent( (nsIRDFDataSource*)pdata, event );
+}
+
+NS_METHOD
+rdfDatabaseWrapper::AddObserver(nsIRDFObserver *observer,
+                                RDF_EventMask type)
+{
+  // XXX event masking does not currently work
+
+  RDF_Notification notification = (RDF_Notification) PL_HashTableLookup( mpObserverMap, observer );
+  if( !notification ) {
+    observer->AddRef();
+    notification = RDF_AddNotifiable( mRDF,
+                                      _comwrap_NotificationCB,
+                                      NULL, // XXX
+                                      observer );
+    PL_HashTableAdd( mpObserverMap,
+                     observer,
+                     notification );
+  }
+
+  return NS_OK; // XXX
+}
+
+NS_METHOD
+rdfDatabaseWrapper::RemoveObserver(nsIRDFObserver *observer,
+                                   RDF_EventMask type)
+{
+
+  RDF_Notification notification = (RDF_Notification) PL_HashTableLookup( mpObserverMap, observer );
+  if( !notification )
+    return NS_ERROR_ILLEGAL_VALUE;
+  
+  RDF_Error err = RDF_DeleteNotifiable( notification );
+  PR_ASSERT( !err ); // the current implementation never fails!
+  PL_HashTableRemove( mpObserverMap, observer );
+  observer->Release();
+    
+  return NS_OK; // XXX
+}
+
+NS_METHOD
+rdfDatabaseWrapper::ArcLabelsIn(RDF_Node node,
+                                nsIRDFCursor **labels /* out */)
+{
+  PR_ASSERT( labels );
+  if( 0 == labels )
+    return NS_ERROR_NULL_POINTER;
+  *labels = 0;
+
+  RDF_Cursor c = RDF_ArcLabelsIn( mRDF, node->value.r );
+
+  if( c ) {
+    *labels = new rdfCursorWrapper( c );
+    (*labels)->AddRef();
+  }
+
+  return NS_OK;
+
+}
+
+NS_METHOD
+rdfDatabaseWrapper::ArcLabelsOut(RDF_Resource source,
+                                 nsIRDFCursor **labels /* out */)
+{
+  PR_ASSERT( labels );
+  if( 0 == labels )
+    return NS_ERROR_NULL_POINTER;
+  *labels = 0;
+
+  RDF_Cursor c = RDF_ArcLabelsOut( mRDF, source );
+
+  if( c ) {
+    *labels = new rdfCursorWrapper( c );
+    (*labels)->AddRef();
+  }
+
+  return NS_OK;
+}
+
+NS_METHOD
+rdfDatabaseWrapper::Flush()
+{
+  return NS_ERROR_NOT_IMPLEMENTED; // XXX
+}
+
+
+NS_METHOD
+rdfDatabaseWrapper::DeleteAllArcs(RDF_Resource resource)
+{
+  return RDF_DeleteAllArcs( mRDF, resource );
+}
+
+/*
+  
+  rdfServiceWrapper:  the RDF service singleton
+
+*/
+
+
+NS_IMPL_ISUPPORTS( rdfServiceWrapper, NS_IRDFSERVICE_IID )
+
+NS_METHOD
+rdfServiceWrapper::CreateDatabase(const RDF_String* url_ary,
+                                  nsIRDFDataBase **db)
+{
+  PR_ASSERT( 0 != db );
+  if( 0 == db )
+    return NS_ERROR_NULL_POINTER;
+
+  *db = 0;
+
+  nsresult result = NS_OK;
+  RDF rdf = RDF_GetDB(url_ary);
+
+  if( 0 == rdf ) {
+    result = RDF_ERROR_UNABLE_TO_CREATE; // XXX this is too wishy-washy
+  } else {
+    *db = new rdfDatabaseWrapper(rdf); // XXX
+  }
+
+  return result;
+}
+
+/*
+
+  rdfCursorWrapper
+
+*/
+
+NS_IMPL_ISUPPORTS( rdfCursorWrapper, NS_IRDFCURSOR_IID )
+
+rdfCursorWrapper::rdfCursorWrapper(RDF_Cursor c) : mCursor(c) 
+{ 
+}
+
+rdfCursorWrapper::~rdfCursorWrapper() 
+{ 
+  RDF_DisposeCursor( mCursor ); 
+}
+
+NS_METHOD
+rdfCursorWrapper::Next(RDF_NodeStruct& next)
+{
+  next.type = RDF_CursorValueType( mCursor );
+  next.value.r = (RDF_Resource) RDF_NextValue( mCursor );
+
+  return NS_OK;
+}
+
+/*
+
+  rdfServiceFactory
+
+*/
+
+NS_IMPL_ISUPPORTS( rdfServiceFactory, NS_IFACTORY_IID )
+
+NS_METHOD
+rdfServiceFactory::CreateInstance( nsISupports *aOuter,
+                                   REFNSIID aIID,
+                                   void **aResult )
+{
+  PR_ASSERT( aResult );
+  if( 0 == aResult )
+    return NS_ERROR_NULL_POINTER;
+  *aResult = 0;
+
+  nsISupports* instance = new rdfServiceWrapper();
+    
+  nsresult result = instance->QueryInterface( aIID, aResult );
+  PR_ASSERT( result = NS_OK );
+
+  if( result != NS_OK )
+    delete instance; // wrong interface!
+
+  return result;
+}
+
+NS_METHOD
+rdfServiceFactory::LockFactory(PRBool lock)
+{
+  PR_ASSERT( PR_FALSE );
+  return NS_ERROR_NOT_IMPLEMENTED;
+}

rdf/src/core.h

@@ -0,0 +1,93 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef	_RDF_MCF_H_
+#define	_RDF_MCF_H_
+
+
+#include "rdf-int.h"
+#include "prprf.h"
+#include "prtime.h"
+#include <string.h>
+
+
+/* mcf.c data structures and defines */
+
+struct RDF_NotificationStruct {
+  RDF_Event  theEvent;
+  void*      pdata;
+  RDF_NotificationProc notifFunction;
+  RDF        rdf;
+  struct RDF_NotificationStruct* next;
+};
+
+
+#define ntr(r, n) (*((RDFT*)r->translators + n))
+#define ntrn(r, n) (*((RDFT*)r->translators + n) == NULL)
+#define callAssert(n, r, u, s, v,type,tv) (ntrn(r, n) || (ntr(r, n)->assert == NULL) ? 0 : (*(ntr(r, n)->assert))(ntr(r, n), u, s, v, type, tv))
+#define callUnassert(n, r, u, s, v,type) (ntrn(r, n) || (ntr(r, n)->unassert == NULL) ? 0 : (*(ntr(r, n)->unassert))(ntr(r, n), u, s, v, type))
+#define callGetSlotValue(n, r, u, s, type, invp, tv) (ntrn(r, n) || (ntr(r, n)->getSlotValue == NULL) ? 0 : (*(ntr(r, n)->getSlotValue))(ntr(r, n), u, s,  type, invp, tv))
+#define callGetSlotValues(n, r, u, s, type,invp, tv) (ntrn(r, n) || (ntr(r, n)->getSlotValues == NULL) ? 0 : (*(ntr(r, n)->getSlotValues))(ntr(r, n), u, s,  type,invp, tv))
+#define callHasAssertions(n, r, u, s, v,type,tv) (ntrn(r, n) || (ntr(r, n)->hasAssertion == NULL) ? 0 : (*(ntr(r, n)->hasAssertion))(ntr(r, n), u, s, v, type, tv))
+#define callArcLabelsOut(n, r, u) (ntrn(r, n) || (ntr(r, n)->arcLabelsOut == NULL) ? 0 : (*(ntr(r, n)->arcLabelsOut))(ntr(r, n), u))
+#define callArcLabelsIn(n, r, u) (ntrn(r, n) || (ntr(r, n)->arcLabelsIn == NULL) ? 0 : (*(ntr(r, n)->arcLabelsIn))(ntr(r, n), u))
+#define callDisposeResource(n, r, u) (ntrn(r, n) || (ntr(r, n)->disposeResource == NULL) ? 1 : (*(ntr(r, n)->disposeResource))(ntr(r, n), u))
+#define callExitRoutine(n, r) (ntrn(r, n) || (ntr(r, n)->destroy == NULL) ? 0 : (*(ntr(r, n)->destroy))(ntr(r, n)))
+#define callUpdateRoutine(n, r, u) (ntrn(r, n) || (ntr(r, n)->update == NULL) ? 0 : (*(ntr(r, n)->update))(ntr(r, n), u))
+
+#define ID_BUF_SIZE	20
+
+
+
+/* mcf.c function prototypes */
+
+
+
+RDFT			getTranslator (char* url);
+RDFL			deleteFromRDFList (RDFL xrl, RDF db);
+RDF_Error		exitRDF (RDF rdf);
+RDF_Resource		addDep (RDF db, RDF_Resource u);
+PRBool			rdfassert(RDF rdf, RDF_Resource u, RDF_Resource  s, void* value, RDF_ValueType type,  PRBool tv);
+PRBool			containerIDp(char* id);
+char *			makeNewID ();
+PRBool			iscontainerp (RDF_Resource u);
+RDF_BT			resourceTypeFromID (char* id);
+RDF_Resource		specialUrlResource (char* id);
+RDF_Resource		NewRDFResource (char* id);
+RDF_Resource		QuickGetResource (char* id);
+RDF_Cursor		getSlotValues (RDF rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep, PRBool tv);
+void 			disposeResourceInt (RDF rdf, RDF_Resource u);
+void			possiblyGCResource (RDF_Resource u);
+RDF_Resource		NewRDFResource (char* id);
+RDF_Resource		QuickGetResource (char* id);
+void			assertNotify (RDF rdf, RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds);
+void			insertNotify (RDF rdf, RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds);
+void			unassertNotify (RDF_Notification not, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, char* ds);
+void			sendNotifications1 (RDFL rl, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+void			sendNotifications (RDF rdf, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds);
+RDF_Resource		nextFindValue (RDF_Cursor c);
+PRBool			matchStrings(RDF_Resource match, char *str1, char *str2);
+PRBool			itemMatchesFind (RDF r, RDF_Resource u, RDF_Resource s, void* v, RDF_Resource match, RDF_ValueType type);
+PR_PUBLIC_API(RDF_Cursor)RDF_Find (RDF_Resource s, RDF_Resource match, void* v, RDF_ValueType type);
+PRIntn			findEnumerator (PLHashEntry *he, PRIntn i, void *arg);
+void			disposeAllDBs ();
+
+
+
+
+#endif

rdf/src/ht.h

@@ -0,0 +1,399 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef	_RDF_HT_H_
+#define	_RDF_HT_H_
+
+#define HT_RAPTOR 1
+
+#ifndef	HT_RAPTOR
+#include "xpassert.h"
+#include "xp_qsort.h"
+#include "xp_time.h"
+#include "client.h"
+#include "net.h"
+#include "xpgetstr.h"
+#include "xp_str.h"
+#include "htmldlgs.h"
+#include "xp_ncent.h"
+#include "xpassert.h"
+#include "nspr.h"
+#include "prefapi.h"
+#include "fe_proto.h"
+#include "intl_csi.h"
+
+#ifdef	XP_MAC
+#include "stdlib.h"
+#include <Aliases.h>
+#endif
+
+#include "rdf.h"
+#include "rdf-int.h"
+#include "math.h"
+#include "htrdf.h"
+
+#ifdef	SMART_MAIL
+#include "pm2rdf.h"
+#endif
+
+#else
+#include "prprf.h"
+#include "plhash.h"
+#include "xp_core.h"
+#include "rdf.h"
+#include "rdf-int.h"
+#include "core.h"
+#include "htrdf.h"
+#include "vocab.h"
+
+#ifndef	XP_ASSERT
+#define	XP_ASSERT(x)
+#endif
+
+#ifndef	XP_FREE
+#define	XP_FREE(x)	PR_Free((x))
+#endif
+
+#ifndef	XP_STRCASECMP
+#define	XP_STRCASECMP(x,y)	strcmp((x),(y))
+#endif
+
+#define	MWContext	void
+#endif
+
+
+/* HT data structures and defines */
+
+#define ITEM_LIST_SIZE			500		/* XXX ITEM_LIST_SIZE should be dynamic */
+#define ITEM_LIST_ELEMENT_SIZE		20
+
+#define NUM_MENU_CMDS           	40
+
+#define RDF_SITEMAP			1
+#define RDF_RELATED_LINKS		2
+#define FROM_PAGE			1
+#define GUESS_FROM_PREVIOUS_PAGE	2
+
+#define HTDEL				remoteStoreRemove
+
+#ifndef	HT_RAPTOR
+	/* external string references in allxpstr */
+extern	int	RDF_HTML_STR, RDF_HTML_STR_1, RDF_HTML_STR_2, RDF_HTML_STR_3;
+extern	int	RDF_HTML_STR_4, RDF_HTML_STR_5, RDF_HTML_STR_NUMBER;
+extern	int	RDF_HTML_WINDATE, RDF_HTML_MACDATE, RDF_CMD_0, RDF_DATA_1, RDF_DATA_2;
+extern	int	RDF_DELETEFILE, RDF_UNABLETODELETEFILE, RDF_DELETEFOLDER;
+extern	int	RDF_UNABLETODELETEFOLDER, RDF_SITEMAPNAME;
+extern	int	RDF_RELATEDLINKSNAME, RDF_DEFAULTCOLUMNNAME;
+extern	int	RDF_NEWWORKSPACEPROMPT, RDF_DELETEWORKSPACE;
+extern	int	RDF_ADDITIONS_ALLOWED, RDF_DELETION_ALLOWED;
+extern	int	RDF_ICON_URL_LOCKED, RDF_NAME_LOCKED, RDF_COPY_ALLOWED;
+extern	int	RDF_MOVE_ALLOWED, RDF_WORKSPACE_POS_LOCKED;
+extern	int	RDF_MAIN_TITLE, RDF_COLOR_TITLE, RDF_HTML_INFOHEADER_STR;
+extern	int	RDF_MISSION_CONTROL_TITLE, RDF_TREE_COLORS_TITLE, RDF_SELECTION_COLORS_TITLE;
+extern	int	RDF_COLUMN_COLORS_TITLE, RDF_TITLEBAR_COLORS_TITLE, RDF_HTML_MAININFOHEADER_STR;
+extern	int	RDF_HTML_EMPTYHEADER_STR, RDF_HTML_COLOR_STR, RDF_SETCOLOR_JS, RDF_DEFAULTCOLOR_JS;
+extern	int	RDF_COLOR_LAYER, RDF_HTMLCOLOR_STR;
+extern	int	RDF_SELECT_START, RDF_SELECT_END, RDF_SELECT_OPTION;
+extern	int	RDF_FIND_STR1, RDF_FIND_STR2, RDF_FIND_INPUT_STR;
+extern	int	RDF_LOCAL_LOCATION_STR, RDF_REMOTE_LOCATION_STR, RDF_ALL_LOCATION_STR;
+extern	int	RDF_CONTAINS_STR, RDF_IS_STR, RDF_IS_NOT_STR, RDF_STARTS_WITH_STR, RDF_ENDS_WITH_STR;
+extern	int	RDF_FIND_TITLE, RDF_FIND_FULLNAME_STR, RDF_SHORTCUT_CONFLICT_STR, RDF_FTP_NAME_STR;
+
+#ifdef	HT_PASSWORD_RTNS
+extern	int	RDF_NEWPASSWORD, RDF_CONFIRMPASSWORD;
+extern	int	RDF_MISMATCHPASSWORD, RDF_ENTERPASSWORD;
+#endif
+
+#endif
+
+
+#define	MISSION_CONTROL_RDF_PREF	"browser.navcenter.admin"
+#define	NETSCAPE_RDF_FILENAME		"netscape.rdf"
+
+typedef struct _SBProviderStruct {
+	struct _SBProviderStruct	*next;
+	char				*url;
+	char				*name;
+	PRBool				containerp;
+	PRBool				openp;
+} SBProviderStruct;
+typedef SBProviderStruct* SBProvider;
+
+typedef struct _HT_PaneStruct {
+	struct _HT_PaneStruct		*next;
+	void				*pdata;
+	HT_Notification			ns;
+	PLHashTable			*hash;
+	HT_NotificationMask		mask;
+	RDF				db;
+	RDF_Notification		rns;
+	struct _HT_ViewStruct		*viewList;
+	struct _HT_ViewStruct		*selectedView;
+	struct _HT_URLSiteMapAssoc	*smp;
+	struct _HT_URLSiteMapAssoc	*sbp;
+	uint32				viewListCount;
+	PRBool				autoFlushFlag;
+	SBProvider			smartBrowsingProviders;
+	PRBool				dirty;
+	PRBool				personaltoolbar;
+	PRBool				toolbar;
+	PRBool				bookmarkmenu;
+	PRBool				special;
+	int					windowType;
+	char				*windowURL;
+	char				*templateType;
+	struct _HT_PaneStruct		*templatePane;
+	char				*htdburl;
+	RDFT				htdb;
+} HT_PaneStruct;
+
+typedef	struct HT_ColumnStruct {
+	struct HT_ColumnStruct		*next;
+	char				*name;
+	uint32				width;
+	uint32				tokenType;
+	void				*token;
+	void				*feData;
+	PRBool				isHiddenFlag;
+} HT_ColumnStruct, *HT_Column;
+
+typedef struct _HT_ViewStruct {
+	struct _HT_ViewStruct		*next;
+	HT_Pane				pane;
+	HT_Resource			top;
+	void				*pdata;
+	HT_Column			columns;
+	uint32				workspacePos;
+	struct _HT_ResourceStruct	***itemList;
+	uint32				itemListSize;
+	uint32				itemListCount;
+	uint32				topNodeIndex;
+	uint32				selectedNodeHint;
+	uint32				sortTokenType;
+	void				*sortToken;
+	PRBool				descendingFlag;
+	PRBool				refreshingItemListp;
+	PRBool				inited;
+	RDF_Resource			treeRel;
+} HT_ViewStruct;
+
+typedef	struct _HT_ValueStruct {
+	struct _HT_ValueStruct		*next;
+	uint32				tokenType;
+	RDF_Resource			token;
+	void				*data;
+} HT_ValueStruct, *HT_Value;
+
+#define	HT_CONTAINER_FLAG	0x0001
+#define	HT_OPEN_FLAG		0x0002
+#define	HT_AUTOFLUSH_OPEN_FLAG	0x0004
+#define	HT_HIDDEN_FLAG		0x0008
+#define	HT_SELECTED_FLAG	0x0010
+#define	HT_VOLATILE_URL_FLAG	0x0020
+#define	HT_FREEICON_URL_FLAG	0x0040
+#define	HT_PASSWORDOK_FLAG	0x0080
+#define	HT_INITED_FLAG		0x0100
+#define	HT_DIRTY_FLAG		0x0200
+#define	HT_ENABLED_FLAG		0x0400
+
+typedef struct _HT_ResourceStruct {
+	struct _HT_ResourceStruct	*nextItem; 
+	HT_View				view;
+	HT_Resource			parent;
+	RDF_Resource			node;
+	void				*feData;
+	char				*dataSource;
+	char				*url[5];
+	HT_Value			values;
+	HT_Resource			child;
+	HT_Resource			*children;		/* used by sorting */
+	uint32				unsortedIndex;		/* used by sorting */
+	uint32				itemListIndex;
+	uint32				numChildren, numChildrenTotal;
+	uint16				flags;
+	uint16				depth;
+	HT_Resource			next;
+	/* a pane or view might have multiple occurances of a RDF_Resource.
+	The hash table just points to the first of them. This allows us to
+	make a linked list of it */
+} HT_ResourceStruct;
+
+typedef	struct	_HT_MenuCommandStruct	{
+	struct	_HT_MenuCommandStruct	*next;
+	HT_MenuCmd			menuCmd;
+	char				*name;
+	RDF_Resource			graphCommand;
+} _HT_MenuCommandStruct, *HT_MenuCommand;
+
+typedef struct _HT_CursorStruct {
+	HT_Resource			container;
+	HT_Resource			node;
+	RDF_Cursor			cursor;
+	uint32				numElements;
+	HT_Column			columns;
+	uint16				contextMenuIndex;
+	PRBool				foundValidMenuItem;
+	PRBool				isWorkspaceFlag;
+	PRBool				isBackgroundFlag;
+	PRBool				commandExtensions;
+	PRBool				commandListBuild;
+	HT_MenuCmd			menuCmd;
+	HT_MenuCommand			menuCommandList;
+} HT_CursorStruct;
+
+typedef	struct _HT_Icon {
+	struct _HT_Icon			*next;
+	char				*name;
+} _HT_Icon, *HT_Icon;
+
+typedef struct	_htmlElement	{
+	struct	_htmlElement		*next;
+	HT_Resource			node;
+	RDF_Resource			token;
+	uint32				tokenType;
+} _htmlElement, *_htmlElementPtr;
+
+typedef struct _HT_URLSiteMapAssoc {
+	uint8				siteToolType;
+    uint8               origin;
+    uint8               onDisplayp;
+	char				*url;
+	RDF_Resource		sitemap;
+    char*               name;
+    char*               sitemapUrl;
+    RDFT                db;
+	struct _HT_URLSiteMapAssoc	*next;
+} HT_URLSiteMapAssoc;
+
+
+
+/* HT function prototypes */
+
+XP_BEGIN_PROTOS
+
+void				HT_Startup();
+void				HT_Shutdown();
+void				htLoadComplete(char *url, int status);
+void				htTimerRoutine(void *timerID);
+PRBool				possiblyUpdateView(HT_View view);
+void				updateViewItem(HT_Resource node);
+HT_Resource			newHTEntry (HT_View view, RDF_Resource node);
+void				addWorkspace(HT_Pane pane, RDF_Resource r, void *feData);
+void				deleteWorkspace(HT_Pane pane, RDF_Resource r);
+void				htrdfNotifFunc (RDF_Event ns, void* pdata);
+void				bmkNotifFunc (RDF_Event ns, void* pdata);
+void				refreshItemListInt (HT_View view, HT_Resource node);
+PRBool				relatedLinksContainerp (HT_Resource node);
+int				nodeCompareRtn(HT_Resource *node1, HT_Resource *node2);
+void				sortNodes(HT_View view, HT_Resource parent, HT_Resource *children, uint32 numChildren);
+uint32				refreshItemList1(HT_View view, HT_Resource node);
+void				refreshItemList (HT_Resource node, HT_Event whatHappened);
+void				refreshPanes();
+PRBool				initToolbars (HT_Pane pane);
+HT_Pane				paneFromResource(RDF db, RDF_Resource resource, HT_Notification notify, PRBool autoFlushFlag, PRBool autoOpenFlag, PRBool useColumns);
+void				htSetBookmarkAddDateToNow(RDF_Resource r);
+RDF				newHTPaneDB();
+RDF				HTRDF_GetDB();
+PRBool				initViews (HT_Pane pane);
+void				htNewWorkspace(HT_Pane pane, char *id, char *optionalTitle, uint32 workspacePos);
+HT_PaneStruct *			HT_GetHTPaneList ();
+HT_PaneStruct *			HT_GetNextHTPane (HT_PaneStruct* pane);
+void				htSetWorkspaceOrder(RDF_Resource src, RDF_Resource dest, PRBool afterDestFlag);
+HT_View				HT_NewView (RDF_Resource topNode, HT_Pane pane, PRBool useColumns, void *feData, PRBool autoOpen);
+void				sendNotification (HT_Resource node, HT_Event whatHappened, RDF_Resource s, HT_ColumnType type);
+void				deleteHTNode(HT_Resource node);
+void				destroyViewInt (HT_Resource r, PRBool saveOpenState);
+void				htDeletePane(HT_Pane pane, PRBool saveWorkspaceOrder);
+void				saveWorkspaceOrder(HT_Pane pane);
+void				resynchItem (HT_Resource node, void *token, void *data, PRBool assertAction);
+void				resynchContainer (HT_Resource container);
+HT_Resource			addContainerItem (HT_Resource container, RDF_Resource item);
+void				refreshContainerIndexes(HT_Resource container);
+void				removeHTFromHash (HT_Pane pane, HT_Resource item);
+void				deleteHTSubtree (HT_Resource subtree);
+void				deleteContainerItem (HT_Resource container, RDF_Resource item);
+uint32				fillContainer (HT_Resource node);
+void				sendColumnNotification (HT_View view, void *token, uint32 tokenType, HT_Event whatHappened);
+PRBool				htIsMenuCmdEnabled(HT_Pane pane, HT_MenuCmd menuCmd, PRBool isWorkspaceFlag, PRBool isBackgroundFlag);
+void				freeMenuCommandList();
+void				exportCallbackWrite(PRFileDesc *fp, char *str);
+void				exportCallback(MWContext *context, char *filename, RDF_Resource node);
+void				htEmptyClipboard(RDF_Resource parent);
+void				htCopyReference(RDF_Resource original, RDF_Resource newParent, PRBool empty);
+PRBool				htVerifyUniqueToken(HT_Resource node, void *token, uint32 tokenType, char *data);
+PRBool				ht_isURLReal(HT_Resource node);
+char *				buildInternalIconURL(HT_Resource node, PRBool *volatileURLFlag,	PRBool largeIconFlag, PRBool workspaceFlag);
+char *				getIconURL( HT_Resource node, PRBool toolbarFlag, PRBool workspaceFlag, int state);
+PRBool				htIsPropertyInMoreOptions(RDF_Resource r);
+void				addHtmlElement(HT_Resource node, RDF_Resource token, uint32 tokenType);
+void				freeHtmlElementList();
+_htmlElementPtr			findHtmlElement(void *token);
+void				freeHtmlElement(void *token);
+char *				constructHTMLTagData(char *dynStr, int strID, char *data);
+char *				constructHTML(char *dynStr, HT_Resource node, void *token, uint32 tokenType);
+char *				constructHTMLPermission(char *dynStr, HT_Resource node, RDF_Resource token, char *permText);
+PRBool				htIsOpLocked(HT_Resource node, RDF_Resource token);
+char *				constructBasicHTML(char *dynStr, int strID, char *data1, char *data2);
+void				setHiddenState (HT_Resource node);
+void				htSetFindResourceName(RDF db, RDF_Resource r);
+void				htOpenTo(HT_View view, RDF_Resource u, PRBool selectView);
+PRBool				mutableContainerp (RDF_Resource node);
+char *				possiblyCleanUpTitle (char* title);
+PRBool				htRemoveChild(HT_Resource parent, HT_Resource child, PRBool moveToTrash);
+void				ht_SetPassword(HT_Resource node, char *password);
+PRBool				ht_hasPassword(HT_Resource node);
+PRBool				ht_checkPassword(HT_Resource node, PRBool alwaysCheck);
+HT_DropAction			htLaunchSmartNode(HT_Resource dropTarget, char *fullURL);
+HT_DropAction			dropOnSmartNode(HT_Resource dropTarget, HT_Resource dropObject, PRBool justAction);
+HT_DropAction			dropOnSmartURL(HT_Resource dropTarget, char *objTitle, PRBool justAction);
+HT_DropAction			dropOn (HT_Resource dropTarget, HT_Resource dropObject, PRBool justAction);
+void				Win32FileCopyMove(HT_Resource dropTarget, HT_Resource dropObject);
+HT_DropAction			copyMoveRDFLink (HT_Resource dropTarget, HT_Resource dropObject);
+HT_DropAction			copyMoveRDFLinkAtPos (HT_Resource dropx, HT_Resource dropObject, PRBool before);
+HT_DropAction			uploadLFS (HT_Resource dropTarget, HT_Resource dropObject);
+HT_DropAction			uploadRDFFile (HT_Resource dropTarget, HT_Resource dropObject);
+HT_DropAction			esfsCopyMoveContent (HT_Resource dropTarget, HT_Resource dropObject);
+RDF_BT				urlResourceType (char* url);
+HT_DropAction			dropURLOn (HT_Resource dropTarget, char* objURL, char *objTitle, PRBool justAction);
+void				replacePipeWithColon(char* url);
+HT_DropAction			copyRDFLinkURL (HT_Resource dropTarget, char* objURL, char *objTitle);
+HT_DropAction			copyRDFLinkURLAt (HT_Resource dropx, char* objURL, char *objTitle, PRBool before);
+HT_DropAction			uploadLFSURL (HT_Resource dropTarget, char* objURL);
+HT_DropAction			uploadRDFFileURL (HT_Resource dropTarget, char* objURL);
+HT_DropAction			esfsCopyMoveContentURL (HT_Resource dropTarget, char* objURL);
+RDFT				HTADD(HT_Pane pane, RDF_Resource u, RDF_Resource s, void* v);
+HT_URLSiteMapAssoc *		makeNewSMP (HT_Pane htPane, char* pUrl, char* sitemapurl);
+void				RetainOldSitemaps (HT_Pane htPane, char *pUrl);
+void				populateSBProviders (HT_Pane htPane);
+SBProvider			SBProviderOfNode (HT_Resource node);
+PRBool				implicitDomainURL (char* url);
+PRBool				domainMatches (char *dom, char *url);
+void				nextDomain (char* dom, size_t *n);
+PRBool				relatedLinksEnabledURL (char* url);
+void				cleanupInt (HT_Pane htPane, HT_URLSiteMapAssoc *nsmp, RDF_Resource parent);
+HT_Pane				newTemplatePane(char* templateName);
+void				PaneDeleteSBPCleanup (HT_Pane htPane);
+
+#ifndef	HT_RAPTOR
+PRBool				rdfFindDialogHandler(XPDialogState *dlgstate, char **argv, int argc, unsigned int button);
+#endif
+
+XP_END_PROTOS
+
+#endif
+

rdf/src/makefile.win

@@ -0,0 +1,58 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+
+DEPTH	= ..\..\..
+LIBRARY_SUFFIX=$(MOZ_BITS)
+MAKE_OBJ_TYPE=DLL
+MAKE_OBJ_TYPE = DLL
+DLLNAME = rdf
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+MODULE=rdf 
+REQUIRES=nspr rdf xpcom netlib
+
+C_OBJS=.\$(OBJDIR)\vocab.obj \
+       .\$(OBJDIR)\core.obj \
+       .\$(OBJDIR)\remstore.obj \
+       .\$(OBJDIR)\utils.obj \
+       .\$(OBJDIR)\rdfparse.obj \
+       .\$(OBJDIR)\bmk2rdf.obj \
+       .\$(OBJDIR)\columns.obj \
+       .\$(OBJDIR)\ht.obj \
+	.\$(OBJDIR)\netglue.obj \
+       .\$(OBJDIR)\rdfht.obj \
+       $(NULL)
+
+CPP_OBJS=\
+	.\$(OBJDIR)\comwrap.obj \
+	$(NULL)
+
+LLIBS=				\
+ $(DIST)\lib\xpcom32.lib	\
+ $(DIST)\lib\libplc21.lib    \
+ $(LIBNSPR)  
+
+LINCS= -I$(PUBLIC)\rdf -I$(LIBNSPR) -I$(XPDIST)\public\xpcom -I$(PUBLIC)\netlib -I$(PUBLIC)\raptor
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+
+
+
+

rdf/src/netglue.cpp

@@ -0,0 +1,183 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsIStreamListener.h"
+#include "nsIURL.h"
+#include "nsIInputStream.h"
+#include "nsString.h"
+#include "rdf-int.h"
+#include "rdfparse.h"
+
+class rdfStreamListener : public nsIStreamListener
+{
+public:
+
+  NS_DECL_ISUPPORTS
+
+  rdfStreamListener(RDFFile);
+  ~rdfStreamListener();
+
+  NS_METHOD GetBindInfo(nsIURL* aURL);
+
+  NS_METHOD OnProgress(nsIURL* aURL, PRInt32 Progress, PRInt32 ProgressMax,  const nsString &aMsg);
+
+  NS_METHOD OnStatus(nsIURL* aURL, const nsString& aMsg);
+
+  NS_METHOD OnStartBinding(nsIURL* aURL, const char *aContentType);
+
+  NS_METHOD OnDataAvailable(nsIURL* aURL, nsIInputStream *pIStream, PRInt32 length);
+
+  NS_METHOD OnStopBinding(nsIURL* aURL, PRInt32 status, const nsString& aMsg);
+
+protected:
+  rdfStreamListener::rdfStreamListener();
+
+private:
+  RDFFile mFile;
+};
+
+rdfStreamListener::rdfStreamListener(RDFFile f) : mFile(f)
+{
+}
+
+
+// ISupports implementation...
+NS_IMPL_ADDREF(rdfStreamListener)
+NS_IMPL_RELEASE(rdfStreamListener)
+
+nsresult rdfStreamListener::QueryInterface(REFNSIID aIID, void** aInstancePtr)
+{
+    if (NULL == aInstancePtr) {
+        return NS_ERROR_NULL_POINTER;
+    }
+    return NS_NOINTERFACE;
+}
+
+
+rdfStreamListener::~rdfStreamListener()
+{
+}
+
+NS_METHOD
+rdfStreamListener::GetBindInfo(nsIURL* aURL)
+{
+  return NS_OK;
+}
+
+NS_METHOD
+rdfStreamListener::OnProgress(nsIURL* aURL,
+			      PRInt32 Progress,
+			      PRInt32 ProgressMax,  const nsString &aMsg)
+{
+  return NS_OK;
+}
+
+NS_METHOD
+rdfStreamListener::OnStatus(nsIURL* aURL, 
+			    const nsString& aMsg)
+{
+  return NS_OK;
+}
+
+NS_METHOD
+rdfStreamListener::OnStartBinding(nsIURL* aURL, 
+				  const char *aContentType)
+{
+  return NS_OK;
+}
+
+
+NS_METHOD
+rdfStreamListener::OnDataAvailable(nsIURL* aURL, 
+				   nsIInputStream *pIStream, 
+				   PRInt32 length)
+{
+  PRInt32 len;
+
+  // PRLOG(("\n+++ rdfStreamListener::OnDataAvailable: URL: %p, %d bytes available...\n", aURL, length));
+
+  do {
+    const PRUint32 buffer_size = 80;
+    char buffer[buffer_size];
+    PRInt32 err;
+
+    len = pIStream->Read(&err, buffer, 0, buffer_size);
+    if (err == NS_OK) {
+      (void) parseNextRDFXMLBlobInt(mFile, buffer, len);
+    } // else XXX ?
+  } while (len > 0);
+  
+  return NS_OK;
+}
+
+NS_METHOD
+rdfStreamListener::OnStopBinding(nsIURL* aURL,
+				 PRInt32 status,
+				 const nsString& aMsg)
+{
+  nsresult result = NS_OK;
+
+  switch( status ) {
+
+  case NS_BINDING_SUCCEEDED:
+    /* finishRDFParse( mFile ); */
+    break;
+
+  case NS_BINDING_FAILED:
+  case NS_BINDING_ABORTED:
+    //    abortRDFParse( mFile );
+    // XXX status code?
+    break;
+
+  default:
+    PR_ASSERT(PR_FALSE);
+    result = NS_ERROR_ILLEGAL_VALUE;
+
+  }
+
+  return result;
+}
+
+/* 
+ * beginReadingRDFFile is called whenever we need to read something of
+ * the net (or local drive). The url of the file to be read is at
+ * file->url.  As the bits are read in (and it can take the bits in
+ * any sized chunks) it should call parseNextRDFBlobInt(file, nextBlock,
+ * blobSize) when its done, it should call void finishRDFParse
+ * (RDFFile f) to abort, it should call void abortRDFParse (RDFFile f)
+ * [which will undo all that has been read from that file] 
+ */
+
+void
+beginReadingRDFFile (RDFFile file)
+{
+   rdfStreamListener* pListener = new rdfStreamListener(file);
+   pListener->AddRef(); // XXX is this evil?  Can't see any reason to use factories but...
+   nsIURL* pURL = NULL;
+   nsString url_address( file->url );
+   nsresult r = NS_NewURL( &pURL, url_address );
+   if( NS_OK != r ) {
+       // XXX what to do?
+   }
+
+   r = pURL->Open(pListener);
+   if( NS_OK != r ) {
+       // XXX what to do?
+   }
+
+}

rdf/src/rdf-int.h

@@ -0,0 +1,460 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+
+
+#ifndef	_RDF_RDF_INT_H
+#define	_RDF_RDF_INT_H
+
+
+#define WINTEST 0
+#define DBMTEST 1 
+#define FSTEST 1
+
+
+#define	RDF_BUF_SIZE	4096
+#define LINE_SIZE     512
+#define RDF_BOOKMARKS 128
+#define RDF_MCF       129
+#define RDF_XML       130
+
+#include <stdlib.h>
+#include <string.h>
+#include "rdf.h"
+#include "nspr.h"
+#include "plhash.h"
+
+#include "rdfstr.h"
+
+
+
+#ifndef true
+#define true PR_TRUE
+#endif
+#ifndef false
+#define false PR_FALSE
+#endif
+#define null NULL
+#define nullp(x) (((void*)x) == ((void*)0))
+#define LookupResource(x) ((RDF_Resource)PL_HashTableLookup(resourceHash, x));
+
+#define noRDFErr 0
+#define noMoreValuesErr 1
+
+#define MAX_ATTRIBUTES 64
+
+#define RDF_RT 0
+#define LFS_RT 1
+#define FTP_RT  3
+#define ES_RT 4
+#define SEARCH_RT  5
+#define HISTORY_RT 6
+#define LDAP_RT 7
+#define PM_RT 8
+#define RDM_RT 9
+#define	IM_RT	10
+#define CACHE_RT 11
+#define	ATALK_RT 12
+#define	ATALKVIRTUAL_RT 13
+#define COOKIE_RT       14
+#define JSEC_RT 15
+#define PMF_RT  16
+
+#define CHECK_VAR(var, return_value) {if (var == NULL) {/*xxx PR_ASSERT(var); */ return return_value;}}
+#define CHECK_VAR1(var) {if (var == NULL) {/*xxx PR_ASSERT(var);*/ return;}}
+
+
+#ifdef	XP_WIN
+#define	FS_URL_OFFSET		8
+#else
+#define	FS_URL_OFFSET		7
+#endif
+
+
+#define MAX_URL_SIZE 300
+
+
+#define convertString2UTF8(charsetid, s) 	\
+   (s != NULL ? 				\
+    INTL_ConvertLineWithoutAutoDetect( 		\
+       (charsetid) , 				\
+       CS_UTF8, 				\
+       (unsigned char*)(s),			\
+       RDF_STRLEN(s)				\
+    ) : NULL)
+	
+#define stringEquals(x, y) (strcmp(x, y) ==0)
+/*#define stringAppend(x, y)   XP_AppendStr(x,y) */
+
+struct RDF_ResourceStruct {
+  char* url;
+  uint8  type;  
+  uint8  flags;
+  struct RDF_AssertionStruct* rarg1;
+  struct RDF_AssertionStruct* rarg2;
+  struct RDF_ListStruct*          rdf;
+  void*  pdata;
+} ;
+
+#define RDF_GET_SLOT_VALUES_QUERY 0x01
+#define RDF_GET_SLOT_VALUE_QUERY 0x02
+#define RDF_FIND_QUERY 0x03
+#define RDF_ARC_LABELS_IN_QUERY 0x04
+#define RDF_ARC_LABELS_OUT_QUERY 0x05
+
+struct RDF_CursorStruct {
+  RDF_Resource u;
+  RDF_Resource s;
+  RDF_Resource match;
+  void *value;
+  struct RDF_CursorStruct* current;
+  RDF    rdf;
+  void* pdata;
+  PRBool tv;
+  PRBool inversep;
+  RDF_ValueType type;
+  int16 count;
+  uint16 size;
+  uint8 queryType;
+};
+
+typedef uint8 RDF_BT;
+
+#define getMem(x) PR_Calloc(1,(x))
+#define freeMem(x) PR_Free((x))
+
+struct RDF_AssertionStruct {
+  RDF_Resource u;
+  RDF_Resource s;
+  void* value;
+  PRBool tv;
+  RDF_ValueType type;
+  uint8 tags;
+  struct RDF_AssertionStruct* next;
+  struct RDF_AssertionStruct* invNext;
+  struct RDF_TranslatorStruct* db;
+} ;
+
+
+typedef struct RDF_AssertionStruct *Assertion;
+typedef struct RDF_FileStruct *RDFFile;
+
+
+typedef PRBool (*assertProc)(RDFT r, RDF_Resource u, RDF_Resource  s, void* value, RDF_ValueType type, PRBool tv);
+typedef PRBool (*hasAssertionProc)(RDFT r, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+typedef void* (*getSlotValueProc)(RDFT r, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv) ;
+typedef RDF_Cursor (*getSlotValuesProc)(RDFT r, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep, PRBool tv);
+typedef PRBool (*unassertProc)(RDFT r, RDF_Resource u, RDF_Resource s, void* value, RDF_ValueType type);
+typedef void* (*nextItemProc)(RDFT r, RDF_Cursor c) ;
+typedef RDF_Error (*disposeCursorProc)(RDFT r, RDF_Cursor c);
+typedef RDF_Error (*disposeResourceProc)(RDFT r, RDF_Resource u);
+typedef RDF_Error (*updateProc)(RDFT r, RDF_Resource u);
+typedef RDF_Error (*destroyProc)(struct RDF_TranslatorStruct*);
+typedef RDF_Cursor (*arcLabelsOutProc)(RDFT r, RDF_Resource u);
+typedef RDF_Cursor (*arcLabelsInProc)(RDFT r, RDF_Resource u);
+typedef PRBool (*fAssert1Proc) (RDFFile  file, RDFT mcf,  RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+typedef PRBool (*fUnAssert1Proc) (RDFFile  file, RDFT mcf,  RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type) ;
+typedef void (*accessFileProc) (RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep) ;
+
+struct RDF_ListStruct {
+  struct RDF_DBStruct*   rdf;
+  struct RDF_ListStruct* next;
+} ;
+
+typedef struct RDF_ListStruct *RDFL;
+
+struct RDF_TranslatorStruct {
+  RDFL             rdf;
+  char*            url;
+  void*            pdata;
+  destroyProc      destroy;
+  hasAssertionProc hasAssertion;
+  unassertProc     unassert;
+  assertProc       assert;
+  getSlotValueProc getSlotValue;
+  getSlotValuesProc getSlotValues;
+  nextItemProc      nextValue;
+  disposeCursorProc disposeCursor;
+  disposeResourceProc disposeResource;
+  arcLabelsInProc   arcLabelsIn;
+  arcLabelsInProc   arcLabelsOut;
+  accessFileProc    possiblyAccessFile;
+  updateProc        update;
+  RDFL dependents;
+  RDFL dependentOn; 
+};
+
+
+extern     PLHashTable*  resourceHash;  
+extern     PLHashTable*  dataSourceHash;  
+extern     char*  gNavCntrUrl;
+struct RDF_DBStruct {
+  int32 numTranslators;
+  int32 translatorArraySize;
+  RDFT*  translators;
+  struct RDF_FileStruct* files;
+  struct RDF_NotificationStruct* notifs;
+  void* context;
+};
+
+extern RDFT gLocalStore;
+extern RDFT gRemoteStore;
+extern RDFT gSessionDB;
+extern size_t gCoreVocabSize;
+extern RDF_Resource* gAllVocab;
+
+/* reading rdf */
+
+#define HEADERS 1
+#define BODY    2
+
+
+struct XMLNameSpaceStruct {
+  char* as;
+  char* url;
+  struct XMLNameSpaceStruct* next;
+} ;
+
+typedef struct XMLNameSpaceStruct *XMLNameSpace;
+
+#define	RDF_MAX_NUM_FILE_TOKENS		8
+
+struct	RDF_FileStructTokens {
+	RDF_Resource	token;
+	RDF_ValueType	type;
+	int16		tokenNum;
+	char		*data;
+};
+
+struct RDF_FileStruct {
+  char* url;
+
+  RDF_Resource currentResource;
+  RDF_Resource top;
+  RDF_Resource rtop;
+  char*  currentSlot;
+  PRBool genlAdded;
+  PRBool localp;
+  char* storeAway;
+  char* line;
+  XMLNameSpace namespaces;
+  uint16   status;
+  char* holdOver;
+  int32   lineSize;
+  RDF_Resource stack[16];
+  uint16   depth ;
+
+
+  uint16   resourceCount;
+  uint16   resourceListSize;
+  uint16   assertionCount;
+  uint16   assertionListSize;
+  RDF_Resource* resourceList;
+  Assertion* assertionList;
+  char*    updateURL;
+  char*    postURL;
+
+  PRTime lastReadTime;
+  PRTime *expiryTime;
+  uint8   fileType;
+  PRBool  locked;
+  RDF_Resource lastItem;
+
+
+  PRBool tv;
+  fAssert1Proc assert;
+  fUnAssert1Proc unassert;
+  RDFT     db;
+  PRBool refreshingp;
+
+  void* pdata;
+
+  int16	numFileTokens;
+  struct RDF_FileStructTokens tokens[RDF_MAX_NUM_FILE_TOKENS];
+  struct RDF_FileStruct* next;
+};
+
+RDF	newNavCenterDB();
+void	walkThroughAllBookmarks (RDF_Resource u);
+RDFT NewRemoteStore (char* url);
+RDF_Resource nextFindValue (RDF_Cursor c) ;
+PRBool isTypeOf (RDF rdf, RDF_Resource u,  RDF_Resource v); 
+RDF getRDFDB (void);
+RDFFile readRDFFile (char* url, RDF_Resource top, PRBool localp, RDFT rdf);
+void sendNotifications (RDF rdf, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv, char* ds);
+void sendNotifications2 (RDFT rdf, RDF_EventType opType, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+RDF_Error exitRDF (RDF rdf);
+void		gcRDFFileInt (RDFFile f);
+void parseNextBkBlob(RDFFile f, char* blob, int32 blobSize);
+void printAssertion(Assertion as);
+RDF_Error addChildAfter (RDFT rdf, RDF_Resource parent, RDF_Resource child, RDF_Resource afterWhat);
+RDF_Error addChildBefore (RDFT rdf, RDF_Resource parent, RDF_Resource child, RDF_Resource beforeWhat);
+void nlclStoreKill(RDFT rdf, RDF_Resource r);
+char* resourceID(RDF_Resource id);
+PRBool containerp (RDF_Resource r);
+void   setContainerp (RDF_Resource r, PRBool contp);
+PRBool lockedp (RDF_Resource r);
+void   setLockedp (RDF_Resource r, PRBool contp);
+uint8  resourceType (RDF_Resource r);
+void   setResourceType (RDF_Resource r, uint8 type);
+char* getBaseURL (const char* url) ;
+void freeNamespaces (RDFFile f) ;
+PRBool		asEqual(RDFT r, Assertion as, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type);
+Assertion	makeNewAssertion (RDFT r, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+
+RDFT MakeRemoteStore (char* url);
+RDFT MakeMailAccountDB(char* url);
+PRDir * OpenDir(char *name);
+void PopGetNewMail (RDF_Resource r) ;
+void readResourceFile(RDF rdf, RDF_Resource u);
+void possiblyGCResource(RDF_Resource u);
+PLHashNumber idenHash(const void* key);
+
+RDFT MakeBMKStore (char* url);
+RDFT MakeLocalStore (char* url);
+RDFT MakeFileDB (char* url);
+RDFT MakeSCookDB (char* url);
+char * makeRDFDBURL(char* directory, char* name);
+void addToResourceList (RDFFile f, RDF_Resource u);
+void removeFromAssertionList(RDFFile f, Assertion as);
+
+
+
+
+/* string utilities */
+
+int16 charSearch(const char c,const  char* string);
+int16 revCharSearch(const char c, const char* string);
+PR_PUBLIC_API(PRBool) startsWith(const char* startPattern,const  char* string);
+PRBool endsWith(const char* endPattern,const  char* string);
+PRBool inverseTV(PRBool tv);
+void createBootstrapResources();
+PRBool urlEquals(const char* url1,const  char* url2);
+char* append2Strings(const char* str1,const  char* str2);
+char* convertString2UTF8AndAppend(int16 charsetID, const char* str1,const  char* str2);
+PRBool substring(const char* pattern, const char* data);
+void stringAppend(char* in, const char* append);
+
+RDFFile makeRDFFile (char* url, RDF_Resource top, PRBool localp);
+void initRDFFile (RDFFile ans) ;
+void parseNextRDFLine (RDFFile f, char* line) ;
+void parseNextRDFBlob (RDFFile f, char* blob, int32 size);
+void finishRDFParse (RDFFile f) ;
+void abortRDFParse (RDFFile f);
+void unitTransition (RDFFile f) ;	
+void assignHeaderSlot (RDFFile f, char* slot, char* value);			
+RDF_Error getFirstToken (char* line, char* nextToken, int16* l) ;
+void addSlotValue (RDFFile f, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, char* op);
+void assignSlot (RDF_Resource u, char* slot, char* value, RDFFile f);
+RDF_Error parseSlotValue (RDFFile f, RDF_Resource s, char* value, void** parsed_value, RDF_ValueType* data_type) ;
+RDF_Resource resolveReference (char *tok, RDFFile f) ;
+RDF_Resource resolveGenlPosReference(char* tok,  RDFFile f);
+RDF_Resource resolveReference (char *tok, RDFFile f) ;
+RDF_Resource resolveGenlPosReference(char* tok,  RDFFile f);
+void beginReadingRDFFile(RDFFile f);
+void gcRDFFile (RDFFile f);
+#ifdef XP_MAC
+char* unescapeURL(char* inURL);
+#endif
+char* convertFileURLToNSPRCopaceticPath(char* inURL);
+PRFileDesc* CallPROpenUsingFileURL(char *fileURL, PRIntn flags, PRIntn mode);
+/* DB *CallDBOpenUsingFileURL(char *fileURL, int flags,int mode, DBTYPE type, const void *openinfo); */
+
+char* copyString (const char* url);
+PRBool nlocalStoreAssert (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, 
+			 RDF_ValueType type, PRBool tv) ;
+char* MCDepFileURL (char* url) ;
+void initLocalStore(RDFT rdf);
+void freeAssertion(Assertion as);
+Assertion localStoreAdd (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv)  ;
+Assertion localStoreRemove (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type)  ;
+ 
+Assertion remoteStoreAdd (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+Assertion remoteStoreRemove (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type) ;
+void* remoteStoreGetSlotValue (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep,  PRBool tv) ;
+void ht_fprintf(PRFileDesc *file, const char *fmt, ...);
+
+RDF_Resource createContainer (char* id);
+PRBool isContainer (RDF_Resource r) ;
+PRBool isSeparator (RDF_Resource r) ;
+PRBool isLeaf (RDF_Resource r) ;
+PRBool bookmarkSlotp (RDF_Resource s) ;
+
+void basicAssertions (void) ;
+char* makeResourceName (RDF_Resource node) ;
+char* makeDBURL (char* name);
+
+/* int rdf_GetURL (MWContext *cx, int method, Net_GetUrlExitFunc *exit_routine, RDFFile rdfFile); */
+
+RDFT MakePopDB (char* url) ;
+PRBool nlocalStoreAssert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv) ;
+PRBool nlocalStoreUnassert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		       RDF_ValueType type) ;
+PRBool nlocalStoreHasAssertion (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+void* nlocalStoreGetSlotValue (RDFT rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep,  PRBool tv) ;
+RDF_Cursor nlocalStoreGetSlotValues (RDFT rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv) ;
+void* nlocalStoreNextValue (RDFT mcf, RDF_Cursor c) ;
+RDF_Error nlocalStoreDisposeCursor (RDFT mcf, RDF_Cursor c) ;
+void createCoreVocab () ;
+
+
+PRBool remoteAssert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv) ;
+PRBool remoteUnassert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		       RDF_ValueType type) ;
+PRBool remoteAssert1 (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv) ;
+PRBool remoteAssert2 (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv) ;
+PRBool remoteUnassert1 (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		       RDF_ValueType type) ;
+PRBool remoteStoreHasAssertion (RDFT rdf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+void* remoteStoreGetSlotValue (RDFT rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep,  PRBool tv) ;
+RDF_Cursor remoteStoreGetSlotValues (RDFT rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv) ;
+RDF_Cursor remoteStoreGetSlotValuesInt (RDFT rdf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv) ;
+RDF_Resource createSeparator(void);
+PRBool
+remoteAssert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v,  RDF_ValueType type, PRBool tv);
+
+void* remoteStoreNextValue (RDFT mcf, RDF_Cursor c) ;
+RDF_Error remoteStoreDisposeCursor (RDFT mcf, RDF_Cursor c) ;
+PRBool remoteStoreHasAssertion (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+PRBool remoteStoreHasAssertionInt (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv) ;
+PRBool  nlocalStoreAddChildAt(RDFT mcf, RDF_Resource obj, RDF_Resource ref, RDF_Resource _new, 
+		      PRBool beforep);
+RDFT getTranslator (char* url);
+
+RDFT MakeCookieStore (char* url);
+
+char* advertURLOfContainer (RDF r, RDF_Resource u) ;
+RDFT RDFTNamed (RDF rdf, char* name) ;
+
+char*  RDF_SerializeRDFStore (RDFT store) ;
+char * unescapeURL(char *inURL);
+
+
+
+
+extern RDF_WDVocab gWebData;
+extern RDF_NCVocab gNavCenter;
+extern RDF_CoreVocab gCoreVocab;
+
+
+      
+#endif

rdf/src/rdfht.c

@@ -0,0 +1,177 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/* 
+   This file implements high level support for the rdf data model.
+   For more information on this file, contact rjc or guha 
+   For more information on RDF, look at the RDF section of www.mozilla.org
+*/
+
+#include "rdf-int.h"
+#include "vocab.h"
+#include "vocabint.h"
+#include "bmk2rdf.h"
+#include "core.h"
+
+
+/* globals */
+char			*profileDirURL = NULL;
+char			*gLocalStoreURL = NULL;
+char			*gBookmarkURL = NULL;
+char			*gGlobalHistoryURL = NULL;
+void			*timerID = NULL;
+char                    *gRLForbiddenDomains = NULL;
+
+extern	RDF	gNCDB ;
+
+
+static PRBool sRDFInitedB = PR_FALSE;
+char*  gNavCntrUrl;
+
+
+char * gNavCenterDataSources[15] = 
+{"rdf:localStore",   "rdf:remoteStore", "rdf:bookmarks", "rdf:remoteStore", "rdf:history",
+ /* "rdf:ldap", */
+ "rdf:esftp",
+ "rdf:lfs", "rdf:CookieStore",
+ "rdf:columns",  "rdf:find",
+
+#ifdef	XP_MAC
+	"rdf:appletalk",
+#endif
+ 
+ NULL, NULL
+};
+
+
+
+RDF
+newNavCenterDB()
+{
+	return  RDF_GetDB((char**)gNavCenterDataSources);
+}
+
+
+void
+walkThroughAllBookmarks (RDF_Resource u)
+{
+#ifdef MOZILLA_CLIENT
+  RDF_Cursor c = RDF_GetSources(gNCDB, u, gCoreVocab->RDF_parent, RDF_RESOURCE_TYPE, true);
+  RDF_Resource next;
+  while ((next = RDF_NextValue(c)) != NULL) {
+    if (resourceType(next) == RDF_RT) walkThroughAllBookmarks(next);
+  }
+  RDF_DisposeCursor(c);
+#endif
+}
+
+
+
+PR_PUBLIC_API(RDF_Error)
+RDF_Init(RDF_InitParams params)
+{
+#ifdef MOZILLA_CLIENT
+  char* navCenterURL;
+#endif
+  if ( sRDFInitedB )
+    return -1;
+
+#ifdef MOZILLA_CLIENT
+
+  /*
+     copy init params out before doing anything else (such as creating vocabulary)
+     to prevent any XP_GetString round-robin problems (ex: FE could be using XP_GetString
+     to pass in the init strings, which createVocabs() could affect
+  */
+  profileDirURL     = copyString(params->profileURL);
+  gBookmarkURL      = copyString(params->bookmarksURL);
+  gGlobalHistoryURL = copyString(params->globalHistoryURL);
+#endif
+
+  resourceHash = PL_NewHashTable(500, PL_HashString, PL_CompareStrings, 
+                                 PL_CompareValues,   NULL, NULL);
+  dataSourceHash = PL_NewHashTable(100, PL_HashString, PL_CompareStrings, 
+                                   PL_CompareValues,  NULL, NULL);
+  /*  RDFglueInitialize(); */
+  MakeRemoteStore("rdf:remoteStore");
+  createVocabs();
+  sRDFInitedB = PR_TRUE;
+
+#ifdef MOZILLA_CLIENT
+  /* xxx
+  PREF_SetDefaultCharPref("browser.NavCenter", "http://rdf.netscape.com/rdf/navcntr.rdf");
+  PREF_CopyCharPref("browser.NavCenter", &navCenterURL);
+  */
+  navCenterURL = copyString("http://rdf.netscape.com/rdf/navcntr.rdf");
+  if (!RDF_STRCHR(navCenterURL, ':')) {
+    navCenterURL = makeDBURL(navCenterURL);
+  }
+   gNavCntrUrl = copyString(navCenterURL);
+  *(gNavCenterDataSources + 1) = copyString(navCenterURL);
+  gNCDB = newNavCenterDB(); 
+  freeMem(navCenterURL);
+
+  HT_Startup();
+
+  /*  GuessIEBookmarks(); */
+
+#endif
+  walkThroughAllBookmarks(RDF_GetResource(NULL, "NC:Bookmarks", true));
+  return 0;
+}
+
+
+
+/*need to keep a linked list of all the dbs opened so that they
+  can all be closed down on exit */
+
+
+
+PR_PUBLIC_API(RDF_Error)
+RDF_Shutdown ()
+{
+#ifdef MOZILLA_CLIENT
+  /*  flushBookmarks(); */
+  HT_Shutdown();
+  /*  RDFglueExit(); */
+  if (profileDirURL != NULL)
+  {
+  	freeMem(profileDirURL);
+  	profileDirURL = NULL;
+  }
+  if (gBookmarkURL != NULL)
+  {
+  	freeMem(gBookmarkURL);
+  	gBookmarkURL = NULL;
+  }
+  if (gGlobalHistoryURL != NULL)
+  {
+  	freeMem(gGlobalHistoryURL);
+  	gGlobalHistoryURL = NULL;
+  }
+  if (gLocalStoreURL != NULL)
+  {
+  	freeMem(gLocalStoreURL);
+  	gLocalStoreURL = NULL;
+  }
+#endif
+  disposeAllDBs();
+  sRDFInitedB = PR_FALSE;
+  
+  return 0;
+}

rdf/src/rdfparse.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef	_RDF_RDFPARSE_H_
+#define	_RDF_RDFPARSE_H_
+
+
+#include "rdf-int.h"
+
+
+
+
+/* rdfparse.c data structures and defines */
+
+#define wsc(c) ((c == ' ') || (c == '\r') || (c == '\n') || (c == '\t'))
+
+
+#define EXPECTING_OBJECT 21
+#define EXPECTING_PROPERTY 22
+
+
+
+/* rdfparse.c function prototypes */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+char		decodeEntityRef (char* string, int32* stringIndexPtr, int32 len);
+char *		copyStringIgnoreWhiteSpace(char* string);
+char *		getHref(char** attlist);
+void		parseRDFProcessingInstruction (RDFFile f, char* token);
+char *		getAttributeValue (char** attlist, char* elName);
+PRBool		tagEquals (RDFFile f, char* tag1, char* tag2);
+void		addElementProps (char** attlist, char* elementName, RDFFile f, RDF_Resource obj);
+PRBool		knownObjectElement (char* eln);
+char *		possiblyMakeAbsolute (RDFFile f, char* url);
+PRBool		containerTagp (RDFFile f, char* elementName);
+RDF_Resource	ResourceFromElementName (RDFFile f, char* elementName);
+void		parseNextRDFToken (RDFFile f, char* token);
+void		tokenizeElement (char* attr, char** attlist, char** elementName);
+void		outputRDFTreeInt (RDF rdf, PRFileDesc *fp, RDF_Resource node, uint32 depth, PRBool localOnly);
+void		outputRDFTree (RDF rdf, PRFileDesc *fp, RDF_Resource node);
+int parseNextRDFXMLBlobInt(RDFFile f, char* blob, int32 size) ;
+
+
+#ifdef __cplusplus
+};
+#endif
+
+
+#endif

rdf/src/remstore.c

@@ -0,0 +1,833 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/* 
+   This file implements remote store support for the rdf data model.
+   For more information on this file, contact rjc or guha 
+   For more information on RDF, look at the RDF section of www.mozilla.org
+*/
+   
+#include "remstore.h"
+
+
+	/* globals */
+
+extern char *profileDirURL;
+extern char *gBookmarkURL;
+RDFT gLocalStore = 0;
+
+RDFT
+MakeRemoteStore (char* url)
+{
+  if (startsWith("rdf:remoteStore", url)) {
+    if (gRemoteStore == 0) {
+      gRemoteStore = NewRemoteStore(url);
+      return gRemoteStore;
+    } else return gRemoteStore;
+  } else return NULL;
+}
+
+
+
+RDFT
+MakeFileDB (char* url)
+{
+  if (RDF_STRCHR(url, ':')) {
+    RDFT ntr = NewRemoteStore(url);
+    ntr->possiblyAccessFile = RDFFilePossiblyAccessFile ;
+    if (RDF_STRCMP(gNavCntrUrl, url) == 0) 
+      readRDFFile(url, RDF_GetResource(NULL, url, 1), 0, ntr); 
+    return ntr;
+  } else return NULL;
+}
+
+
+
+PRBool
+asEqual(RDFT r, Assertion as, RDF_Resource u, RDF_Resource s, void* v, 
+	       RDF_ValueType type)
+{
+  return ((as->db == r) && (as->u == u) && (as->s == s) && (as->type == type) && 
+	  ((as->value == v) || 
+	   ((type == RDF_STRING_TYPE) && ((RDF_STRCMP(v, as->value) == 0) || (((char *)v)[0] =='\0')))));
+}
+
+
+
+Assertion
+makeNewAssertion (RDFT r, RDF_Resource u, RDF_Resource s, void* v, 
+			    RDF_ValueType type, PRBool tv)
+{
+  Assertion newAs = (Assertion) getMem(sizeof(struct RDF_AssertionStruct));
+  newAs->u = u;
+  newAs->s = s;
+  newAs->value = v;
+  newAs->type = type;
+  newAs->tv = tv;
+  newAs->db = r;
+  if (RDF_STRCMP(r->url, "rdf:history")) {
+    int n = 0;
+  }
+  return newAs;
+}
+
+
+
+void
+freeAssertion (Assertion as)
+{
+  if (as->type == RDF_STRING_TYPE) {
+    freeMem(as->value);
+  } 
+  freeMem(as);
+}
+
+
+PRBool
+remoteAssert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv)
+{
+  return (remoteStoreAdd(mcf, u, s, v, type, tv) != NULL);
+}
+
+
+PRBool
+remoteUnassert (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type)
+{
+  return (remoteStoreRemove(mcf, u, s, v, type) != NULL);
+}
+
+
+PRBool
+remoteAssert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type, PRBool tv)
+{
+  Assertion as = remoteStoreAdd(mcf, u, s, v, type, tv);
+  if (as != NULL) {
+    addToAssertionList(fi, as);
+    return 1;
+  } else return 0;
+}
+
+
+
+PRBool
+remoteUnassert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+		     RDF_ValueType type)
+{
+  Assertion as = remoteStoreRemove(mcf, u, s, v, type);
+  if (as != NULL) {
+    removeFromAssertionList(fi, as);
+    return 1;
+  } else return 0;
+}
+
+
+
+void
+remoteStoreflushChildren(RDFT mcf, RDF_Resource parent)
+{
+	RDF_Cursor		c;
+	RDF_Resource		child;
+#if 0
+	RDF_Cursor		cc;
+	RDF_Resource		s;
+	char			*value;
+#endif
+
+	if (parent == NULL)	return;
+	if ((c = remoteStoreGetSlotValues (mcf, parent, gCoreVocab->RDF_parent,
+		RDF_RESOURCE_TYPE,  true, true)) != NULL)
+	{
+		while((child = remoteStoreNextValue (mcf, c)) != NULL)
+		{
+			remoteStoreflushChildren(mcf, child);
+
+			/* XXX should we remove all arcs coming off of this node? */
+#if 0
+			if ((cc = remoteStoreArcLabelsOut(mcf, child)) != NULL)
+			{
+				if ((s = remoteStoreNextValue (mcf, cc)) != NULL)
+				{
+					if (s == gCoreVocab->RDF_name)
+					{
+						value = remoteStoreGetSlotValue (mcf, child, s,
+							RDF_STRING_TYPE, PR_FALSE, PR_TRUE);
+						if (value != NULL)
+						{
+							remoteStoreRemove (mcf, child, s,
+								value, RDF_STRING_TYPE);
+						}
+					}
+				}
+				remoteStoreDisposeCursor(mcf, cc);
+			}
+#endif
+			remoteStoreRemove (mcf, child, gCoreVocab->RDF_parent,
+				parent, RDF_RESOURCE_TYPE);
+		}
+		remoteStoreDisposeCursor (mcf, c);
+	}
+}
+
+
+
+Assertion
+remoteStoreAdd (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, 
+			  RDF_ValueType type, PRBool tv)
+{
+  Assertion nextAs, prevAs, newAs; 
+  nextAs = prevAs = u->rarg1;
+
+  if (s == gNavCenter->RDF_Command)
+  {
+  	if ((type == RDF_RESOURCE_TYPE) && (tv) && (v == gNavCenter->RDF_Command_Refresh))
+  	{
+  		/* flush any children of 'u' */
+  		remoteStoreflushChildren(mcf, u);
+	}
+	/* don't store RDF Commands in the remote store */
+  	return(NULL);
+  }
+  
+  while (nextAs != null) {
+    if (asEqual(mcf, nextAs, u, s, v, type)) return null;
+    prevAs = nextAs;
+    nextAs = nextAs->next;
+  }
+  newAs = makeNewAssertion(mcf, u, s, v, type, tv);
+  if (prevAs == null) {
+    u->rarg1 = newAs;
+  } else {
+    prevAs->next = newAs;
+  }
+  if (type == RDF_RESOURCE_TYPE) {
+    nextAs = prevAs = ((RDF_Resource)v)->rarg2;
+    while (nextAs != null) {
+      prevAs = nextAs;
+      nextAs = nextAs->invNext;
+    }
+    if (prevAs == null) {
+      ((RDF_Resource)v)->rarg2 = newAs;
+    } else {
+      prevAs->invNext = newAs;
+    }
+  }
+  sendNotifications2(mcf, RDF_ASSERT_NOTIFY, u, s, v, type, tv);
+  return newAs;
+}
+
+
+
+Assertion
+remoteStoreRemove (RDFT mcf, RDF_Resource u, RDF_Resource s,
+			     void* v, RDF_ValueType type)
+{
+  Assertion nextAs, prevAs, ans;
+  PRBool found = false;
+  nextAs = prevAs = u->rarg1;
+  while (nextAs != null) {
+    if (asEqual(mcf, nextAs, u, s, v, type)) {
+      if (prevAs == nextAs) {
+	u->rarg1 = nextAs->next;
+      } else {
+	prevAs->next = nextAs->next;
+      }
+      found = true;
+      ans = nextAs;
+      break;
+    }
+    prevAs = nextAs;
+    nextAs = nextAs->next; 
+  }
+  if (found == false) return null;
+  if (type == RDF_RESOURCE_TYPE) {
+    nextAs = prevAs = ((RDF_Resource)v)->rarg2;
+    while (nextAs != null) {
+      if (nextAs == ans) {
+	if (prevAs == nextAs) {
+	  ((RDF_Resource)v)->rarg2 = nextAs->invNext;
+	} else {
+	  prevAs->invNext = nextAs->invNext;
+	}
+      }
+      prevAs = nextAs;
+      nextAs = nextAs->invNext;
+    }
+  }
+  sendNotifications2(mcf, RDF_DELETE_NOTIFY, u, s, v, type, ans->tv);
+  return ans;
+}
+
+
+
+static PRBool
+fileReadp (RDFT rdf, char* url, PRBool mark)
+{
+  RDFFile f;
+  RDFFile rdfFiles = (RDFFile) rdf->pdata;
+  uint n = 0;
+  for (f = rdfFiles; (f != NULL) ; f = f->next) {
+    if (urlEquals(url, f->url)) {
+      if (mark == true)	f->lastReadTime = PR_Now();
+      return false;	/* true; */
+    }
+  }
+  return false;
+}
+
+
+
+static void
+possiblyAccessFile (RDFT mcf, RDF_Resource u, RDF_Resource s, PRBool inversep)
+{
+    if (mcf->possiblyAccessFile) 
+    (*(mcf->possiblyAccessFile))(mcf, u, s, inversep); 
+}
+
+
+
+void
+RDFFilePossiblyAccessFile (RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep)
+{
+  if ((resourceType(u) == RDF_RT) && 
+      (startsWith(rdf->url, resourceID(u))) &&
+	 
+      (s == gCoreVocab->RDF_parent) && (containerp(u))) {
+    readRDFFile( resourceID(u), u, false, rdf);
+    /*    if(newFile) newFile->lastReadTime = PR_Now(); */
+  }
+}
+
+
+
+PRBool
+remoteStoreHasAssertion (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv)
+{
+  Assertion nextAs;
+  if ((s == gNavCenter->RDF_Command) && (type == RDF_RESOURCE_TYPE) && (tv) && (v == gNavCenter->RDF_Command_Refresh))
+  {
+  	return true;
+  }
+  
+  nextAs = u->rarg1;
+  while (nextAs != null) {
+    if (asEqual(mcf, nextAs, u, s, v, type) && (nextAs->tv == tv)) return true;
+    nextAs = nextAs->next;
+  }
+  possiblyAccessFile(mcf, u, s, 0);
+  return false;
+}
+
+
+
+void *
+remoteStoreGetSlotValue (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep,  PRBool tv)
+{
+  Assertion nextAs;
+
+  if ((s == gWebData->RDF_URL) && (tv) && (!inversep) && (type == RDF_STRING_TYPE))
+  {		
+    return copyString(resourceID(u));         
+  }	
+
+  nextAs = (inversep ? u->rarg2 : u->rarg1);
+  while (nextAs != null) {
+    if ((nextAs->db == mcf) && (nextAs->s == s) && (nextAs->tv == tv) && (nextAs->type == type)) {
+      void* ans = (inversep ? nextAs->u : nextAs->value);
+      if (type == RDF_STRING_TYPE) {
+	return copyString((char*)ans); 
+      } else return ans;
+    }
+    nextAs = (inversep ? nextAs->invNext : nextAs->next);
+  }
+  if (s == gCoreVocab->RDF_parent) possiblyAccessFile(mcf, u, s, inversep);
+  return null;
+}
+
+
+
+RDF_Cursor
+remoteStoreGetSlotValuesInt (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv)
+{
+  Assertion as = (inversep ? u->rarg2 : u->rarg1);
+  RDF_Cursor c;
+  if (as == null) {
+    possiblyAccessFile(mcf, u, s, inversep);
+    as = (inversep ? u->rarg2 : u->rarg1);
+    if (as == NULL) return null;
+  }  	
+  c = (RDF_Cursor)getMem(sizeof(struct RDF_CursorStruct));
+  c->u = u;
+  c->s = s;
+  c->type = type;
+  c->inversep = inversep;
+  c->tv = tv;
+  c->count = 0;
+  c->pdata = as;
+  return c;
+}
+
+
+
+RDF_Cursor
+remoteStoreGetSlotValues (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv)
+{
+ 
+  return remoteStoreGetSlotValuesInt(mcf, u, s, type, inversep, tv);
+}
+
+
+
+RDF_Cursor
+remoteStoreArcLabelsIn (RDFT mcf, RDF_Resource u)
+{
+  if (u->rarg2) {
+    RDF_Cursor c = (RDF_Cursor)getMem(sizeof(struct RDF_CursorStruct));
+    c->u = u;
+    c->queryType = RDF_ARC_LABELS_IN_QUERY;
+    c->pdata = u->rarg2;
+    return c;
+  } else return NULL;
+}
+
+
+
+RDF_Cursor
+remoteStoreArcLabelsOut (RDFT mcf, RDF_Resource u)
+{
+  if (u->rarg1) {
+    RDF_Cursor c = (RDF_Cursor)getMem(sizeof(struct RDF_CursorStruct));
+    c->u = u;
+    c->queryType = RDF_ARC_LABELS_OUT_QUERY;
+    c->pdata = u->rarg1;
+    return c;
+  } else return NULL;
+}
+
+
+
+void *
+arcLabelsOutNextValue (RDFT mcf, RDF_Cursor c)
+{
+  while (c->pdata != null) {
+    Assertion as = (Assertion) c->pdata;
+    if ((as->db == mcf) && (as->u == c->u)) {
+      c->value = as->s;
+      c->pdata = as->next;
+      return c->value;
+    }
+    c->pdata = as->next;
+  }  
+  return null;
+}
+
+
+
+void *
+arcLabelsInNextValue (RDFT mcf, RDF_Cursor c)
+{
+  while (c->pdata != null) {
+    Assertion as = (Assertion) c->pdata;
+    if ((as->db == mcf) && (as->value == c->u)) {
+      c->value = as->s;
+      c->pdata = as->invNext;
+      return c->value;
+    }
+    c->pdata = as->invNext;
+  }  
+  return null;
+}
+
+
+
+void *
+remoteStoreNextValue (RDFT mcf, RDF_Cursor c)
+{
+  if (c->queryType == RDF_ARC_LABELS_OUT_QUERY) {
+    return arcLabelsOutNextValue(mcf, c);
+  } else if (c->queryType == RDF_ARC_LABELS_IN_QUERY) {
+    return arcLabelsInNextValue(mcf, c);
+  } else {
+    while (c->pdata != null) {
+      Assertion as = (Assertion) c->pdata;
+      if ((as->db == mcf) && (as->s == c->s) && (as->tv == c->tv) && (c->type == as->type)) {
+        c->value = (c->inversep ? as->u : as->value);
+        c->pdata = (c->inversep ? as->invNext : as->next);
+        return c->value;
+      }
+    c->pdata = (c->inversep ? as->invNext : as->next);
+  }
+  return null;
+  }
+}
+
+
+
+RDF_Error
+remoteStoreDisposeCursor (RDFT mcf, RDF_Cursor c)
+{
+  freeMem(c);
+  return noRDFErr;
+}
+
+
+
+static RDFFile
+leastRecentlyUsedRDFFile (RDF mcf)
+{
+  RDFFile lru = mcf->files;
+  RDFFile f;
+#ifndef HAVE_LONG_LONG
+  int64 result;
+#endif /* !HAVE_LONG_LONG */
+  for (f = mcf->files ; (f != NULL) ; f = f->next) {
+    if (!f->locked) {
+#ifndef HAVE_LONG_LONG
+      LL_SUB(result, lru->lastReadTime, f->lastReadTime);
+      if ((!LL_IS_ZERO(result) && LL_GE_ZERO(result)) && (f->localp == false))
+#else
+	if (((lru->lastReadTime - f->lastReadTime) > 0) && (f->localp == false))
+#endif /* !HAVE_LONG_LONG */
+	  lru = f;
+    }
+  }
+  if (!lru->locked) {
+    return lru;
+  } else return NULL;
+}
+
+
+
+void
+gcRDFFileInt (RDFFile f)
+{
+  int32 n = 0;
+  while (n < f->assertionCount) {
+    Assertion as = *(f->assertionList + n);
+    remoteStoreRemove(f->db, as->u, as->s, as->value, as->type);
+    freeAssertion(as);
+    *(f->assertionList + n) = NULL;
+    n++;
+  }
+  n = 0;
+  while (n < f->resourceCount) {
+    *(f->resourceList + n) = NULL;
+    n++;
+  }
+}
+
+
+
+RDF_Error
+DeleteRemStore (RDFT db)
+{
+  RDFFile f = (RDFFile) db->pdata;
+  RDFFile next;
+  while (f) {
+    next = f->next;
+    gcRDFFileInt(f);
+    freeMem(f->assertionList);
+    freeMem(f->resourceList);	
+    f = next;
+  }
+  freeMem(db);
+  return 0;
+}
+
+
+
+RDF_Error 
+remStoreUpdate (RDFT db, RDF_Resource u)
+{
+  RDFFile f = db->pdata;
+  if (f != NULL) {
+    int32 n = 0;
+    PRBool proceedp = 0;
+    while (n < f->resourceCount) {
+      if (*(f->resourceList + n++) == u) {
+        proceedp = 1;
+        break;
+      }
+    }
+
+    if (proceedp) {
+      RDF_Resource top = f->top;
+      char* url = db->url;
+      PRBool localp = f->localp;    
+      gcRDFFileInt(f);
+      freeMem(f->assertionList);
+      freeMem(f->resourceList);	
+      f->assertionList = NULL;
+      f->resourceList = NULL;
+      initRDFFile(f);
+      f->refreshingp = 1;
+      beginReadingRDFFile(f);
+      return 0;
+    } else return -1;
+  } else return -1;
+}
+    
+
+
+void
+gcRDFFile (RDFFile f)
+{
+  RDFFile f1 = (RDFFile) f->db->pdata;
+
+  if (f->locked) return;
+  
+  if (f == f1) {
+    f->db->pdata = f->next;
+  } else {
+    RDFFile prev = f1;
+    while (f1 != NULL) {
+      if (f1 == f) {
+	prev->next = f->next;
+	break;
+      }
+      prev = f1;
+      f1 = f1->next;
+    }
+  }
+  gcRDFFileInt(f);
+  freeMem(f->assertionList);
+  freeMem(f->resourceList);	
+  
+}
+
+
+
+static PRBool
+freeSomeRDFSpace (RDF mcf)
+{
+  RDFFile lru = leastRecentlyUsedRDFFile (mcf);
+  if (lru== NULL) {
+    return false;
+  } else {
+    gcRDFFile(lru);
+    freeMem(lru);
+    return true;
+  }
+}
+
+
+
+RDFFile
+readRDFFile (char* url, RDF_Resource top, PRBool localp, RDFT db)
+{
+  RDFFile f = makeNewRDFFile(url, top, localp, db);
+  if (!f) return NULL;
+  beginReadingRDFFile(f);
+  return f;
+}
+
+
+
+RDFFile 
+makeNewRDFFile (char* url, RDF_Resource top, PRBool localp, RDFT db)
+{
+  if ((!strstr(url, ":/")) ||
+      (fileReadp(db, url, true))) {
+    return NULL;
+  } else {
+    RDFFile newFile = makeRDFFile(url, top, localp);  
+    if (db->pdata) {  
+      newFile->next = (RDFFile) db->pdata;
+      db->pdata = newFile;
+    } else {
+      db->pdata = (RDFFile) newFile;
+  }
+    newFile->assert = remoteAssert3;
+    newFile->unassert = remoteUnassert3;
+    if (top) {
+      if (resourceType(top) == RDF_RT) {
+        if (strstr(url, ".mcf")) {
+          newFile->fileType = RDF_MCF;
+        } else {
+          newFile->fileType = RDF_XML;
+      }
+      } else {
+        newFile->fileType = resourceType(top);
+      }
+    }
+    newFile->db = db;
+    return newFile;
+  }
+}
+
+
+
+void
+possiblyRefreshRDFFiles ()
+{
+  RDFFile f = (RDFFile)gRemoteStore->pdata;
+  PRTime tm = PR_Now();  
+  while (f != NULL) {
+    if (f->expiryTime != NULL) {
+      PRTime *expiry = f->expiryTime;
+#ifdef HAVE_LONG_LONG
+      if ((tm  - *expiry) > 0) 
+#else
+      int64 result;
+      LL_SUB(result, tm, *expiry);
+      if ((!LL_IS_ZERO(result) && LL_GE_ZERO(result)))
+#endif
+	{
+      gcRDFFile (f);
+      initRDFFile(f);
+      beginReadingRDFFile(f);      
+    } 
+    }
+	f = f->next;
+  }
+}
+
+
+
+void
+SCookPossiblyAccessFile (RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep)
+{
+  /*if ((resourceType(u) == RDF_RT) && (startsWith("rdf:ht", rdf->url)) &&      
+	     (s == gCoreVocab->RDF_parent) && 
+        (containerp(u))) {
+    RDFFile newFile = readRDFFile( resourceID(u), u, false, rdf);
+    if(newFile) newFile->lastReadTime = PR_Now();
+  } */
+}
+
+
+
+RDFT
+NewRemoteStore (char* url)
+{
+	RDFT		ntr;
+
+	if ((ntr = (RDFT)getMem(sizeof(struct RDF_TranslatorStruct))) != NULL)
+	{
+		ntr->getSlotValue = remoteStoreGetSlotValue;
+		ntr->getSlotValues = remoteStoreGetSlotValues;
+		ntr->hasAssertion = remoteStoreHasAssertion;
+		ntr->nextValue = remoteStoreNextValue;
+		ntr->disposeCursor = remoteStoreDisposeCursor;
+		ntr->url = copyString(url);
+		ntr->destroy =  DeleteRemStore;
+		ntr->arcLabelsIn = remoteStoreArcLabelsIn;
+		ntr->arcLabelsOut = remoteStoreArcLabelsOut;
+		ntr->update = remStoreUpdate;
+	}
+	return(ntr);
+}
+
+
+
+RDFT
+MakeSCookDB (char* url)
+{
+  if (startsWith("rdf:scook:", url) || (startsWith("rdf:ht", url))) {
+    RDFT ntr = NewRemoteStore(url);
+    ntr->possiblyAccessFile = SCookPossiblyAccessFile;
+    return ntr;
+  } else return NULL;
+}
+
+
+RDFT
+MakeLocalStore (char* url)
+{
+  char* file = makeRDFDBURL(profileDirURL, "localStore.rdf");
+  RDFT ntr = NewRemoteStore(file);
+  gLocalStore = ntr;
+  ntr->assert = remoteAssert;
+  ntr->unassert = remoteUnassert;
+  return ntr;
+}
+
+
+
+void
+addToRDFTOut (RDFTOut out)
+{
+  int32 len = RDF_STRLEN(out->temp);
+  if (len + out->bufferPos < out->bufferSize) {
+    RDF_STRCAT(out->buffer, out->temp);
+    out->bufferPos = out->bufferPos + len;
+    memset(out->temp, '\0', 1000);
+  } else {
+    PR_Realloc(out->buffer, out->bufferSize + 20000);
+    out->bufferSize = out->bufferSize + 20000;
+    addToRDFTOut (out);
+  }
+}
+
+
+
+PRIntn
+RDFSerializerEnumerator (PLHashEntry *he, PRIntn i, void *arg)
+{
+  RDF_Resource u = (RDF_Resource)he->value;
+  RDFTOut out    = (RDFTOut) arg;
+  Assertion as = u->rarg1;
+  PRBool somethingOutp = 0;
+  while (as) {
+    if (as->db == out->store) {
+      if (!somethingOutp) {
+        somethingOutp = 1;
+        sprintf(out->temp, "<RDF:Description href=\"%s\">\n", resourceID(as->u));
+        addToRDFTOut(out);
+      }
+      if (as->type == RDF_RESOURCE_TYPE) {
+        sprintf(out->temp, "       <%s href=\"%s\"/>\n", resourceID(as->s), 
+                resourceID((RDF_Resource)as->value));    
+      } else if (as->type == RDF_INT_TYPE) {
+        sprintf(out->temp, "       <%s dt=\"int\">%i</%s>\n", resourceID(as->s), 
+                (int)as->value, resourceID(as->s));     
+      } else {  
+        sprintf(out->temp, "       <%s>%s</%s>\n", resourceID(as->s), 
+                (char*)as->value, resourceID(as->s));     
+      }
+      addToRDFTOut(out);
+    }
+    as = as->next;
+  }
+  if (somethingOutp) {
+    sprintf(out->temp, "</RDF:Description>\n\n");
+    addToRDFTOut(out);
+  }
+  return  HT_ENUMERATE_NEXT;    
+}
+
+
+char* 
+RDF_SerializeRDFStore (RDFT store) {
+  RDFTOut out = getMem(sizeof(struct RDFTOutStruct));
+  char* ans = out->buffer = getMem(20000);
+  out->bufferSize = 20000;
+  out->temp = getMem(1000);
+  out->store = store;
+  sprintf(out->temp, "<RDF:RDF>\n\n");
+  addToRDFTOut(out);
+  PL_HashTableEnumerateEntries(resourceHash, RDFSerializerEnumerator, out);
+  sprintf(out->temp, "</RDF:RDF>\n\n");
+  addToRDFTOut(out);
+  freeMem(out->temp);
+  freeMem(out);
+  return ans;
+}
+

rdf/src/remstore.h

@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef	_RDF_REMSTORE_H_
+#define	_RDF_REMSTORE_H_
+
+
+#include "rdf-int.h"
+
+#include "prtime.h"
+
+
+
+/* remstore.c data structures and defines */
+
+struct RDFTOutStruct {
+	char		*buffer;
+	int32		bufferSize;
+	int32		bufferPos;
+	char		*temp;
+	RDFT		store;
+};
+typedef struct RDFTOutStruct	*RDFTOut;
+
+
+
+/* remstore.c function prototypes */
+
+
+
+RDFT		MakeRemoteStore (char* url);
+RDFT		existingRDFFileDB (char* url);
+RDFT		MakeFileDB (char* url);
+void		freeAssertion (Assertion as);
+PRBool		remoteAssert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+PRBool		remoteUnassert3 (RDFFile fi, RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type);
+void		remoteStoreflushChildren(RDFT mcf, RDF_Resource parent);
+Assertion	remoteStoreAdd (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+Assertion	remoteStoreRemove (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type);
+PRBool		fileReadablep (char* id);
+PRBool		remoteStoreHasAssertionInt (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+PRBool		remoteStoreHasAssertion (RDFT mcf, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type, PRBool tv);
+void *		remoteStoreGetSlotValue (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type, PRBool inversep,  PRBool tv);
+RDF_Cursor	remoteStoreGetSlotValuesInt (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv);
+RDF_Cursor	remoteStoreGetSlotValues (RDFT mcf, RDF_Resource u, RDF_Resource s, RDF_ValueType type,  PRBool inversep, PRBool tv);
+RDF_Cursor	remoteStoreArcLabelsIn (RDFT mcf, RDF_Resource u);
+RDF_Cursor	remoteStoreArcLabelsOut (RDFT mcf, RDF_Resource u);
+void *		arcLabelsOutNextValue (RDFT mcf, RDF_Cursor c);
+void *		arcLabelsInNextValue (RDFT mcf, RDF_Cursor c);
+void *		remoteStoreNextValue (RDFT mcf, RDF_Cursor c);
+RDF_Error	remoteStoreDisposeCursor (RDFT mcf, RDF_Cursor c);
+RDF_Error	DeleteRemStore (RDFT db);
+RDF_Error 	remStoreUpdate (RDFT db, RDF_Resource u);
+void		gcRDFFile (RDFFile f);
+void		RDFFilePossiblyAccessFile (RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep);
+void		possiblyRefreshRDFFiles ();
+void		SCookPossiblyAccessFile (RDFT rdf, RDF_Resource u, RDF_Resource s, PRBool inversep);
+RDFT		MakeSCookDB (char* url);
+void		addToRDFTOut (RDFTOut out);
+PRIntn		RDFSerializerEnumerator (PLHashEntry *he, PRIntn i, void *arg);
+RDFFile makeNewRDFFile (char* url, RDF_Resource top, PRBool localp, RDFT db) ;
+static PRBool	fileReadp (RDFT rdf, char* url, PRBool mark);
+static void	possiblyAccessFile (RDFT mcf, RDF_Resource u, RDF_Resource s, PRBool inversep);
+static RDFFile	leastRecentlyUsedRDFFile (RDF mcf);
+static PRBool	freeSomeRDFSpace (RDF mcf);
+RDFFile  reReadRDFFile (char* url, RDF_Resource top, PRBool localp, RDFT db);
+
+
+
+#endif

rdf/src/utils.c

@@ -0,0 +1,798 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/* 
+   This file implements utility routines for the rdf data model.
+   For more information on this file, contact rjc or guha 
+   For more information on RDF, look at the RDF section of www.mozilla.org
+*/
+
+
+#include "utils.h"
+#include "vocabint.h"
+
+
+	/* globals */
+PRBool rdfDBInited = 0;
+PLHashTable*  resourceHash = 0;
+PLHashTable*  dataSourceHash = 0;
+RDFT gRemoteStore = 0;
+RDFT gSessionDB = 0;
+
+	/* externs */
+extern	char	*profileDirURL;
+
+#define INITIAL_RESOURCE_LIST_SIZE 50
+#define INITIAL_ASSERTION_LIST_SIZE 100
+#define GROW_LIST_INCR 50
+
+
+
+int
+compareStrings(char *s1, char *s2)
+{
+   return RDF_STRCASECMP(s1, s2);
+}
+
+
+char *
+makeRDFDBURL(char* directory, char* name)
+{
+  char		*ans;
+  size_t		s;
+  
+  if (profileDirURL == NULL) return NULL;
+  if ((ans = (char*) getMem(RDF_STRLEN(profileDirURL) + strlen(directory) + strlen(name) + 3)) != NULL) {
+    s = RDF_STRLEN(profileDirURL);
+    memcpy(ans, profileDirURL, s);
+    if (ans[s-1] != '/') {
+      ans[s++] = '/';
+    }
+    stringAppend(ans, directory);
+    stringAppend(ans, "/");
+    stringAppend(ans, name);
+  }
+  return(ans);
+}
+
+
+RDF_Resource
+getMCFFrtop (char* furl)
+{
+  char* url = getBaseURL(furl);
+  RDF_Resource r;
+  r = RDF_GetResource(NULL, url, 1);
+  freeMem(url);
+  return r;
+}
+
+char*
+copyString (const char* url) {
+  int32 len = RDF_STRLEN(url);
+  char* newStr = (char*)getMem(len+1);
+  if (newStr != NULL) {
+    memcpy(newStr, url, len);
+  } 
+  return newStr;
+}
+
+
+
+RDFFile
+makeRDFFile (char* url, RDF_Resource top, PRBool localp)
+{
+  RDFFile ans = (RDFFile)getMem(sizeof(struct RDF_FileStruct));
+  /*  ans->rdf = rdf; */
+  ans->url = getBaseURL(url);
+  ans->top = top;
+  ans->localp = localp;
+  if (!localp)  ans->refreshingp = PR_TRUE;
+  initRDFFile(ans);
+  return ans;
+}
+
+
+
+void
+initRDFFile (RDFFile ans)
+{
+  char* url = ans->url;
+  ans->rtop = getMCFFrtop(url);
+  ans->line = (char*)getMem(RDF_BUF_SIZE);
+  ans->currentSlot = (char*)getMem(100);
+  ans->resourceList = (RDF_Resource*)getMem(INITIAL_RESOURCE_LIST_SIZE * sizeof(RDF_Resource));
+  ans->assertionList = (Assertion*)getMem(INITIAL_ASSERTION_LIST_SIZE * sizeof(Assertion));
+  ans->resourceListSize = INITIAL_RESOURCE_LIST_SIZE;
+  ans->assertionListSize = INITIAL_ASSERTION_LIST_SIZE;
+  ans->holdOver = (char*)getMem(RDF_BUF_SIZE);
+  ans->depth = 1;
+  ans->lastItem = ans->stack[0] = ans->top;
+  ans->locked = ans->localp;
+  ans->lineSize = LINE_SIZE;
+  ans->tv = true;
+  ans->resourceCount = 0;
+  ans->assertionCount = 0;
+}
+
+
+void
+addToResourceList (RDFFile f, RDF_Resource u)
+{
+  if (f->resourceListSize == f->resourceCount) {
+    RDF_Resource* newResourceList = (RDF_Resource*)getMem(sizeof(RDF_Resource)*(f->resourceListSize + GROW_LIST_INCR));
+    RDF_Resource* old = f->resourceList;
+    memcpy((char*)newResourceList, (char*)f->resourceList, sizeof(RDF_Resource)*f->resourceListSize);
+    f->resourceList = newResourceList;
+    f->resourceListSize = f->resourceListSize + GROW_LIST_INCR;
+    freeMem(old);
+  }
+  *(f->resourceList + f->resourceCount++) = u;
+}
+
+
+
+void
+addToAssertionList (RDFFile f, Assertion as)
+{
+  if (f->assertionListSize == f->assertionCount) {
+    Assertion* newAssertionList = (Assertion*)getMem(sizeof(RDF_Resource)*(f->assertionListSize + GROW_LIST_INCR));
+    Assertion* old = f->assertionList;
+    memcpy((char*)newAssertionList, (char*)f->assertionList, sizeof(RDF_Resource)*f->assertionListSize);
+    f->assertionList = newAssertionList;
+    f->assertionListSize = f->assertionListSize + GROW_LIST_INCR;
+    freeMem(old);
+  }
+  *(f->assertionList + f->assertionCount++) = as;
+}
+
+
+
+void
+removeFromAssertionList(RDFFile f, Assertion as)
+{
+	/* XXX implement */
+}
+
+
+
+void
+ht_fprintf(PRFileDesc *file, const char *fmt, ...) 
+{
+    va_list ap;
+    char *buf;
+    va_start(ap, fmt);
+    buf = PR_smprintf(fmt, ap);
+    va_end(ap);
+    if(buf) {
+      	PR_Write(file, buf, RDF_STRLEN(buf));
+	free(buf);
+    }
+}
+
+
+
+void
+ht_rjcprintf(PRFileDesc *file, const char *fmt, const char *data)
+{
+	char	*buf;
+
+	buf = PR_smprintf(fmt, data);
+	if(buf) {
+		PR_Write(file, buf, RDF_STRLEN(buf));
+		free(buf);
+	}
+}
+
+
+char *
+makeDBURL(char* name)
+{
+  char		*ans;
+  size_t		s;
+  
+  if (profileDirURL == NULL) return NULL;
+  if ((ans = (char*) getMem(RDF_STRLEN(profileDirURL) + strlen(name) + 3)) != NULL) {
+    s = RDF_STRLEN(profileDirURL);
+    memcpy(ans, profileDirURL, s);
+    if (ans[s-1] != '/') {
+      ans[s++] = '/';
+    }
+    memcpy(&ans[s], name, RDF_STRLEN(name));
+    
+#ifdef	XP_WIN
+    if (ans[9] == '|') ans[9] = ':';
+#endif
+  }
+  return(ans);
+}
+
+
+PLHashNumber
+idenHash (const void *key)
+{
+	return (PLHashNumber)key;
+}
+
+
+
+int
+idenEqual (const void *v1, const void *v2)
+{
+	return (v1 == v2);
+}
+
+
+
+PRBool
+inverseTV (PRBool tv)
+{
+  if (tv == true) {
+    return false;
+  } else return true;
+}
+
+
+
+char *
+append2Strings (const char* str1, const char* str2)
+{
+  int32 l1 = RDF_STRLEN(str1);
+  int32 len = l1 + RDF_STRLEN(str2);
+  char* ans = (char*) getMem(len+1);
+  memcpy(ans, str1, l1);
+  memcpy(&ans[l1], str2, len-l1);
+  return ans;
+}
+
+
+
+void
+stringAppendBase (char* dest, const char* addition)
+{
+  int32 l1 = RDF_STRLEN(dest);
+  int32 l2 = RDF_STRLEN(addition);
+  int32 l3 = charSearch('#', addition);
+  if (l3 != -1) l2 = l3;
+  memcpy(&dest[l1], addition, l2);
+}
+
+
+
+void
+stringAppend (char* dest, const char* addition)
+{
+  int32 l1 = RDF_STRLEN(dest);
+  int32 l2 = RDF_STRLEN(addition);
+  memcpy(&dest[l1], addition, l2);
+}
+
+
+
+int16
+charSearch (const char c, const char* data)
+{
+  char* ch = RDF_STRCHR(data, c);
+
+  if (ch) {
+    return (ch - data);
+  } else {
+    return -1;
+  }
+ 
+}
+
+
+
+PRBool
+endsWith (const char* pattern, const char* uuid)
+{
+  short l1 = RDF_STRLEN(pattern);
+  short l2 = RDF_STRLEN(uuid);
+  short index;
+  
+  if (l2 < l1) return false;
+  
+  for (index = 1; index <= l1; index++) {
+    if (toupper(pattern[l1-index]) != toupper(uuid[l2-index])) return false;
+  }
+  
+  return true;
+}
+
+
+
+PR_PUBLIC_API(PRBool)
+startsWith (const char* pattern, const char* uuid)
+{
+  short l1 = RDF_STRLEN(pattern);
+  short l2 = RDF_STRLEN(uuid);
+  if (l2 < l1) return false;
+  return (RDF_STRNCASECMP(pattern, uuid, l1)  == 0);
+}
+
+
+
+PRBool
+substring (const char* pattern, const char* data)
+{
+  char *p = RDF_STRCASESTR(data, pattern);
+  return p != NULL;
+}
+
+
+
+int16
+revCharSearch (const char c, const char* data)
+{
+  char *p = RDF_STRRCHR(data, c);
+  return p ? p-data : -1;
+}
+
+
+
+PRBool
+urlEquals (const char* url1, const char* url2)
+{
+  int16 n1 = charSearch('#', url1);
+  int16 n2 = charSearch('#',  url2);
+  if ((n1 == -1) && (n2 == -1)) {    
+    return (RDF_STRCMP(url1, url2) == 0);
+  } else if ((n2 == -1) && (n1 > 0)) {
+    return ((RDF_STRLEN(url2) == (size_t)(n1)) && (strncmp(url1, url2, n1) == 0));
+  } else if ((n1 == -1) && (size_t) (n2 > 0)) {
+    return ((RDF_STRLEN(url1) == (size_t)(n2)) && (strncmp(url1, url2, n2) == 0));
+  } else return 0;
+}
+
+
+
+PRBool
+isSeparator (RDF_Resource r)
+{
+  return (startsWith("separator", resourceID(r)) || startsWith("nc:separator", resourceID(r))) ;
+}
+
+
+
+char *
+getBaseURL (const char* url)
+{
+  int n = charSearch('#' , url);
+  char* ans;
+  if (n == -1) return copyString(url);
+  if (n == 0) return NULL;
+  ans = getMem(n+1);
+  memcpy(ans, url, n);
+  return ans;
+}
+
+
+
+void
+setContainerp (RDF_Resource r, PRBool val)
+{
+  if (val) {
+    r->flags |= CONTAINER_FLAG;
+  } else {
+    r->flags &= (~CONTAINER_FLAG);
+  }
+}
+
+
+
+PRBool
+containerp (RDF_Resource r)
+{
+  return (r->flags & CONTAINER_FLAG);
+}
+
+
+
+void
+setLockedp (RDF_Resource r, PRBool val)
+{
+  if (val) {
+    r->flags |= LOCKED_FLAG;
+  } else {
+    r->flags &= (~LOCKED_FLAG);
+  }
+}
+
+
+
+PRBool
+lockedp (RDF_Resource r)
+{
+  return (r->flags & LOCKED_FLAG);
+}
+
+
+
+uint8
+resourceType (RDF_Resource r)
+{
+ return r->type;
+}
+
+
+
+void
+setResourceType (RDF_Resource r, uint8 val)
+{
+  r->type = val;
+}
+
+
+
+char *
+resourceID(RDF_Resource r)
+{
+  return r->url;
+ }
+
+char* opTypeToString (RDF_EventType opType) {
+  switch (opType) {
+    case RDF_ASSERT_NOTIFY :
+      return "Assert";
+	case RDF_INSERT_NOTIFY :
+      return "Insert";
+	case RDF_DELETE_NOTIFY :
+      return "Unassert";
+  }
+  return "Unknown Op";
+}
+
+
+void traceNotify (char* event, RDF_Resource u, RDF_Resource s, void* v, RDF_ValueType type) {
+#ifdef DEBUG_guha1    
+      char* traceLine = getMem(1000);
+      if (type == RDF_INT_TYPE) {
+        sprintf(traceLine, "%s  %s(%s, %i)\n", 
+              event, resourceID(s), resourceID(u), (int) v);
+      } else if (type == RDF_STRING_TYPE){
+        sprintf(traceLine, "%s %s(%s, \"%s\")\n", 
+                event,  resourceID(s), resourceID(u), (char*) v);
+      } else if (type == RDF_RESOURCE_TYPE) {
+        sprintf(traceLine, "%s %s(%s, %s)\n", 
+                event,  resourceID(s), resourceID(u), resourceID((RDF_Resource)v));
+      } else {
+        sprintf(traceLine, "%s <gubbish>\n", event);
+      }
+      FE_Trace(traceLine);
+      freeMem(traceLine);    
+#endif
+}
+
+
+char *
+makeResourceName (RDF_Resource node)
+{
+	char		*name = NULL;
+
+	name =  resourceID(node);
+	if (startsWith("http:", resourceID(node)))
+	{
+      name = &name[7];
+	}
+	else if (startsWith("file:", resourceID(node)))
+	{
+      name = &name[FS_URL_OFFSET];
+	}
+	else
+	{
+      name = resourceID(node);
+
+	}
+	return ((name != NULL) ? copyString(name) : NULL);
+}
+
+
+
+PR_PUBLIC_API(char *)
+RDF_GetResourceName(RDF rdf, RDF_Resource node)
+{
+  char* name = RDF_GetSlotValue(rdf, node, gCoreVocab->RDF_name, RDF_STRING_TYPE, false, true);
+  if (name != NULL) return name;
+  name = makeResourceName(node);
+  return name;
+}
+
+
+#ifdef MOZILLA_CLIENT
+PR_PUBLIC_API(RDF_Resource)
+RDFUtil_GetFirstInstance (RDF_Resource type, char* defaultURL)
+{
+
+  RDF_Resource bmk = remoteStoreGetSlotValue(gLocalStore, type,
+					     gCoreVocab->RDF_instanceOf,
+					     RDF_RESOURCE_TYPE, true, true);
+  if (bmk == NULL) {
+    /* bmk = RDF_GetResource(NULL, defaultURL, 1); */
+    bmk = createContainer(defaultURL);
+    remoteAssert(gLocalStore, bmk, gCoreVocab->RDF_instanceOf, 
+		      type, RDF_RESOURCE_TYPE, 1);
+  }
+  return bmk;
+}
+
+
+PR_PUBLIC_API(void)
+RDFUtil_SetFirstInstance (RDF_Resource type, RDF_Resource item)
+{
+  RDF_Resource bmk = remoteStoreGetSlotValue(gLocalStore, type,
+					     gCoreVocab->RDF_instanceOf,
+					     RDF_RESOURCE_TYPE, true, true);
+  if (bmk) {
+    remoteUnassert(gLocalStore, bmk,  gCoreVocab->RDF_instanceOf, 
+			type,	 RDF_RESOURCE_TYPE);
+  }
+  if (item) {
+    remoteAssert(gLocalStore, item, gCoreVocab->RDF_instanceOf, 
+			type, RDF_RESOURCE_TYPE, true);
+  }
+}
+
+
+
+PR_PUBLIC_API(RDF_Resource)
+RDFUtil_GetQuickFileFolder()
+{
+  return RDFUtil_GetFirstInstance(gNavCenter->RDF_BookmarkFolderCategory, "NC:Bookmarks");
+}
+
+
+
+PR_PUBLIC_API(void)
+RDFUtil_SetQuickFileFolder(RDF_Resource container)
+{
+  RDFUtil_SetFirstInstance(gNavCenter->RDF_BookmarkFolderCategory, container);
+}
+
+
+RDF_Resource gPTFolder = NULL;
+PR_PUBLIC_API(RDF_Resource)
+RDFUtil_GetPTFolder()
+{
+  if (gPTFolder) return gPTFolder;
+ return (gPTFolder =  RDFUtil_GetFirstInstance(gNavCenter->RDF_PersonalToolbarFolderCategory, "PersonalToolbar"));
+}
+
+
+
+PR_PUBLIC_API(void)
+RDFUtil_SetPTFolder(RDF_Resource container)
+{
+  /*
+  RDFUtil_SetFirstInstance( gNavCenter->RDF_PersonalToolbarFolderCategory, container);
+  */
+}
+
+
+
+PR_PUBLIC_API(RDF_Resource)
+RDFUtil_GetNewBookmarkFolder()
+{
+  return RDFUtil_GetFirstInstance(gNavCenter->RDF_NewBookmarkFolderCategory, "NC:Bookmarks");
+}
+
+
+
+PR_PUBLIC_API(void)
+RDFUtil_SetNewBookmarkFolder(RDF_Resource container)
+{
+  RDFUtil_SetFirstInstance(gNavCenter->RDF_NewBookmarkFolderCategory, container);
+}
+
+
+
+PR_PUBLIC_API(RDF_Resource)
+RDFUtil_GetDefaultSelectedView()
+{
+  return RDFUtil_GetFirstInstance(gNavCenter->RDF_DefaultSelectedView, "selectedView");
+}
+
+
+
+PR_PUBLIC_API(void)
+RDFUtil_SetDefaultSelectedView(RDF_Resource container)
+{
+  RDFUtil_SetFirstInstance(gNavCenter->RDF_DefaultSelectedView, container);
+}
+
+
+
+
+
+/* Returns a new string with inURL unescaped. */
+/* We return a new string because NET_UnEscape unescapes */
+/* string in place */
+char *
+unescapeURL(char *inURL)
+{
+	char *escapedPath = copyString(inURL);
+
+#ifdef MOZILLA_CLIENT
+#ifdef XP_WIN
+	replacePipeWithColon(escapedPath);
+#endif
+
+    /* xxx	NET_UnEscape(escapedPath); */
+#endif
+
+	return (escapedPath);
+}
+
+
+
+/* Given a file URL of form "file:///", return substring */
+/* that can be used as a path for PR_Open. */
+/* NOTE: This routine DOESN'T allocate a new string */
+
+
+char *
+convertFileURLToNSPRCopaceticPath(char* inURL)
+{
+#ifdef	XP_WIN
+	if (startsWith("file://", inURL))	return (inURL + 8);
+	else if (startsWith("mailbox:/", inURL))	return (inURL + 9);
+	else if (startsWith("IMAP:/", inURL))	return (inURL + 6);
+	else return (inURL);
+#else
+	/* For Mac & Unix, need preceeding '/' so that NSPR */
+	/* interprets path as full path */
+	if (startsWith("file://", inURL))	return (inURL + 7);
+	else if (startsWith("mailbox:/", inURL))	return (inURL + 8);
+	else if (startsWith("IMAP:/", inURL))	return (inURL + 5);
+	else return (inURL);
+#endif
+}
+
+char* MCDepFileURL (char* url) {
+	char* furl;  
+	int32 len;   
+	char* baz = "\\";
+	int32 n = 0; 
+	furl = convertFileURLToNSPRCopaceticPath(unescapeURL(url));
+	len = RDF_STRLEN(furl);
+#ifdef XP_WIN
+	while (n < len) {
+		if (furl[n] == '/') furl[n] = baz[0];
+		n++;
+	}
+#endif
+	return furl;
+}
+
+PRFileDesc *
+CallPROpenUsingFileURL(char *fileURL, PRIntn flags, PRIntn mode)
+{
+	PRFileDesc* result = NULL;
+	const char *path;
+
+	char *escapedPath = unescapeURL(fileURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_Open(path, flags, mode);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+PRDir *
+CallPROpenDirUsingFileURL(char *fileURL)
+{
+	PRDir* result = NULL;
+	const char *path;
+	char *escapedPath = unescapeURL(fileURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_OpenDir(path);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+int32
+CallPRWriteAccessFileUsingFileURL(char *fileURL)
+{
+	int32 result = -1;
+	const char *path;
+	char *escapedPath = unescapeURL(fileURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_Access(path, PR_ACCESS_WRITE_OK);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+int32
+CallPRDeleteFileUsingFileURL(char *fileURL)
+{
+	int32 result = -1;
+	const char *path;
+	char *escapedPath = unescapeURL(fileURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_Delete(path);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+int
+CallPR_RmDirUsingFileURL(char *dirURL)
+{
+	int32 result=-1;
+	const char *path;
+
+	char *escapedPath = unescapeURL(dirURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_RmDir(path);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+int32
+CallPRMkDirUsingFileURL(char *dirURL, int mode)
+{
+	int32 result=-1;
+	const char *path;
+
+	char *escapedPath = unescapeURL(dirURL);
+	path = convertFileURLToNSPRCopaceticPath(escapedPath);
+
+	if (path != NULL)	{
+		result = PR_MkDir(path,mode);
+	}
+
+	if (escapedPath != NULL)	freeMem(escapedPath);
+
+	return result;
+}
+
+
+
+#endif /* MOZILLA_CLIENT */