ReactOS  0.4.15-dev-439-g292f67a
xsltutils.h File Reference
#include <libxslt/xsltconfig.h>
#include <libxml/xpath.h>
#include <libxml/dict.h>
#include <libxml/xmlerror.h>
#include "xsltexports.h"
#include "xsltInternals.h"
Include dependency graph for xsltutils.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define XSLT_TODO
 
#define XSLT_STRANGE
 
#define IS_XSLT_ELEM(n)
 
#define IS_XSLT_NAME(n, val)   (xmlStrEqual((n)->name, (const xmlChar *) (val)))
 
#define IS_XSLT_REAL_NODE(n)
 
#define XSLT_TRACE(ctxt, code, call)
 
#define XSLT_TIMESTAMP_TICS_PER_SEC   100000l
 

Typedefs

typedef void(* xsltHandleDebuggerCallback) (xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)
 
typedef int(* xsltAddCallCallback) (xsltTemplatePtr templ, xmlNodePtr source)
 
typedef void(* xsltDropCallCallback) (void)
 

Enumerations

enum  xsltDebugTraceCodes {
  XSLT_TRACE_ALL = -1, XSLT_TRACE_NONE = 0, XSLT_TRACE_COPY_TEXT = 1<<0, XSLT_TRACE_PROCESS_NODE = 1<<1,
  XSLT_TRACE_APPLY_TEMPLATE = 1<<2, XSLT_TRACE_COPY = 1<<3, XSLT_TRACE_COMMENT = 1<<4, XSLT_TRACE_PI = 1<<5,
  XSLT_TRACE_COPY_OF = 1<<6, XSLT_TRACE_VALUE_OF = 1<<7, XSLT_TRACE_CALL_TEMPLATE = 1<<8, XSLT_TRACE_APPLY_TEMPLATES = 1<<9,
  XSLT_TRACE_CHOOSE = 1<<10, XSLT_TRACE_IF = 1<<11, XSLT_TRACE_FOR_EACH = 1<<12, XSLT_TRACE_STRIP_SPACES = 1<<13,
  XSLT_TRACE_TEMPLATES = 1<<14, XSLT_TRACE_KEYS = 1<<15, XSLT_TRACE_VARIABLES = 1<<16
}
 
enum  xsltDebugStatusCodes {
  XSLT_DEBUG_NONE = 0, XSLT_DEBUG_INIT, XSLT_DEBUG_STEP, XSLT_DEBUG_STEPOUT,
  XSLT_DEBUG_NEXT, XSLT_DEBUG_STOP, XSLT_DEBUG_CONT, XSLT_DEBUG_RUN,
  XSLT_DEBUG_RUN_RESTART, XSLT_DEBUG_QUIT
}
 

Functions

