ReactOS  0.4.15-dev-5500-g82cf6c2
templates.h File Reference
#include <libxml/xpath.h>
#include <libxml/xpathInternals.h>
#include "xsltexports.h"
#include "xsltInternals.h"
Include dependency graph for templates.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

XSLTPUBFUN int XSLTCALL xsltEvalXPathPredicate (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, xmlNsPtr *nsList, int nsNr)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltEvalTemplateString (xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr inst)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltEvalAttrValueTemplate (xsltTransformContextPtr ctxt, xmlNodePtr node, const xmlChar *name, const xmlChar *ns)
 
XSLTPUBFUN const xmlChar *XSLTCALL xsltEvalStaticAttrValueTemplate (xsltStylesheetPtr style, xmlNodePtr node, const xmlChar *name, const xmlChar *ns, int *found)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltEvalXPathString (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltEvalXPathStringNs (xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, int nsNr, xmlNsPtr *nsList)
 
XSLTPUBFUN xmlNodePtr *XSLTCALL xsltTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr node)
 
XSLTPUBFUN xmlAttrPtr XSLTCALL xsltAttrListTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr target, xmlAttrPtr cur)
 
XSLTPUBFUN xmlAttrPtr XSLTCALL xsltAttrTemplateProcess (xsltTransformContextPtr ctxt, xmlNodePtr target, xmlAttrPtr attr)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltAttrTemplateValueProcess (xsltTransformContextPtr ctxt, const xmlChar *attr)
 
XSLTPUBFUN xmlChar *XSLTCALL xsltAttrTemplateValueProcessNode (xsltTransformContextPtr ctxt, const xmlChar *str, xmlNodePtr node)
 

Function Documentation

◆ xsltAttrListTemplateProcess()

XSLTPUBFUN xmlAttrPtr XSLTCALL xsltAttrListTemplateProcess ( xsltTransformContextPtr  ctxt,
xmlNodePtr  target,
xmlAttrPtr  attrs 
)

xsltAttrListTemplateProcess: @ctxt: the XSLT transformation context @target: the element where the attributes will be grafted @attrs: the first attribute

Processes all attributes of a Literal Result Element. Attribute references are applied via xsl:use-attribute-set attributes. Copies all non XSLT-attributes over to the @target element and evaluates Attribute Value Templates.

Called by xsltApplySequenceConstructor() (transform.c).

Returns a new list of attribute nodes, or NULL in case of error. (Don't assign the result to @target->properties; if the result is NULL, you'll get memory leaks, since the attributes will be disattached.)

Definition at line 635 of file templates.c.

