ReactOS  0.4.15-dev-5608-gafb953a
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
#define XSLT_NAMESPACE
Definition: xslt.h:46
Definition: mxnamespace.c:44
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160

IS_XSLT_ELEM:

Checks that the element pertains to XSLT namespace.

Definition at line 51 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 60 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
#define NULL
Definition: types.h:112
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545

IS_XSLT_REAL_NODE:

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

Definition at line 68 of file xsltutils.h.

◆ XSLT_STRANGE

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

XSLT_STRANGE:

Macro to flag that a problem was detected internally.

Definition at line 41 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 266 of file xsltutils.h.

◆ XSLT_TODO

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

XSLT_TODO:

Macro to flag unimplemented blocks.

Definition at line 31 of file xsltutils.h.

◆ XSLT_TRACE

#define XSLT_TRACE (   ctxt,
  code,
  call 
)
Value:
if (ctxt->traceCode && (*(ctxt->traceCode) & code)) \
call
Definition: inflate.c:139

XSLT_TRACE:

Control the type of xsl debugtrace messages emitted.

Definition at line 125 of file xsltutils.h.

Typedef Documentation

◆ xsltAddCallCallback

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

Definition at line 289 of file xsltutils.h.

◆ xsltDropCallCallback

typedef void(* xsltDropCallCallback) (void)

Definition at line 290 of file xsltutils.h.

◆ xsltHandleDebuggerCallback

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

Definition at line 287 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 272 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 98 of file xsltutils.h.