XSLTPUBFUN xmlChar *XSLTCALL xsltGetNsProp (xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
 
XSLTPUBFUN const xmlChar *XSLTCALL xsltGetCNsProp (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
 
XSLTPUBFUN int XSLTCALL xsltGetUTF8Char (const unsigned char *utf, int *len)
 
XSLTPUBFUN void XSLTCALL xsltDebugSetDefaultTrace (xsltDebugTraceCodes val)
 
XSLTPUBFUN xsltDebugTraceCodes XSLTCALL xsltDebugGetDefaultTrace (void)
 
XSLTPUBFUN void XSLTCALL xsltPrintErrorContext (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node)
 
XSLTPUBFUN void XSLTCALL xsltMessage (xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst)
 
XSLTPUBFUN void XSLTCALL xsltSetGenericErrorFunc (void *ctx, xmlGenericErrorFunc handler)
 
XSLTPUBFUN void XSLTCALL xsltSetGenericDebugFunc (void *ctx, xmlGenericErrorFunc handler)
 
XSLTPUBFUN void XSLTCALL xsltSetTransformErrorFunc (xsltTransformContextPtr ctxt, void *ctx, xmlGenericErrorFunc handler)
 
XSLTPUBFUN void XSLTCALL xsltTransformError (xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...) LIBXSLT_ATTR_FORMAT(4
 
XSLTPUBFUN void XSLTCALL XSLTPUBFUN int XSLTCALL xsltSetCtxtParseOptions (xsltTransformContextPtr ctxt, int options)
 
XSLTPUBFUN void XSLTCALL xsltDocumentSortFunction (xmlNodeSetPtr list)
 
XSLTPUBFUN void XSLTCALL xsltSetSortFunc (xsltSortFunc handler)
 
XSLTPUBFUN void XSLTCALL xsltSetCtxtSortFunc (xsltTransformContextPtr ctxt, xsltSortFunc handler)
 
XSLTPUBFUN void XSLTCALL xsltDefaultSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
 
XSLTPUBFUN void XSLTCALL xsltDoSortFunction (xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
 
XSLTPUBFUN xmlXPathObjectPtr *XSLTCALL xsltComputeSortResult (xsltTransformContextPtr ctxt, xmlNodePtr sort)
 
XSLTPUBFUN const xmlChar *XSLTCALL xsltSplitQName (xmlDictPtr dict, const xmlChar *name, const xmlChar **prefix)
 
XSLTPUBFUN const xmlChar *XSLTCALL xsltGetQNameURI (xmlNodePtr node, xmlChar **name)
 
XSLTPUBFUN const xmlChar *XSLTCALL xsltGetQNameURI2 (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar **name)
 
XSLTPUBFUN int XSLTCALL xsltSaveResultTo (xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
 
XSLTPUBFUN int XSLTCALL xsltSaveResultToFilename (const char *URI, xmlDocPtr result, xsltStylesheetPtr style, int compression)
 
XSLTPUBFUN int XSLTCALL xsltSaveResultToFile (FILE *file, xmlDocPtr result, xsltStylesheetPtr style)
 
XSLTPUBFUN int XSLTCALL xsltSaveResultToFd (int fd, xmlDocPtr result, xsltStylesheetPtr style)
 
XSLTPUBFUN int XSLTCALL xsltSaveResultToString (xmlChar **doc_txt_ptr, int *doc_txt_len, xmlDocPtr result, xsltStylesheetPtr style)
 
XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL xsltXPathCompile (xsltStylesheetPtr style, const xmlChar *str)
 
XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL xsltXPathCompileFlags (xsltStylesheetPtr style, const xmlChar *str, int flags)
 
XSLTPUBFUN void XSLTCALL xsltSaveProfiling (xsltTransformContextPtr ctxt, FILE *output)
 
XSLTPUBFUN xmlDocPtr XSLTCALL xsltGetProfileInformation (xsltTransformContextPtr ctxt)
 
XSLTPUBFUN long XSLTCALL xsltTimestamp (void)
 
XSLTPUBFUN void XSLTCALL xsltCalibrateAdjust (long delta)
 
XSLTPUBFUN void XSLTCALL xsltSetDebuggerStatus (int value)
 
XSLTPUBFUN int XSLTCALL xsltGetDebuggerStatus (void)
 
XSLTPUBFUN int XSLTCALL xsltSetDebuggerCallbacks (int no, void *block)
 
XSLTPUBFUN int XSLTCALL xslAddCall (xsltTemplatePtr templ, xmlNodePtr source)
 
XSLTPUBFUN void XSLTCALL xslDropCall (void)
 

Variables

XSLTPUBVAR xmlGenericErrorFunc xsltGenericError
 
XSLTPUBVAR voidxsltGenericErrorContext
 
XSLTPUBVAR xmlGenericErrorFunc xsltGenericDebug
 
XSLTPUBVAR voidxsltGenericDebugContext
 
XSLTPUBVAR int xslDebugStatus
 

Macro Definition Documentation

◆ IS_XSLT_ELEM

#define IS_XSLT_ELEM (   n)
Value:
(((n) != NULL) && ((n)->type == XML_ELEMENT_NODE) && \
((n)->ns != NULL) && (xmlStrEqual((n)->ns->href, XSLT_NAMESPACE)))
GLdouble n
Definition: glext.h:7729
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
#define XSLT_NAMESPACE
Definition: xslt.h:46
smooth NULL
Definition: ftsmooth.c:416
Definition: mxnamespace.c:44
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157

IS_XSLT_ELEM:

Checks that the element pertains to XSLT namespace.

Definition at line 54 of file xsltutils.h.

◆ IS_XSLT_NAME

#define IS_XSLT_NAME (   n,
  val 
)    (xmlStrEqual((n)->name, (const xmlChar *) (val)))

IS_XSLT_NAME:

Checks the value of an element in XSLT namespace.

Definition at line 63 of file xsltutils.h.

◆ IS_XSLT_REAL_NODE

#define IS_XSLT_REAL_NODE (   n)
Value:
(((n) != NULL) && \
(((n)->type == XML_ELEMENT_NODE) || \
((n)->type == XML_TEXT_NODE) || \
((n)->type == XML_ATTRIBUTE_NODE) || \
((n)->type == XML_DOCUMENT_NODE) || \
((n)->type == XML_COMMENT_NODE) || \
((n)->type == XML_PI_NODE)))
GLdouble n
Definition: glext.h:7729
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
smooth NULL
Definition: ftsmooth.c:416

IS_XSLT_REAL_NODE:

Check that a node is a 'real' one: document, element, text or attribute.

Definition at line 71 of file xsltutils.h.

◆ XSLT_STRANGE

#define XSLT_STRANGE
Value:
"Internal error at %s:%d\n", \
__FILE__, __LINE__);
XSLTPUBVAR xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.h:140
XSLTPUBVAR void * xsltGenericErrorContext
Definition: xsltutils.h:141

XSLT_STRANGE:

Macro to flag that a problem was detected internally.

Definition at line 44 of file xsltutils.h.

◆ XSLT_TIMESTAMP_TICS_PER_SEC

#define XSLT_TIMESTAMP_TICS_PER_SEC   100000l

XSLT_TIMESTAMP_TICS_PER_SEC:

Sampling precision for profiling

Definition at line 269 of file xsltutils.h.

◆ XSLT_TODO

#define XSLT_TODO
Value:
"Unimplemented block at %s:%d\n", \
__FILE__, __LINE__);
XSLTPUBVAR xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.h:140
XSLTPUBVAR void * xsltGenericErrorContext
Definition: xsltutils.h:141

XSLT_TODO:

Macro to flag unimplemented blocks.

Definition at line 34 of file xsltutils.h.

◆ XSLT_TRACE

#define XSLT_TRACE (   ctxt,
  code,
  call 
)
Value:
if (ctxt->traceCode && (*(ctxt->traceCode) & code)) \
call

XSLT_TRACE:

Control the type of xsl debugtrace messages emitted.

Definition at line 128 of file xsltutils.h.

Typedef Documentation

◆ xsltAddCallCallback

typedef int(* xsltAddCallCallback) (xsltTemplatePtr templ, xmlNodePtr source)

Definition at line 292 of file xsltutils.h.

◆ xsltDropCallCallback

typedef void(* xsltDropCallCallback) (void)

Definition at line 293 of file xsltutils.h.

◆ xsltHandleDebuggerCallback

typedef void(* xsltHandleDebuggerCallback) (xmlNodePtr cur, xmlNodePtr node, xsltTemplatePtr templ, xsltTransformContextPtr ctxt)

Definition at line 290 of file xsltutils.h.

Enumeration Type Documentation

◆ xsltDebugStatusCodes

Enumerator
XSLT_DEBUG_NONE 
XSLT_DEBUG_INIT 
XSLT_DEBUG_STEP 
XSLT_DEBUG_STEPOUT 
XSLT_DEBUG_NEXT 
XSLT_DEBUG_STOP 
XSLT_DEBUG_CONT 
XSLT_DEBUG_RUN 
XSLT_DEBUG_RUN_RESTART 
XSLT_DEBUG_QUIT 

Definition at line 275 of file xsltutils.h.

◆ xsltDebugTraceCodes

Enumerator
XSLT_TRACE_ALL 
XSLT_TRACE_NONE 
XSLT_TRACE_COPY_TEXT 
XSLT_TRACE_PROCESS_NODE 
XSLT_TRACE_APPLY_TEMPLATE 
XSLT_TRACE_COPY 
XSLT_TRACE_COMMENT 
XSLT_TRACE_PI 
XSLT_TRACE_COPY_OF 
XSLT_TRACE_VALUE_OF 
XSLT_TRACE_CALL_TEMPLATE 
XSLT_TRACE_APPLY_TEMPLATES 
XSLT_TRACE_CHOOSE 
XSLT_TRACE_IF 
XSLT_TRACE_FOR_EACH 
XSLT_TRACE_STRIP_SPACES 
XSLT_TRACE_TEMPLATES 
XSLT_TRACE_KEYS 
XSLT_TRACE_VARIABLES 

Definition at line 101 of file xsltutils.h.

101  {
102  XSLT_TRACE_ALL = -1,
103  XSLT_TRACE_NONE = 0,
104  XSLT_TRACE_COPY_TEXT = 1<<0,
107  XSLT_TRACE_COPY = 1<<3,
108  XSLT_TRACE_COMMENT = 1<<4,
109  XSLT_TRACE_PI = 1<<5,
110  XSLT_TRACE_COPY_OF = 1<<6,
111  XSLT_TRACE_VALUE_OF = 1<<7,
114  XSLT_TRACE_CHOOSE = 1<<10,
115  XSLT_TRACE_IF = 1<<11,
116  XSLT_TRACE_FOR_EACH = 1<<12,
117  XSLT_TRACE_STRIP_SPACES = 1<<13,
118  XSLT_TRACE_TEMPLATES = 1<<14,
119  XSLT_TRACE_KEYS = 1<<15,
120  XSLT_TRACE_VARIABLES = 1<<16
xsltDebugTraceCodes
Definition: xsltutils.h:101

Function Documentation

◆ xslAddCall()

XSLTPUBFUN int XSLTCALL xslAddCall ( xsltTemplatePtr  templ,
xmlNodePtr  source 
)

◆ xslDropCall()

◆ xsltCalibrateAdjust()

XSLTPUBFUN void XSLTCALL xsltCalibrateAdjust ( long  delta)

Referenced by xsltApplyXSLTTemplate().

◆ xsltComputeSortResult()

XSLTPUBFUN xmlXPathObjectPtr* XSLTCALL xsltComputeSortResult ( xsltTransformContextPtr  ctxt,
xmlNodePtr  sort 
)

xsltComputeSortResult: @ctxt: a XSLT process context @sort: node list

reorder the current node list accordingly to the set of sorting requirement provided by the array of nodes.

Returns a ordered XPath nodeset or NULL in case of error.

Definition at line 937 of file xsltutils.c.

937  {
938 #ifdef XSLT_REFACTORED
939  xsltStyleItemSortPtr comp;
940 #else
941  xsltStylePreCompPtr comp;
942 #endif
943  xmlXPathObjectPtr *results = NULL;
944  xmlNodeSetPtr list = NULL;
945  xmlXPathObjectPtr res;
946  int len = 0;
947  int i;
948  xmlNodePtr oldNode;
949  xmlNodePtr oldInst;
950  int oldPos, oldSize ;
951  int oldNsNr;
952  xmlNsPtr *oldNamespaces;
953 
954  comp = sort->psvi;
955  if (comp == NULL) {
957  "xsl:sort : compilation failed\n");
958  return(NULL);
959  }
960 
961  if ((comp->select == NULL) || (comp->comp == NULL))
962  return(NULL);
963 
964  list = ctxt->nodeList;
965  if ((list == NULL) || (list->nodeNr <= 1))
966  return(NULL);
967 
968  len = list->nodeNr;
969 
970  /* TODO: xsl:sort lang attribute */
971  /* TODO: xsl:sort case-order attribute */
972 
973 
974  results = xmlMalloc(len * sizeof(xmlXPathObjectPtr));
975  if (results == NULL) {
977  "xsltComputeSortResult: memory allocation failure\n");
978  return(NULL);
979  }
980 
981  oldNode = ctxt->node;
982  oldInst = ctxt->inst;
983  oldPos = ctxt->xpathCtxt->proximityPosition;
984  oldSize = ctxt->xpathCtxt->contextSize;
985  oldNsNr = ctxt->xpathCtxt->nsNr;
986  oldNamespaces = ctxt->xpathCtxt->namespaces;
987  for (i = 0;i < len;i++) {
988  ctxt->inst = sort;
989  ctxt->xpathCtxt->contextSize = len;
990  ctxt->xpathCtxt->proximityPosition = i + 1;
991  ctxt->node = list->nodeTab[i];
992  ctxt->xpathCtxt->node = ctxt->node;
993 #ifdef XSLT_REFACTORED
994  if (comp->inScopeNs != NULL) {
995  ctxt->xpathCtxt->namespaces = comp->inScopeNs->list;
996  ctxt->xpathCtxt->nsNr = comp->inScopeNs->xpathNumber;
997  } else {
998  ctxt->xpathCtxt->namespaces = NULL;
999  ctxt->xpathCtxt->nsNr = 0;
1000  }
1001 #else
1002  ctxt->xpathCtxt->namespaces = comp->nsList;
1003  ctxt->xpathCtxt->nsNr = comp->nsNr;
1004 #endif
1005  res = xmlXPathCompiledEval(comp->comp, ctxt->xpathCtxt);
1006  if (res != NULL) {
1007  if (res->type != XPATH_STRING)
1008  res = xmlXPathConvertString(res);
1009  if (comp->number)
1010  res = xmlXPathConvertNumber(res);
1011  res->index = i; /* Save original pos for dupl resolv */
1012  if (comp->number) {
1013  if (res->type == XPATH_NUMBER) {
1014  results[i] = res;
1015  } else {
1016 #ifdef WITH_XSLT_DEBUG_PROCESS
1018  "xsltComputeSortResult: select didn't evaluate to a number\n");
1019 #endif
1020  results[i] = NULL;
1021  }
1022  } else {
1023  if (res->type == XPATH_STRING) {
1024  if (comp->locale != (xsltLocale)0) {
1025  xmlChar *str = res->stringval;
1026  res->stringval = (xmlChar *) xsltStrxfrm(comp->locale, str);
1027  xmlFree(str);
1028  }
1029 
1030  results[i] = res;
1031  } else {
1032 #ifdef WITH_XSLT_DEBUG_PROCESS
1034  "xsltComputeSortResult: select didn't evaluate to a string\n");
1035 #endif
1036  results[i] = NULL;
1037  }
1038  }
1039  } else {
1040  ctxt->state = XSLT_STATE_STOPPED;
1041  results[i] = NULL;
1042  }
1043  }
1044  ctxt->node = oldNode;
1045  ctxt->inst = oldInst;
1046  ctxt->xpathCtxt->contextSize = oldSize;
1047  ctxt->xpathCtxt->proximityPosition = oldPos;
1048  ctxt->xpathCtxt->nsNr = oldNsNr;
1049  ctxt->xpathCtxt->namespaces = oldNamespaces;
1050 
1051  return(results);
1052 }
xmlNodeSetPtr nodeList
xsltLocaleChar * xsltStrxfrm(xsltLocale locale, const xmlChar *string)
Definition: xsltlocale.c:359
Definition: tree.h:389
_STLP_MOVE_TO_STD_NAMESPACE void sort(_RandomAccessIter __first, _RandomAccessIter __last)
Definition: _algo.c:993
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
xsltTransformState state
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
xmlXPathContextPtr xpathCtxt
void * xsltGenericDebugContext
Definition: xsltutils.c:549
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
struct _test_info results[8]
Definition: SetCursorPos.c:29
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: tree.h:489
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
Definition: _list.h:228
xmlXPathCompExprPtr comp
XMLPUBVAR xmlMallocFunc xmlMalloc
Definition: globals.h:247
const xmlChar * select
GLuint res
Definition: glext.h:9613

Referenced by xsltDefaultSortFunction().

◆ xsltDebugGetDefaultTrace()

XSLTPUBFUN xsltDebugTraceCodes XSLTCALL xsltDebugGetDefaultTrace ( void  )

xsltDebugGetDefaultTrace:

Get the current default debug tracing level mask