637 {
639  xmlNodePtr oldInsert, text;
640  xmlNsPtr origNs = NULL, copyNs = NULL;
641  const xmlChar *value;
642  xmlChar *valueAVT;
643  int hasAttr = 0;
644 
645  if ((ctxt == NULL) || (target == NULL) || (attrs == NULL) ||
646  (target->type != XML_ELEMENT_NODE))
647  return(NULL);
648 
649  oldInsert = ctxt->insert;
650  ctxt->insert = target;
651 
652  /*
653  * Apply attribute-sets.
654  */
655  attr = attrs;
656  do {
657 #ifdef XSLT_REFACTORED
658  if ((attr->psvi == xsltXSLTAttrMarker) &&
659  xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets"))
660  {
661  xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
662  }
663 #else
664  if ((attr->ns != NULL) &&
665  xmlStrEqual(attr->name, (const xmlChar *)"use-attribute-sets") &&
666  xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
667  {
668  xsltApplyAttributeSet(ctxt, ctxt->node, (xmlNodePtr) attr, NULL);
669  }
670 #endif
671  attr = attr->next;
672  } while (attr != NULL);
673 
674  if (target->properties != NULL) {
675  hasAttr = 1;
676  }
677 
678  /*
679  * Instantiate LRE-attributes.
680  */
681  attr = attrs;
682  do {
683  /*
684  * Skip XSLT attributes.
685  */
686 #ifdef XSLT_REFACTORED
687  if (attr->psvi == xsltXSLTAttrMarker) {
688  goto next_attribute;
689  }
690 #else
691  if ((attr->ns != NULL) &&
692  xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
693  {
694  goto next_attribute;
695  }
696 #endif
697  /*
698  * Get the value.
699  */
700  if (attr->children != NULL) {
701  if ((attr->children->type != XML_TEXT_NODE) ||
702  (attr->children->next != NULL))
703  {
704  xsltTransformError(ctxt, NULL, attr->parent,
705  "Internal error: The children of an attribute node of a "
706  "literal result element are not in the expected form.\n");
707  goto error;
708  }
709  value = attr->children->content;
710  if (value == NULL)
711  value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
712  } else
713  value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
714 
715  /*
716  * Get the namespace. Avoid lookups of same namespaces.
717  */
718  if (attr->ns != origNs) {
719  origNs = attr->ns;
720  if (attr->ns != NULL) {
721 #ifdef XSLT_REFACTORED
722  copyNs = xsltGetSpecialNamespace(ctxt, attr->parent,
723  attr->ns->href, attr->ns->prefix, target);
724 #else
725  copyNs = xsltGetNamespace(ctxt, attr->parent,
726  attr->ns, target);
727 #endif
728  if (copyNs == NULL)
729  goto error;
730  } else
731  copyNs = NULL;
732  }
733  /*
734  * Create a new attribute.
735  */
736  if (hasAttr) {
737  copy = xmlSetNsProp(target, copyNs, attr->name, NULL);
738  } else {
739  /*
740  * Avoid checking for duplicate attributes if there aren't
741  * any attribute sets.
742  */
743  copy = xmlNewDocProp(target->doc, attr->name, NULL);
744 
745  if (copy != NULL) {
746  copy->ns = copyNs;
747 
748  /*
749  * Attach it to the target element.
750  */
751  copy->parent = target;
752  if (last == NULL) {
753  target->properties = copy;
754  last = copy;
755  } else {
756  last->next = copy;
757  copy->prev = last;
758  last = copy;
759  }
760  }
761  }
762  if (copy == NULL) {
763  if (attr->ns) {
764  xsltTransformError(ctxt, NULL, attr->parent,
765  "Internal error: Failed to create attribute '{%s}%s'.\n",
766  attr->ns->href, attr->name);
767  } else {
768  xsltTransformError(ctxt, NULL, attr->parent,
769  "Internal error: Failed to create attribute '%s'.\n",
770  attr->name);
771  }
772  goto error;
773  }
774 
775  /*
776  * Set the value.
777  */
778  text = xmlNewText(NULL);
779  if (text != NULL) {
780  copy->last = copy->children = text;
781  text->parent = (xmlNodePtr) copy;
782  text->doc = copy->doc;
783 
784  if (attr->psvi != NULL) {
785  /*
786  * Evaluate the Attribute Value Template.
787  */
788  valueAVT = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
789  if (valueAVT == NULL) {
790  /*
791  * TODO: Damn, we need an easy mechanism to report
792  * qualified names!
793  */
794  if (attr->ns) {
795  xsltTransformError(ctxt, NULL, attr->parent,
796  "Internal error: Failed to evaluate the AVT "
797  "of attribute '{%s}%s'.\n",
798  attr->ns->href, attr->name);
799  } else {
800  xsltTransformError(ctxt, NULL, attr->parent,
801  "Internal error: Failed to evaluate the AVT "
802  "of attribute '%s'.\n",
803  attr->name);
804  }
805  text->content = xmlStrdup(BAD_CAST "");
806  goto error;
807  } else {
808  text->content = valueAVT;
809  }
810  } else if ((ctxt->internalized) &&
811  (target->doc != NULL) &&
812  (target->doc->dict == ctxt->dict) &&
813  xmlDictOwns(ctxt->dict, value))
814  {
815  text->content = (xmlChar *) value;
816  } else {
817  text->content = xmlStrdup(value);
818  }
819  if ((copy != NULL) && (text != NULL) &&
820  (xmlIsID(copy->doc, copy->parent, copy)))
821  xmlAddID(NULL, copy->doc, text->content, copy);
822  }
823 
825  attr = attr->next;
826  } while (attr != NULL);
827 
828  ctxt->insert = oldInsert;
829  return(target->properties);
830 
831 error:
832  ctxt->insert = oldInsert;
833  return(NULL);
834 }
Definition: pdh_main.c:93
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value)
#define error(str)
Definition: mkdosfs.c:1605
POINT last
Definition: font.c:46
Definition: tree.h:389
const WCHAR * text
Definition: package.c:1799
xmlNsPtr xsltGetNamespace(xsltTransformContextPtr ctxt, xmlNodePtr cur, xmlNsPtr ns, xmlNodePtr out)
Definition: namespaces.c:596
xmlNsPtr xsltGetSpecialNamespace(xsltTransformContextPtr ctxt, xmlNodePtr invocNode, const xmlChar *nsName, const xmlChar *nsPrefix, xmlNodePtr target)
Definition: namespaces.c:299
#define XSLT_NAMESPACE
Definition: xslt.h:46
#define next_attribute(a)
Definition: reader.c:252
xmlChar * xsltEvalAVT(xsltTransformContextPtr ctxt, void *avt, xmlNodePtr node)
Definition: attrvt.c:356
xmlNode * xmlNodePtr
Definition: tree.h:488
#define BAD_CAST
Definition: xmlstring.h:35
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
Definition: cookie.c:201
Definition: tree.h:489
void xsltApplyAttributeSet(xsltTransformContextPtr ctxt, xmlNodePtr node, xmlNodePtr inst, const xmlChar *attrSets)
Definition: attributes.c:1086
XMLPUBFUN int XMLCALL xmlIsID(xmlDocPtr doc, xmlNodePtr elem, xmlAttrPtr attr)
Definition: valid.c:2774
__u8 attr
Definition: mkdosfs.c:359
unsigned char xmlChar
Definition: xmlstring.h:28
GLsizei const GLfloat * value
Definition: glext.h:6069
XMLPUBFUN xmlIDPtr XMLCALL xmlAddID(xmlValidCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *value, xmlAttrPtr attr)
Definition: valid.c:2672
XMLPUBFUN xmlNodePtr XMLCALL xmlNewText(const xmlChar *content)
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
#define NULL
Definition: types.h:112
Definition: tree.h:434
WCHAR * name
Definition: cookie.c:203
GLenum target
Definition: glext.h:7315
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
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

Referenced by xsltApplySequenceConstructor().

◆ xsltAttrTemplateProcess()

XSLTPUBFUN xmlAttrPtr XSLTCALL xsltAttrTemplateProcess ( xsltTransformContextPtr  ctxt,
xmlNodePtr  target,
xmlAttrPtr  attr 
)

xsltAttrTemplateProcess: @ctxt: the XSLT transformation context @target: the element where the attribute will be grafted @attr: the attribute node of a literal result element

Process one attribute of a Literal Result Element (in the stylesheet). Evaluates Attribute Value Templates and copies the attribute over to the result element. This does not process attribute sets (xsl:use-attribute-set).

Returns the generated attribute node.

Definition at line 479 of file templates.c.

481 {
482  const xmlChar *value;
483  xmlAttrPtr ret;
484 
485  if ((ctxt == NULL) || (attr == NULL) || (target == NULL) ||
486  (target->type != XML_ELEMENT_NODE))
487  return(NULL);
488 
489  if (attr->type != XML_ATTRIBUTE_NODE)
490  return(NULL);
491 
492  /*
493  * Skip all XSLT attributes.
494  */
495 #ifdef XSLT_REFACTORED
496  if (attr->psvi == xsltXSLTAttrMarker)
497  return(NULL);
498 #else
499  if ((attr->ns != NULL) && xmlStrEqual(attr->ns->href, XSLT_NAMESPACE))
500  return(NULL);
501 #endif
502  /*
503  * Get the value.
504  */
505  if (attr->children != NULL) {
506  if ((attr->children->type != XML_TEXT_NODE) ||
507  (attr->children->next != NULL))
508  {
509  xsltTransformError(ctxt, NULL, attr->parent,
510  "Internal error: The children of an attribute node of a "
511  "literal result element are not in the expected form.\n");
512  return(NULL);
513  }
514  value = attr->children->content;
515  if (value == NULL)
516  value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
517  } else
518  value = xmlDictLookup(ctxt->dict, BAD_CAST "", 0);
519  /*
520  * Overwrite duplicates.
521  */
522  ret = target->properties;
523  while (ret != NULL) {
524  if (((attr->ns != NULL) == (ret->ns != NULL)) &&
525  xmlStrEqual(ret->name, attr->name) &&
526  ((attr->ns == NULL) || xmlStrEqual(ret->ns->href, attr->ns->href)))
527  {
528  break;
529  }
530  ret = ret->next;
531  }
532  if (ret != NULL) {
533  /* free the existing value */
534  xmlFreeNodeList(ret->children);
535  ret->children = ret->last = NULL;
536  /*
537  * Adjust ns-prefix if needed.
538  */
539  if ((ret->ns != NULL) &&
540  (! xmlStrEqual(ret->ns->prefix, attr->ns->prefix)))
541  {
542  ret->ns = xsltGetNamespace(ctxt, attr->parent, attr->ns, target);
543  }
544  } else {
545  /* create a new attribute */
546  if (attr->ns != NULL)
548  xsltGetNamespace(ctxt, attr->parent, attr->ns, target),
549  attr->name, NULL);
550  else
552  }
553  /*
554  * Set the value.
555  */
556  if (ret != NULL) {
558 
559  text = xmlNewText(NULL);
560  if (text != NULL) {
561  ret->last = ret->children = text;
562  text->parent = (xmlNodePtr) ret;
563  text->doc = ret->doc;
564 
565  if (attr->psvi != NULL) {
566  /*
567  * Evaluate the Attribute Value Template.
568  */
569  xmlChar *val;
570  val = xsltEvalAVT(ctxt, attr->psvi, attr->parent);
571  if (val == NULL) {
572  /*
573  * TODO: Damn, we need an easy mechanism to report
574  * qualified names!
575  */
576  if (attr->ns) {
577  xsltTransformError(ctxt, NULL, attr->parent,
578  "Internal error: Failed to evaluate the AVT "
579  "of attribute '{%s}%s'.\n",
580  attr->ns->href, attr->name);
581  } else {
582  xsltTransformError(ctxt, NULL, attr->parent,
583  "Internal error: Failed to evaluate the AVT "
584  "of attribute '%s'.\n",
585  attr->name);
586  }
587  text->content = xmlStrdup(BAD_CAST "");
588  } else {
589  text->content = val;
590  }
591  } else if ((ctxt->internalized) && (target != NULL) &&
592  (target->doc != NULL) &&
593  (target->doc->dict == ctxt->dict) &&
594  xmlDictOwns(ctxt->dict, value)) {
595  text->content = (xmlChar *) value;
596  } else {
597  text->content = xmlStrdup(value);
598  }
599  }
600  } else {
601  if (attr->ns) {
602  xsltTransformError(ctxt, NULL, attr->parent,
603  "Internal error: Failed to create attribute '{%s}%s'.\n",
604  attr->ns->href, attr->name);
605  } else {
606  xsltTransformError(ctxt, NULL, attr->parent,
607  "Internal error: Failed to create attribute '%s'.\n",
608  attr->name);
609  }
610  }
611  return(ret);
612 }
Definition: pdh_main.c:93
XMLPUBFUN void XMLCALL xmlFreeNodeList(xmlNodePtr cur)
const WCHAR * text
Definition: package.c:1799
xmlNsPtr xsltGetNamespace(xsltTransformContextPtr ctxt, xmlNodePtr cur, xmlNsPtr ns, xmlNodePtr out)
Definition: namespaces.c:596
#define XSLT_NAMESPACE
Definition: xslt.h:46
xmlChar * xsltEvalAVT(xsltTransformContextPtr ctxt, void *avt, xmlNodePtr node)
Definition: attrvt.c:356
xmlNode * xmlNodePtr
Definition: tree.h:488
#define BAD_CAST
Definition: xmlstring.h:35
GLuint GLfloat * val
Definition: glext.h:7180
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
Definition: cookie.c:201
Definition: tree.h:489
int ret
XMLPUBFUN xmlAttrPtr XMLCALL xmlNewNsProp(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value)
unsigned char xmlChar
Definition: xmlstring.h:28
GLsizei const GLfloat * value
Definition: glext.h:6069
XMLPUBFUN xmlNodePtr XMLCALL xmlNewText(const xmlChar *content)
XMLPUBFUN int XMLCALL xmlDictOwns(xmlDictPtr dict, const xmlChar *str)
Definition: dict.c:1220
#define NULL
Definition: types.h:112
Definition: tree.h:434
WCHAR * name
Definition: cookie.c:203
GLenum target
Definition: glext.h:7315
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
XMLPUBFUN xmlChar *XMLCALL xmlStrdup(const xmlChar *cur)
Definition: xmlstring.c:67

◆ xsltAttrTemplateValueProcess()

XSLTPUBFUN xmlChar* XSLTCALL xsltAttrTemplateValueProcess ( xsltTransformContextPtr  ctxt,
const xmlChar str 
)

xsltAttrTemplateValueProcess: @ctxt: the XSLT transformation context @str: the attribute template node value

Process the given node and return the new string value.

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 372 of file templates.c.

372  {
373  return(xsltAttrTemplateValueProcessNode(ctxt, str, NULL));
374 }
const WCHAR * str
xmlChar * xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt, const xmlChar *str, xmlNodePtr inst)
Definition: templates.c:260
#define NULL
Definition: types.h:112

