summaryrefslogtreecommitdiff
path: root/win32/sablot/include/sablot.h
diff options
context:
space:
mode:
Diffstat (limited to 'win32/sablot/include/sablot.h')
-rw-r--r--win32/sablot/include/sablot.h560
1 files changed, 560 insertions, 0 deletions
diff --git a/win32/sablot/include/sablot.h b/win32/sablot/include/sablot.h
new file mode 100644
index 0000000..71b05a2
--- /dev/null
+++ b/win32/sablot/include/sablot.h
@@ -0,0 +1,560 @@
+/*
+ * 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.
+ */
+
+/*
+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"
+
+/* common types */
+typedef void *SablotHandle;
+typedef void *SDOM_Document;
+typedef void *SablotSituation;
+
+#if defined(WIN32) && defined(_MSC_VER)
+#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
+} 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 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 */
+