mirror of
https://github.com/reactos/reactos.git
synced 2024-08-27 05:38:41 +00:00
376 lines
9.4 KiB
C
376 lines
9.4 KiB
C
/*
|
|
* attrvt.c: Implementation of the XSL Transformation 1.0 engine
|
|
* attribute value template handling part.
|
|
*
|
|
* References:
|
|
* http://www.w3.org/TR/1999/REC-xslt-19991116
|
|
*
|
|
* Michael Kay "XSLT Programmer's Reference" pp 637-643
|
|
* Writing Multiple Output Files
|
|
*
|
|
* See Copyright for the status of this software.
|
|
*
|
|
* daniel@veillard.com
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
|
|
#ifdef WITH_XSLT_DEBUG
|
|
#define WITH_XSLT_DEBUG_AVT
|
|
#endif
|
|
|
|
#define MAX_AVT_SEG 10
|
|
|
|
typedef struct _xsltAttrVT xsltAttrVT;
|
|
typedef xsltAttrVT *xsltAttrVTPtr;
|
|
struct _xsltAttrVT {
|
|
struct _xsltAttrVT *next; /* next xsltAttrVT */
|
|
int nb_seg; /* Number of segments */
|
|
int max_seg; /* max capacity before re-alloc needed */
|
|
int strstart; /* is the start a string */
|
|
/*
|
|
* the namespaces in scope
|
|
*/
|
|
xmlNsPtr *nsList;
|
|
int nsNr;
|
|
/*
|
|
* the content is an alternate of string and xmlXPathCompExprPtr
|
|
*/
|
|
void *segments[MAX_AVT_SEG];
|
|
};
|
|
|
|
/**
|
|
* xsltNewAttrVT:
|
|
* @style: a XSLT process context
|
|
*
|
|
* Build a new xsltAttrVT structure
|
|
*
|
|
* Returns the structure or NULL in case of error
|
|
*/
|
|
static xsltAttrVTPtr
|
|
xsltNewAttrVT(xsltStylesheetPtr style) {
|
|
xsltAttrVTPtr cur;
|
|
|
|
cur = (xsltAttrVTPtr) xmlMalloc(sizeof(xsltAttrVT));
|
|
if (cur == NULL) {
|
|
xsltTransformError(NULL, style, NULL,
|
|
"xsltNewAttrVTPtr : malloc failed\n");
|
|
if (style != NULL) style->errors++;
|
|
return(NULL);
|
|
}
|
|
memset(cur, 0, sizeof(xsltAttrVT));
|
|
|
|
cur->nb_seg = 0;
|
|
cur->max_seg = MAX_AVT_SEG;
|
|
cur->strstart = 0;
|
|
cur->next = style->attVTs;
|
|
/*
|
|
* Note: this pointer may be changed by a re-alloc within xsltCompileAttr,
|
|
* so that code may change the stylesheet pointer also!
|
|
*/
|
|
style->attVTs = (xsltAttrVTPtr) cur;
|
|
|
|
return(cur);
|
|
}
|
|
|
|
/**
|
|
* xsltFreeAttrVT:
|
|
* @avt: pointer to an xsltAttrVT structure
|
|
*
|
|
* Free up the memory associated to the attribute value template
|
|
*/
|
|
static void
|
|
xsltFreeAttrVT(xsltAttrVTPtr avt) {
|
|
int i;
|
|
|
|
if (avt == NULL) return;
|
|
|
|
if (avt->strstart == 1) {
|
|
for (i = 0;i < avt->nb_seg; i += 2)
|
|
if (avt->segments[i] != NULL)
|
|
xmlFree((xmlChar *) avt->segments[i]);
|
|
for (i = 1;i < avt->nb_seg; i += 2)
|
|
xmlXPathFreeCompExpr((xmlXPathCompExprPtr) avt->segments[i]);
|
|
} else {
|
|
for (i = 0;i < avt->nb_seg; i += 2)
|
|
xmlXPathFreeCompExpr((xmlXPathCompExprPtr) avt->segments[i]);
|
|
for (i = 1;i < avt->nb_seg; i += 2)
|
|
if (avt->segments[i] != NULL)
|
|
xmlFree((xmlChar *) avt->segments[i]);
|
|
}
|
|
if (avt->nsList != NULL)
|
|
xmlFree(avt->nsList);
|
|
xmlFree(avt);
|
|
}
|
|
|
|
/**
|
|
* xsltFreeAVTList:
|
|
* @avt: pointer to an list of AVT structures
|
|
*
|
|
* Free up the memory associated to the attribute value templates
|
|
*/
|
|
void
|
|
xsltFreeAVTList(void *avt) {
|
|
xsltAttrVTPtr cur = (xsltAttrVTPtr) avt, next;
|
|
|
|
while (cur != NULL) {
|
|
next = cur->next;
|
|
xsltFreeAttrVT(cur);
|
|
cur = next;
|
|
}
|
|
}
|
|
/**
|
|
* xsltSetAttrVTsegment:
|
|
* @ avt: pointer to an xsltAttrVT structure
|
|
* @ val: the value to be set to the next available segment
|
|
*
|
|
* Within xsltCompileAttr there are several places where a value
|
|
* needs to be added to the 'segments' array within the xsltAttrVT
|
|
* structure, and at each place the allocated size may have to be
|
|
* re-allocated. This routine takes care of that situation.
|
|
*
|
|
* Returns the avt pointer, which may have been changed by a re-alloc
|
|
*/
|
|
static xsltAttrVTPtr
|
|
xsltSetAttrVTsegment(xsltAttrVTPtr avt, void *val) {
|
|
if (avt->nb_seg >= avt->max_seg) {
|
|
avt = (xsltAttrVTPtr) xmlRealloc(avt, sizeof(xsltAttrVT) +
|
|
avt->max_seg * sizeof(void *));
|
|
if (avt == NULL) {
|
|
return NULL;
|
|
}
|
|
memset(&avt->segments[avt->nb_seg], 0, MAX_AVT_SEG*sizeof(void *));
|
|
avt->max_seg += MAX_AVT_SEG;
|
|
}
|
|
avt->segments[avt->nb_seg++] = val;
|
|
return avt;
|
|
}
|
|
|
|
/**
|
|
* xsltCompileAttr:
|
|
* @style: a XSLT process context
|
|
* @attr: the attribute coming from the stylesheet.
|
|
*
|
|
* Precompile an attribute in a stylesheet, basically it checks if it is
|
|
* an attrubute value template, and if yes establish some structures needed
|
|
* to process it at transformation time.
|
|
*/
|
|
void
|
|
xsltCompileAttr(xsltStylesheetPtr style, xmlAttrPtr attr) {
|
|
const xmlChar *str;
|
|
const xmlChar *cur;
|
|
xmlChar *ret = NULL;
|
|
xmlChar *expr = NULL;
|
|
xsltAttrVTPtr avt;
|
|
int i = 0, lastavt = 0;
|
|
|
|
if ((style == NULL) || (attr == NULL) || (attr->children == NULL))
|
|
return;
|
|
if ((attr->children->type != XML_TEXT_NODE) ||
|
|
(attr->children->next != NULL)) {
|
|
xsltTransformError(NULL, style, attr->parent,
|
|
"Attribute '%s': The content is expected to be a single text "
|
|
"node when compiling an AVT.\n", attr->name);
|
|
style->errors++;
|
|
return;
|
|
}
|
|
str = attr->children->content;
|
|
if ((xmlStrchr(str, '{') == NULL) &&
|
|
(xmlStrchr(str, '}') == NULL)) return;
|
|
|
|
#ifdef WITH_XSLT_DEBUG_AVT
|
|
xsltGenericDebug(xsltGenericDebugContext,
|
|
"Found AVT %s: %s\n", attr->name, str);
|
|
#endif
|
|
if (attr->psvi != NULL) {
|
|
#ifdef WITH_XSLT_DEBUG_AVT
|
|
xsltGenericDebug(xsltGenericDebugContext,
|
|
"AVT %s: already compiled\n", attr->name);
|
|
#endif
|
|
return;
|
|
}
|
|
/*
|
|
* Create a new AVT object.
|
|
*/
|
|
avt = xsltNewAttrVT(style);
|
|
if (avt == NULL)
|
|
return;
|
|
attr->psvi = avt;
|
|
|
|
avt->nsList = xmlGetNsList(attr->doc, attr->parent);
|
|
if (avt->nsList != NULL) {
|
|
while (avt->nsList[i] != NULL)
|
|
i++;
|
|
}
|
|
avt->nsNr = i;
|
|
|
|
cur = str;
|
|
while (*cur != 0) {
|
|
if (*cur == '{') {
|
|
if (*(cur+1) == '{') { /* escaped '{' */
|
|
cur++;
|
|
ret = xmlStrncat(ret, str, cur - str);
|
|
cur++;
|
|
str = cur;
|
|
continue;
|
|
}
|
|
if (*(cur+1) == '}') { /* skip empty AVT */
|
|
ret = xmlStrncat(ret, str, cur - str);
|
|
cur += 2;
|
|
str = cur;
|
|
continue;
|
|
}
|
|
if ((ret != NULL) || (cur - str > 0)) {
|
|
ret = xmlStrncat(ret, str, cur - str);
|
|
str = cur;
|
|
if (avt->nb_seg == 0)
|
|
avt->strstart = 1;
|
|
if ((avt = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL)
|
|
goto error;
|
|
ret = NULL;
|
|
lastavt = 0;
|
|
}
|
|
|
|
cur++;
|
|
while ((*cur != 0) && (*cur != '}')) {
|
|
/* Need to check for literal (bug539741) */
|
|
if ((*cur == '\'') || (*cur == '"')) {
|
|
char delim = *(cur++);
|
|
while ((*cur != 0) && (*cur != delim))
|
|
cur++;
|
|
if (*cur != 0)
|
|
cur++; /* skip the ending delimiter */
|
|
} else
|
|
cur++;
|
|
}
|
|
if (*cur == 0) {
|
|
xsltTransformError(NULL, style, attr->parent,
|
|
"Attribute '%s': The AVT has an unmatched '{'.\n",
|
|
attr->name);
|
|
style->errors++;
|
|
goto error;
|
|
}
|
|
str++;
|
|
expr = xmlStrndup(str, cur - str);
|
|
if (expr == NULL) {
|
|
/*
|
|
* TODO: What needs to be done here?
|
|
*/
|
|
XSLT_TODO
|
|
goto error;
|
|
} else {
|
|
xmlXPathCompExprPtr comp;
|
|
|
|
comp = xsltXPathCompile(style, expr);
|
|
if (comp == NULL) {
|
|
xsltTransformError(NULL, style, attr->parent,
|
|
"Attribute '%s': Failed to compile the expression "
|
|
"'%s' in the AVT.\n", attr->name, expr);
|
|
style->errors++;
|
|
goto error;
|
|
}
|
|
if (avt->nb_seg == 0)
|
|
avt->strstart = 0;
|
|
if (lastavt == 1) {
|
|
if ((avt = xsltSetAttrVTsegment(avt, NULL)) == NULL)
|
|
goto error;
|
|
}
|
|
if ((avt = xsltSetAttrVTsegment(avt, (void *) comp)) == NULL)
|
|
goto error;
|
|
lastavt = 1;
|
|
xmlFree(expr);
|
|
expr = NULL;
|
|
}
|
|
cur++;
|
|
str = cur;
|
|
} else if (*cur == '}') {
|
|
cur++;
|
|
if (*cur == '}') { /* escaped '}' */
|
|
ret = xmlStrncat(ret, str, cur - str);
|
|
cur++;
|
|
str = cur;
|
|
continue;
|
|
} else {
|
|
xsltTransformError(NULL, style, attr->parent,
|
|
"Attribute '%s': The AVT has an unmatched '}'.\n",
|
|
attr->name);
|
|
goto error;
|
|
}
|
|
} else
|
|
cur++;
|
|
}
|
|
if ((ret != NULL) || (cur - str > 0)) {
|
|
ret = xmlStrncat(ret, str, cur - str);
|
|
str = cur;
|
|
if (avt->nb_seg == 0)
|
|
avt->strstart = 1;
|
|
if ((avt = xsltSetAttrVTsegment(avt, (void *) ret)) == NULL)
|
|
goto error;
|
|
ret = NULL;
|
|
}
|
|
|
|
error:
|
|
if (avt == NULL) {
|
|
xsltTransformError(NULL, style, attr->parent,
|
|
"xsltCompileAttr: malloc problem\n");
|
|
} else {
|
|
if (attr->psvi != avt) { /* may have changed from realloc */
|
|
attr->psvi = avt;
|
|
/*
|
|
* This is a "hack", but I can't see any clean method of
|
|
* doing it. If a re-alloc has taken place, then the pointer
|
|
* for this AVT may have changed. style->attVTs was set by
|
|
* xsltNewAttrVT, so it needs to be re-set to the new value!
|
|
*/
|
|
style->attVTs = avt;
|
|
}
|
|
}
|
|
if (ret != NULL)
|
|
xmlFree(ret);
|
|
if (expr != NULL)
|
|
xmlFree(expr);
|
|
}
|
|
|
|
|
|
/**
|
|
* xsltEvalAVT:
|
|
* @ctxt: the XSLT transformation context
|
|
* @avt: the prevompiled attribute value template info
|
|
* @node: the node hosting the attribute
|
|
*
|
|
* Process the given AVT, and return the new string value.
|
|
*
|
|
* Returns the computed string value or NULL, must be deallocated by the
|
|
* caller.
|
|
*/
|
|
xmlChar *
|
|
xsltEvalAVT(xsltTransformContextPtr ctxt, void *avt, xmlNodePtr node) {
|
|
xmlChar *ret = NULL, *tmp;
|
|
xmlXPathCompExprPtr comp;
|
|
xsltAttrVTPtr cur = (xsltAttrVTPtr) avt;
|
|
int i;
|
|
int str;
|
|
|
|
if ((ctxt == NULL) || (avt == NULL) || (node == NULL))
|
|
return(NULL);
|
|
str = cur->strstart;
|
|
for (i = 0;i < cur->nb_seg;i++) {
|
|
if (str) {
|
|
ret = xmlStrcat(ret, (const xmlChar *) cur->segments[i]);
|
|
} else {
|
|
comp = (xmlXPathCompExprPtr) cur->segments[i];
|
|
tmp = xsltEvalXPathStringNs(ctxt, comp, cur->nsNr, cur->nsList);
|
|
if (tmp != NULL) {
|
|
if (ret != NULL) {
|
|
ret = xmlStrcat(ret, tmp);
|
|
xmlFree(tmp);
|
|
} else {
|
|
ret = tmp;
|
|
}
|
|
}
|
|
}
|
|
str = !str;
|
|
}
|
|
return(ret);
|
|
}
|