◆ xsltAttrTemplateValueProcessNode()

XSLTPUBFUN xmlChar* XSLTCALL xsltAttrTemplateValueProcessNode ( xsltTransformContextPtr  ctxt,
const xmlChar str,
xmlNodePtr  inst 
)

xsltAttrTemplateValueProcessNode: @ctxt: the XSLT transformation context @str: the attribute template node value @inst: the instruction (or LRE) in the stylesheet holding the attribute with an AVT

Process the given string, allowing to pass a namespace mapping context and return the new string value.

Called by:

QUESTION: Why is this function public? It is not used outside of templates.c.

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 260 of file templates.c.

262 {
263  xmlChar *ret = NULL;
264  const xmlChar *cur;
265  xmlChar *expr, *val;
266  xmlNsPtr *nsList = NULL;
267  int nsNr = 0;
268 
269  if (str == NULL) return(NULL);
270  if (*str == 0)
271  return(xmlStrndup((xmlChar *)"", 0));
272 
273  cur = str;
274  while (*cur != 0) {
275  if (*cur == '{') {
276  if (*(cur+1) == '{') { /* escaped '{' */
277  cur++;
278  ret = xmlStrncat(ret, str, cur - str);
279  cur++;
280  str = cur;
281  continue;
282  }
283  ret = xmlStrncat(ret, str, cur - str);
284  str = cur;
285  cur++;
286  while ((*cur != 0) && (*cur != '}')) {
287  /* Need to check for literal (bug539741) */
288  if ((*cur == '\'') || (*cur == '"')) {
289  char delim = *(cur++);
290  while ((*cur != 0) && (*cur != delim))
291  cur++;
292  if (*cur != 0)
293  cur++; /* skip the ending delimiter */
294  } else
295  cur++;
296  }
297  if (*cur == 0) {
298  xsltTransformError(ctxt, NULL, inst,
299  "xsltAttrTemplateValueProcessNode: unmatched '{'\n");
300  ret = xmlStrncat(ret, str, cur - str);
301  goto exit;
302  }
303  str++;
304  expr = xmlStrndup(str, cur - str);
305  if (expr == NULL)
306  goto exit;
307  else if (*expr == '{') {
308  ret = xmlStrcat(ret, expr);
309  xmlFree(expr);
310  } else {
311  xmlXPathCompExprPtr comp;
312  /*
313  * TODO: keep precompiled form around
314  */
315  if ((nsList == NULL) && (inst != NULL)) {
316  int i = 0;
317 
318  nsList = xmlGetNsList(inst->doc, inst);
319  if (nsList != NULL) {
320  while (nsList[i] != NULL)
321  i++;
322  nsNr = i;
323  }
324  }
325  comp = xmlXPathCtxtCompile(ctxt->xpathCtxt, expr);
326  val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
327  xmlXPathFreeCompExpr(comp);
328  xmlFree(expr);
329  if (val != NULL) {
330  ret = xmlStrcat(ret, val);
331  xmlFree(val);
332  }
333  }
334  cur++;
335  str = cur;
336  } else if (*cur == '}') {
337  cur++;
338  if (*cur == '}') { /* escaped '}' */
339  ret = xmlStrncat(ret, str, cur - str);
340  cur++;
341  str = cur;
342  continue;
343  } else {
344  xsltTransformError(ctxt, NULL, inst,
345  "xsltAttrTemplateValueProcessNode: unmatched '}'\n");
346  }
347  } else
348  cur++;
349  }
350  if (cur != str) {
351  ret = xmlStrncat(ret, str, cur - str);
352  }
353 
354 exit:
355  if (nsList != NULL)
356  xmlFree(nsList);
357 
358  return(ret);
359 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: tree.h:389
XMLPUBFUN xmlChar *XMLCALL xmlStrndup(const xmlChar *cur, int len)
Definition: xmlstring.c:42
Definition: query.h:86
struct _xmlDoc * doc
Definition: tree.h:498
XMLPUBFUN xmlChar *XMLCALL xmlStrcat(xmlChar *cur, const xmlChar *add)
Definition: xmlstring.c:524
const WCHAR * str
xmlXPathContextPtr xpathCtxt
GLuint GLfloat * val
Definition: glext.h:7180
XMLPUBFUN xmlChar *XMLCALL xmlStrncat(xmlChar *cur, const xmlChar *add, int len)
Definition: xmlstring.c:446
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
int ret
unsigned char xmlChar
Definition: xmlstring.h:28
FxCollectionEntry * cur
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
xmlChar * xsltEvalXPathStringNs(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, int nsNr, xmlNsPtr *nsList)
Definition: templates.c:105
void exit(int exitcode)
Definition: _exit.c:33
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678

Referenced by xsltAttrTemplateValueProcess(), and xsltEvalAttrValueTemplate().

◆ xsltEvalAttrValueTemplate()

XSLTPUBFUN xmlChar* XSLTCALL xsltEvalAttrValueTemplate ( xsltTransformContextPtr  ctxt,
xmlNodePtr  node,
const xmlChar name,
const xmlChar ns 
)

Definition at line 392 of file templates.c.

394 {
395  xmlChar *ret;
396  xmlChar *expr;
397 
398  if ((ctxt == NULL) || (inst == NULL) || (name == NULL) ||
399  (inst->type != XML_ELEMENT_NODE))
400  return(NULL);
401 
402  expr = xsltGetNsProp(inst, name, ns);
403  if (expr == NULL)
404  return(NULL);
405 
406  /*
407  * TODO: though now {} is detected ahead, it would still be good to
408  * optimize both functions to keep the splitted value if the
409  * attribute content and the XPath precompiled expressions around
410  */
411 
413 #ifdef WITH_XSLT_DEBUG_TEMPLATES
415  "xsltEvalAttrValueTemplate: %s returns %s\n", expr, ret));
416 #endif
417  if (expr != NULL)
418  xmlFree(expr);
419  return(ret);
420 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
Definition: query.h:86
void * xsltGenericDebugContext
Definition: xsltutils.c:549
xmlChar * xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt, const xmlChar *str, xmlNodePtr inst)
Definition: templates.c:260
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_TRACE(ctxt, code, call)
Definition: xsltutils.h:125
#define NULL
Definition: types.h:112
Definition: name.c:38
xmlChar * xsltGetNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
Definition: xsltutils.c:142