98  {
99  XSLT_TRACE_ALL = -1,
100  XSLT_TRACE_NONE = 0,
101  XSLT_TRACE_COPY_TEXT = 1<<0,
104  XSLT_TRACE_COPY = 1<<3,
105  XSLT_TRACE_COMMENT = 1<<4,
106  XSLT_TRACE_PI = 1<<5,
107  XSLT_TRACE_COPY_OF = 1<<6,
108  XSLT_TRACE_VALUE_OF = 1<<7,
111  XSLT_TRACE_CHOOSE = 1<<10,
112  XSLT_TRACE_IF = 1<<11,
113  XSLT_TRACE_FOR_EACH = 1<<12,
114  XSLT_TRACE_STRIP_SPACES = 1<<13,
115  XSLT_TRACE_TEMPLATES = 1<<14,
116  XSLT_TRACE_KEYS = 1<<15,
117  XSLT_TRACE_VARIABLES = 1<<16
xsltDebugTraceCodes
Definition: xsltutils.h:98

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 1067 of file xsltutils.c.

1067  {
1068  return xsltComputeSortResultInternal(ctxt, sort, /* xfrm */ 0);
1069 }
_STLP_MOVE_TO_STD_NAMESPACE void sort(_RandomAccessIter __first, _RandomAccessIter __last)
Definition: _algo.c:993
static xmlXPathObjectPtr * xsltComputeSortResultInternal(xsltTransformContextPtr ctxt, xmlNodePtr sort, int xfrm)
Definition: xsltutils.c:938

◆ 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 1081 of file xsltutils.c.

1082  {
1083 #ifdef XSLT_REFACTORED
1084  xsltStyleItemSortPtr comp;
1085 #else
1086  xsltStylePreCompPtr comp;
1087 #endif
1088  xmlXPathObjectPtr *resultsTab[XSLT_MAX_SORT];
1089  xmlXPathObjectPtr *results = NULL, *res;
1090  xmlNodeSetPtr list = NULL;
1091  int descending, number, desc, numb;
1092  int len = 0;
1093  int i, j, incr;
1094  int tst;
1095  int depth;
1096  xmlNodePtr node;
1097  xmlXPathObjectPtr tmp;
1098  int tempstype[XSLT_MAX_SORT], temporder[XSLT_MAX_SORT],
1099  templang[XSLT_MAX_SORT];
1100 
1101  if ((ctxt == NULL) || (sorts == NULL) || (nbsorts <= 0) ||
1102  (nbsorts >= XSLT_MAX_SORT))
1103  return;
1104  if (sorts[0] == NULL)
1105  return;
1106  comp = sorts[0]->psvi;
1107  if (comp == NULL)
1108  return;
1109 
1110  list = ctxt->nodeList;
1111  if ((list == NULL) || (list->nodeNr <= 1))
1112  return; /* nothing to do */
1113 
1114  for (j = 0; j < nbsorts; j++) {
1115  comp = sorts[j]->psvi;
1116  tempstype[j] = 0;
1117  if ((comp->stype == NULL) && (comp->has_stype != 0)) {
1118  comp->stype =
1119  xsltEvalAttrValueTemplate(ctxt, sorts[j],
1120  (const xmlChar *) "data-type",
1121  NULL);
1122  if (comp->stype != NULL) {
1123  tempstype[j] = 1;
1124  if (xmlStrEqual(comp->stype, (const xmlChar *) "text"))
1125  comp->number = 0;
1126  else if (xmlStrEqual(comp->stype, (const xmlChar *) "number"))
1127  comp->number = 1;
1128  else {
1129  xsltTransformError(ctxt, NULL, sorts[j],
1130  "xsltDoSortFunction: no support for data-type = %s\n",
1131  comp->stype);
1132  comp->number = 0; /* use default */
1133  }
1134  }
1135  }
1136  temporder[j] = 0;
1137  if ((comp->order == NULL) && (comp->has_order != 0)) {
1138  comp->order = xsltEvalAttrValueTemplate(ctxt, sorts[j],
1139  (const xmlChar *) "order",
1140  NULL);
1141  if (comp->order != NULL) {
1142  temporder[j] = 1;
1143  if (xmlStrEqual(comp->order, (const xmlChar *) "ascending"))
1144  comp->descending = 0;
1145  else if (xmlStrEqual(comp->order,
1146  (const xmlChar *) "descending"))
1147  comp->descending = 1;
1148  else {
1149  xsltTransformError(ctxt, NULL, sorts[j],
1150  "xsltDoSortFunction: invalid value %s for order\n",
1151  comp->order);
1152  comp->descending = 0; /* use default */
1153  }
1154  }
1155  }
1156  templang[j] = 0;
1157  if ((comp->lang == NULL) && (comp->has_lang != 0)) {
1158  xmlChar *lang = xsltEvalAttrValueTemplate(ctxt, sorts[j],
1159  (xmlChar *) "lang",
1160  NULL);
1161  if (lang != NULL) {
1162  templang[j] = 1;
1163  comp->locale = xsltNewLocale(lang);
1164  xmlFree(lang);
1165  }
1166  }
1167  }
1168 
1169  len = list->nodeNr;
1170 
1171  resultsTab[0] = xsltComputeSortResultInternal(ctxt, sorts[0],
1172  /* xfrm */ 1);
1173  for (i = 1;i < XSLT_MAX_SORT;i++)
1174  resultsTab[i] = NULL;
1175 
1176  results = resultsTab[0];
1177 
1178  comp = sorts[0]->psvi;
1179  descending = comp->descending;
1180  number = comp->number;
1181  if (results == NULL)
1182  goto cleanup;
1183 
1184  /* Shell's sort of node-set */
1185  for (incr = len / 2; incr > 0; incr /= 2) {
1186  for (i = incr; i < len; i++) {
1187  j = i - incr;
1188  if (results[i] == NULL)
1189  continue;
1190 
1191  while (j >= 0) {
1192  if (results[j] == NULL)
1193  tst = 1;
1194  else {
1195  if (number) {
1196  /* We make NaN smaller than number in accordance
1197  with XSLT spec */
1198  if (xmlXPathIsNaN(results[j]->floatval)) {
1199  if (xmlXPathIsNaN(results[j + incr]->floatval))
1200  tst = 0;
1201  else
1202  tst = -1;
1203  } else if (xmlXPathIsNaN(results[j + incr]->floatval))
1204  tst = 1;
1205  else if (results[j]->floatval ==
1206  results[j + incr]->floatval)
1207  tst = 0;
1208  else if (results[j]->floatval >
1209  results[j + incr]->floatval)
1210  tst = 1;
1211  else tst = -1;
1212  } else if(comp->locale != (xsltLocale)0) {
1213  tst = xsltLocaleStrcmp(
1214  comp->locale,
1215  (xsltLocaleChar *) results[j]->stringval,
1216  (xsltLocaleChar *) results[j + incr]->stringval);
1217  } else {
1218  tst = xmlStrcmp(results[j]->stringval,
1219  results[j + incr]->stringval);
1220  }
1221  if (descending)
1222  tst = -tst;
1223  }
1224  if (tst == 0) {
1225  /*
1226  * Okay we need to use multi level sorts
1227  */
1228  depth = 1;
1229  while (depth < nbsorts) {
1230  if (sorts[depth] == NULL)
1231  break;
1232  comp = sorts[depth]->psvi;
1233  if (comp == NULL)
1234  break;
1235  desc = comp->descending;
1236  numb = comp->number;
1237 
1238  /*
1239  * Compute the result of the next level for the
1240  * full set, this might be optimized ... or not
1241  */
1242  if (resultsTab[depth] == NULL)
1243  resultsTab[depth] =
1245  sorts[depth],
1246  /* xfrm */ 1);
1247  res = resultsTab[depth];
1248  if (res == NULL)
1249  break;
1250  if (res[j] == NULL) {
1251  if (res[j+incr] != NULL)
1252  tst = 1;
1253  } else if (res[j+incr] == NULL) {
1254  tst = -1;
1255  } else {
1256  if (numb) {
1257  /* We make NaN smaller than number in
1258  accordance with XSLT spec */
1259  if (xmlXPathIsNaN(res[j]->floatval)) {
1260  if (xmlXPathIsNaN(res[j +
1261  incr]->floatval))
1262  tst = 0;
1263  else
1264  tst = -1;
1265  } else if (xmlXPathIsNaN(res[j + incr]->
1266  floatval))
1267  tst = 1;
1268  else if (res[j]->floatval == res[j + incr]->
1269  floatval)
1270  tst = 0;
1271  else if (res[j]->floatval >
1272  res[j + incr]->floatval)
1273  tst = 1;
1274  else tst = -1;
1275  } else if(comp->locale != (xsltLocale)0) {
1276  tst = xsltLocaleStrcmp(
1277  comp->locale,
1278  (xsltLocaleChar *) res[j]->stringval,
1279  (xsltLocaleChar *) res[j + incr]->stringval);
1280  } else {
1281  tst = xmlStrcmp(res[j]->stringval,
1282  res[j + incr]->stringval);
1283  }
1284  if (desc)
1285  tst = -tst;
1286  }
1287 
1288  /*
1289  * if we still can't differenciate at this level
1290  * try one level deeper.
1291  */
1292  if (tst != 0)
1293  break;
1294  depth++;
1295  }
1296  }
1297  if (tst == 0) {
1298  tst = results[j]->index > results[j + incr]->index;
1299  }
1300  if (tst > 0) {
1301  tmp = results[j];
1302  results[j] = results[j + incr];
1303  results[j + incr] = tmp;
1304  node = list->nodeTab[j];
1305  list->nodeTab[j] = list->nodeTab[j + incr];
1306  list->nodeTab[j + incr] = node;
1307  depth = 1;
1308  while (depth < nbsorts) {
1309  if (sorts[depth] == NULL)
1310  break;
1311  if (resultsTab[depth] == NULL)
1312  break;
1313  res = resultsTab[depth];
1314  tmp = res[j];
1315  res[j] = res[j + incr];
1316  res[j + incr] = tmp;
1317  depth++;
1318  }
1319  j -= incr;
1320  } else
1321  break;
1322  }
1323  }
1324  }
1325 
1326 cleanup:
1327  for (j = 0; j < nbsorts; j++) {
1328  comp = sorts[j]->psvi;
1329  if (tempstype[j] == 1) {
1330  /* The data-type needs to be recomputed each time */
1331  xmlFree((void *)(comp->stype));
1332  comp->stype = NULL;
1333  }
1334  if (temporder[j] == 1) {
1335  /* The order needs to be recomputed each time */
1336  xmlFree((void *)(comp->order));
1337  comp->order = NULL;
1338  }
1339  if (templang[j] == 1) {
1340  xsltFreeLocale(comp->locale);
1341  comp->locale = (xsltLocale)0;
1342  }
1343  if (resultsTab[j] != NULL) {
1344  for (i = 0;i < len;i++)
1345  xmlXPathFreeObject(resultsTab[j][i]);
1346  xmlFree(resultsTab[j]);
1347  }
1348  }
1349 }
xmlNodeSetPtr nodeList
void * psvi
Definition: tree.h:505
int xsltLocaleStrcmp(xsltLocale locale, const xsltLocaleChar *str1, const xsltLocaleChar *str2)
Definition: xsltlocale.c:423
void * xsltLocale
Definition: xsltlocale.h:63
const xmlChar * order
xmlChar * xsltEvalAttrValueTemplate(xsltTransformContextPtr ctxt, xmlNodePtr inst, const xmlChar *name, const xmlChar *ns)
Definition: templates.c:392
const xmlChar * lang
struct node node
#define XSLT_MAX_SORT
static size_t double number
Definition: printf.c:71
static const WCHAR desc[]
Definition: protectdata.c:36
const xmlChar * stype
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
static const WCHAR lang[]
Definition: wbemdisp.c:287
void xsltFreeLocale(xsltLocale locale)
Definition: xsltlocale.c:342
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
xmlChar xsltLocaleChar
Definition: xsltlocale.h:64
static struct _test_info results[8]
Definition: SetCursorPos.c:31
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
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 NULL
Definition: types.h:112
xsltLocale xsltNewLocale(const xmlChar *languageTag)
Definition: xsltlocale.c:82
GLuint res
Definition: glext.h:9613
char * cleanup(char *str)
Definition: wpickclick.c:99
static xmlXPathObjectPtr * xsltComputeSortResultInternal(xsltTransformContextPtr ctxt, xmlNodePtr sort, int xfrm)
Definition: xsltutils.c:938
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
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:133

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 GLint GLint j
Definition: glfuncs.h:250
Definition: tree.h:489
GLenum GLsizei len
Definition: glext.h:6722
Definition: _list.h:228
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 NULL
Definition: types.h:112
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 1369 of file xsltutils.c.