Returns the current default debug tracing level mask

Definition at line 460 of file transform.c.

460  {
461  return xsltDefaultTrace;
462 }
static unsigned long xsltDefaultTrace
Definition: transform.c:441

◆ xsltDebugSetDefaultTrace()

XSLTPUBFUN void XSLTCALL xsltDebugSetDefaultTrace ( xsltDebugTraceCodes  val)

xsltDebugSetDefaultTrace: @val: tracing level mask

Set the default debug tracing level mask

Definition at line 449 of file transform.c.

449  {
451 }
GLuint GLfloat * val
Definition: glext.h:7180
static unsigned long xsltDefaultTrace
Definition: transform.c:441

◆ xsltDefaultSortFunction()

XSLTPUBFUN void XSLTCALL xsltDefaultSortFunction ( xsltTransformContextPtr  ctxt,
xmlNodePtr sorts,
int  nbsorts 
)

xsltDefaultSortFunction: @ctxt: a XSLT process context @sorts: array of sort nodes @nbsorts: the number of sorts in the array

reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes.

Definition at line 1064 of file xsltutils.c.

1065  {
1066 #ifdef XSLT_REFACTORED
1067  xsltStyleItemSortPtr comp;
1068 #else
1069  xsltStylePreCompPtr comp;
1070 #endif
1071  xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
1072  xmlXPathObjectPtr *results = NULL, *res;
1073  xmlNodeSetPtr list = NULL;
1074  int descending, number, desc, numb;
1075  int len = 0;
1076  int i, j, incr;
1077  int tst;
1078  int depth;
1079  xmlNodePtr node;
1080  xmlXPathObjectPtr tmp;
1081  int tempstype[XSLT_MAX_SORT], temporder[XSLT_MAX_SORT];
1082 
1083  if ((ctxt == NULL) || (sorts == NULL) || (nbsorts <= 0) ||
1084  (nbsorts >= XSLT_MAX_SORT))
1085  return;
1086  if (sorts[0] == NULL)
1087  return;
1088  comp = sorts[0]->psvi;
1089  if (comp == NULL)
1090  return;
1091 
1092  list = ctxt->nodeList;
1093  if ((list == NULL) || (list->nodeNr <= 1))
1094  return; /* nothing to do */
1095 
1096  for (j = 0; j < nbsorts; j++) {
1097  comp = sorts[j]->psvi;
1098  tempstype[j] = 0;
1099  if ((comp->stype == NULL) && (comp->has_stype != 0)) {
1100  comp->stype =
1101  xsltEvalAttrValueTemplate(ctxt, sorts[j],
1102  (const xmlChar *) "data-type",
1103  XSLT_NAMESPACE);
1104  if (comp->stype != NULL) {
1105  tempstype[j] = 1;
1106  if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
1107  comp->number = 0;
1108  else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
1109  comp->number = 1;
1110  else {
1111  xsltTransformError(ctxt, NULL, sorts[j],
1112  "xsltDoSortFunction: no support for data-type = %s\n",
1113  comp->stype);
1114  comp->number = 0; /* use default */
1115  }
1116  }
1117  }
1118  temporder[j] = 0;
1119  if ((comp->order == NULL) && (comp->has_order != 0)) {
1120  comp->order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
1121  (const xmlChar *) "order",
1122  XSLT_NAMESPACE);
1123  if (comp->order != NULL) {
1124  temporder[j] = 1;
1125  if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
1126  comp->descending = 0;
1127  else if (xmlStrEqual(comp->order,
1128  (const xmlChar *) "descending"))
1129  comp->descending = 1;
1130  else {
1131  xsltTransformError(ctxt, NULL, sorts[j],
1132  "xsltDoSortFunction: invalid value %s for order\n",
1133  comp->order);
1134  comp->descending = 0; /* use default */
1135  }
1136  }
1137  }
1138  }
1139 
1140  len = list->nodeNr;
1141 
1142  resultsTab[0] = xsltComputeSortResult(ctxt, sorts[0]);
1143  for (i = 1;i < XSLT_MAX_SORT;i++)
1144  resultsTab[i] = NULL;
1145 
1146  results = resultsTab[0];
1147 
1148  comp = sorts[0]->psvi;
1149  descending = comp->descending;
1150  number = comp->number;
1151  if (results == NULL)
1152  return;
1153 
1154  /* Shell's sort of node-set */
1155  for (incr = len / 2; incr > 0; incr /= 2) {
1156  for (i = incr; i < len; i++) {
1157  j = i - incr;
1158  if (results[i] == NULL)
1159  continue;
1160 
1161  while (j >= 0) {
1162  if (results[j] == NULL)
1163  tst = 1;
1164  else {
1165  if (number) {
1166  /* We make NaN smaller than number in accordance
1167  with XSLT spec */
1168  if (xmlXPathIsNaN(results[j]->floatval)) {
1169  if (xmlXPathIsNaN(results[j + incr]->floatval))
1170  tst = 0;
1171  else
1172  tst = -1;
1173  } else if (xmlXPathIsNaN(results[j + incr]->floatval))
1174  tst = 1;
1175  else if (results[j]->floatval ==
1176  results[j + incr]->floatval)
1177  tst = 0;
1178  else if (results[j]->floatval >
1179  results[j + incr]->floatval)
1180  tst = 1;
1181  else tst = -1;
1182  } else if(comp->locale != (xsltLocale)0) {
1183  tst = xsltLocaleStrcmp(
1184  comp->locale,
1185  (xsltLocaleChar *) results[j]->stringval,
1186  (xsltLocaleChar *) results[j + incr]->stringval);
1187  } else {
1188  tst = xmlStrcmp(results[j]->stringval,
1189  results[j + incr]->stringval);
1190  }
1191  if (descending)
1192  tst = -tst;
1193  }
1194  if (tst == 0) {
1195  /*
1196  * Okay we need to use multi level sorts
1197  */
1198  depth = 1;
1199  while (depth < nbsorts) {
1200  if (sorts[depth] == NULL)
1201  break;
1202  comp = sorts[depth]->psvi;
1203  if (comp == NULL)
1204  break;
1205  desc = comp->descending;
1206  numb = comp->number;
1207 
1208  /*
1209  * Compute the result of the next level for the
1210  * full set, this might be optimized ... or not
1211  */
1212  if (resultsTab[depth] == NULL)
1213  resultsTab[depth] = xsltComputeSortResult(ctxt,
1214  sorts[depth]);
1215  res = resultsTab[depth];
1216  if (res == NULL)
1217  break;
1218  if (res[j] == NULL) {
1219  if (res[j+incr] != NULL)
1220  tst = 1;
1221  } else if (res[j+incr] == NULL) {
1222  tst = -1;
1223  } else {
1224  if (numb) {
1225  /* We make NaN smaller than number in
1226  accordance with XSLT spec */
1227  if (xmlXPathIsNaN(res[j]->floatval)) {
1228  if (xmlXPathIsNaN(res[j +
1229  incr]->floatval))
1230  tst = 0;
1231  else
1232  tst = -1;
1233  } else if (xmlXPathIsNaN(res[j + incr]->
1234  floatval))
1235  tst = 1;
1236  else if (res[j]->floatval == res[j + incr]->
1237  floatval)
1238  tst = 0;
1239  else if (res[j]->floatval >
1240  res[j + incr]->floatval)
1241  tst = 1;
1242  else tst = -1;
1243  } else if(comp->locale != (xsltLocale)0) {
1244  tst = xsltLocaleStrcmp(
1245  comp->locale,
1246  (xsltLocaleChar *) res[j]->stringval,
1247  (xsltLocaleChar *) res[j + incr]->stringval);
1248  } else {
1249  tst = xmlStrcmp(res[j]->stringval,
1250  res[j + incr]->stringval);
1251  }
1252  if (desc)
1253  tst = -tst;
1254  }
1255 
1256  /*
1257  * if we still can't differenciate at this level
1258  * try one level deeper.
1259  */
1260  if (tst != 0)
1261  break;
1262  depth++;
1263  }
1264  }
1265  if (tst == 0) {
1266  tst = results[j]->index > results[j + incr]->index;
1267  }
1268  if (tst > 0) {
1269  tmp = results[j];
1270  results[j] = results[j + incr];
1271  results[j + incr] = tmp;
1272  node = list->nodeTab[j];
1273  list->nodeTab[j] = list->nodeTab[j + incr];
1274  list->nodeTab[j + incr] = node;
1275  depth = 1;
1276  while (depth < nbsorts) {
1277  if (sorts[depth] == NULL)
1278  break;
1279  if (resultsTab[depth] == NULL)
1280  break;
1281  res = resultsTab[depth];
1282  tmp = res[j];
1283  res[j] = res[j + incr];
1284  res[j + incr] = tmp;
1285  depth++;
1286  }
1287  j -= incr;
1288  } else
1289  break;
1290  }
1291  }
1292  }
1293 
1294  for (j = 0; j < nbsorts; j++) {
1295  comp = sorts[j]->psvi;
1296  if (tempstype[j] == 1) {
1297  /* The data-type needs to be recomputed each time */
1298  xmlFree((void *)(comp->stype));
1299  comp->stype = NULL;
1300  }
1301  if (temporder[j] == 1) {
1302  /* The order needs to be recomputed each time */
1303  xmlFree((void *)(comp->order));
1304  comp->order = NULL;
1305  }
1306  if (resultsTab[j] != NULL) {
1307  for (i = 0;i < len;i++)
1308  xmlXPathFreeObject(resultsTab[j][i]);
1309  xmlFree(resultsTab[j]);
1310  }
1311  }
1312 }
xmlNodeSetPtr nodeList
void * psvi
Definition: tree.h:505
int xsltLocaleStrcmp(xsltLocale locale, const xsltLocaleChar *str1, const xsltLocaleChar *str2)
Definition: xsltlocale.c:422
#define XSLT_NAMESPACE
Definition: xslt.h:46
const xmlChar * order
xmlChar * xsltEvalAttrValueTemplate(xsltTransformContextPtr ctxt, xmlNodePtr inst, const xmlChar *name, const xmlChar *ns)
Definition: templates.c:384
struct node node
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define XSLT_MAX_SORT
static size_t double number
Definition: printf.c:69
static const WCHAR desc[]
Definition: protectdata.c:36
const xmlChar * stype
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
xmlChar xsltLocaleChar
Definition: xsltlocale.h:64
struct _test_info results[8]
Definition: SetCursorPos.c:29
Definition: tree.h:489
GLint GLint GLsizei GLsizei GLsizei depth
Definition: gl.h:1546
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
Definition: _list.h:228
xmlXPathObjectPtr * xsltComputeSortResult(xsltTransformContextPtr ctxt, xmlNodePtr sort)
Definition: xsltutils.c:937
GLuint res
Definition: glext.h:9613
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678
Definition: dlist.c:348
XMLPUBFUN int XMLCALL xmlStrcmp(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:132

Referenced by xsltSetSortFunc().

◆ xsltDocumentSortFunction()

XSLTPUBFUN void XSLTCALL xsltDocumentSortFunction ( xmlNodeSetPtr  list)

xsltDocumentSortFunction: @list: the node set

reorder the current node list @list accordingly to the document order This function is slow, obsolete and should not be used anymore.

Definition at line 903 of file xsltutils.c.

903  {
904  int i, j;
905  int len, tst;
907 
908  if (list == NULL)
909  return;
910  len = list->nodeNr;
911  if (len <= 1)
912  return;
913  /* TODO: sort is really not optimized, does it needs to ? */
914  for (i = 0;i < len -1;i++) {
915  for (j = i + 1; j < len; j++) {
916  tst = xmlXPathCmpNodes(list->nodeTab[i], list->nodeTab[j]);
917  if (tst == -1) {
918  node = list->nodeTab[i];
919  list->nodeTab[i] = list->nodeTab[j];
920  list->nodeTab[j] = node;
921  }
922  }
923  }
924 }
struct node node
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
smooth NULL
Definition: ftsmooth.c:416
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
Definition: tree.h:489
GLenum GLsizei len
Definition: glext.h:6722
Definition: _list.h:228
Definition: dlist.c:348

◆ xsltDoSortFunction()

XSLTPUBFUN void XSLTCALL xsltDoSortFunction ( xsltTransformContextPtr  ctxt,
xmlNodePtr sorts,
int  nbsorts 
)

xsltDoSortFunction: @ctxt: a XSLT process context @sorts: array of sort nodes @nbsorts: the number of sorts in the array

reorder the current node list accordingly to the set of sorting requirement provided by the arry of nodes. This is a wrapper function, the actual function used is specified using xsltSetCtxtSortFunc() to set the context specific sort function, or xsltSetSortFunc() to set the global sort function. If a sort function is set on the context, this will get called. Otherwise the global sort function is called.

Definition at line 1332 of file xsltutils.c.

1334 {
1335  if (ctxt->sortfunc != NULL)
1336  (ctxt->sortfunc)(ctxt, sorts, nbsorts);
1337  else if (xsltSortFunction != NULL)
1338  xsltSortFunction(ctxt, sorts, nbsorts);
1339 }
static xsltSortFunc xsltSortFunction
Definition: xsltutils.c:1315
smooth NULL
Definition: ftsmooth.c:416

Referenced by xsltApplyTemplates(), and xsltForEach().

◆ xsltGetCNsProp()

XSLTPUBFUN const xmlChar* XSLTCALL xsltGetCNsProp ( xsltStylesheetPtr  style,
xmlNodePtr  node,
const xmlChar name,
const xmlChar nameSpace 
)

Definition at line 52 of file xsltutils.c.

53  {
54  xmlAttrPtr prop;
55  xmlDocPtr doc;
56  xmlNsPtr ns;
57  xmlChar *tmp;
58  const xmlChar *ret;
59 
60  if ((node == NULL) || (style == NULL) || (style->dict == NULL))
61  return(NULL);
62 
63  if (nameSpace == NULL)
64  return xmlGetProp(node, name);
65 
66  if (node->type == XML_NAMESPACE_DECL)
67  return(NULL);
68  if (node->type == XML_ELEMENT_NODE)
69  prop = node->properties;
70  else
71  prop = NULL;
72  while (prop != NULL) {
73  /*
74  * One need to have
75  * - same attribute names
76  * - and the attribute carrying that namespace
77  */
78  if ((xmlStrEqual(prop->name, name)) &&
79  (((prop->ns == NULL) && (node->ns != NULL) &&
80  (xmlStrEqual(node->ns->href, nameSpace))) ||
81  ((prop->ns != NULL) &&
82  (xmlStrEqual(prop->ns->href, nameSpace))))) {
83 
84  tmp = xmlNodeListGetString(node->doc, prop->children, 1);
85  if (tmp == NULL)
86  ret = xmlDictLookup(style->dict, BAD_CAST "", 0);
87  else {
88  ret = xmlDictLookup(style->dict, tmp, -1);
89  xmlFree(tmp);
90  }
91  return ret;
92  }
93  prop = prop->next;
94  }
95  tmp = NULL;
96  /*
97  * Check if there is a default declaration in the internal
98  * or external subsets
99  */
100  doc = node->doc;
101  if (doc != NULL) {
102  if (doc->intSubset != NULL) {
103  xmlAttributePtr attrDecl;
104 
105  attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
106  if ((attrDecl == NULL) && (doc->extSubset != NULL))
107  attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
108 
109  if ((attrDecl != NULL) && (attrDecl->prefix != NULL)) {
110  /*
111  * The DTD declaration only allows a prefix search
112  */
113  ns = xmlSearchNs(doc, node, attrDecl->prefix);
114  if ((ns != NULL) && (xmlStrEqual(ns->href, nameSpace)))
115  return(xmlDictLookup(style->dict,
116  attrDecl->defaultValue, -1));
117  }
118  }
119  }
120  return(NULL);
121 }
const xmlChar * prefix
Definition: tree.h:269
xmlNs * ns
Definition: tree.h:444
struct _xmlDtd * intSubset
Definition: tree.h:570
Definition: tree.h:389
XMLPUBFUN xmlChar *XMLCALL xmlGetProp(const xmlNode *node, const xmlChar *name)
struct _xmlAttr * next
Definition: tree.h:441
struct _xmlNode * children
Definition: tree.h:438
XMLPUBFUN xmlAttributePtr XMLCALL xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
Definition: valid.c:3341
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
smooth NULL
Definition: ftsmooth.c:416
#define BAD_CAST
Definition: xmlstring.h:35
const xmlChar * defaultValue
Definition: tree.h:267
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:865
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
Definition: tree.h:551
struct _xmlDtd * extSubset
Definition: tree.h:571
Definition: tree.h:434
Definition: name.c:38
const xmlChar * name
Definition: tree.h:437
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
const xmlChar * href
Definition: tree.h:392
Definition: dlist.c:348

Referenced by xsltApplyTemplatesComp(), xsltCopyComp(), xsltCopyOfComp(), xsltForEachComp(), xsltGetQNameProperty(), xsltIfComp(), xsltNumberComp(), xsltParamComp(), xsltSortComp(), xsltTextComp(), xsltValueOfComp(), xsltVariableComp(), xsltWhenComp(), and xsltWithParamComp().

◆ xsltGetDebuggerStatus()

XSLTPUBFUN int XSLTCALL xsltGetDebuggerStatus ( void  )

xsltGetDebuggerStatus:

Get xslDebugStatus.

Returns the value of xslDebugStatus.

Definition at line 2339 of file xsltutils.c.

2340 {
2341  return(xslDebugStatus);
2342 }
int xslDebugStatus
Definition: xsltutils.c:2329

◆ xsltGetNsProp()

XSLTPUBFUN xmlChar* XSLTCALL xsltGetNsProp ( xmlNodePtr  node,
const xmlChar name,
const xmlChar nameSpace 
)

Definition at line 142 of file xsltutils.c.

142  {
143  xmlAttrPtr prop;
144  xmlDocPtr doc;
145  xmlNsPtr ns;
146 
147  if (node == NULL)
148  return(NULL);
149 
150  if (nameSpace == NULL)
151  return xmlGetProp(node, name);
152 
153  if (node->type == XML_NAMESPACE_DECL)
154  return(NULL);
155  if (node->type == XML_ELEMENT_NODE)
156  prop = node->properties;
157  else
158  prop = NULL;
159  /*
160  * TODO: Substitute xmlGetProp() for xmlGetNsProp(), since the former
161  * is not namespace-aware and will return an attribute with equal
162  * name regardless of its namespace.
163  * Example:
164  * <xsl:element foo:name="myName"/>
165  * So this would return "myName" even if an attribute @name
166  * in the XSLT was requested.
167  */
168  while (prop != NULL) {
169  /*
170  * One need to have
171  * - same attribute names
172  * - and the attribute carrying that namespace
173  */
174  if ((xmlStrEqual(prop->name, name)) &&
175  (((prop->ns == NULL) && (node->ns != NULL) &&
176  (xmlStrEqual(node->ns->href, nameSpace))) ||
177  ((prop->ns != NULL) &&
178  (xmlStrEqual(prop->ns->href, nameSpace))))) {
179  xmlChar *ret;
180 
181  ret = xmlNodeListGetString(node->doc, prop->children, 1);
182  if (ret == NULL) return(xmlStrdup((xmlChar *)""));
183  return(ret);
184  }
185  prop = prop->next;
186  }
187 
188  /*
189  * Check if there is a default declaration in the internal
190  * or external subsets
191  */
192  doc = node->doc;
193  if (doc != NULL) {
194  if (doc->intSubset != NULL) {
195  xmlAttributePtr attrDecl;
196 
197  attrDecl = xmlGetDtdAttrDesc(doc->intSubset, node->name, name);
198  if ((attrDecl == NULL) && (doc->extSubset != NULL))
199  attrDecl = xmlGetDtdAttrDesc(doc->extSubset, node->name, name);
200 
201  if ((attrDecl != NULL) && (attrDecl->prefix != NULL)) {
202  /*
203  * The DTD declaration only allows a prefix search
204  */
205  ns = xmlSearchNs(doc, node, attrDecl->prefix);
206  if ((ns != NULL) && (xmlStrEqual(ns->href, nameSpace)))
207  return(xmlStrdup(attrDecl->defaultValue));
208  }
209  }
210  }
211  return(NULL);
212 }
const xmlChar * prefix
Definition: tree.h:269
xmlNs * ns
Definition: tree.h:444
struct _xmlDtd * intSubset
Definition: tree.h:570
Definition: tree.h:389
XMLPUBFUN xmlChar *XMLCALL xmlGetProp(const xmlNode *node, const xmlChar *name)
struct _xmlAttr * next
Definition: tree.h:441
struct _xmlNode * children
Definition: tree.h:438
XMLPUBFUN xmlAttributePtr XMLCALL xmlGetDtdAttrDesc(xmlDtdPtr dtd, const xmlChar *elem, const xmlChar *name)
Definition: valid.c:3341
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
smooth NULL
Definition: ftsmooth.c:416
const xmlChar * defaultValue
Definition: tree.h:267
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
Definition: tree.h:551
struct _xmlDtd * extSubset
Definition: tree.h:571
Definition: tree.h:434
Definition: name.c:38
const xmlChar * name
Definition: tree.h:437
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
const xmlChar * href
Definition: tree.h:392
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:66
Definition: dlist.c:348

Referenced by xsltEvalAttrValueTemplate(), and xsltEvalStaticAttrValueTemplate().

◆ xsltGetProfileInformation()

XSLTPUBFUN xmlDocPtr XSLTCALL xsltGetProfileInformation ( xsltTransformContextPtr  ctxt)

◆ xsltGetQNameURI()

XSLTPUBFUN const xmlChar* XSLTCALL xsltGetQNameURI ( xmlNodePtr  node,
xmlChar **  name 
)

Definition at line 753 of file xsltutils.c.

754 {
755  int len = 0;
756  xmlChar *qname;
757  xmlNsPtr ns;
758 
759  if (name == NULL)
760  return(NULL);
761  qname = *name;
762  if ((qname == NULL) || (*qname == 0))
763  return(NULL);
764  if (node == NULL) {
766  "QName: no element for namespace lookup %s\n",
767  qname);
768  xmlFree(qname);
769  *name = NULL;
770  return(NULL);
771  }
772 
773  /* nasty but valid */
774  if (qname[0] == ':')
775  return(NULL);
776 
777  /*
778  * we are not trying to validate but just to cut, and yes it will
779  * work even if this is a set of UTF-8 encoded chars
780  */
781  while ((qname[len] != 0) && (qname[len] != ':'))
782  len++;
783 
784  if (qname[len] == 0)
785  return(NULL);
786 
787  /*
788  * handle xml: separately, this one is magical
789  */
790  if ((qname[0] == 'x') && (qname[1] == 'm') &&
791  (qname[2] == 'l') && (qname[3] == ':')) {
792  if (qname[4] == 0)
793  return(NULL);
794  *name = xmlStrdup(&qname[4]);
795  xmlFree(qname);
796  return(XML_XML_NAMESPACE);
797  }
798 
799  qname[len] = 0;
800  ns = xmlSearchNs(node->doc, node, qname);
801  if (ns == NULL) {
803  "%s:%s : no namespace bound to prefix %s\n",
804  qname, &qname[len + 1], qname);
805  *name = NULL;
806  xmlFree(qname);
807  return(NULL);
808  }
809  *name = xmlStrdup(&qname[len + 1]);
810  xmlFree(qname);
811  return(ns->href);
812 }
Definition: tree.h:389
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
smooth NULL
Definition: ftsmooth.c:416
#define XML_XML_NAMESPACE
Definition: tree.h:140
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
Definition: name.c:38
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:66
Definition: dlist.c:348
GLuint const GLchar * name
Definition: glext.h:6031

