summaryrefslogtreecommitdiff
path: root/win32/sablot/include
diff options
context:
space:
mode:
authorStef <stef@ws.local>2004-06-29 22:51:34 +0000
committerStef <stef@ws.local>2004-06-29 22:51:34 +0000
commit256f6e5222d11be55c06a91a4db360bac0e3a6d6 (patch)
tree5ebbcee77572f15f4df220ccce95950029c929fc /win32/sablot/include
parent9786ecb6d1dcf21b332c407810d894c3f57dd90b (diff)
Updated to new sablot library
Diffstat (limited to 'win32/sablot/include')
-rw-r--r--win32/sablot/include/sabdbg.h58
-rw-r--r--win32/sablot/include/sablot.h594
-rw-r--r--win32/sablot/include/sablot.libbin28044 -> 0 bytes
-rw-r--r--win32/sablot/include/sdom.h957
-rw-r--r--win32/sablot/include/shandler.h371
-rw-r--r--win32/sablot/include/sxpath.h400
6 files changed, 2369 insertions, 11 deletions
diff --git a/win32/sablot/include/sabdbg.h b/win32/sablot/include/sabdbg.h
index 1428af6..3c97944 100644
--- a/win32/sablot/include/sabdbg.h
+++ b/win32/sablot/include/sabdbg.h
@@ -1,58 +1,116 @@
/*
+
* The contents of this file are subject to the Mozilla Public
+
* License Version 1.1 (the "License"); you may not use this file
+
* except in compliance with the License. You may obtain a copy of
+
* the License at http://www.mozilla.org/MPL/
+
*
+
* Software distributed under the License is distributed on an "AS
+
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+
* implied. See the License for the specific language governing
+
* rights and limitations under the License.
+
*
+
* The Original Code is the Sablotron XSLT Processor.
+
*
+
* The Initial Developer of the Original Code is Ginger Alliance Ltd.
+
* Portions created by Ginger Alliance are Copyright (C) 2000-2002
+
* Ginger Alliance Ltd. All Rights Reserved.
+
*
+
* Contributor(s):
+
*
+
* Alternatively, the contents of this file may be used under the
+
* terms of the GNU General Public License Version 2 or later (the
+
* "GPL"), in which case the provisions of the GPL are applicable
+
* instead of those above. If you wish to allow use of your
+
* version of this file only under the terms of the GPL and not to
+
* allow others to use your version of this file under the MPL,
+
* indicate your decision by deleting the provisions above and
+
* replace them with the notice and other provisions required by
+
* the GPL. If you do not delete the provisions above, a recipient
+
* may use your version of this file under either the MPL or the
+
* GPL.
+
*/
+
+
#ifndef SabdbgHIncl
+
#define SabdbgHIncl
+
+
#define SablotAsExport
+
#include <sablot.h>
+
+
/************************************************************/
+
/* DEBUGGER stuff */
+
/************************************************************/
+
+
Declare
+
(
+
void debuggerInit();
+
)
+
+
Declare
+
(
+
void debuggerDone();
+
)
+
+
Declare
+
(
+
void debuggerEnterIdle();
+
)
+
+
#endif
+
diff --git a/win32/sablot/include/sablot.h b/win32/sablot/include/sablot.h
index 71b05a2..0d63579 100644
--- a/win32/sablot/include/sablot.h
+++ b/win32/sablot/include/sablot.h
@@ -1,560 +1,1134 @@
/*
+
* The contents of this file are subject to the Mozilla Public
+
* License Version 1.1 (the "License"); you may not use this file
+
* except in compliance with the License. You may obtain a copy of
+
* the License at http://www.mozilla.org/MPL/
+
*
+
* Software distributed under the License is distributed on an "AS
+
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+
* implied. See the License for the specific language governing
+
* rights and limitations under the License.
+
*
+
* The Original Code is the Sablotron XSLT Processor.
+
*
+
* The Initial Developer of the Original Code is Ginger Alliance Ltd.
- * Portions created by Ginger Alliance are Copyright (C) 2000-2002
+
+ * Portions created by Ginger Alliance are Copyright (C) 2000-2003
+
* Ginger Alliance Ltd. All Rights Reserved.
+
*
+
* Contributor(s):
+
*
+
* Alternatively, the contents of this file may be used under the
+
* terms of the GNU General Public License Version 2 or later (the
+
* "GPL"), in which case the provisions of the GPL are applicable
+
* instead of those above. If you wish to allow use of your
+
* version of this file only under the terms of the GPL and not to
+
* allow others to use your version of this file under the MPL,
+
* indicate your decision by deleting the provisions above and
+
* replace them with the notice and other provisions required by
+
* the GPL. If you do not delete the provisions above, a recipient
+
* may use your version of this file under either the MPL or the
+
* GPL.
+
*/
+
+
/*
+
sablot.h
+
TK Dec 14, 99
+
header file for Sablot.cpp
+
*/
+
+
#ifndef SablotHIncl
+
#define SablotHIncl
+
+
+
/* version info */
-#define SAB_VERSION "0.96"
-#define SAB_DATE "Sep 5, 2002"
+
+#define SAB_VERSION "1.0.1"
+
+#define SAB_DATE "November 24, 2003"
+
+
/* common types */
+
typedef void *SablotHandle;
+
typedef void *SDOM_Document;
+
typedef void *SablotSituation;
-#if defined(WIN32) && defined(_MSC_VER)
+
+
+#if defined(WIN32) && defined(_MSC_VER) && !defined(SABLOT_STATIC)
+
#if defined(SablotAsExport)
+
#define DllImpExp __declspec( dllexport )
+
#else
+
#define DllImpExp __declspec( dllimport )
+
#endif /* SablotAsExport */
+
#else /* WIN32 && _MSC_VER */
+
#define DllImpExp extern
+
#endif
+
+
#ifdef __cplusplus
+
#define DeclBegin extern "C" { DllImpExp
+
#define DeclEnd }
+
#else
+
#define DeclBegin DllImpExp
+
#define DeclEnd
+
#endif
+
+
#define Declare(STATEMENT) DeclBegin STATEMENT DeclEnd
+
+
#include "shandler.h"
+
#include "sxpath.h"
+
+
typedef enum
+
{
- SAB_NO_ERROR_REPORTING = 0x1,
- SAB_PARSE_PUBLIC_ENTITIES = 0x2,
- SAB_DISABLE_ADDING_META = 0x4,
- SAB_DISABLE_STRIPPING = 0x8,
- SAB_IGNORE_DOC_NOT_FOUND =0x10
+
+ SAB_NO_ERROR_REPORTING = 0x1,
+
+ SAB_PARSE_PUBLIC_ENTITIES = 0x2,
+
+ SAB_DISABLE_ADDING_META = 0x4,
+
+ SAB_DISABLE_STRIPPING = 0x8,
+
+ SAB_IGNORE_DOC_NOT_FOUND = 0x10,
+
+ SAB_FILES_TO_HANDLER = 0x20,
+
+ SAB_DUMP_SHEET_STRUCTURE = 0x40,
+
+ SAB_NO_EXTERNAL_ENTITIES = 0x80
+
} SablotFlag;
+
+
/* create a new document */
+
+
Declare
+
(
+
int SablotCreateDocument(
+
SablotSituation S,
+
SDOM_Document *D);
+
)
+
+
/* parse in a document from the given URI */
+
+
Declare
+
(
+
int SablotParse(
+
SablotSituation S,
+
const char *uri,
+
SDOM_Document *D);
+
)
+
+
/* parse a document given in an in-memory buffer */
+
+
Declare
+
(
+
int SablotParseBuffer(
+
SablotSituation S,
+
const char *buffer,
+
SDOM_Document *D);
+
)
+
+
Declare
+
(
+
int SablotParseStylesheet(
+
SablotSituation S,
+
const char *uri,
+
SDOM_Document *D);
+
)
+
+
+
Declare
+
(
+
int SablotParseStylesheetBuffer(
+
SablotSituation S,
+
const char *buffer,
+
SDOM_Document *D);
+
)
+
+
+
/* lock document before using it */
+
+
Declare
+
(
+
int SablotLockDocument(
+
SablotSituation S,
+
SDOM_Document D);
+
)
+
+
Declare
+
(
+
int SablotDestroyDocument(
+
SablotSituation S,
+
SDOM_Document D);
+
)
+
+
Declare
+
(
+
int SablotAddParam(
+
SablotSituation S,
+
void *processor_,
+
const char *paramName,
+
const char *paramValue);
+
)
+
+
Declare
+
(
+
int SablotAddArgBuffer(
+
SablotSituation S,
+
void *processor_,
+
const char *argName,
+
const char *bufferValue);
+
)
+
+
Declare(
+
int SablotAddArgTree(
+
SablotSituation S,
+
void *processor_,
+
const char *argName,
+
SDOM_Document tree);
+
)
+
+
Declare
+
(
+
int SablotRunProcessorGen(
+
SablotSituation S,
+
void *processor_,
+
const char *sheetURI,
+
const char *inputURI,
+
const char *resultURI);
+
)
+
+
Declare
+
(
+
int SablotRunProcessorExt(
+
SablotSituation S,
+
void *processor_,
+
const char *sheetURI,
+
const char *resultURI,
+
NodeHandle doc);
+
)
+
+
/*
+
* Situation functions
+
*/
+
+
/* Creates a new situation. */
+
+
Declare
+
(
+
int SablotCreateSituation(SablotSituation *sPtr);
+
)
+
+
/* Sets situation flags. */
+
+
Declare
+
(
+
int SablotSetOptions(SablotSituation S, int flags);
+
)
+
+
Declare
+
(
+
+ int SablotGetOptions(SablotSituation S);
+
+)
+
+
+
+Declare
+
+(
+
int SablotClearSituation(SablotSituation S);
+
)
+
+
Declare
+
(
+
const char* SablotGetErrorURI(SablotSituation S);
+
)
+
+
Declare
+
(
+
int SablotGetErrorLine(SablotSituation S);
+
)
+
+
Declare
+
(
+
const char* SablotGetErrorMsg(SablotSituation S);
+
)
+
+
/* Disposes of the situation. */
+
+
Declare
+
(
+
int SablotDestroySituation(SablotSituation S);
+
)
+
+
+
/*****************************************************************
+
SablotCreateProcessor
+
creates a new instance of the processor
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotCreateProcessor(SablotHandle *processorPtr);
+
)
+
+
/*****************************************************************
+
SablotCreateProcessorForSituation
+
use this instead of SablotCreateProcessor with any of the
+
situation-aware functions like SablotRunProcessorGen,
+
SablotAddArgTree etc.
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotCreateProcessorForSituation(SablotSituation S, void **processorPtr);
+
)
+
+
+
/*****************************************************************
+
SablotDestroyProcessor
+
destroys the processor
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotDestroyProcessor(SablotHandle processor_);
+
)
+
+
/*****************************************************************
+
SablotRunProcessor
+
runs the existing instance on the given documents
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotRunProcessor(SablotHandle processor_,
+
const char *sheetURI,
+
const char *inputURI,
+
const char *resultURI,
+
const char **params,
+
const char **arguments);
+
)
+
+
/*****************************************************************
+
SablotGetResultArg
+
gets the result arg buffer from the last Sablot run
+
the buffer is identified by an URI (to enable output to
+
multiple documents)
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotGetResultArg(SablotHandle processor_,
+
const char *argURI,
+
char **argValue);
+
)
+
+
/*****************************************************************
+
SablotFreeResultArgs
+
kill all result arg buffers from the last Sablot run
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotFreeResultArgs(SablotHandle processor_);
+
)
+
+
/*****************************************************************
+
SablotRegHandler
+
General handler registrator.
+
type the type of the handler (scheme etc.)
+
handler pointer to the struct of callbacks of the given type
+
userData the user data this handler wishes to receive
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotRegHandler(
+
SablotHandle processor_,
+
HandlerType type, /* HLR_MESSAGE, HLR_SCHEME, HLR_SAX */
+
void *handler,
+
void *userData);
+
)
+
+
/*****************************************************************
+
SablotUnregHandler
+
+
General handler unregistrator.
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotUnregHandler(
+
SablotHandle processor_,
+
HandlerType type, /* HLR_MESSAGE, HLR_SCHEME, HLR_SAX */
+
void *handler,
+
void *userData);
+
)
+
+
/*****************************************************************
+
SablotSetBase
+
+
overrides the default base URI for relative reference
+
resolution.
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotSetBase(
+
SablotHandle processor_,
+
const char *theBase);
+
)
+
+
/*****************************************************************
+
SablotSetBaseForScheme
+
+
a softer form of SablotSetBase: the hard base URI will only
+
be in effect for relative references whose bases have
+
the given scheme.
+
+
Example: assume we call
+
SablotSetBaseForScheme( P, "arg", "http://server" )
+
and then runs a stylesheet at "arg:/xxx" which contains "document('foo.xml')".
+
The relative reference is resolved as "http://server/foo.xml"
+
but if the stylesheet were at "file:/xxx" it would become "file:/foo.xml".
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotSetBaseForScheme(void* processor_,
+
const char *scheme,
+
const char *base);
+
)
+
+
/****************************************************************
+
SablotSetLog
+
+
sets the logging options. Logging is off by default.
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotSetLog(
+
SablotHandle processor_,
+
const char *logFilename,
+
int logLevel);
+
)
+
+
+
/*****************************************************************
+
SablotProcess
+
+
the main function published by Sablotron. Feeds given XML
+
input to a stylesheet. Both of these as well as the location for
+
output are identified by a URI. One can also pass top-level
+
stylesheet parameters and named buffers ('args').
+
ARGS
+
sheetURI URI of the XSLT stylesheet
+
inputURI URI of the XML document
+
resultURI URI of the output document
+
params a NULL-terminated array of char*'s defining the top-level
+
parameters to be passed, interpreted as a
+
sequence of (name, value) pairs.
+
arguments a NULL-terminated array of char*'s defining the named
+
buffers to be passed, interpreted as a
+
sequence of (name, value) pairs. Both params and arguments
+
may be NULL.
+
RETURNS
+
. nonzero iff error
+
resultArg in case output goes to a named buffer, *resultArg is set to
+
point to it (otherwise to NULL). Free it using SablotFree().
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotProcess(
+
const char *sheetURI, const char *inputURI, const char *resultURI,
+
const char **params, const char **arguments, char **resultArg);
+
)
+
+
/*****************************************************************
+
SablotProcessFiles
+
+
calls SablotProcess to process files identified by their
+
file names. No named buffers or params are passed. Included
+
for backward compatibility.
+
ARGUMENTS
+
styleSheetName, inputName, resultName
+
file names of the stylesheet, XML input and output,
+
respectively.
+
RETURNS
+
. error flag
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotProcessFiles(
+
const char *styleSheetName,
+
const char *inputName,
+
const char *resultName);
+
)
+
+
/*****************************************************************
+
SablotProcessStrings
+
+
calls SablotProcess to process documents in memory, passing
+
pointers to the documents. No named buffers or params are passed.
+
Included for backward compatibility.
+
ARGUMENTS
+
styleSheetStr, inputStr
+
text of the stylesheet and the XML input
+
RETURNS
+
. error flag
+
*resultStr pointer to the newly allocated block containing
+
the result
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotProcessStrings(
+
const char *styleSheetStr,
+
const char *inputStr,
+
char **resultStr);
+
)
+
+
/*****************************************************************
+
SablotProcessStringsWithBase
+
+
Like SablotProcessStrings but lets you pass an URI that replaces
+
the stylesheet's URI in relative address resolution.
+
+
ARGUMENTS
+
styleSheetStr, inputStr
+
text of the stylesheet and the XML input
+
theHardBase the "hard base URI" replacing the stylesheet's URI
+
in all relevant situations
+
RETURNS
+
. error flag
+
*resultStr pointer to the newly allocated block containing
+
the result
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotProcessStringsWithBase(
+
const char *styleSheetStr,
+
const char *inputStr,
+
char **resultStr,
+
const char *theHardBase);
+
)
+
+
/*****************************************************************
+
SablotFree
+
+
Frees the Sablotron-allocated buffer. The user cannot free it
+
directly by free().
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotFree(char *resultStr);
+
)
+
+
/*****************************************************************
+
SablotClearError
+
+
Clears the pending error for the given instance of Sablot.
+
*****************************************************************/
+
+
Declare
+
(
+
int SablotClearError(SablotHandle processor_);
+
)
+
+
/*****************************************************************
+
SablotGetMsgText
+
+
Returns the text of a message with the given code.
+
*****************************************************************/
+
+
Declare
+
(
+
const char* SablotGetMsgText(int code);
+
)
+
+
/*****************************************************************
+
SablotSetInstanceData
+
*****************************************************************/
+
+
Declare
+
(
+
void SablotSetInstanceData(SablotHandle processor_, void *idata);
+
)
+
+
/*****************************************************************
+
SablotGetInstanceData
+
*****************************************************************/
+
+
Declare
+
(
+
void* SablotGetInstanceData(SablotHandle processor_);
+
)
+
+
/*
+
SablotSetEncoding
+
sets the output encoding to be used regardless of the encoding
+
specified by the stylesheet
+
To unset, call with encoding_ NULL.
+
*/
+
+
Declare
+
(
+
void SablotSetEncoding(SablotHandle processor_, char *encoding_);
+
)
-#endif /* defined SablotHIncl */
+
+
+#endif
diff --git a/win32/sablot/include/sablot.lib b/win32/sablot/include/sablot.lib
deleted file mode 100644
index e002170..0000000
--- a/win32/sablot/include/sablot.lib
+++ /dev/null
Binary files differ
diff --git a/win32/sablot/include/sdom.h b/win32/sablot/include/sdom.h
index cee53ff..476f32a 100644
--- a/win32/sablot/include/sdom.h
+++ b/win32/sablot/include/sdom.h
@@ -1,921 +1,1878 @@
/*
+
* The contents of this file are subject to the Mozilla Public
+
* License Version 1.1 (the "License"); you may not use this file
+
* except in compliance with the License. You may obtain a copy of
+
* the License at http://www.mozilla.org/MPL/
+
*
+
* Software distributed under the License is distributed on an "AS
+
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+
* implied. See the License for the specific language governing
+
* rights and limitations under the License.
+
*
+
* The Original Code is the Sablotron XSLT Processor.
+
*
+
* The Initial Developer of the Original Code is Ginger Alliance Ltd.
+
* Portions created by Ginger Alliance are Copyright (C) 2000-2002
+
* Ginger Alliance Ltd. All Rights Reserved.
+
*
+
* Contributor(s):
+
*
+
* Alternatively, the contents of this file may be used under the
+
* terms of the GNU General Public License Version 2 or later (the
+
* "GPL"), in which case the provisions of the GPL are applicable
+
* instead of those above. If you wish to allow use of your
+
* version of this file only under the terms of the GPL and not to
+
* allow others to use your version of this file under the MPL,
+
* indicate your decision by deleting the provisions above and
+
* replace them with the notice and other provisions required by
+
* the GPL. If you do not delete the provisions above, a recipient
+
* may use your version of this file under either the MPL or the
+
* GPL.
+
*/
+
+
/* sdom.h */
+
+
#ifndef SDomHIncl
+
#define SDomHIncl
+
+
//used for DISABLE_DOM only anything else is DANGEROUS
+
#ifdef HAVE_CONFIG_H
+
#include <config.h>
+
#endif
+
+
#ifndef DISABLE_DOM
+
+
#include "sablot.h"
+
+
/**
+
**
+
** types
+
**
+
**/
+
+
typedef void* SDOM_Node;
+
typedef void* SDOM_NodeList;
+
/* typedef void* SDOM_Document; */
+
+
typedef enum
+
{
+
SDOM_ELEMENT_NODE = 1,
+
SDOM_ATTRIBUTE_NODE = 2,
+
SDOM_TEXT_NODE = 3,
+
SDOM_CDATA_SECTION_NODE = 4,
+
SDOM_ENTITY_REFERENCE_NODE = 5,
+
SDOM_ENTITY_NODE = 6,
+
SDOM_PROCESSING_INSTRUCTION_NODE = 7,
+
SDOM_COMMENT_NODE = 8,
+
SDOM_DOCUMENT_NODE = 9,
+
SDOM_DOCUMENT_TYPE_NODE = 10,
+
SDOM_DOCUMENT_FRAGMENT_NODE = 11,
+
SDOM_NOTATION_NODE = 12,
+
SDOM_OTHER_NODE /* not in spec */
+
}
+
SDOM_NodeType;
+
+
/*
+
* we define DOM_char as char, although the spec says strings should be
+
* UTF_16. Needs check.
+
*/
+
typedef char SDOM_char;
+
+
+
/*
+
* DomException
+
* will be an enum of all the values given in the spec.
+
*/
+
+
/*
+
INDEX_SIZE_ERR, 1
+
STRING_SIZE_ERR, 2
+
HIERARCHY_REQUEST_ERR, 3
+
WRONG_DOCUMENT_ERR, 4
+
INVALID_CHARACTER_ERR, 5
+
NO_DATA_ALLOWED_ERR, 6
+
NO_MODIFICATION_ALLOWED_ERR, 7
+
NOT_FOUND_ERR, 8
+
NOT_SUPPORTED_ERR, 9
+
INUSE_ATTRIBUTE_ERR, 10
+
INVALID_STATE_ERR, 11
+
SYNTAX_ERR, 12
+
INVALID_MODIFICATION_ERR, 13
+
NAMESPACE_ERR, 14
+
INVALID_ACCESS_ERR, 15
+
*/
+
+
typedef enum
+
{
+
SDOM_OK,
+
SDOM_INDEX_SIZE_ERR = 1,
+
SDOM_DOMSTRING_SIZE_ERR = 2,
+
SDOM_HIERARCHY_REQUEST_ERR = 3,
+
SDOM_WRONG_DOCUMENT_ERR = 4,
+
SDOM_INVALID_CHARACTER_ERR = 5,
+
SDOM_NO_DATA_ALLOWED_ERR = 6,
+
SDOM_NO_MODIFICATION_ALLOWED_ERR = 7,
+
SDOM_NOT_FOUND_ERR = 8,
+
SDOM_NOT_SUPPORTED_ERR = 9,
+
SDOM_INUSE_ATTRIBUTE_ERR = 10,
+
SDOM_INVALID_STATE_ERR = 11,
+
SDOM_SYNTAX_ERR = 12,
+
SDOM_INVALID_MODIFICATION_ERR = 13,
+
SDOM_NAMESPACE_ERR = 14,
+
SDOM_INVALID_ACCESS_ERR = 15,
+
/* not in spec below this point: */
+
SDOM_INVALID_NODE_TYPE, /* eg passing a non-element for an element */
+
SDOM_QUERY_PARSE_ERR,
+
SDOM_QUERY_EXECUTION_ERR,
+
SDOM_NOT_OK
+
} SDOM_Exception;
+
+
/**
+
**
+
** Node
+
** n is always the node the function is to operate on (kind of 'this')
+
**
+
**/
+
+
/*
+
createElement
+
Creates a new element Node with NULL parent and specified owner,
+
and returns it in *pn.
+
Raises:
+
*/
+
Declare(
+
SDOM_Exception SDOM_createElement(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *tagName);
+
)
+
+
//_JP_ v
+
/*
+
createElementNS
+
Creates a new element Node with NULL parent and specified owner,
+
and returns it in *pn.
+
Raises:
+
SDOM_NAMESPACE_ERR or SDOM_INVALID_CHARACTER_ERR when qName or uri malformed
+
*/
+
Declare(
+
SDOM_Exception SDOM_createElementNS(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *uri,
+
const SDOM_char *qName);
+
)
+
//_JP_ ^
+
+
/*
+
createAttribute
+
Creates a new attribute Node and returns it in *pn.
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_createAttribute(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *name);
+
)
+
+
//_JP_ v
+
/*
+
createAttributeNS
+
Creates a new attribute Node and returns it in *pn.
+
Raises:
+
SDOM_NAMESPACE_ERR or SDOM_INVALID_CHARACTER_ERR when qName or uri malformed
+
*/
+
Declare(
+
SDOM_Exception SDOM_createAttributeNS(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *uri,
+
const SDOM_char *qName);
+
)
+
//_JP_ ^
+
+
+
/*
+
createTextNode
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_createTextNode(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *data);
+
)
+
+
/*
+
createAttribute
+
Creates a new attribute Node and returns it in *pn.
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_createCDATASection(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *data);
+
)
+
+
/*
+
createComment
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_createComment(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *data);
+
)
+
+
/*
+
createProcessingInstruction
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_createProcessingInstruction(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node *pn,
+
const SDOM_char *target,
+
const SDOM_char *data);
+
)
+
+
/*
+
disposeNode
+
Frees all memory used by the node.
+
Raises:
+
!SPEC: Not in the spec.
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_disposeNode(
+
SablotSituation s,
+
SDOM_Node n);
+
)
+
+
+
/*
+
getNodeType
+
Returns the node type in *pType.
+
Raises:
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_getNodeType(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_NodeType *pType);
+
)
+
+
+
/*
+
getNodeName
+
Returns the pointer to the name of the node in *pName.
+
*/
+
+
Declare
+
(
+
SDOM_Exception SDOM_getNodeName(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char **pName);
+
)
+
+
Declare
+
(
+
SDOM_Exception SDOM_getNodeNSUri(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char **pName);
+
)
+
+
Declare
+
(
+
SDOM_Exception SDOM_getNodePrefix(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char **pName);
+
)
+
+
Declare
+
(
+
SDOM_Exception SDOM_getNodeLocalName(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char **pName);
+
)
+
+
/*
+
setNodeName
+
Sets the node name.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setNodeName(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *name);
+
)
+
+
/*
+
getNodeValue
+
Returns in *pValue the string value of the node.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getNodeValue(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char **pValue);
+
)
+
+
/*
+
setNodeValue
+
Sets the node value.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setNodeValue(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *value);
+
)
+
+
/*
+
getParentNode
+
Returns the parent in *pParent.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getParentNode(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node *pParent);
+
)
+
+
/*
+
getFirstChild
+
Returns the first child in *pFirstChild.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getFirstChild(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node *pFirstChild);
+
)
+
+
/*
+
getLastChild
+
Returns the last child in *pLastChild.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getLastChild(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node *pLastChild);
+
)
+
+
/*
+
getPreviousSibling
+
Returns the previous sibling in *pPreviousSibling.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getPreviousSibling(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node *pPreviousSibling);
+
)
+
+
/*
+
getNextSibling
+
Returns the next sibling in *pNextSibling.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getNextSibling(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node *pNextSibling);
+
)
+
+
/*
+
getChildNode
+
Returns the child node in specified index or NULL.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getChildNodeIndex(
+
SablotSituation s,
+
SDOM_Node n,
+
int index,
+
SDOM_Node *pChildNode);
+
)
+
+
/*
+
getChildNodeCount
+
Returns the count of child nodes.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getChildNodeCount(
+
SablotSituation s,
+
SDOM_Node n,
+
int *count);
+
)
+
+
/*
+
getOwnerDocument
+
Returns, in *pOwnerDocument, the Document owning the node.
+
!SPEC: If the node is standalone, returns NULL.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getOwnerDocument(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Document *pOwnerDocument);
+
)
+
+
/*
+
insertBefore
+
Inserts newChild as n's child, just before refChild.
+
*/
+
Declare(
+
SDOM_Exception SDOM_insertBefore(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node newChild,
+
SDOM_Node refChild);
+
)
+
+
/*
+
removeChild
+
Removes oldChild (a child of n) without deallocating it.
+
*/
+
+
Declare(
+
SDOM_Exception SDOM_removeChild(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node oldChild);
+
)
+
+
/*
+
replaceChild
+
Replaces oldChild (a child of n) by newChild.
+
*/
+
Declare(
+
SDOM_Exception SDOM_replaceChild(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node newChild,
+
SDOM_Node oldChild);
+
)
+
+
/*
+
appendChild
+
Appends newChild as the last of n's children.
+
*/
+
Declare(
+
SDOM_Exception SDOM_appendChild(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node newChild);
+
)
+
+
/*
+
cloneNode
+
Duplicates the node, returning the result in *clone.
+
If deep is nonzero, the cloning process will be recursive.
+
*/
+
+
Declare(
+
SDOM_Exception SDOM_cloneNode(
+
SablotSituation s,
+
SDOM_Node n,
+
int deep,
+
SDOM_Node *clone);
+
)
+
+
/*
+
cloneForeignNode
+
Duplicates a node from a different doc, returning the result in *clone.
+
If deep is nonzero, the cloning process will be recursive.
+
As opposed to cloneNode, represents a Document method
+
*/
+
+
Declare(
+
SDOM_Exception SDOM_cloneForeignNode(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node n,
+
int deep,
+
SDOM_Node *clone);
+
)
+
+
/*
+
getAttribute
+
Returns, in *pValue, the contents of the attribute (of n) named 'name'.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttribute(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *name,
+
SDOM_char **pValue);
+
)
+
+
/*
+
getAttributeNS
+
Returns, in *pValue, the contents of the attribute (of n) with 'uri' and 'local'.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeNS(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char *uri,
+
SDOM_char *local,
+
SDOM_char **pValue);
+
)
+
+
/*
+
getAttributeNode
+
Returns, in *attr, the attribute named 'name'.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeNode(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *name,
+
SDOM_Node *attr);
+
)
+
+
/*
+
getAttributeNodeNS
+
Returns, in *attr, the n's attribute with uri and local.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeNodeNS(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_char *uri,
+
SDOM_char *local,
+
SDOM_Node *attr);
+
)
+
+
//_JP_ v
+
/*
+
getAttributeNodeIndex
+
Returns, in *attr, the index'th attribute, namespaces precede other atts.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeNodeIndex(
+
SablotSituation s,
+
SDOM_Node n,
+
const int index,
+
SDOM_Node *attr);
+
)
+
+
/*
+
getAttributeNodeCount
+
Returns, in *count, the count of atts, including namespaces in scope.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeNodeCount(
+
SablotSituation s,
+
SDOM_Node n,
+
int *count);
+
)
+
//_JP_ ^
+
+
/*
+
setAttribute
+
Assigns the given value to n's attribute named 'name'.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setAttribute(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *name,
+
const SDOM_char *value);
+
)
+
+
/*
+
setAttributeNS
+
Assigns the given value to n's attribute with 'uri' and qualified name 'qName'.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setAttributeNS(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *uri,
+
const SDOM_char *qName,
+
const SDOM_char *value);
+
)
+
+
/*
+
setAttributeNode
+
Assigns the given attnode as n's attribute.
+
Returns replaced, if was replaced some node with the same nodeName.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setAttributeNode(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node attnode,
+
SDOM_Node *replaced);
+
)
+
+
/*
+
setAttributeNodeNS
+
Assigns the given attnode to n's attribute with attnode.uri and attnode.localname.
+
Returns replaced, if was replaced some node.
+
*/
+
Declare(
+
SDOM_Exception SDOM_setAttributeNodeNS(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node attnode,
+
SDOM_Node *replaced);
+
)
+
+
/*
+
removeAttribute
+
Removes the given attribute of n.
+
*/
+
Declare(
+
SDOM_Exception SDOM_removeAttribute(
+
SablotSituation s,
+
SDOM_Node n,
+
const SDOM_char *name);
+
)
+
+
/*
+
removeAttribute
+
Removes the given attribute of n.
+
*/
+
Declare(
+
SDOM_Exception SDOM_removeAttributeNode(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_Node attnode,
+
SDOM_Node *removed);
+
)
+
/*
+
attributeElement
+
returns owner element of attribute specified
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeElement(
+
SablotSituation s,
+
SDOM_Node attr,
+
SDOM_Node *owner);
+
)
+
+
/*
+
getAttributeList
+
Returns, in *pAttrList, the list of all attributes of the element n.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getAttributeList(
+
SablotSituation s,
+
SDOM_Node n,
+
SDOM_NodeList *pAttrList);
+
)
+
+
/**
+
** END Node
+
**/
+
+
+
/**
+
** Functions related to Document
+
**/
+
+
+
/*
+
docToString
+
Serializes the document, returning the resulting string in
+
*pSerialized, which is a Sablotron-allocated buffer.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_docToString(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_char **pSerialized);
+
)
+
+
Declare(
+
SDOM_Exception SDOM_nodeToString(
+
SablotSituation s,
+
SDOM_Document d,
+
SDOM_Node n,
+
SDOM_char **pSerialized);
+
)
+
+
/**
+
** END Document functions
+
**/
+
+
+
/**
+
** NodeList
+
** An ordered collection of nodes, returned by xql.
+
**/
+
+
+
/*
+
getNodeListLength
+
Returns, in *pLength, the number of nodes in the list l.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getNodeListLength(
+
SablotSituation s,
+
SDOM_NodeList l,
+
int *pLength);
+
)
+
+
/*
+
getNodeListItem
+
Returns, in *pItem, the index'th member of the node list l.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_getNodeListItem(
+
SablotSituation s,
+
SDOM_NodeList l,
+
int index,
+
SDOM_Node *pItem);
+
)
+
+
/*
+
disposeNodeList
+
Destroys the node list l. The nodes themselves are NOT disposed.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_disposeNodeList(
+
SablotSituation s,
+
SDOM_NodeList l);
+
)
+
+
/**
+
** END NodeList
+
**/
+
+
+
/**
+
** Miscellaneous
+
**/
+
+
/*
+
xql
+
Returns, in *pResult, the list of all nodes satisfying the XPath
+
query given as a string in 'query'. For the evaluation of the query, the
+
current node will be set to currentNode.
+
Note that the query is necessarily rather restricted.
+
After the contents of *pResult have been retrieved, the list should
+
be freed using disposeNodeList.
+
!SPEC: Not in spec.
+
*/
+
Declare(
+
SDOM_Exception SDOM_xql(
+
SablotSituation s,
+
const SDOM_char *query,
+
SDOM_Node currentNode,
+
SDOM_NodeList *pResult);
+
)
+
+
+Declare(
+
+SDOM_Exception SDOM_xql_ns(
+
+ SablotSituation s,
+
+ const SDOM_char *query,
+
+ SDOM_Node currentNode,
+
+ char** nsmap,
+
+ SDOM_NodeList *pResult);
+
+)
+
+
+
/**
+
** END Miscellaneous
+
**
+
**
+
**
+
** Exception retrieval
+
**/
+
+
/*
+
getExceptionCode
+
returns the code of the pending exception
+
*/
+
+
Declare
+
(
+
int SDOM_getExceptionCode(SablotSituation s);
+
)
+
+
/*
+
getExceptionMessage
+
returns the message for the pending exception
+
*/
+
+
Declare
+
(
+
char* SDOM_getExceptionMessage(SablotSituation s);
+
)
+
+
/*
+
getExceptionDetails
+
returns extra information for the pending exception
+
- on the code and message of the primary error
+
- on the document and file line where the primary error occured
+
*/
+
+
Declare
+
(
+
void SDOM_getExceptionDetails(
+
SablotSituation s,
+
int *code,
+
char **message,
+
char **documentURI,
+
int *fileLine);
+
)
+
+
/**
+
** END Exception retrieval
+
**
+
**
+
** Internal functions
+
**/
+
+
/*
+
setNodeInstanceData
+
saves a pointer in a node instance
+
*/
+
+
Declare(
+
void SDOM_setNodeInstanceData(SDOM_Node n, void *data);
+
)
+
+
/*
+
getNodeInstanceData
+
retrieves the saved pointer
+
*/
+
Declare(
+
void* SDOM_getNodeInstanceData(SDOM_Node n);
+
)
+
/*
+
setDisposeNodeCallback
+
sets callback to be called on every node disposal
+
*/
+
+
typedef void SDOM_NodeCallback(SDOM_Node n);
+
+
Declare
+
(
+
void SDOM_setDisposeCallback(SDOM_NodeCallback *f);
+
)
+
+
Declare
+
(
+
SDOM_NodeCallback* SDOM_getDisposeCallback();
+
)
+
+
/**
+
** FOR IMPLEMENTATION IN PERL
+
** None of these fuctions appear in the spec.
+
**/
+
+
+
/*
+
ArrayRef getChildNodes(Node n)
+
Returns the array of n's children.
+
Implement using getFirstChild and getNextSibling.
+
+
+
HashRef getAttributes(Node n)
+
Returns the hash of n's attributes.
+
Implement using getAttributeList, getNodeListLength,
+
getNodeListItem, getNodeName and getNodeValue.
+
+
+
setAttributes(Node n, HashRef atts)
+
Sets n's attributes to atts, keeping the old ones alive but making
+
them standalone.
+
Implement using getAttributeList, getNodeListLength, removeAttribute
+
and setAttribute (not too efficient perhaps).
+
*/
+
+
/* _TH_ v */
+
Declare
+
(
+
void SDOM_tmpListDump(SDOM_Document doc, int p);
+
)
+
+
+Declare
+
+(
+
+ SDOM_Exception SDOM_compareNodes(
+
+ SablotSituation s,
+
+ SDOM_Node n1,
+
+ SDOM_Node n2,
+
+ int *res);
+
+)
+
+
+
#endif /* DISABLE_DOM */
+
+
#endif /* SDomHIncl */
+
diff --git a/win32/sablot/include/shandler.h b/win32/sablot/include/shandler.h
index ea7fc83..bf4f3fa 100644
--- a/win32/sablot/include/shandler.h
+++ b/win32/sablot/include/shandler.h
@@ -1,369 +1,738 @@
/*
+
* The contents of this file are subject to the Mozilla Public
+
* License Version 1.1 (the "License"); you may not use this file
+
* except in compliance with the License. You may obtain a copy of
+
* the License at http://www.mozilla.org/MPL/
+
*
+
* Software distributed under the License is distributed on an "AS
+
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+
* implied. See the License for the specific language governing
+
* rights and limitations under the License.
+
*
+
* The Original Code is the Sablotron XSLT Processor.
+
*
+
* The Initial Developer of the Original Code is Ginger Alliance Ltd.
+
* Portions created by Ginger Alliance are Copyright (C) 2000-2002
+
* Ginger Alliance Ltd. All Rights Reserved.
+
*
+
* Contributor(s):
+
*
+
* Alternatively, the contents of this file may be used under the
+
* terms of the GNU General Public License Version 2 or later (the
+
* "GPL"), in which case the provisions of the GPL are applicable
+
* instead of those above. If you wish to allow use of your
+
* version of this file only under the terms of the GPL and not to
+
* allow others to use your version of this file under the MPL,
+
* indicate your decision by deleting the provisions above and
+
* replace them with the notice and other provisions required by
+
* the GPL. If you do not delete the provisions above, a recipient
+
* may use your version of this file under either the MPL or the
+
* GPL.
+
*/
+
+
#ifndef ShandlerHIncl
+
#define ShandlerHIncl
+
+
/* we have to deal with the size_t type, sys/types.h;
+
is needed on some platforms */
-#if !defined(_MSC_VER)
+
+#if !defined(_MSC_VER) && !defined(__BORLANDC__)
+
#include <sabcfg.h>
+
#endif
+
+
#include <stddef.h>
+
+
/* GP: clean */
+
+
/*****************************************************************
+
+
handler types
+
+
*****************************************************************/
+
+
typedef enum
+
{
+
HLR_MESSAGE = 0,
+
HLR_SCHEME,
+
HLR_SAX,
+
HLR_MISC,
+
HLR_ENC
+
} HandlerType;
+
+
extern const char* hlrTypeNames[]; /* found in base.cpp */
+
+
typedef enum
+
{
+
SH_ERR_OK = 0,
+
SH_ERR_NOT_OK = 1,
+
SH_ERR_UNSUPPORTED_SCHEME
+
} SchemeHandlerErrors;
+
+
/*****************************************************************
+
SchemeHandler
+
+
is a structure for a scheme handler. It contains pointers to
+
the following functions of the handler:
+
open(), get(), put(), close().
+
All of these function return an error flag (0=OK, 1=not).
+
open() may also return SH_ERR_UNSUPPORTED_SCHEME.
+
*****************************************************************/
+
+
/* getAll: open the URI and return the whole string
+
scheme = URI scheme (e.g. "http")
+
rest = the rest of the URI (without colon)
+
the document is returned in a handler-allocated buffer
+
byteCount holds the byte count on return
+
return *buffer = NULL if not processed
+
*/
+
typedef int SchemeHandlerGetAll(void *userData, SablotHandle processor_,
+
const char *scheme, const char *rest,
+
char **buffer, int *byteCount);
+
+
/* freeMemory: free the buffer allocated by getAll
+
*/
+
+
typedef int SchemeHandlerFreeMemory(void *userData, SablotHandle processor_,
+
char *buffer);
+
+
/* open: open the URI and return a handle
+
scheme = URI scheme (e.g. "http")
+
rest = the rest of the URI (without colon)
+
the resulting handle is returned in '*handle'
+
*/
+
typedef int SchemeHandlerOpen(void *userData, SablotHandle processor_,
+
const char *scheme, const char *rest, int *handle);
+
+
/* get: retrieve data from the URI
+
handle = the handle assigned on open
+
buffer = pointer to the data
+
*byteCount = number of bytes to read
+
(the number actually read is returned here)
+
*/
+
typedef int SchemeHandlerGet(void *userData, SablotHandle processor_,
+
int handle, char *buffer, int *byteCount);
+
+
/* put: save data to the URI (if possible)
+
handle = the handle assigned on open
+
buffer = pointer to the data
+
*byteCount = number of bytes to write
+
(the number actually written is returned here)
+
*/
+
typedef int SchemeHandlerPut(void *userData, SablotHandle processor_,
+
int handle, const char *buffer, int *byteCount);
+
+
/* close: close the URI with the given handle
+
handle = the handle assigned on open
+
*/
+
typedef int SchemeHandlerClose(void *userData, SablotHandle processor_,
+
int handle);
+
+
typedef struct
+
{
+
SchemeHandlerGetAll *getAll;
+
SchemeHandlerFreeMemory *freeMemory;
+
SchemeHandlerOpen *open;
+
SchemeHandlerGet *get;
+
SchemeHandlerPut *put;
+
SchemeHandlerClose *close;
+
} SchemeHandler;
+
+
/*****************************************************************
+
MessageHandler
+
+
a structure for external message handlers. Such a handler, if set,
+
receives all error reports, displays them, keeps the log, the
+
error trace, etc.
+
*****************************************************************/
+
+
/*
+
define the "facility number" for Sablotron. This does not mean much
+
nowadays.
+
*/
+
+
#define MH_FACILITY_SABLOTRON 2
+
+
/* type for the error codes used by the message handler */
+
+
typedef unsigned long MH_ERROR;
+
+
/* logging levels for the message handler */
+
+
typedef enum
+
{
+
MH_LEVEL_DEBUG,
+
MH_LEVEL_INFO,
+
MH_LEVEL_WARN,
+
MH_LEVEL_ERROR,
+
MH_LEVEL_CRITICAL
+
} MH_LEVEL;
+
+
/*
+
makeCode()
+
makes the "external" error code to report with log() or error()
+
call with facility = module id; severity = 1 iff critical.
+
'code' is the error code internal to Sablotron.
+
*/
+
+
typedef MH_ERROR
+
MessageHandlerMakeCode(
+
void *userData, SablotHandle processor_,
+
int severity, unsigned short facility, unsigned short code);
+
+
/*
+
log()
+
pass code created by makeCode, level as necessary
+
fields is a NULL-terminated list of strings in form "field:contents"
+
distinguished fields include: msg, file, line, token
+
*/
+
+
typedef MH_ERROR
+
MessageHandlerLog(
+
void *userData, SablotHandle processor_,
+
MH_ERROR code, MH_LEVEL level, char **fields);
+
+
/*
+
error()
+
for reporting errors, meaning as with log()
+
*/
+
+
typedef MH_ERROR
+
MessageHandlerError(void *userData, SablotHandle processor_,
+
MH_ERROR code, MH_LEVEL level, char **fields);
+
+
/* the message handler structure. Use SablotRegMessageHandler() to register. */
+
+
typedef struct
+
{
+
MessageHandlerMakeCode *makeCode;
+
MessageHandlerLog *log;
+
MessageHandlerError *error;
+
} MessageHandler;
+
+
+
+
+
+
/*
+
+
SAXHandler
+
a SAX-like, streaming interface for access to XML docs
+
+
*/
+
+
+
#define SAX_RETURN void
+
+
typedef SAX_RETURN
+
SAXHandlerStartDocument(void* userData, SablotHandle processor_);
+
+
typedef SAX_RETURN
+
SAXHandlerStartElement(void* userData, SablotHandle processor_,
+
const char* name, const char** atts);
+
+
typedef SAX_RETURN
+
SAXHandlerEndElement(void* userData, SablotHandle processor_,
+
const char* name);
+
+
typedef SAX_RETURN
+
SAXHandlerStartNamespace(void* userData, SablotHandle processor_,
+
const char* prefix, const char* uri);
+
+
typedef SAX_RETURN
+
SAXHandlerEndNamespace(void* userData, SablotHandle processor_,
+
const char* prefix);
+
+
typedef SAX_RETURN
+
SAXHandlerComment(void* userData, SablotHandle processor_,
+
const char* contents);
+
+
typedef SAX_RETURN
+
SAXHandlerPI(void* userData, SablotHandle processor_,
+
const char* target, const char* contents);
+
+
typedef SAX_RETURN
+
SAXHandlerCharacters(void* userData, SablotHandle processor_,
+
const char* contents, int length);
+
+
typedef SAX_RETURN
+
SAXHandlerEndDocument(void* userData, SablotHandle processor_);
+
+
+
/*
+
The SAX handler structure. Use SablotRegSAXHandler() to register.
+
*/
+
+
+
typedef struct
+
{
+
SAXHandlerStartDocument *startDocument;
+
SAXHandlerStartElement *startElement;
+
SAXHandlerEndElement *endElement;
+
SAXHandlerStartNamespace *startNamespace;
+
SAXHandlerEndNamespace *endNamespace;
+
SAXHandlerComment *comment;
+
SAXHandlerPI *processingInstruction;
+
SAXHandlerCharacters *characters;
+
SAXHandlerEndDocument *endDocument;
+
} SAXHandler;
+
+
+
/*****************************************************************
+
MiscHandler
+
+
Collects miscellaneous callbacks.
+
*****************************************************************/
+
+
/*
+
documentInfo()
+
If set, this callback gets called after the output of a result
+
document is finished, giving information about its content type
+
and encoding.
+
*/
+
+
typedef void
+
MiscHandlerDocumentInfo(void* userData, SablotHandle processor_,
+
const char *contentType, const char *encoding);
+
+
/*
+
The Misc handler structure.
+
Use SablotRegHandler(HLR_MISC, ...) to register.
+
*/
+
+
typedef struct
+
{
+
MiscHandlerDocumentInfo *documentInfo;
+
} MiscHandler;
+
+
/*****************************************************************
+
EncHandler
+
+
Handler for recoding requests in absence of iconv.
+
*****************************************************************/
+
+
#define EH_FROM_UTF8 1
+
#define EH_TO_UTF8 0
+
+
/*
+
the conversion descriptor like iconv_t
+
*/
+
+
typedef void* EHDescriptor;
+
+
typedef enum
+
{
+
EH_OK,
+
EH_EINVAL,
+
EH_E2BIG,
+
EH_EILSEQ
+
} EHResult;
+
+
/*
+
open()
+
direction is either EH_FROM_UTF8 or EH_TO_UTF8
+
encoding is the other encoding
+
RETURN the descriptor, or -1 if the encoding is not supported
+
*/
+
+
typedef EHDescriptor EncHandlerOpen(void* userData, SablotHandle processor_,
+
int direction, const char *encoding);
+
+
/*
+
conv()
+
arguments 3 through 7 are just like for iconv, see the manpage
+
RETURN -1 on error (set errno), a different value (e.g. 0) if OK
+
*/
+
+
typedef EHResult EncHandlerConv(void* userData, SablotHandle processor_,
+
EHDescriptor cd, const char** inbuf, size_t *inbytesleft,
+
char ** outbuf, size_t *outbytesleft);
+
+
/*
+
close()
+
cd is the descriptor to close. Return 0 if OK, -1 on error.
+
*/
+
+
typedef int EncHandlerClose(void* userData, SablotHandle processor_,
+
EHDescriptor cd);
+
+
/*
+
The EncHandler structure.
+
Use SablotRegHandler(HLR_ENC, ...) to register.
+
*/
+
+
typedef struct
+
{
+
EncHandlerOpen *open;
+
EncHandlerConv *conv;
+
EncHandlerClose *close;
+
} EncHandler;
+
+
#endif
+
diff --git a/win32/sablot/include/sxpath.h b/win32/sablot/include/sxpath.h
index d6bd448..56888b4 100644
--- a/win32/sablot/include/sxpath.h
+++ b/win32/sablot/include/sxpath.h
@@ -1,264 +1,664 @@
/*
+
* The contents of this file are subject to the Mozilla Public
+
* License Version 1.1 (the "License"); you may not use this file
+
* except in compliance with the License. You may obtain a copy of
+
* the License at http://www.mozilla.org/MPL/
+
*
+
* Software distributed under the License is distributed on an "AS
+
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+
* implied. See the License for the specific language governing
+
* rights and limitations under the License.
+
*
+
* The Original Code is the Sablotron XSLT Processor.
+
*
+
* The Initial Developer of the Original Code is Ginger Alliance Ltd.
+
* Portions created by Ginger Alliance are Copyright (C) 2000-2002
+
* Ginger Alliance Ltd. All Rights Reserved.
+
*
+
* Contributor(s):
+
*
+
* Alternatively, the contents of this file may be used under the
+
* terms of the GNU General Public License Version 2 or later (the
+
* "GPL"), in which case the provisions of the GPL are applicable
+
* instead of those above. If you wish to allow use of your
+
* version of this file only under the terms of the GPL and not to
+
* allow others to use your version of this file under the MPL,
+
* indicate your decision by deleting the provisions above and
+
* replace them with the notice and other provisions required by
+
* the GPL. If you do not delete the provisions above, a recipient
+
* may use your version of this file under either the MPL or the
+
* GPL.
+
*/
+
+
#ifndef SXPathHIncl
+
#define SXPathHIncl
+
+
/* basic types needed in sablot.h */
+
typedef void *SXP_Node;
+
typedef void *SXP_Document;
+
typedef void *SXP_NodeList;
+
typedef SXP_Node NodeHandle;
+
+
#include "sablot.h"
+
+
typedef enum
+
{
+
ELEMENT_NODE = 1,
+
ATTRIBUTE_NODE = 2,
+
TEXT_NODE = 3,
+
PROCESSING_INSTRUCTION_NODE = 7,
+
COMMENT_NODE = 8,
+
DOCUMENT_NODE = 9,
+
NAMESPACE_NODE = 13
+
} SXP_NodeType;
+
+
typedef enum
+
{
+
SXP_NONE,
+
SXP_NUMBER,
+
SXP_STRING,
+
SXP_BOOLEAN,
+
SXP_NODESET
+
} SXP_ExpressionType;
+
+
typedef char SXP_char;
+
+
typedef void *QueryContext;
+
+
/*option constants */
+
typedef enum
+
{
+
SXPF_DISPOSE_NAMES = 0x1,
+
SXPF_DISPOSE_VALUES = 0x2,
+
SXPF_SUPPORTS_UNPARSED_ENTITIES =0x4
+
} SXPFlags;
+
+
/*
+
* DOM handler functions
+
* This handler is registered with the Situation rather than the Processor
+
*/
+
+
/*****************************************************************
+
DOMHandler
+
+
Handler providing information about a DOM tree to the XPath
+
processor
+
*****************************************************************/
+
+
typedef SXP_NodeType DOMH_getNodeType(SXP_Node n);
+
+typedef SXP_NodeType DOMH_getNodeTypeExt(SXP_Node n, void *userData);
+
+
+
typedef const SXP_char* DOMH_getNodeName(SXP_Node n);
+
+typedef const SXP_char* DOMH_getNodeNameExt(SXP_Node n, void *userData);
+
+
+
typedef const SXP_char* DOMH_getNodeNameURI(SXP_Node n);
+
+typedef const SXP_char* DOMH_getNodeNameURIExt(SXP_Node n, void *userData);
+
+
+
typedef const SXP_char* DOMH_getNodeNameLocal(SXP_Node n);
+
+typedef const SXP_char* DOMH_getNodeNameLocalExt(SXP_Node n, void *userData);
+
+
+
typedef const SXP_char* DOMH_getNodeValue(SXP_Node n);
+
+typedef const SXP_char* DOMH_getNodeValueExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Node DOMH_getNextSibling(SXP_Node n);
+
+typedef SXP_Node DOMH_getNextSiblingExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Node DOMH_getPreviousSibling(SXP_Node n);
+
+typedef SXP_Node DOMH_getPreviousSiblingExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Node DOMH_getNextAttrNS(SXP_Node n);
+
+typedef SXP_Node DOMH_getNextAttrNSExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Node DOMH_getPreviousAttrNS(SXP_Node n);
+
+typedef SXP_Node DOMH_getPreviousAttrNSExt(SXP_Node n, void *userData);
+
+
+
typedef int DOMH_getChildCount(SXP_Node n);
+
+typedef int DOMH_getChildCountExt(SXP_Node n, void *userData);
+
+
+
typedef int DOMH_getAttributeCount(SXP_Node n);
+
+typedef int DOMH_getAttributeCountExt(SXP_Node n, void *userData);
+
+
+
typedef int DOMH_getNamespaceCount(SXP_Node n);
+
+typedef int DOMH_getNamespaceCountExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Node DOMH_getChildNo(SXP_Node n, int ndx);
+
+typedef SXP_Node DOMH_getChildNoExt(SXP_Node n, int ndx, void *userData);
+
+
+
typedef SXP_Node DOMH_getAttributeNo(SXP_Node n, int ndx);
+
+typedef SXP_Node DOMH_getAttributeNoExt(SXP_Node n, int ndx, void *userData);
+
+
+
typedef SXP_Node DOMH_getNamespaceNo(SXP_Node n, int ndx);
+
+typedef SXP_Node DOMH_getNamespaceNoExt(SXP_Node n, int ndx, void *userData);
+
+
+
typedef SXP_Node DOMH_getParent(SXP_Node n);
+
+typedef SXP_Node DOMH_getParentExt(SXP_Node n, void *userData);
+
+
+
typedef SXP_Document DOMH_getOwnerDocument(SXP_Node n);
+
+typedef SXP_Document DOMH_getOwnerDocumentExt(SXP_Node n, void *userData);
+
+
+
typedef int DOMH_compareNodes(SXP_Node n1, SXP_Node n2);
+
+typedef int DOMH_compareNodesExt(SXP_Node n1, SXP_Node n2, void *userData);
+
+
+
typedef SXP_Document DOMH_retrieveDocument(const SXP_char* uri,
+
void* udata);
+
+typedef SXP_Document DOMH_retrieveDocumentExt(const SXP_char* uri,
+
+ const SXP_char* baseUri,
+
+ void* udata);
+
+
+
typedef SXP_Node DOMH_getNodeWithID(SXP_Document doc, const SXP_char* id);
+
+typedef SXP_Node DOMH_getNodeWithIDExt(SXP_Document doc, const SXP_char* id, void *userData);
+
+
+
typedef void DOMH_freeBuffer(SXP_char *buff);
+typedef void DOMH_freeBufferExt(SXP_Node n, SXP_char *buff, void *userData);
+
+
+
+
+
typedef struct
+
{
+
DOMH_getNodeType *getNodeType;
+
DOMH_getNodeName *getNodeName;
+
DOMH_getNodeNameURI *getNodeNameURI;
+
DOMH_getNodeNameLocal *getNodeNameLocal;
+
DOMH_getNodeValue *getNodeValue;
+
DOMH_getNextSibling *getNextSibling;
+
DOMH_getPreviousSibling *getPreviousSibling;
+
DOMH_getNextAttrNS *getNextAttrNS;
+
DOMH_getPreviousAttrNS *getPreviousAttrNS;
+
DOMH_getChildCount *getChildCount;
+
DOMH_getAttributeCount *getAttributeCount;
+
DOMH_getNamespaceCount *getNamespaceCount;
+
DOMH_getChildNo *getChildNo;
+
DOMH_getAttributeNo *getAttributeNo;
+
DOMH_getNamespaceNo *getNamespaceNo;
+
DOMH_getParent *getParent;
+
DOMH_getOwnerDocument *getOwnerDocument;
+
DOMH_compareNodes *compareNodes;
+
DOMH_retrieveDocument *retrieveDocument;
+
DOMH_getNodeWithID *getNodeWithID;
+
/*optional entries - driven by sxpOptions */
+
DOMH_freeBuffer *freeBuffer;
+
+
+
+ DOMH_getNodeTypeExt *getNodeTypeExt;
+
+ DOMH_getNodeNameExt *getNodeNameExt;
+
+ DOMH_getNodeNameURIExt *getNodeNameURIExt;
+
+ DOMH_getNodeNameLocalExt *getNodeNameLocalExt;
+
+ DOMH_getNodeValueExt *getNodeValueExt;
+
+ DOMH_getNextSiblingExt *getNextSiblingExt;
+
+ DOMH_getPreviousSiblingExt *getPreviousSiblingExt;
+
+ DOMH_getNextAttrNSExt *getNextAttrNSExt;
+
+ DOMH_getPreviousAttrNSExt *getPreviousAttrNSExt;
+
+ DOMH_getChildCountExt *getChildCountExt;
+
+ DOMH_getAttributeCountExt *getAttributeCountExt;
+
+ DOMH_getNamespaceCountExt *getNamespaceCountExt;
+
+ DOMH_getChildNoExt *getChildNoExt;
+
+ DOMH_getAttributeNoExt *getAttributeNoExt;
+
+ DOMH_getNamespaceNoExt *getNamespaceNoExt;
+
+ DOMH_getParentExt *getParentExt;
+
+ DOMH_getOwnerDocumentExt *getOwnerDocumentExt;
+
+ DOMH_compareNodesExt *compareNodesExt;
+
+ DOMH_retrieveDocumentExt *retrieveDocumentExt;
+
+ DOMH_getNodeWithIDExt *getNodeWithIDExt;
+
+ /*optional entries - driven by sxpOptions */
+
+ DOMH_freeBufferExt *freeBufferExt;
+
+
+
} DOMHandler;
+
+
Declare
+
(
+
void SXP_registerDOMHandler(SablotSituation S,
+
DOMHandler *domh, void* udata);
+
)
+
+
Declare
+
(
+
void SXP_unregisterDOMHandler(SablotSituation S);
+
)
+
+
/*
+
*
+
* QueryContext functions
+
*
+
*/
+
+
/* options setter getter */
+
Declare
+
(
+
void SXP_setOptions(SablotSituation S, unsigned long options);
+
)
+
+
Declare
+
(
+
void SXP_setMaskBit(SablotSituation S, int mask);
+
)
+
+
Declare
+
(
+
unsigned long SXP_getOptions(SablotSituation S);
+
)
+
+
Declare
+
(
+
int SXP_createQueryContext(SablotSituation S, QueryContext *Q);
+
)
+
+
Declare
+
(
+
int SXP_addVariableBinding(QueryContext Q,
+
const SXP_char* name, QueryContext source);
+
)
+
+
Declare
+
(
+
int SXP_addVariableNumber(QueryContext Q,
+
const SXP_char* name, double value);
+
)
+
+
Declare
+
(
+
int SXP_addVariableString(QueryContext Q,
+
const SXP_char* name, const SXP_char* value);
+
)
+
+
Declare
+
(
+
int SXP_addVariableBoolean(QueryContext Q,
+
const SXP_char* name, int value);
+
)
+
+
Declare
+
(
+
int SXP_addNamespaceDeclaration(QueryContext Q,
+
const SXP_char* prefix, const SXP_char* uri);
+
)
+
+
Declare
+
(
+
int SXP_query(QueryContext Q, const SXP_char* query,
+
SXP_Node n, int contextPosition, int contextSize);
+
)
+
+
Declare
+
(
+
int SXP_destroyQueryContext(QueryContext Q);
+
)
+
+
/*
+
*
+
* Functions to retrieve the query result and its type
+
*
+
*/
+
+
Declare
+
(
+
int SXP_getResultType(QueryContext Q, SXP_ExpressionType *type);
+
)
+
+
Declare
+
(
+
int SXP_getResultNumber(QueryContext Q, double *result);
+
)
+
+
Declare
+
(
+
int SXP_getResultBool(QueryContext Q, int *result);
+
)
+
+
Declare
+
(
+
int SXP_getResultString(QueryContext Q, const char **result);
+
)
+
+
Declare
+
(
+
int SXP_getResultNodeset(QueryContext Q, SXP_NodeList *result);
+
)
+
+
/*
+
*
+
* NodeList manipulation
+
*
+
*/
+
+
Declare
+
(
+
int SXP_getNodeListLength(SXP_NodeList l);
+
)
+
+
Declare
+
(
+
SXP_Node SXP_getNodeListItem(QueryContext Q, SXP_NodeList l, int index);
+
)
+
+
+
#endif /* SXPathHIncl */
+