1371 {
1372  if (ctxt->sortfunc != NULL)
1373  (ctxt->sortfunc)(ctxt, sorts, nbsorts);
1374  else if (xsltSortFunction != NULL)
1375  xsltSortFunction(ctxt, sorts, nbsorts);
1376 }
static xsltSortFunc xsltSortFunction
Definition: xsltutils.c:1352
#define NULL
Definition: types.h:112

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:3379
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
#define BAD_CAST
Definition: xmlstring.h:35
const xmlChar * defaultValue
Definition: tree.h:267
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
XMLPUBFUN xmlChar *XMLCALL xmlNodeListGetString(xmlDocPtr doc, const xmlNode *list, int inLine)
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
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:160
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 2376 of file xsltutils.c.

2377 {
2378  return(xslDebugStatus);
2379 }
int xslDebugStatus
Definition: xsltutils.c:2366

◆ 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:3379
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
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
#define NULL
Definition: types.h:112
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:160
const xmlChar * href
Definition: tree.h:392
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
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)
#define XML_XML_NAMESPACE
Definition: tree.h:140
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
Definition: name.c:38
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67
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:42
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
XMLPUBFUN xmlNsPtr XMLCALL xmlSearchNs(xmlDocPtr doc, xmlNodePtr node, const xmlChar *nameSpace)
#define XML_XML_NAMESPACE
Definition: tree.h:140
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
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
const GLubyte * c
Definition: glext.h:8905
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
#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:426
GLenum GLuint GLenum GLsizei const GLchar * message
Definition: glext.h:5579
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
xsltTransformState state
void MSVCRT() terminate()
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
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
#define NULL
Definition: types.h:112
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:847
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
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
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
xsltTransformState state
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
#define NULL
Definition: types.h:112
Definition: tree.h:551
Definition: name.c:38
void(XMLCDECL * xmlGenericErrorFunc)(void *ctx, const char *msg,...) LIBXML_ATTR_FORMAT(2
Definition: xmlerror.h:847
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
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 1460 of file xsltutils.c.

1461  {
1462  const xmlChar *encoding;
1463  int base;
1464  const xmlChar *method;
1465  int indent;
1466 
1467  if ((buf == NULL) || (result == NULL) || (style == NULL))
1468  return(-1);
1469  if ((result->children == NULL) ||
1470  ((result->children->type == XML_DTD_NODE) &&
1471  (result->children->next == NULL)))
1472  return(0);
1473 
1474  if ((style->methodURI != NULL) &&
1475  ((style->method == NULL) ||
1476  (!xmlStrEqual(style->method, (const xmlChar *) "xhtml")))) {
1478  "xsltSaveResultTo : unknown output method\n");
1479  return(-1);
1480  }
1481 
1482  base = buf->written;
1483 
1487 
1488  if ((method == NULL) && (result->type == XML_HTML_DOCUMENT_NODE))
1489  method = (const xmlChar *) "html";
1490 
1491  if ((method != NULL) &&
1492  (xmlStrEqual(method, (const xmlChar *) "html"))) {
1493  if (encoding != NULL) {
1494  htmlSetMetaEncoding(result, (const xmlChar *) encoding);
1495  } else {
1496  htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
1497  }
1498  if (indent == -1)
1499  indent = 1;
1500  htmlDocContentDumpFormatOutput(buf, result, (const char *) encoding,
1501  indent);
1502  xmlOutputBufferFlush(buf);
1503  } else if ((method != NULL) &&
1504  (xmlStrEqual(method, (const xmlChar *) "xhtml"))) {
1505  if (encoding != NULL) {
1506  htmlSetMetaEncoding(result, (const xmlChar *) encoding);
1507  } else {
1508  htmlSetMetaEncoding(result, (const xmlChar *) "UTF-8");
1509  }
1510  htmlDocContentDumpOutput(buf, result, (const char *) encoding);
1511  xmlOutputBufferFlush(buf);
1512  } else if ((method != NULL) &&
1513  (xmlStrEqual(method, (const xmlChar *) "text"))) {
1514  xmlNodePtr cur;
1515 
1516  cur = result->children;
1517  while (cur != NULL) {
1518  if (cur->type == XML_TEXT_NODE)
1519  xmlOutputBufferWriteString(buf, (const char *) cur->content);
1520 
1521  /*
1522  * Skip to next node
1523  */
1524  if (cur->children != NULL) {
1525  if ((cur->children->type != XML_ENTITY_DECL) &&
1526  (cur->children->type != XML_ENTITY_REF_NODE) &&
1527  (cur->children->type != XML_ENTITY_NODE)) {
1528  cur = cur->children;
1529  continue;
1530  }
1531  }
1532  if (cur->next != NULL) {
1533  cur = cur->next;
1534  continue;
1535  }
1536 
1537  do {
1538  cur = cur->parent;
1539  if (cur == NULL)
1540  break;
1541  if (cur == (xmlNodePtr) style->doc) {
1542  cur = NULL;
1543  break;
1544  }
1545  if (cur->next != NULL) {
1546  cur = cur->next;
1547  break;
1548  }
1549  } while (cur != NULL);
1550  }
1551  xmlOutputBufferFlush(buf);
1552  } else {
1553  int omitXmlDecl;
1554  int standalone;
1555 
1556  XSLT_GET_IMPORT_INT(omitXmlDecl, style, omitXmlDeclaration);
1557  XSLT_GET_IMPORT_INT(standalone, style, standalone);
1558 
1559  if (omitXmlDecl != 1) {
1560  xmlOutputBufferWriteString(buf, "<?xml version=");
1561  if (result->version != NULL) {
1562  xmlOutputBufferWriteString(buf, "\"");
1563  xmlOutputBufferWriteString(buf, (const char *)result->version);
1564  xmlOutputBufferWriteString(buf, "\"");
1565  } else
1566  xmlOutputBufferWriteString(buf, "\"1.0\"");
1567  if (encoding == NULL) {
1568  if (result->encoding != NULL)
1569  encoding = result->encoding;
1570  else if (result->charset != XML_CHAR_ENCODING_UTF8)
1571  encoding = (const xmlChar *)
1573  result->charset);
1574  }
1575  if (encoding != NULL) {
1576  xmlOutputBufferWriteString(buf, " encoding=");
1577  xmlOutputBufferWriteString(buf, "\"");
1578  xmlOutputBufferWriteString(buf, (const char *) encoding);
1579  xmlOutputBufferWriteString(buf, "\"");
1580  }
1581  switch (standalone) {
1582  case 0:
1583  xmlOutputBufferWriteString(buf, " standalone=\"no\"");
1584  break;
1585  case 1:
1586  xmlOutputBufferWriteString(buf, " standalone=\"yes\"");
1587  break;
1588  default:
1589  break;
1590  }
1591  xmlOutputBufferWriteString(buf, "?>\n");
1592  }
1593  if (result->children != NULL) {
1594  xmlNodePtr children = result->children;
1595  xmlNodePtr child = children;
1596 
1597  /*
1598  * Hack to avoid quadratic behavior when scanning
1599  * result->children in xmlGetIntSubset called by
1600  * xmlNodeDumpOutput.
1601  */
1602  result->children = NULL;
1603 
1604  while (child != NULL) {
1605  xmlNodeDumpOutput(buf, result, child, 0, (indent == 1),
1606  (const char *) encoding);
1607  if (indent && ((child->type == XML_DTD_NODE) ||
1608  ((child->type == XML_COMMENT_NODE) &&
1609  (child->next != NULL))))
1610  xmlOutputBufferWriteString(buf, "\n");
1611  child = child->next;
1612  }
1613  if (indent)
1614  xmlOutputBufferWriteString(buf, "\n");
1615 
1616  result->children = children;
1617  }
1618  xmlOutputBufferFlush(buf);
1619  }
1620  return(buf->written - base);
1621 }
static const WCHAR indent[]
Definition: object.c:1156
GLuint64EXT * result
Definition: glext.h:11304
static char * encoding
Definition: xmllint.c:155
xmlCharEncoding
Definition: encoding.h:56
XMLPUBFUN const char *XMLCALL xmlGetCharEncodingName(xmlCharEncoding enc)
Definition: encoding.c:1254
static HWND child
Definition: cursoricon.c:298
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define XSLT_GET_IMPORT_INT(res, style, name)
Definition: imports.h:40
GLuint base
Definition: 3dtext.c:35
xmlGenericErrorFunc xsltGenericError
Definition: xsltutils.c:502
method
Definition: dragdrop.c:53
void * xsltGenericErrorContext
Definition: xsltutils.c:503
Definition: tree.h:489
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
#define NULL
Definition: types.h:112
struct _xmlNode * children
Definition: tree.h:493
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Arabic default style
Definition: afstyles.h:93

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 1724 of file xsltutils.c.