Referenced by xsltCompileStepPattern(), xsltDocumentElem(), xsltParseStylesheetDecimalFormat(), xsltParseStylesheetKey(), xsltParseStylesheetOutput(), xsltParseStylesheetPreserveSpace(), xsltParseStylesheetStripSpace(), and xsltParseStylesheetTemplate().

◆ xsltGetQNameURI2()

XSLTPUBFUN const xmlChar* XSLTCALL xsltGetQNameURI2 ( xsltStylesheetPtr  style,
xmlNodePtr  node,
const xmlChar **  name 
)

Definition at line 827 of file xsltutils.c.

828  {
829  int len = 0;
830  xmlChar *qname;
831  xmlNsPtr ns;
832 
833  if (name == NULL)
834  return(NULL);
835  qname = (xmlChar *)*name;
836  if ((qname == NULL) || (*qname == 0))
837  return(NULL);
838  if (node == NULL) {
840  "QName: no element for namespace lookup %s\n",
841  qname);
842  *name = NULL;
843  return(NULL);
844  }
845 
846  /*
847  * we are not trying to validate but just to cut, and yes it will
848  * work even if this is a set of UTF-8 encoded chars
849  */
850  while ((qname[len] != 0) && (qname[len] != ':'))
851  len++;
852 
853  if (qname[len] == 0)
854  return(NULL);
855 
856  /*
857  * handle xml: separately, this one is magical
858  */
859  if ((qname[0] == 'x') && (qname[1] == 'm') &&
860  (qname[2] == 'l') && (qname[3] == ':')) {
861  if (qname[4] == 0)
862  return(NULL);
863  *name = xmlDictLookup(style->dict, &qname[4], -1);
864  return(XML_XML_NAMESPACE);
865  }
866 
867  qname = xmlStrndup(*name, len);
868  ns = xmlSearchNs(node->doc, node, qname);
869  if (ns == NULL) {
870  if (style) {
872  "No namespace bound to prefix '%s'.\n",
873  qname);
874  style->errors++;
875  } else {
877  "%s : no namespace bound to prefix %s\n",
878  *name, qname);
879  }
880  *name = NULL;
881  xmlFree(qname);
882  return(NULL);
883  }
884  *name = xmlDictLookup(style->dict, (*name)+len+1, -1);
885  xmlFree(qname);
886  return(ns->href);
887 }
Definition: tree.h:389
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:41
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
smooth NULL
Definition: ftsmooth.c:416
#define XML_XML_NAMESPACE
Definition: tree.h:140
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:865
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
Definition: name.c:38
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678
Arabic default style
Definition: afstyles.h:93
Definition: dlist.c:348