Referenced by xsltAttribute(), xsltDefaultSortFunction(), xsltDocumentElem(), xsltElement(), xsltNumberFormat(), and xsltProcessingInstruction().

◆ xsltEvalStaticAttrValueTemplate()

XSLTPUBFUN const xmlChar* XSLTCALL xsltEvalStaticAttrValueTemplate ( xsltStylesheetPtr  style,
xmlNodePtr  node,
const xmlChar name,
const xmlChar ns,
int found 
)

Definition at line 438 of file templates.c.

439  {
440  const xmlChar *ret;
441  xmlChar *expr;
442 
443  if ((style == NULL) || (inst == NULL) || (name == NULL) ||
444  (inst->type != XML_ELEMENT_NODE))
445  return(NULL);
446 
447  expr = xsltGetNsProp(inst, name, ns);
448  if (expr == NULL) {
449  *found = 0;
450  return(NULL);
451  }
452  *found = 1;
453 
454  ret = xmlStrchr(expr, '{');
455  if (ret != NULL) {
456  xmlFree(expr);
457  return(NULL);
458  }
459  ret = xmlDictLookup(style->dict, expr, -1);
460  xmlFree(expr);
461  return(ret);
462 }
LOCAL int expr(arg_t *ap, int *altp)
Definition: match.c:512
XMLPUBFUN const xmlChar *XMLCALL xmlStrchr(const xmlChar *str, xmlChar val)
Definition: xmlstring.c:325
Definition: query.h:86
XMLPUBVAR xmlFreeFunc xmlFree
Definition: globals.h:251
XMLPUBFUN const xmlChar *XMLCALL xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len)
Definition: dict.c:867
int ret
Definition: mxnamespace.c:44
unsigned char xmlChar
Definition: xmlstring.h:28
#define NULL
Definition: types.h:112
Definition: name.c:38
xmlChar * xsltGetNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *nameSpace)
Definition: xsltutils.c:142
Arabic default style
Definition: afstyles.h:93