1724  {
1726  const xmlChar *encoding;
1727  int ret;
1728 
1729  if ((fd < 0) || (result == NULL) || (style == NULL))
1730  return(-1);
1731  if (result->children == NULL)
1732  return(0);
1733 
1735  if (encoding != NULL) {
1736  xmlCharEncodingHandlerPtr encoder;
1737 
1738  encoder = xmlFindCharEncodingHandler((char *)encoding);
1739  if ((encoder != NULL) &&
1740  (xmlStrEqual((const xmlChar *)encoder->name,
1741  (const xmlChar *) "UTF-8")))
1742  encoder = NULL;
1743  buf = xmlOutputBufferCreateFd(fd, encoder);
1744  } else {
1745  buf = xmlOutputBufferCreateFd(fd, NULL);
1746  }
1747  if (buf == NULL)
1748  return(-1);
1750  ret = xmlOutputBufferClose(buf);
1751  return(ret);
1752 }
GLuint64EXT * result
Definition: glext.h:11304
static char * encoding
Definition: xmllint.c:155
static int fd
Definition: io.c:51
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:1460
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1678
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
#define NULL
Definition: types.h:112
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Arabic default style
Definition: afstyles.h:93

◆ xsltSaveResultToFile()

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

Definition at line 1680 of file xsltutils.c.