Referenced by xsltGetQNameProperty().

◆ xsltGetUTF8Char()

XSLTPUBFUN int XSLTCALL xsltGetUTF8Char ( const unsigned char utf,
int len 
)

xsltGetUTF8Char: @utf: a sequence of UTF-8 encoded bytes @len: a pointer to @bytes len

Read one UTF8 Char from @utf Function copied from libxml2 xmlGetUTF8Char() ... to discard ultimately and use the original API

Returns the char value or -1 in case of error and update @len with the number of bytes used

Definition at line 227 of file xsltutils.c.

227  {
228  unsigned int c;
229 
230  if (utf == NULL)
231  goto error;
232  if (len == NULL)
233  goto error;
234  if (*len < 1)
235  goto error;
236 
237  c = utf[0];
238  if (c & 0x80) {
239  if (*len < 2)
240  goto error;
241  if ((utf[1] & 0xc0) != 0x80)
242  goto error;
243  if ((c & 0xe0) == 0xe0) {
244  if (*len < 3)
245  goto error;
246  if ((utf[2] & 0xc0) != 0x80)
247  goto error;
248  if ((c & 0xf0) == 0xf0) {
249  if (*len < 4)
250  goto error;
251  if ((c & 0xf8) != 0xf0 || (utf[3] & 0xc0) != 0x80)
252  goto error;
253  *len = 4;
254  /* 4-byte code */
255  c = (utf[0] & 0x7) << 18;
256  c |= (utf[1] & 0x3f) << 12;
257  c |= (utf[2] & 0x3f) << 6;
258  c |= utf[3] & 0x3f;
259  } else {
260  /* 3-byte code */
261  *len = 3;
262  c = (utf[0] & 0xf) << 12;
263  c |= (utf[1] & 0x3f) << 6;
264  c |= utf[2] & 0x3f;
265  }
266  } else {
267  /* 2-byte code */
268  *len = 2;
269  c = (utf[0] & 0x1f) << 6;
270  c |= utf[1] & 0x3f;
271  }
272  } else {
273  /* 1-byte code */
274  *len = 1;
275  }
276  return(c);
277 
278 error:
279  if (len != NULL)
280  *len = 0;
281  return(-1);
282 }
#define error(str)
Definition: mkdosfs.c:1605
smooth NULL
Definition: ftsmooth.c:416
const GLubyte * c
Definition: glext.h:8905
GLenum GLsizei len
Definition: glext.h:6722
#define c
Definition: ke_i.h:80

Referenced by xsltFormatNumberConversion(), and xsltNumberComp().

◆ xsltMessage()

XSLTPUBFUN void XSLTCALL xsltMessage ( xsltTransformContextPtr  ctxt,
xmlNodePtr  node,
xmlNodePtr  inst 
)

xsltMessage: @ctxt: an XSLT processing context @node: The current node @inst: The node containing the message instruction

Process and xsl:message construct

Definition at line 408 of file xsltutils.c.