Referenced by xsltAttributeComp(), xsltDocumentComp(), xsltElementComp(), xsltNumberComp(), xsltProcessingInstructionComp(), and xsltSortComp().

◆ xsltEvalTemplateString()

XSLTPUBFUN xmlChar* XSLTCALL xsltEvalTemplateString ( xsltTransformContextPtr  ctxt,
xmlNodePtr  contextNode,
xmlNodePtr  inst 
)

xsltEvalTemplateString: @ctxt: the XSLT transformation context @contextNode: the current node in the source tree @inst: the XSLT instruction (xsl:comment, xsl:processing-instruction)

Processes the sequence constructor of the given instruction on @contextNode and converts the resulting tree to a string. This is needed by e.g. xsl:comment and xsl:processing-instruction.

Returns the computed string value or NULL; it's up to the caller to free the result.

Definition at line 189 of file templates.c.

192 {
193  xmlNodePtr oldInsert, insert = NULL;
194  xmlChar *ret;
195  const xmlChar *oldLastText;
196  int oldLastTextSize, oldLastTextUse;
197 
198  if ((ctxt == NULL) || (contextNode == NULL) || (inst == NULL) ||
199  (inst->type != XML_ELEMENT_NODE))
200  return(NULL);
201 
202  if (inst->children == NULL)
203  return(NULL);
204 
205  /*
206  * This creates a temporary element-node to add the resulting
207  * text content to.
208  * OPTIMIZE TODO: Keep such an element-node in the transformation
209  * context to avoid creating it every time.
210  */
211  insert = xmlNewDocNode(ctxt->output, NULL,
212  (const xmlChar *)"fake", NULL);
213  if (insert == NULL) {
214  xsltTransformError(ctxt, NULL, contextNode,
215  "Failed to create temporary node\n");
216  return(NULL);
217  }
218  oldInsert = ctxt->insert;
219  ctxt->insert = insert;
220  oldLastText = ctxt->lasttext;
221  oldLastTextSize = ctxt->lasttsize;
222  oldLastTextUse = ctxt->lasttuse;
223  /*
224  * OPTIMIZE TODO: if inst->children consists only of text-nodes.
225  */
226  xsltApplyOneTemplate(ctxt, contextNode, inst->children, NULL, NULL);
227 
228  ctxt->insert = oldInsert;
229  ctxt->lasttext = oldLastText;
230  ctxt->lasttsize = oldLastTextSize;
231  ctxt->lasttuse = oldLastTextUse;
232 
234  if (insert != NULL)
236  return(ret);
237 }
static int insert
Definition: xmllint.c:138
void xsltApplyOneTemplate(xsltTransformContextPtr ctxt, xmlNodePtr contextNode, xmlNodePtr list, xsltTemplatePtr templ ATTRIBUTE_UNUSED, xsltStackElemPtr params)
Definition: transform.c:3273
Definition: tree.h:489
int ret
const xmlChar * lasttext
unsigned char xmlChar
Definition: xmlstring.h:28
xmlElementType type
Definition: tree.h:491
XMLPUBFUN xmlChar *XMLCALL xmlNodeGetContent(const xmlNode *cur)
#define NULL
Definition: types.h:112
XMLPUBFUN xmlNodePtr XMLCALL xmlNewDocNode(xmlDocPtr doc, xmlNsPtr ns, const xmlChar *name, const xmlChar *content)
XMLPUBFUN void XMLCALL xmlFreeNode(xmlNodePtr cur)
struct _xmlNode * children
Definition: tree.h:493
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678