1680  {
1682  const xmlChar *encoding;
1683  int ret;
1684 
1685  if ((file == NULL) || (result == NULL) || (style == NULL))
1686  return(-1);
1687  if (result->children == NULL)
1688  return(0);
1689 
1691  if (encoding != NULL) {
1692  xmlCharEncodingHandlerPtr encoder;
1693 
1694  encoder = xmlFindCharEncodingHandler((char *)encoding);
1695  if ((encoder != NULL) &&
1696  (xmlStrEqual((const xmlChar *)encoder->name,
1697  (const xmlChar *) "UTF-8")))
1698  encoder = NULL;
1699  buf = xmlOutputBufferCreateFile(file, encoder);
1700  } else {
1701  buf = xmlOutputBufferCreateFile(file, NULL);
1702  }
1703 
1704  if (buf == NULL)
1705  return(-1);
1707  ret = xmlOutputBufferClose(buf);
1708  return(ret);
1709 }
GLuint64EXT * result
Definition: glext.h:11304
static char * encoding
Definition: xmllint.c:155
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:1460
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1678
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
#define NULL
Definition: types.h:112
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Arabic default style
Definition: afstyles.h:93
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 1636 of file xsltutils.c.

1637  {
1639  const xmlChar *encoding;
1640  int ret;
1641 
1642  if ((URL == NULL) || (result == NULL) || (style == NULL))
1643  return(-1);
1644  if (result->children == NULL)
1645  return(0);
1646 
1648  if (encoding != NULL) {
1649  xmlCharEncodingHandlerPtr encoder;
1650 
1651  encoder = xmlFindCharEncodingHandler((char *)encoding);
1652  if ((encoder != NULL) &&
1653  (xmlStrEqual((const xmlChar *)encoder->name,
1654  (const xmlChar *) "UTF-8")))
1655  encoder = NULL;
1656  buf = xmlOutputBufferCreateFilename(URL, encoder, compression);
1657  } else {
1658  buf = xmlOutputBufferCreateFilename(URL, NULL, compression);
1659  }
1660  if (buf == NULL)
1661  return(-1);
1663  ret = xmlOutputBufferClose(buf);
1664  return(ret);
1665 }
GLuint64EXT * result
Definition: glext.h:11304
static char * encoding
Definition: xmllint.c:155
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
_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:1364
xmlOutputBuffer * xmlOutputBufferPtr
Definition: tree.h:32
int xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result, xsltStylesheetPtr style)
Definition: xsltutils.c:1460
int ret
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1678
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
#define NULL
Definition: types.h:112
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Arabic default style
Definition: afstyles.h:93

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 1767 of file xsltutils.c.