408  {
410  void *errctx = xsltGenericErrorContext;
411  xmlChar *prop, *message;
412  int terminate = 0;
413 
414  if ((ctxt == NULL) || (inst == NULL))
415  return;
416 
417  if (ctxt->error != NULL) {
418  error = ctxt->error;
419  errctx = ctxt->errctx;
420  }
421 
422  prop = xmlGetNsProp(inst, (const xmlChar *)"terminate", NULL);
423  if (prop != NULL) {
424  if (xmlStrEqual(prop, (const xmlChar *)"yes")) {
425  terminate = 1;
426  } else if (xmlStrEqual(prop, (const xmlChar *)"no")) {
427  terminate = 0;
428  } else {
429  xsltTransformError(ctxt, NULL, inst,
430  "xsl:message : terminate expecting 'yes' or 'no'\n");
431  }
432  xmlFree(prop);
433  }
434  message = xsltEvalTemplateString(ctxt, node, inst);
435  if (message != NULL) {
436  int len = xmlStrlen(message);
437 
438  error(errctx, "%s", (const char *)message);
439  if ((len > 0) && (message[len - 1] != '\n'))
440  error(errctx, "\n");
441  xmlFree(message);
442  }
443  if (terminate)
444  ctxt->state = XSLT_STATE_STOPPED;
445 }
Definition: tftpd.h:59
#define error(str)
Definition: mkdosfs.c:1605
XMLPUBFUN int XMLCALL xmlStrlen(const xmlChar *str)
Definition: xmlstring.c:422
GLenum GLuint GLenum GLsizei const GLchar * message
Definition: glext.h:5579
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
xsltTransformState state
smooth NULL
Definition: ftsmooth.c:416
void MSVCRT() terminate()
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:250
XMLPUBFUN xmlChar *XMLCALL xmlGetNsProp(const xmlNode *node, const xmlChar *name, const xmlChar *nameSpace)
void * xsltGenericErrorContext
Definition: xsltutils.c:503
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
xmlGenericErrorFunc error
xmlChar * xsltEvalTemplateString(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst)
Definition: templates.c:189
void(XMLCDECL * xmlGenericErrorFunc)(void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
Definition: xmlerror.h:845
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678
Definition: dlist.c:348

Referenced by xsltApplySequenceConstructor(), and xsltMessageWrapper().

◆ xsltPrintErrorContext()

XSLTPUBFUN void XSLTCALL xsltPrintErrorContext ( xsltTransformContextPtr  ctxt,
xsltStylesheetPtr  style,
xmlNodePtr  node 
)

xsltPrintErrorContext: @ctxt: the transformation context @style: the stylesheet @node: the current node being processed

Display the context of an error.

Definition at line 583 of file xsltutils.c.

584  {
585  int line = 0;
586  const xmlChar *file = NULL;
587  const xmlChar *name = NULL;
588  const char *type = "error";
590  void *errctx = xsltGenericErrorContext;
591 
592  if (ctxt != NULL) {
593  if (ctxt->state == XSLT_STATE_OK)
594  ctxt->state = XSLT_STATE_ERROR;
595  if (ctxt->error != NULL) {
596  error = ctxt->error;
597  errctx = ctxt->errctx;
598  }
599  }
600  if ((node == NULL) && (ctxt != NULL))
601  node = ctxt->inst;
602 
603  if (node != NULL) {
604  if ((node->type == XML_DOCUMENT_NODE) ||
605  (node->type == XML_HTML_DOCUMENT_NODE)) {
606  xmlDocPtr doc = (xmlDocPtr) node;
607 
608  file = doc->URL;
609  } else {
611  if ((node->doc != NULL) && (node->doc->URL != NULL))
612  file = node->doc->URL;
613  if (node->name != NULL)
614  name = node->name;
615  }
616  }
617 
618  if (ctxt != NULL)
619  type = "runtime error";
620  else if (style != NULL) {
621 #ifdef XSLT_REFACTORED
622  if (XSLT_CCTXT(style)->errSeverity == XSLT_ERROR_SEVERITY_WARNING)
623  type = "compilation warning";
624  else
625  type = "compilation error";
626 #else
627  type = "compilation error";
628 #endif
629  }
630 
631  if ((file != NULL) && (line != 0) && (name != NULL))
632  error(errctx, "%s: file %s line %d element %s\n",
633  type, file, line, name);
634  else if ((file != NULL) && (name != NULL))
635  error(errctx, "%s: file %s element %s\n", type, file, name);
636  else if ((file != NULL) && (line != 0))
637  error(errctx, "%s: file %s line %d\n", type, file, line);
638  else if (file != NULL)
639  error(errctx, "%s: file %s\n", type, file);
640  else if (name != NULL)
641  error(errctx, "%s: element %s\n", type, name);
642  else
643  error(errctx, "%s\n", type);
644 }
const xmlChar * URL
Definition: tree.h:577
#define error(str)
Definition: mkdosfs.c:1605
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
xsltTransformState state
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
XMLPUBFUN long XMLCALL xmlGetLineNo(const xmlNode *node)
void * xsltGenericErrorContext
Definition: xsltutils.c:503
unsigned char xmlChar
Definition: xmlstring.h:28
xmlDoc * xmlDocPtr
Definition: tree.h:550
xmlGenericErrorFunc error
Definition: tree.h:551
Definition: name.c:38
void(XMLCDECL * xmlGenericErrorFunc)(void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
Definition: xmlerror.h:845
Arabic default style
Definition: afstyles.h:93
Definition: dlist.c:348
Definition: fci.c:126

Referenced by xsltTransformError().

◆ xsltSaveProfiling()

XSLTPUBFUN void XSLTCALL xsltSaveProfiling ( xsltTransformContextPtr  ctxt,
FILE output 
)

◆ xsltSaveResultTo()

XSLTPUBFUN int XSLTCALL xsltSaveResultTo ( xmlOutputBufferPtr  buf,
xmlDocPtr  result,
xsltStylesheetPtr  style 
)

xsltSaveResultTo: @buf: an output buffer

Returns
: the result xmlDocPtr @style: the stylesheet

Save the result

Returns
obtained by applying the @style stylesheet to an I/O output channel @buf

Returns the number of byte written or -1 in case of failure.

Definition at line 1423 of file xsltutils.c.

1424  {
1425  const xmlChar *encoding;
1426  int base;
1427  const xmlChar *method;
1428  int indent;
1429 
1430  if ((buf == NULL) || (result == NULL) || (style == NULL))
1431  return(-1);
1432  if ((result->children == NULL) ||
1433  ((result->children->type == XML_DTD_NODE) &&
1434  (result->children->next == NULL)))
1435  return(0);
1436 
1437  if ((style->methodURI != NULL) &&
1438  ((style->method == NULL) ||
1439  (!xmlStrEqual(style->method, (const xmlChar *) "xhtml")))) {
1441  "xsltSaveResultTo : unknown output method\n");
1442  return(-1);
1443  }
1444 
1445  base = buf->written;
1446 
1450 
1451  if ((method == NULL) && (result->type == XML_HTML_DOCUMENT_NODE))
1452  method = (const xmlChar *) "html";
1453 
1454  if ((method != NULL) &&
1455  (xmlStrEqual(method, (const xmlChar *) "html"))) {
1456  if (encoding != NULL) {
1457  htmlSetMetaEncoding(result, (const xmlChar *) encoding);
1458  } else {
1459  htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
1460  }
1461  if (indent == -1)
1462  indent = 1;
1463  htmlDocContentDumpFormatOutput(buf, result, (const char *) encoding,
1464  indent);
1465  xmlOutputBufferFlush(buf);
1466  } else if ((method != NULL) &&
1467  (xmlStrEqual(method, (const xmlChar *) "xhtml"))) {
1468  if (encoding != NULL) {
1469  htmlSetMetaEncoding(result, (const xmlChar *) encoding);
1470  } else {
1471  htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
1472  }
1473  htmlDocContentDumpOutput(buf, result, (const char *) encoding);
1474  xmlOutputBufferFlush(buf);
1475  } else if ((method != NULL) &&
1476  (xmlStrEqual(method, (const xmlChar *) "text"))) {
1477  xmlNodePtr cur;
1478 
1479  cur = result->children;
1480  while (cur != NULL) {
1481  if (cur->type == XML_TEXT_NODE)
1482  xmlOutputBufferWriteString(buf, (const char *) cur->content);
1483 
1484  /*
1485  * Skip to next node
1486  */
1487  if (cur->children != NULL) {
1488  if ((cur->children->type != XML_ENTITY_DECL) &&
1489  (cur->children->type != XML_ENTITY_REF_NODE) &&
1490  (cur->children->type != XML_ENTITY_NODE)) {
1491  cur = cur->children;
1492  continue;
1493  }
1494  }
1495  if (cur->next != NULL) {
1496  cur = cur->next;
1497  continue;
1498  }
1499 
1500  do {
1501  cur = cur->parent;
1502  if (cur == NULL)
1503  break;
1504  if (cur == (xmlNodePtr) style->doc) {
1505  cur = NULL;
1506  break;
1507  }
1508  if (cur->next != NULL) {
1509  cur = cur->next;
1510  break;
1511  }
1512  } while (cur != NULL);
1513  }
1514  xmlOutputBufferFlush(buf);
1515  } else {
1516  int omitXmlDecl;
1517  int standalone;
1518 
1519  XSLT_GET_IMPORT_INT(omitXmlDecl, style, omitXmlDeclaration);
1520  XSLT_GET_IMPORT_INT(standalone, style, standalone);
1521 
1522  if (omitXmlDecl != 1) {
1523  xmlOutputBufferWriteString(buf, "<?xml version=");
1524  if (result->version != NULL) {
1525  xmlOutputBufferWriteString(buf, "\"");
1526  xmlOutputBufferWriteString(buf, (const char *)result->version);
1527  xmlOutputBufferWriteString(buf, "\"");
1528  } else
1529  xmlOutputBufferWriteString(buf, "\"1.0\"");
1530  if (encoding == NULL) {
1531  if (result->encoding != NULL)
1532  encoding = result->encoding;
1533  else if (result->charset != XML_CHAR_ENCODING_UTF8)
1534  encoding = (const xmlChar *)
1536  result->charset);
1537  }
1538  if (encoding != NULL) {
1539  xmlOutputBufferWriteString(buf, " encoding=");
1540  xmlOutputBufferWriteString(buf, "\"");
1541  xmlOutputBufferWriteString(buf, (const char *) encoding);
1542  xmlOutputBufferWriteString(buf, "\"");
1543  }
1544  switch (standalone) {
1545  case 0:
1546  xmlOutputBufferWriteString(buf, " standalone=\"no\"");
1547  break;
1548  case 1:
1549  xmlOutputBufferWriteString(buf, " standalone=\"yes\"");
1550  break;
1551  default:
1552  break;
1553  }
1554  xmlOutputBufferWriteString(buf, "?>\n");
1555  }
1556  if (result->children != NULL) {
1557  xmlNodePtr children = result->children;
1558  xmlNodePtr child = children;
1559 
1560  /*
1561  * Hack to avoid quadratic behavior when scanning
1562  * result->children in xmlGetIntSubset called by
1563  * xmlNodeDumpOutput.
1564  */
1565  result->children = NULL;
1566 
1567  while (child != NULL) {
1568  xmlNodeDumpOutput(buf, result, child, 0, (indent == 1),
1569  (const char *) encoding);
1570  if (indent && ((child->type == XML_DTD_NODE) ||
1571  ((child->type == XML_COMMENT_NODE) &&
1572  (child->next != NULL))))
1573  xmlOutputBufferWriteString(buf, "\n");
1574  child = child->next;
1575  }
1576  if (indent)
1577  xmlOutputBufferWriteString(buf, "\n");
1578 
1579  result->children = children;
1580  }
1581  xmlOutputBufferFlush(buf);
1582  }
1583  return(buf->written - base);
1584 }
static const WCHAR indent[]
Definition: object.c:1156
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlCharEncoding
Definition: encoding.h:58
XMLPUBFUN const char *XMLCALL xmlGetCharEncodingName(xmlCharEncoding enc)
Definition: encoding.c:1234
static HWND child
Definition: cursoricon.c:298
#define XSLT_GET_IMPORT_INT(res, style, name)
Definition: imports.h:40
GLuint base
Definition: 3dtext.c:35
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
smooth NULL
Definition: ftsmooth.c:416
struct _xmlNode * parent
Definition: tree.h:495
xmlChar * content
Definition: tree.h:502
method
Definition: dragdrop.c:53
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: tree.h:489
unsigned char xmlChar
Definition: xmlstring.h:28
xmlElementType type
Definition: tree.h:491
ed encoding
Definition: write.c:2825
struct _xmlNode * next
Definition: tree.h:496
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
struct _xmlNode * children
Definition: tree.h:493
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
GLuint64EXT * result
Definition: glext.h:11304