Referenced by xsltAttribute(), xsltComment(), xsltMessage(), and xsltProcessingInstruction().

◆ xsltEvalXPathPredicate()

XSLTPUBFUN int XSLTCALL xsltEvalXPathPredicate ( xsltTransformContextPtr  ctxt,
xmlXPathCompExprPtr  comp,
xmlNsPtr nsList,
int  nsNr 
)

xsltEvalXPathPredicate: @ctxt: the XSLT transformation context @comp: the XPath compiled expression @nsList: the namespaces in scope @nsNr: the number of namespaces in scope

Process the expression using XPath and evaluate the result as an XPath predicate

Returns 1 is the predicate was true, 0 otherwise

Definition at line 39 of file templates.c.

40  {
41  int ret;
42  xmlXPathObjectPtr res;
43  int oldNsNr;
44  xmlNsPtr *oldNamespaces;
45  xmlNodePtr oldInst;
46  int oldProximityPosition, oldContextSize;
47 
48  if ((ctxt == NULL) || (ctxt->inst == NULL)) {
50  "xsltEvalXPathPredicate: No context or instruction\n");
51  return(0);
52  }
53 
54  oldContextSize = ctxt->xpathCtxt->contextSize;
55  oldProximityPosition = ctxt->xpathCtxt->proximityPosition;
56  oldNsNr = ctxt->xpathCtxt->nsNr;
57  oldNamespaces = ctxt->xpathCtxt->namespaces;
58  oldInst = ctxt->inst;
59 
60  ctxt->xpathCtxt->node = ctxt->node;
61  ctxt->xpathCtxt->namespaces = nsList;
62  ctxt->xpathCtxt->nsNr = nsNr;
63 
64  res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
65 
66  if (res != NULL) {
67  ret = xmlXPathEvalPredicate(ctxt->xpathCtxt, res);
68  xmlXPathFreeObject(res);
69 #ifdef WITH_XSLT_DEBUG_TEMPLATES
71  "xsltEvalXPathPredicate: returns %d\n", ret));
72 #endif
73  } else {
74 #ifdef WITH_XSLT_DEBUG_TEMPLATES
76  "xsltEvalXPathPredicate: failed\n"));
77 #endif
78  ctxt->state = XSLT_STATE_STOPPED;
79  ret = 0;
80  }
81  ctxt->xpathCtxt->nsNr = oldNsNr;
82 
83  ctxt->xpathCtxt->namespaces = oldNamespaces;
84  ctxt->inst = oldInst;
85  ctxt->xpathCtxt->contextSize = oldContextSize;
86  ctxt->xpathCtxt->proximityPosition = oldProximityPosition;
87 
88  return(ret);
89 }
Definition: tree.h:389
xsltTransformState state
xmlXPathContextPtr xpathCtxt
void * xsltGenericDebugContext
Definition: xsltutils.c:549
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
Definition: tree.h:489
int ret
#define XSLT_TRACE(ctxt, code, call)
Definition: xsltutils.h:125
#define NULL
Definition: types.h:112
GLuint res
Definition: glext.h:9613
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678