1768  {
1770  const xmlChar *encoding;
1771 
1772  *doc_txt_ptr = NULL;
1773  *doc_txt_len = 0;
1774  if (result->children == NULL)
1775  return(0);
1776 
1778  if (encoding != NULL) {
1779  xmlCharEncodingHandlerPtr encoder;
1780 
1781  encoder = xmlFindCharEncodingHandler((char *)encoding);
1782  if ((encoder != NULL) &&
1783  (xmlStrEqual((const xmlChar *)encoder->name,
1784  (const xmlChar *) "UTF-8")))
1785  encoder = NULL;
1786  buf = xmlAllocOutputBuffer(encoder);
1787  } else {
1788  buf = xmlAllocOutputBuffer(NULL);
1789  }
1790  if (buf == NULL)
1791  return(-1);
1793 #ifdef LIBXML2_NEW_BUFFER
1794  if (buf->conv != NULL) {
1795  *doc_txt_len = xmlBufUse(buf->conv);
1796  *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->conv), *doc_txt_len);
1797  } else {
1798  *doc_txt_len = xmlBufUse(buf->buffer);
1799  *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->buffer), *doc_txt_len);
1800  }
1801 #else
1802  if (buf->conv != NULL) {
1803  *doc_txt_len = buf->conv->use;
1804  *doc_txt_ptr = xmlStrndup(buf->conv->content, *doc_txt_len);
1805  } else {
1806  *doc_txt_len = buf->buffer->use;
1807  *doc_txt_ptr = xmlStrndup(buf->buffer->content, *doc_txt_len);
1808  }
1809 #endif
1810  (void)xmlOutputBufferClose(buf);
1811  return 0;
1812 }
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:553
GLuint64EXT * result
Definition: glext.h:11304
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42
static char * encoding
Definition: xmllint.c:155
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:1460
XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL xmlFindCharEncodingHandler(const char *name)
Definition: encoding.c:1678
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_GET_IMPORT_PTR(res, style, name)
Definition: imports.h:27
#define NULL
Definition: types.h:112
XMLPUBFUN int XMLCALL xmlStrEqual(const xmlChar *str1, const xmlChar *str2)
Definition: xmlstring.c:160
Arabic default style
Definition: afstyles.h:93
XMLPUBFUN size_t XMLCALL xmlBufUse(const xmlBufPtr buf)
Definition: buf.c:633