Referenced by xsltRunStylesheetUser(), xsltSaveResultToFd(), xsltSaveResultToFile(), xsltSaveResultToFilename(), and xsltSaveResultToString().

◆ xsltSaveResultToFd()

XSLTPUBFUN int XSLTCALL xsltSaveResultToFd ( int  fd,
xmlDocPtr  result,
xsltStylesheetPtr  style 
)

xsltSaveResultToFd: @fd: a file descriptor

Returns
: the result xmlDocPtr @style: the stylesheet

Save the result

Returns
obtained by applying the @style stylesheet to an open file descriptor This does not close the descriptor.

Returns the number of bytes written or -1 in case of failure.

Definition at line 1687 of file xsltutils.c.

1687  {
1689  const xmlChar *encoding;
1690  int ret;
1691 
1692  if ((fd < 0) || (result == NULL) || (style == NULL))
1693  return(-1);
1694  if (result->children == NULL)
1695  return(0);
1696 
1698  if (encoding != NULL) {
1699  xmlCharEncodingHandlerPtr encoder;
1700 
1701  encoder = xmlFindCharEncodingHandler((char *)encoding);
1702  if ((encoder != NULL) &&
1703  (xmlStrEqual((const xmlChar *)encoder->name,
1704  (const xmlChar *) "UTF-8")))
1705  encoder = NULL;
1706  buf = xmlOutputBufferCreateFd(fd, encoder);
1707  } else {
1708  buf = xmlOutputBufferCreateFd(fd, NULL);
1709  }
1710  if (buf == NULL)
1711  return(-1);
1713  ret = xmlOutputBufferClose(buf);
1714  return(ret);
1715 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static int fd
Definition: io.c:51
xmlOutputBuffer * xmlOutputBufferPtr
Definition: tree.h:32
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1423
smooth NULL
Definition: ftsmooth.c:416
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1641
unsigned char xmlChar
Definition: xmlstring.h:28
ed encoding
Definition: write.c:2825
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
GLuint64EXT * result
Definition: glext.h:11304

◆ xsltSaveResultToFile()

XSLTPUBFUN int XSLTCALL xsltSaveResultToFile ( FILE file,
xmlDocPtr  result,
xsltStylesheetPtr  style 
)

Definition at line 1643 of file xsltutils.c.

1643  {
1645  const xmlChar *encoding;
1646  int ret;
1647 
1648  if ((file == NULL) || (result == NULL) || (style == NULL))
1649  return(-1);
1650  if (result->children == NULL)
1651  return(0);
1652 
1654  if (encoding != NULL) {
1655  xmlCharEncodingHandlerPtr encoder;
1656 
1657  encoder = xmlFindCharEncodingHandler((char *)encoding);
1658  if ((encoder != NULL) &&
1659  (xmlStrEqual((const xmlChar *)encoder->name,
1660  (const xmlChar *) "UTF-8")))
1661  encoder = NULL;
1662  buf = xmlOutputBufferCreateFile(file, encoder);
1663  } else {
1664  buf = xmlOutputBufferCreateFile(file, NULL);
1665  }
1666 
1667  if (buf == NULL)
1668  return(-1);
1670  ret = xmlOutputBufferClose(buf);
1671  return(ret);
1672 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlOutputBuffer * xmlOutputBufferPtr
Definition: tree.h:32
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1423
smooth NULL
Definition: ftsmooth.c:416
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1641
unsigned char xmlChar
Definition: xmlstring.h:28
ed encoding
Definition: write.c:2825
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
GLuint64EXT * result
Definition: glext.h:11304
Definition: fci.c:126

Referenced by xsltDocumentElem().

◆ xsltSaveResultToFilename()

XSLTPUBFUN int XSLTCALL xsltSaveResultToFilename ( const char URL,
xmlDocPtr  result,
xsltStylesheetPtr  style,
int  compression 
)

xsltSaveResultToFilename: @URL: a filename or URL

Returns
: the result xmlDocPtr @style: the stylesheet @compression: the compression factor (0 - 9 included)

Save the result

Returns
obtained by applying the @style stylesheet to a file or @URL

Returns the number of byte written or -1 in case of failure.

Definition at line 1599 of file xsltutils.c.

1600  {
1602  const xmlChar *encoding;
1603  int ret;
1604 
1605  if ((URL == NULL) || (result == NULL) || (style == NULL))
1606  return(-1);
1607  if (result->children == NULL)
1608  return(0);
1609 
1611  if (encoding != NULL) {
1612  xmlCharEncodingHandlerPtr encoder;
1613 
1614  encoder = xmlFindCharEncodingHandler((char *)encoding);
1615  if ((encoder != NULL) &&
1616  (xmlStrEqual((const xmlChar *)encoder->name,
1617  (const xmlChar *) "UTF-8")))
1618  encoder = NULL;
1619  buf = xmlOutputBufferCreateFilename(URL, encoder, compression);
1620  } else {
1621  buf = xmlOutputBufferCreateFilename(URL, NULL, compression);
1622  }
1623  if (buf == NULL)
1624  return(-1);
1626  ret = xmlOutputBufferClose(buf);
1627  return(ret);
1628 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
xmlOutputBuffer * xmlOutputBufferPtr
Definition: tree.h:32
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1423
smooth NULL
Definition: ftsmooth.c:416
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1641
_In_ fcb _In_ chunk _In_ uint64_t _In_ uint64_t _In_ bool _In_opt_ void _In_opt_ PIRP _In_ LIST_ENTRY _In_ uint8_t compression
Definition: btrfs_drv.h:1357
unsigned char xmlChar
Definition: xmlstring.h:28
ed encoding
Definition: write.c:2825
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
GLuint64EXT * result
Definition: glext.h:11304

Referenced by xsltDocumentElem(), and xsltRunStylesheetUser().

◆ xsltSaveResultToString()

XSLTPUBFUN int XSLTCALL xsltSaveResultToString ( xmlChar **  doc_txt_ptr,
int doc_txt_len,
xmlDocPtr  result,
xsltStylesheetPtr  style 
)

xsltSaveResultToString: @doc_txt_ptr: Memory pointer for allocated XML text @doc_txt_len: Length of the generated XML text

Returns
: the result xmlDocPtr @style: the stylesheet

Save the result

Returns
obtained by applying the @style stylesheet to a new allocated string.

Returns 0 in case of success and -1 in case of error

Definition at line 1730 of file xsltutils.c.

1731  {
1733  const xmlChar *encoding;
1734 
1735  *doc_txt_ptr = NULL;
1736  *doc_txt_len = 0;
1737  if (result->children == NULL)
1738  return(0);
1739 
1741  if (encoding != NULL) {
1742  xmlCharEncodingHandlerPtr encoder;
1743 
1744  encoder = xmlFindCharEncodingHandler((char *)encoding);
1745  if ((encoder != NULL) &&
1746  (xmlStrEqual((const xmlChar *)encoder->name,
1747  (const xmlChar *) "UTF-8")))
1748  encoder = NULL;
1749  buf = xmlAllocOutputBuffer(encoder);
1750  } else {
1751  buf = xmlAllocOutputBuffer(NULL);
1752  }
1753  if (buf == NULL)
1754  return(-1);
1756 #ifdef LIBXML2_NEW_BUFFER
1757  if (buf->conv != NULL) {
1758  *doc_txt_len = xmlBufUse(buf->conv);
1759  *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->conv), *doc_txt_len);
1760  } else {
1761  *doc_txt_len = xmlBufUse(buf->buffer);
1762  *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->buffer), *doc_txt_len);
1763  }
1764 #else
1765  if (buf->conv != NULL) {
1766  *doc_txt_len = buf->conv->use;
1767  *doc_txt_ptr = xmlStrndup(buf->conv->content, *doc_txt_len);
1768  } else {
1769  *doc_txt_len = buf->buffer->use;
1770  *doc_txt_ptr = xmlStrndup(buf->buffer->content, *doc_txt_len);
1771  }
1772 #endif
1773  (void)xmlOutputBufferClose(buf);
1774  return 0;
1775 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
XMLPUBFUN xmlChar *XMLCALL xmlBufContent(const xmlBuf *buf)
Definition: buf.c:582
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:41
xmlOutputBuffer * xmlOutputBufferPtr
Definition: tree.h:32
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1423
smooth NULL
Definition: ftsmooth.c:416
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1641
unsigned char xmlChar
Definition: xmlstring.h:28
ed encoding
Definition: write.c:2825
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:157
Arabic default style
Definition: afstyles.h:93
GLuint64EXT * result
Definition: glext.h:11304
XMLPUBFUN size_t XMLCALL xmlBufUse(const xmlBufPtr buf)
Definition: buf.c:687