Referenced by xsltTestPredicateMatch().

◆ xsltEvalXPathString()

XSLTPUBFUN xmlChar* XSLTCALL xsltEvalXPathString ( xsltTransformContextPtr  ctxt,
xmlXPathCompExprPtr  comp 
)

xsltEvalXPathString: @ctxt: the XSLT transformation context @comp: the compiled XPath expression

Process the expression using XPath and get a string

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 171 of file templates.c.

171  {
172  return(xsltEvalXPathStringNs(ctxt, comp, 0, NULL));
173 }
#define NULL
Definition: types.h:112
xmlChar * xsltEvalXPathStringNs(xsltTransformContextPtr ctxt, xmlXPathCompExprPtr comp, int nsNr, xmlNsPtr *nsList)
Definition: templates.c:105

Referenced by xsltDocumentElem().

◆ xsltEvalXPathStringNs()

XSLTPUBFUN xmlChar* XSLTCALL xsltEvalXPathStringNs ( xsltTransformContextPtr  ctxt,
xmlXPathCompExprPtr  comp,
int  nsNr,
xmlNsPtr nsList 
)

xsltEvalXPathStringNs: @ctxt: the XSLT transformation context @comp: the compiled XPath expression @nsNr: the number of namespaces in the list @nsList: the list of in-scope namespaces to use