◆ 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 1425 of file xsltutils.c.

1426 {
1427  int oldopts;
1428 
1429  if (ctxt == NULL)
1430  return(-1);
1431  oldopts = ctxt->parserOptions;
1432  if (ctxt->xinclude)
1433  oldopts |= XML_PARSE_XINCLUDE;
1434  ctxt->parserOptions = options;
1436  ctxt->xinclude = 1;
1437  else
1438  ctxt->xinclude = 0;
1439  return(oldopts);
1440 }
int options
Definition: main.c:106
#define NULL
Definition: types.h:112

◆ 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 1404 of file xsltutils.c.

1404  {
1405  ctxt->sortfunc = handler;
1406 }
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

◆ 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 }
void * xsltGenericDebugContext
Definition: xsltutils.c:549
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
#define NULL
Definition: types.h:112
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

◆ 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
void * xsltGenericErrorContext
Definition: xsltutils.c:503
#define NULL
Definition: types.h:112
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

◆ 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 1386 of file xsltutils.c.

1386  {
1387  if (handler != NULL)
1389  else
1391 }
static xsltSortFunc xsltSortFunction
Definition: xsltutils.c:1352
void xsltDefaultSortFunction(xsltTransformContextPtr ctxt, xmlNodePtr *sorts, int nbsorts)
Definition: xsltutils.c:1081
#define NULL
Definition: types.h:112
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482