◆ xsltSetCtxtParseOptions()

XSLTPUBFUN void XSLTCALL XSLTPUBFUN int XSLTCALL xsltSetCtxtParseOptions ( xsltTransformContextPtr  ctxt,
int  options 
)

xsltSetCtxtParseOptions: @ctxt: a XSLT process context @options: a combination of libxml2 xmlParserOption

Change the default parser option passed by the XSLT engine to the parser when using document() loading.

Returns the previous options or -1 in case of error

Definition at line 1388 of file xsltutils.c.

1389 {
1390  int oldopts;
1391 
1392  if (ctxt == NULL)
1393  return(-1);
1394  oldopts = ctxt->parserOptions;
1395  if (ctxt->xinclude)
1396  oldopts |= XML_PARSE_XINCLUDE;
1397  ctxt->parserOptions = options;
1399  ctxt->xinclude = 1;
1400  else
1401  ctxt->xinclude = 0;
1402  return(oldopts);
1403 }
smooth NULL
Definition: ftsmooth.c:416
int options
Definition: main.c:106

◆ xsltSetCtxtSortFunc()

XSLTPUBFUN void XSLTCALL xsltSetCtxtSortFunc ( xsltTransformContextPtr  ctxt,
xsltSortFunc  handler 
)

xsltSetCtxtSortFunc: @ctxt: a XSLT process context @handler: the new handler function

Function to set the handler for XSLT sorting for the specified context. If the handler is NULL, then the global sort function will be called

Definition at line 1367 of file xsltutils.c.

1367  {
1368  ctxt->sortfunc = handler;
1369 }
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7786

◆ xsltSetDebuggerCallbacks()

XSLTPUBFUN int XSLTCALL xsltSetDebuggerCallbacks ( int  no,
void block 
)

◆ xsltSetDebuggerStatus()

XSLTPUBFUN void XSLTCALL xsltSetDebuggerStatus ( int  value)

◆ xsltSetGenericDebugFunc()

XSLTPUBFUN void XSLTCALL xsltSetGenericDebugFunc ( void ctx,
xmlGenericErrorFunc  handler 
)

xsltSetGenericDebugFunc: @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing or validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

Definition at line 566 of file xsltutils.c.

566  {
568  if (handler != NULL)
570  else
571  xsltGenericDebug = xsltGenericDebugDefaultFunc;
572 }
smooth NULL
Definition: ftsmooth.c:416
void * xsltGenericDebugContext
Definition: xsltutils.c:549
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7786

◆ xsltSetGenericErrorFunc()

XSLTPUBFUN void XSLTCALL xsltSetGenericErrorFunc ( void ctx,
xmlGenericErrorFunc  handler 
)

xsltSetGenericErrorFunc: @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages. This simply means that @handler will be called for subsequent error messages while not parsing nor validating. And @ctx will be passed as first argument to @handler One can simply force messages to be emitted to another FILE * than stderr by setting @ctx to this file handle and @handler to NULL.

Definition at line 520 of file xsltutils.c.

520  {
522  if (handler != NULL)
524  else
525  xsltGenericError = xsltGenericErrorDefaultFunc;
526 }
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
smooth NULL
Definition: ftsmooth.c:416
void * xsltGenericErrorContext
Definition: xsltutils.c:503
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7786

◆ xsltSetSortFunc()

XSLTPUBFUN void XSLTCALL xsltSetSortFunc ( xsltSortFunc  handler)

xsltSetSortFunc: @handler: the new handler function

Function to reset the global handler for XSLT sorting. If the handler is NULL, the default sort function will be used.

Definition at line 1349 of file xsltutils.c.

1349  {
1350  if (handler != NULL)
1352  else
1354 }
static xsltSortFunc xsltSortFunction
Definition: xsltutils.c:1315
smooth NULL
Definition: ftsmooth.c:416
void xsltDefaultSortFunction(xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
Definition: xsltutils.c:1064
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7786

◆ xsltSetTransformErrorFunc()

XSLTPUBFUN void XSLTCALL xsltSetTransformErrorFunc ( xsltTransformContextPtr  ctxt,
void ctx,
xmlGenericErrorFunc  handler 
)

xsltSetTransformErrorFunc: @ctxt: the XSLT transformation context @ctx: the new error handling context @handler: the new handler function

Function to reset the handler and the error context for out of context error messages specific to a given XSLT transromation.

This simply means that @handler will be called for subsequent error messages while running the transformation.

Definition at line 659 of file xsltutils.c.

661 {
662  ctxt->error = handler;
663  ctxt->errctx = ctx;
664 }
xmlGenericErrorFunc error
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7786

◆ xsltSplitQName()

XSLTPUBFUN const xmlChar* XSLTCALL xsltSplitQName ( xmlDictPtr  dict,
const xmlChar name,
const xmlChar **  prefix 
)

Definition at line 720 of file xsltutils.c.

720  {
721  int len = 0;
722  const xmlChar *ret = NULL;
723 
724  *prefix = NULL;
725  if ((name == NULL) || (dict == NULL)) return(NULL);
726  if (name[0] == ':')
727  return(xmlDictLookup(dict, name, -1));
728  while ((name[len] != 0) && (name[len] != ':')) len++;
729  if (name[len] == 0) return(xmlDictLookup(dict, name, -1));
730  *prefix = xmlDictLookup(dict, name, len);
731  ret = xmlDictLookup(dict, &name[len + 1], -1);
732  return(ret);
733 }
smooth NULL
Definition: ftsmooth.c:416
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:865
int ret
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
Definition: name.c:38

Referenced by xsltApplyAttributeSet(), xsltAttribute(), xsltAttributeComp(), xsltElement(), xsltElementComp(), xsltFormatNumberFunction(), xsltParseStylesheetAttributeSet(), and xsltProcessUserParamInternal().

◆ xsltTimestamp()

XSLTPUBFUN long XSLTCALL xsltTimestamp ( void  )

Referenced by xsltApplyXSLTTemplate().

◆ xsltTransformError()

XSLTPUBFUN void XSLTCALL xsltTransformError ( xsltTransformContextPtr  ctxt,
xsltStylesheetPtr  style,
xmlNodePtr  node,
const char msg,
  ... 
)

◆ xsltXPathCompile()

XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL xsltXPathCompile ( xsltStylesheetPtr  style,
const xmlChar str 
)

xsltXPathCompile: @style: the stylesheet @str: the XPath expression

Compile an XPath expression

Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.

Definition at line 2319 of file xsltutils.c.

2319  {
2320  return(xsltXPathCompileFlags(style, str, 0));
2321 }
const WCHAR * str
xmlXPathCompExprPtr xsltXPathCompileFlags(xsltStylesheetPtr style, const xmlChar *str, int flags)
Definition: xsltutils.c:2276
Arabic default style
Definition: afstyles.h:93

Referenced by xsltAddKey(), xsltApplyTemplatesComp(), xsltCompileAttr(), xsltCopyOfComp(), xsltForEachComp(), xsltIfComp(), xsltParamComp(), xsltSortComp(), xsltValueOfComp(), xsltVariableComp(), xsltWhenComp(), and xsltWithParamComp().

◆ xsltXPathCompileFlags()

XSLTPUBFUN xmlXPathCompExprPtr XSLTCALL xsltXPathCompileFlags ( xsltStylesheetPtr  style,
const xmlChar str,
int  flags 
)

xsltXPathCompileFlags: @style: the stylesheet @str: the XPath expression @flags: extra compilation flags to pass down to libxml2 XPath

Compile an XPath expression

Returns the xmlXPathCompExprPtr resulting from the compilation or NULL. the caller has to free the object.

Definition at line 2276 of file xsltutils.c.

2276  {
2277  xmlXPathContextPtr xpathCtxt;
2278  xmlXPathCompExprPtr ret;
2279 
2280  if (style != NULL) {
2281  xpathCtxt = style->principal->xpathCtxt;
2282  if (xpathCtxt == NULL)
2283  return NULL;
2284  xpathCtxt->dict = style->dict;
2285  } else {
2286  xpathCtxt = xmlXPathNewContext(NULL);
2287  if (xpathCtxt == NULL)
2288  return NULL;
2289  }
2290  xpathCtxt->flags = flags;
2291 
2292  /*
2293  * Compile the expression.
2294  */
2295  ret = xmlXPathCtxtCompile(xpathCtxt, str);
2296 
2297  if (style == NULL) {
2298  xmlXPathFreeContext(xpathCtxt);
2299  }
2300  /*
2301  * TODO: there is a lot of optimizations which should be possible
2302  * like variable slot precomputations, function precomputations, etc.
2303  */
2304 
2305  return(ret);
2306 }
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
GLbitfield flags
Definition: glext.h:7161
int ret
Arabic default style
Definition: afstyles.h:93

Referenced by xsltAddKey(), xsltCompMatchAdd(), and xsltXPathCompile().

Variable Documentation

◆ xslDebugStatus

XSLTPUBVAR int xslDebugStatus

Definition at line 288 of file xsltutils.h.

◆ xsltGenericDebug

XSLTPUBVAR xmlGenericErrorFunc xsltGenericDebug

Definition at line 142 of file xsltutils.h.

◆ xsltGenericDebugContext

XSLTPUBVAR void* xsltGenericDebugContext

Definition at line 143 of file xsltutils.h.

◆ xsltGenericError

XSLTPUBVAR xmlGenericErrorFunc xsltGenericError

Definition at line 140 of file xsltutils.h.

◆ xsltGenericErrorContext

XSLTPUBVAR void* xsltGenericErrorContext

Definition at line 141 of file xsltutils.h.