Process the expression using XPath, allowing to pass a namespace mapping context and get a string

Returns the computed string value or NULL, must be deallocated by the caller.

Definition at line 105 of file templates.c.

106  {
107  xmlChar *ret = NULL;
108  xmlXPathObjectPtr res;
109  xmlNodePtr oldInst;
110  xmlNodePtr oldNode;
111  int oldPos, oldSize;
112  int oldNsNr;
113  xmlNsPtr *oldNamespaces;
114 
115  if ((ctxt == NULL) || (ctxt->inst == NULL)) {
117  "xsltEvalXPathStringNs: No context or instruction\n");
118  return(0);
119  }
120 
121  oldInst = ctxt->inst;
122  oldNode = ctxt->node;
123  oldPos = ctxt->xpathCtxt->proximityPosition;
124  oldSize = ctxt->xpathCtxt->contextSize;
125  oldNsNr = ctxt->xpathCtxt->nsNr;
126  oldNamespaces = ctxt->xpathCtxt->namespaces;
127 
128  ctxt->xpathCtxt->node = ctxt->node;
129  /* TODO: do we need to propagate the namespaces here ? */
130  ctxt->xpathCtxt->namespaces = nsList;
131  ctxt->xpathCtxt->nsNr = nsNr;
132  res = xmlXPathCompiledEval(comp, ctxt->xpathCtxt);
133  if (res != NULL) {
134  if (res->type != XPATH_STRING)
135  res = xmlXPathConvertString(res);
136  if (res->type == XPATH_STRING) {
137  ret = res->stringval;
138  res->stringval = NULL;
139  } else {
141  "xpath : string() function didn't return a String\n");
142  }
143  xmlXPathFreeObject(res);
144  } else {
145  ctxt->state = XSLT_STATE_STOPPED;
146  }
147 #ifdef WITH_XSLT_DEBUG_TEMPLATES
149  "xsltEvalXPathString: returns %s\n", ret));
150 #endif
151  ctxt->inst = oldInst;
152  ctxt->node = oldNode;
153  ctxt->xpathCtxt->contextSize = oldSize;
154  ctxt->xpathCtxt->proximityPosition = oldPos;
155  ctxt->xpathCtxt->nsNr = oldNsNr;
156  ctxt->xpathCtxt->namespaces = oldNamespaces;
157  return(ret);
158 }
Definition: tree.h:389
xsltTransformState state
xmlXPathContextPtr xpathCtxt
void * xsltGenericDebugContext
Definition: xsltutils.c:549
xmlGenericErrorFunc xsltGenericDebug
Definition: xsltutils.c:548
Definition: tree.h:489
int ret
unsigned char xmlChar
Definition: xmlstring.h:28
#define XSLT_TRACE(ctxt, code, call)
Definition: xsltutils.h:125
#define NULL
Definition: types.h:112
GLuint res
Definition: glext.h:9613
void xsltTransformError(xsltTransformContextPtr ctxt, xsltStylesheetPtr style, xmlNodePtr node, const char *msg,...)
Definition: xsltutils.c:678

Referenced by xsltAttrTemplateValueProcessNode(), xsltEvalAVT(), and xsltEvalXPathString().

◆ xsltTemplateProcess()

XSLTPUBFUN xmlNodePtr* XSLTCALL xsltTemplateProcess ( xsltTransformContextPtr ctxt  ATTRIBUTE_UNUSED,
xmlNodePtr  node 
)

xsltTemplateProcess: @ctxt: the XSLT transformation context @node: the attribute template node

Obsolete. Don't use it.

Returns NULL.

Definition at line 847 of file templates.c.

847  {
848  if (node == NULL)
849  return(NULL);
850 
851  return(0);
852 }
#define NULL
Definition: types.h:112
Definition: dlist.c:348