◆ 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:7482

◆ 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 }
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
int ret
unsigned char xmlChar
Definition: xmlstring.h:28
GLenum GLsizei len
Definition: glext.h:6722
#define NULL
Definition: types.h:112
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 2356 of file xsltutils.c.

2356  {
2357  return(xsltXPathCompileFlags(style, str, 0));
2358 }
const WCHAR * str
xmlXPathCompExprPtr xsltXPathCompileFlags(xsltStylesheetPtr style, const xmlChar *str, int flags)
Definition: xsltutils.c:2313
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 2313 of file xsltutils.c.

2313  {
2314  xmlXPathContextPtr xpathCtxt;
2315  xmlXPathCompExprPtr ret;
2316 
2317  if (style != NULL) {
2318  xpathCtxt = style->principal->xpathCtxt;
2319  if (xpathCtxt == NULL)
2320  return NULL;
2321  xpathCtxt->dict = style->dict;
2322  } else {
2323  xpathCtxt = xmlXPathNewContext(NULL);
2324  if (xpathCtxt == NULL)
2325  return NULL;
2326  }
2327  xpathCtxt->flags = flags;
2328 
2329  /*
2330  * Compile the expression.
2331  */
2332  ret = xmlXPathCtxtCompile(xpathCtxt, str);
2333 
2334  if (style == NULL) {
2335  xmlXPathFreeContext(xpathCtxt);
2336  }
2337  /*
2338  * TODO: there is a lot of optimizations which should be possible
2339  * like variable slot precomputations, function precomputations, etc.
2340  */
2341 
2342  return(ret);
2343 }
const WCHAR * str
GLbitfield flags
Definition: glext.h:7161
int ret
#define NULL
Definition: types.h:112
Arabic default style
Definition: afstyles.h:93

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

Variable Documentation

◆ xslDebugStatus

XSLTPUBVAR int xslDebugStatus

Definition at line 285 of file xsltutils.h.

◆ xsltGenericDebug

XSLTPUBVAR xmlGenericErrorFunc xsltGenericDebug

Definition at line 139 of file xsltutils.h.

◆ xsltGenericDebugContext

XSLTPUBVAR void* xsltGenericDebugContext

Definition at line 140 of file xsltutils.h.

◆ xsltGenericError

XSLTPUBVAR xmlGenericErrorFunc xsltGenericError

Definition at line 137 of file xsltutils.h.

◆ xsltGenericErrorContext

XSLTPUBVAR void* xsltGenericErrorContext

Definition at line 138 of file xsltutils.h.