/**
* htmlDocDumpMemory:
* @cur: the document
* @mem: OUT: the memory pointer
* @size: OUT: the memory length
*
* Dump an HTML document in memory and return the xmlChar * and it's size.
* It's up to the caller to free the memory.
*/
void
htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
xmlOutputBufferPtr buf;
xmlCharEncodingHandlerPtr handler = NULL;
const char *encoding;
xmlInitParser();
if (cur == NULL) {
#ifdef DEBUG_TREE
xmlGenericError(xmlGenericErrorContext,
"htmlDocDumpMemory : document == NULL\n");
#endif
*mem = NULL;
*size = 0;
return;
}
encoding = (const char *) htmlGetMetaEncoding(cur);
if (encoding != NULL) {
xmlCharEncoding enc;
enc = xmlParseCharEncoding(encoding);
if (enc != cur->charset) {
if (cur->charset != XML_CHAR_ENCODING_UTF8) {
/*
* Not supported yet
*/
*mem = NULL;
*size = 0;
return;
}
handler = xmlFindCharEncodingHandler(encoding);
if (handler == NULL) {
*mem = NULL;
*size = 0;
return;
}
}
}
/*
* Fallback to HTML or ASCII when the encoding is unspecified
*/
if (handler == NULL)
handler = xmlFindCharEncodingHandler("HTML");
if (handler == NULL)
handler = xmlFindCharEncodingHandler("ascii");
buf = xmlAllocOutputBuffer(handler);
if (buf == NULL) {
*mem = NULL;
*size = 0;
return;
}
htmlDocContentDumpOutput(buf, cur, NULL);
xmlOutputBufferFlush(buf);
if (buf->conv != NULL) {
*size = buf->conv->use;
*mem = xmlStrndup(buf->conv->content, *size);
} else {
*size = buf->buffer->use;
*mem = xmlStrndup(buf->buffer->content, *size);
}
(void)xmlOutputBufferClose(buf);
}
/**
* Parse command line for XSLT parameters
*/
int
trParseParams(const char** params, int* plen,
int count, char **argv)
{
int i;
*plen = 0;
params[0] = 0;
for (i=0; i<count; i++)
{
if (argv[i][0] == '-')
{
if (!strcmp(argv[i], "-p"))
{
int j;
xmlChar *name, *value;
i++;
if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS);
for(j=0; argv[i][j] && (argv[i][j] != '='); j++);
if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS);
name = xmlStrndup((const xmlChar *) argv[i], j);
value = xmlStrdup((const xmlChar *) argv[i]+j+1);
if (*plen >= MAX_PARAMETERS)
{
fprintf(stderr, "too many params increase MAX_PARAMETERS\n");
exit(EXIT_INTERNAL_ERROR);
}
params[*plen] = (char *)name;
(*plen)++;
params[*plen] = (char *)value;
(*plen)++;
params[*plen] = 0;
}
else if (!strcmp(argv[i], "-s"))
{
int j;
const xmlChar *string;
xmlChar *name, *value;
i++;
if (i >= count) trUsage(argv[0], EXIT_BAD_ARGS);
for(j=0; argv[i][j] && (argv[i][j] != '='); j++);
if (argv[i][j] != '=') trUsage(argv[0], EXIT_BAD_ARGS);
name = xmlStrndup((const xmlChar *)argv[i], j);
string = (const xmlChar *)(argv[i]+j+1);
if (xmlStrchr(string, '"'))
{
if (xmlStrchr(string, '\''))
{
fprintf(stderr,
"string parameter contains both quote and double-quotes\n");
exit(EXIT_INTERNAL_ERROR);
}
value = xmlStrdup((const xmlChar *)"'");
value = xmlStrcat(value, string);
value = xmlStrcat(value, (const xmlChar *)"'");
}
else
{
value = xmlStrdup((const xmlChar *)"\"");
value = xmlStrcat(value, string);
value = xmlStrcat(value, (const xmlChar *)"\"");
}
if (*plen >= MAX_PARAMETERS)
{
fprintf(stderr, "too many params increase MAX_PARAMETERS\n");
exit(EXIT_INTERNAL_ERROR);
}
params[*plen] = (char *)name;
(*plen)++;
params[*plen] = (char *)value;
(*plen)++;
params[*plen] = 0;
}
}
else
break;
}
return i;
}
/**
* 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:
* - xsltAttrTemplateValueProcess() (templates.c)
* - xsltEvalAttrValueTemplate() (templates.c)
*
* 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.
*/
xmlChar *
xsltAttrTemplateValueProcessNode(xsltTransformContextPtr ctxt,
const xmlChar *str, xmlNodePtr inst)
{
xmlChar *ret = NULL;
const xmlChar *cur;
xmlChar *expr, *val;
xmlNsPtr *nsList = NULL;
int nsNr = 0;
if (str == NULL) return(NULL);
if (*str == 0)
return(xmlStrndup((xmlChar *)"", 0));
cur = str;
while (*cur != 0) {
if (*cur == '{') {
if (*(cur+1) == '{') { /* escaped '{' */
cur++;
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
}
ret = xmlStrncat(ret, str, cur - str);
str = cur;
cur++;
while ((*cur != 0) && (*cur != '}')) cur++;
if (*cur == 0) {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '{'\n");
ret = xmlStrncat(ret, str, cur - str);
return(ret);
}
str++;
expr = xmlStrndup(str, cur - str);
if (expr == NULL)
return(ret);
else if (*expr == '{') {
ret = xmlStrcat(ret, expr);
xmlFree(expr);
} else {
xmlXPathCompExprPtr comp;
/*
* TODO: keep precompiled form around
*/
if ((nsList == NULL) && (inst != NULL)) {
int i = 0;
nsList = xmlGetNsList(inst->doc, inst);
if (nsList != NULL) {
while (nsList[i] != NULL)
i++;
nsNr = i;
}
}
comp = xmlXPathCompile(expr);
val = xsltEvalXPathStringNs(ctxt, comp, nsNr, nsList);
xmlXPathFreeCompExpr(comp);
xmlFree(expr);
if (val != NULL) {
ret = xmlStrcat(ret, val);
xmlFree(val);
}
}
cur++;
str = cur;
} else if (*cur == '}') {
cur++;
if (*cur == '}') { /* escaped '}' */
ret = xmlStrncat(ret, str, cur - str);
cur++;
str = cur;
continue;
} else {
xsltTransformError(ctxt, NULL, inst,
"xsltAttrTemplateValueProcessNode: unmatched '}'\n");
}
} else
cur++;
}
if (cur != str) {
ret = xmlStrncat(ret, str, cur - str);
}
if (nsList != NULL)
xmlFree(nsList);
return(ret);
}
static void
_start_element_handler_ns(void *user, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI, int nb_namespaces, const xmlChar ** namespaces, int nb_attributes, int nb_defaulted, const xmlChar ** attributes)
{
XML_Parser parser = (XML_Parser) user;
xmlChar *qualified_name = NULL;
xmlChar **attrs = NULL;
int i;
int z = 0;
int y = 0;
if (nb_namespaces > 0 && parser->h_start_ns != NULL) {
for (i = 0; i < nb_namespaces; i += 1) {
parser->h_start_ns(parser->user, (const XML_Char *) namespaces[y], (const XML_Char *) namespaces[y+1]);
y += 2;
}
y = 0;
}
if (parser->h_start_element == NULL) {
if (parser->h_default) {
if (prefix) {
qualified_name = xmlStrncatNew((xmlChar *)"<", prefix, xmlStrlen(prefix));
qualified_name = xmlStrncat(qualified_name, (xmlChar *)":", 1);
qualified_name = xmlStrncat(qualified_name, name, xmlStrlen(name));
} else {
qualified_name = xmlStrncatNew((xmlChar *)"<", name, xmlStrlen(name));
}
if (namespaces) {
int i, j;
for (i = 0,j = 0;j < nb_namespaces;j++) {
int ns_len;
char *ns_string, *ns_prefix, *ns_url;
ns_prefix = (char *) namespaces[i++];
ns_url = (char *) namespaces[i++];
if (ns_prefix) {
ns_len = spprintf(&ns_string, 0, " xmlns:%s=\"%s\"", ns_prefix, ns_url);
} else {
ns_len = spprintf(&ns_string, 0, " xmlns=\"%s\"", ns_url);
}
qualified_name = xmlStrncat(qualified_name, (xmlChar *)ns_string, ns_len);
efree(ns_string);
}
}
if (attributes) {
for (i = 0; i < nb_attributes; i += 1) {
int att_len;
char *att_string, *att_name, *att_value, *att_prefix, *att_valueend;
att_name = (char *) attributes[y++];
att_prefix = (char *)attributes[y++];
y++;
att_value = (char *)attributes[y++];
att_valueend = (char *)attributes[y++];
if (att_prefix) {
att_len = spprintf(&att_string, 0, " %s:%s=\"", att_prefix, att_name);
} else {
att_len = spprintf(&att_string, 0, " %s=\"", att_name);
}
qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_string, att_len);
qualified_name = xmlStrncat(qualified_name, (xmlChar *)att_value, att_valueend - att_value);
qualified_name = xmlStrncat(qualified_name, (xmlChar *)"\"", 1);
efree(att_string);
}
}
qualified_name = xmlStrncat(qualified_name, (xmlChar *)">", 1);
parser->h_default(parser->user, (const XML_Char *) qualified_name, xmlStrlen(qualified_name));
xmlFree(qualified_name);
}
return;
}
_qualify_namespace(parser, name, URI, &qualified_name);
if (attributes != NULL) {
xmlChar *qualified_name_attr = NULL;
attrs = safe_emalloc((nb_attributes * 2) + 1, sizeof(int *), 0);
for (i = 0; i < nb_attributes; i += 1) {
if (attributes[y+1] != NULL) {
_qualify_namespace(parser, attributes[y] , attributes[y + 2], &qualified_name_attr);
} else {
qualified_name_attr = xmlStrdup(attributes[y]);
}
attrs[z] = qualified_name_attr;
attrs[z + 1] = xmlStrndup(attributes[y + 3] , (int) (attributes[y + 4] - attributes[y + 3]));
z += 2;
y += 5;
}
attrs[z] = NULL;
}
parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attrs);
if (attrs) {
for (i = 0; i < z; i++) {
xmlFree(attrs[i]);
}
efree(attrs);
}
xmlFree(qualified_name);
}
/**
* htmlDocDumpMemoryFormat:
* @cur: the document
* @mem: OUT: the memory pointer
* @size: OUT: the memory length
* @format: should formatting spaces been added
*
* Dump an HTML document in memory and return the xmlChar * and it's size.
* It's up to the caller to free the memory.
*/
void
htmlDocDumpMemoryFormat(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
xmlOutputBufferPtr buf;
xmlCharEncodingHandlerPtr handler = NULL;
const char *encoding;
xmlInitParser();
if ((mem == NULL) || (size == NULL))
return;
if (cur == NULL) {
*mem = NULL;
*size = 0;
return;
}
encoding = (const char *) htmlGetMetaEncoding(cur);
if (encoding != NULL) {
xmlCharEncoding enc;
enc = xmlParseCharEncoding(encoding);
if (enc != cur->charset) {
if (cur->charset != XML_CHAR_ENCODING_UTF8) {
/*
* Not supported yet
*/
*mem = NULL;
*size = 0;
return;
}
handler = xmlFindCharEncodingHandler(encoding);
if (handler == NULL)
htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
} else {
handler = xmlFindCharEncodingHandler(encoding);
}
}
/*
* Fallback to HTML or ASCII when the encoding is unspecified
*/
if (handler == NULL)
handler = xmlFindCharEncodingHandler("HTML");
if (handler == NULL)
handler = xmlFindCharEncodingHandler("ascii");
buf = xmlAllocOutputBufferInternal(handler);
if (buf == NULL) {
*mem = NULL;
*size = 0;
return;
}
htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
xmlOutputBufferFlush(buf);
if (buf->conv != NULL) {
*size = xmlBufUse(buf->conv);
*mem = xmlStrndup(xmlBufContent(buf->conv), *size);
} else {
*size = xmlBufUse(buf->buffer);
*mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
}
(void)xmlOutputBufferClose(buf);
}
/*
* xmlAddEntity : register a new entity for an entities table.
*/
static xmlEntityPtr
xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
xmlDictPtr dict = NULL;
xmlEntitiesTablePtr table = NULL;
xmlEntityPtr ret;
if (name == NULL)
return(NULL);
if (dtd == NULL)
return(NULL);
if (dtd->doc != NULL)
dict = dtd->doc->dict;
switch (type) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
if (dtd->entities == NULL)
dtd->entities = xmlHashCreateDict(0, dict);
table = dtd->entities;
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if (dtd->pentities == NULL)
dtd->pentities = xmlHashCreateDict(0, dict);
table = dtd->pentities;
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
return(NULL);
}
if (table == NULL)
return(NULL);
ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (ret == NULL) {
xmlEntitiesErrMemory("xmlAddEntity:: malloc failed");
return(NULL);
}
memset(ret, 0, sizeof(xmlEntity));
ret->type = XML_ENTITY_DECL;
ret->checked = 0;
/*
* fill the structure.
*/
ret->etype = (xmlEntityType) type;
if (dict == NULL) {
ret->name = xmlStrdup(name);
if (ExternalID != NULL)
ret->ExternalID = xmlStrdup(ExternalID);
if (SystemID != NULL)
ret->SystemID = xmlStrdup(SystemID);
} else {
ret->name = xmlDictLookup(dict, name, -1);
if (ExternalID != NULL)
ret->ExternalID = xmlDictLookup(dict, ExternalID, -1);
if (SystemID != NULL)
ret->SystemID = xmlDictLookup(dict, SystemID, -1);
}
if (content != NULL) {
ret->length = xmlStrlen(content);
if ((dict != NULL) && (ret->length < 5))
ret->content = (xmlChar *)
xmlDictLookup(dict, content, ret->length);
else
ret->content = xmlStrndup(content, ret->length);
} else {
ret->length = 0;
ret->content = NULL;
}
ret->URI = NULL; /* to be computed by the layer knowing
the defining entity */
ret->orig = NULL;
ret->owner = 0;
ret->doc = dtd->doc;
if (xmlHashAddEntry(table, name, ret)) {
/*
* entity was already defined at another level.
*/
xmlFreeEntity(ret);
return(NULL);
}
return(ret);
}
static void
xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
const char *cur = line;
if (line == NULL) return;
if (!strncmp(line, "HTTP/", 5)) {
int version = 0;
int ret = 0;
cur += 5;
while ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
if (*cur == '.') {
cur++;
if ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
while ((*cur >= '0') && (*cur <= '9'))
cur++;
} else
version *= 10;
if ((*cur != ' ') && (*cur != '\t')) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ((*cur < '0') || (*cur > '9')) return;
while ((*cur >= '0') && (*cur <= '9')) {
ret *= 10;
ret += *cur - '0';
cur++;
}
if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;
ctxt->returnValue = ret;
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
const xmlChar *charset, *last, *mime;
cur += 13;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->contentType != NULL)
xmlFree(ctxt->contentType);
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
const xmlChar *charset, *last, *mime;
cur += 12;
if (ctxt->contentType != NULL) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
cur += 9;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->location != NULL)
xmlFree(ctxt->location);
if (*cur == '/') {
xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
xmlChar *tmp_loc =
xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
ctxt->location =
(char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);
} else {
ctxt->location = xmlMemStrdup(cur);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
cur += 19;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
#ifdef HAVE_ZLIB_H
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {
ctxt->usesGzip = 1;
ctxt->strm = xmlMalloc(sizeof(z_stream));
if (ctxt->strm != NULL) {
ctxt->strm->zalloc = Z_NULL;
ctxt->strm->zfree = Z_NULL;
ctxt->strm->opaque = Z_NULL;
ctxt->strm->avail_in = 0;
ctxt->strm->next_in = Z_NULL;
inflateInit2( ctxt->strm, 31 );
}
}
#endif
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
cur += 15;
ctxt->ContentLength = strtol( cur, NULL, 10 );
}
}
/**
* 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 == '}') {
ngx_inline static ngx_http_xrlt_ctx_t *
ngx_http_xrlt_create_ctx(ngx_http_request_t *r, size_t id) {
ngx_http_xrlt_ctx_t *ctx;
ngx_http_xrlt_loc_conf_t *conf;
ngx_uint_t i, j;
ngx_http_xrlt_param_t *params;
xmlChar **xrltparams;
conf = ngx_http_get_module_loc_conf(r, ngx_http_xrlt_module);
ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_xrlt_ctx_t));
if (ctx == NULL) {
return NULL;
}
if (id == 0) {
ngx_pool_cleanup_t *cln;
cln = ngx_pool_cleanup_add(r->pool, 0);
if (cln == NULL) {
return NULL;
}
dd("XRLT context creation");
if (conf->params != NULL && conf->params->nelts > 0) {
params = conf->params->elts;
xrltparams = ngx_palloc(
r->pool, sizeof(xmlChar *) * (conf->params->nelts * 2 + 1)
);
j = 0;
for (i = 0; i < conf->params->nelts; i++) {
xrltparams[j++] = xmlStrndup(params[i].name.data,
params[i].name.len);
xrltparams[j++] = xmlStrndup(params[i].value.value.data,
params[i].value.value.len);
}
xrltparams[j] = NULL;
} else {
xrltparams = NULL;
}
ctx->xctx = xrltContextCreate(conf->sheet, xrltparams);
ctx->id = 0;
ctx->main_ctx = ctx;
if (ctx->xctx == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"Failed to create XRLT context");
}
cln->handler = ngx_http_xrlt_cleanup_context;
cln->data = ctx->xctx;
} else {
ngx_http_xrlt_ctx_t *main_ctx;
main_ctx = ngx_http_get_module_ctx(r->main, ngx_http_xrlt_module);
if (main_ctx == NULL || main_ctx->xctx == NULL) {
return NULL;
}
ctx->xctx = main_ctx->xctx;
ctx->id = id;
ctx->main_ctx = main_ctx;
}
return ctx;
}
/*
* xmlAddEntity : register a new entity for an entities table.
*/
static xmlEntityPtr
xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
xmlEntitiesTablePtr table = NULL;
xmlEntityPtr ret;
if (name == NULL)
return(NULL);
switch (type) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
if (dtd->entities == NULL)
dtd->entities = xmlHashCreate(0);
table = (xmlEntitiesTablePtr)dtd->entities;
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if (dtd->pentities == NULL)
dtd->pentities = xmlHashCreate(0);
table = (xmlEntitiesTablePtr)dtd->pentities;
break;
case XML_INTERNAL_PREDEFINED_ENTITY:
return(NULL);
}
if (table == NULL)
return(NULL);
ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (ret == NULL) {
xmlGenericError(xmlGenericErrorContext, EMBED_ERRTXT("xmlAddEntity: out of memory\n"));
return(NULL);
}
memset(ret, 0, sizeof(xmlEntity));
ret->type = XML_ENTITY_DECL;
/*
* fill the structure.
*/
ret->name = xmlStrdup(name);
ret->etype = (xmlEntityType) type;
if (ExternalID != NULL)
ret->ExternalID = xmlStrdup(ExternalID);
if (SystemID != NULL)
ret->SystemID = xmlStrdup(SystemID);
if (content != NULL) {
ret->length = xmlStrlen(content);
ret->content = xmlStrndup(content, ret->length);
} else {
ret->length = 0;
ret->content = NULL;
}
ret->URI = NULL; /* to be computed by the layer knowing the defining entity */
ret->orig = NULL;
ret->owner = 0;
if (xmlHashAddEntry(table, name, ret)) {
/*
* entity was already defined at another level.
*/
xmlFreeEntity(ret);
return(NULL);
}
return(ret);
}
/**
* Return the next token from the string
*/
static xQStatusCode nextToken(xQToken* tokenContext) {
const xmlChar* start = tokenContext->strPtr;
xmlChar* strStr = 0;
xmlChar* strOut = 0;
tokenContext->type = XQ_TT_NONE;
if (tokenContext->content) xmlFree(tokenContext->content);
tokenContext->content = 0;
tokenContext->length = 0;
// consume any leading space
while (*start && xqIsSpace(*start))
++start;
// advance the pointer to the end of the token
tokenContext->strPtr = start;
// STRING
if (*start == '"' || *start == '\'') {
++(tokenContext->strPtr);
strStr = malloc(xmlStrlen(tokenContext->strPtr));
if ((!strStr) && *(tokenContext->strPtr))
return tokenContext->lastStatus = XQ_OUT_OF_MEMORY;
strOut = strStr;
while (*(tokenContext->strPtr)) {
while (xqIsNotQuote(*(tokenContext->strPtr)))
*(strOut++) = *(tokenContext->strPtr++);
// escape
if (*(tokenContext->strPtr) == '\\') {
if (xqIsNotQuote(*(tokenContext->strPtr+1))) {
*(strOut++) = *(tokenContext->strPtr++);
*(strOut++) = *(tokenContext->strPtr++);
} else if (*(tokenContext->strPtr+1)) {
++(tokenContext->strPtr);
*(strOut++) = *(tokenContext->strPtr++);
}
// opposite quote
} else if (*(tokenContext->strPtr) && (*(tokenContext->strPtr) != *start)) {
*(strOut++) = *(tokenContext->strPtr++);
// end of string
} else if (*(tokenContext->strPtr)) {
++(tokenContext->strPtr); // move past the end of string marker
*strOut = 0;
tokenContext->type = XQ_TT_STRING;
tokenContext->content = strStr;
tokenContext->length = strOut - strStr;
return tokenContext->lastStatus = XQ_OK;
}
}
// unterminated string
if (strStr) free(strStr);
return tokenContext->lastStatus = XQ_INVALID_SEL_UNTERMINATED_STR;
// TOKEN
} else if (xqIsToken(*start)) {
tokenContext->type = XQ_TT_TOKEN;
++(tokenContext->strPtr);
// IDENT
} else if (*start) {
tokenContext->type = XQ_TT_IDENT;
while (xqIsNotSpace(*(tokenContext->strPtr)))
++(tokenContext->strPtr);
} else {
return tokenContext->lastStatus = XQ_NO_TOKEN;
}
tokenContext->content = xmlStrndup(start, tokenContext->strPtr - start);
tokenContext->length = tokenContext->strPtr - start;
return tokenContext->lastStatus = XQ_OK;
}
static void
xsltNumberFormatTokenize(const xmlChar *format,
xsltFormatPtr tokens)
{
int ix = 0;
int j;
int val;
int len;
default_token.token = DEFAULT_TOKEN;
default_token.width = 1;
default_token.separator = BAD_CAST(DEFAULT_SEPARATOR);
tokens->start = NULL;
tokens->tokens[0].separator = NULL;
tokens->end = NULL;
/*
* Insert initial non-alphanumeric token.
* There is always such a token in the list, even if NULL
*/
while (! (IS_LETTER(val=xmlStringCurrentChar(NULL, format+ix, &len)) ||
IS_DIGIT(val)) ) {
if (format[ix] == 0) /* if end of format string */
break; /* while */
ix += len;
}
if (ix > 0)
tokens->start = xmlStrndup(format, ix);
for (tokens->nTokens = 0; tokens->nTokens < MAX_TOKENS;
tokens->nTokens++) {
if (format[ix] == 0)
break; /* for */
/*
* separator has already been parsed (except for the first
* number) in tokens->end, recover it.
*/
if (tokens->nTokens > 0) {
tokens->tokens[tokens->nTokens].separator = tokens->end;
tokens->end = NULL;
}
val = xmlStringCurrentChar(NULL, format+ix, &len);
if (IS_DIGIT_ONE(val) ||
IS_DIGIT_ZERO(val)) {
tokens->tokens[tokens->nTokens].width = 1;
while (IS_DIGIT_ZERO(val)) {
tokens->tokens[tokens->nTokens].width++;
ix += len;
val = xmlStringCurrentChar(NULL, format+ix, &len);
}
if (IS_DIGIT_ONE(val)) {
tokens->tokens[tokens->nTokens].token = val - 1;
ix += len;
val = xmlStringCurrentChar(NULL, format+ix, &len);
}
} else if ( (val == (xmlChar)'A') ||
(val == (xmlChar)'a') ||
(val == (xmlChar)'I') ||
(val == (xmlChar)'i') ) {
tokens->tokens[tokens->nTokens].token = val;
ix += len;
val = xmlStringCurrentChar(NULL, format+ix, &len);
} else {
/* XSLT section 7.7
* "Any other format token indicates a numbering sequence
* that starts with that token. If an implementation does
* not support a numbering sequence that starts with that
* token, it must use a format token of 1."
*/
tokens->tokens[tokens->nTokens].token = (xmlChar)'0';
tokens->tokens[tokens->nTokens].width = 1;
}
/*
* Skip over remaining alphanumeric characters from the Nd
* (Number, decimal digit), Nl (Number, letter), No (Number,
* other), Lu (Letter, uppercase), Ll (Letter, lowercase), Lt
* (Letters, titlecase), Lm (Letters, modifiers), and Lo
* (Letters, other (uncased)) Unicode categories. This happens
* to correspond to the Letter and Digit classes from XML (and
* one wonders why XSLT doesn't refer to these instead).
*/
while (IS_LETTER(val) || IS_DIGIT(val)) {
ix += len;
val = xmlStringCurrentChar(NULL, format+ix, &len);
}
/*
* Insert temporary non-alphanumeric final tooken.
*/
j = ix;
while (! (IS_LETTER(val) || IS_DIGIT(val))) {
if (val == 0)
break; /* while */
ix += len;
val = xmlStringCurrentChar(NULL, format+ix, &len);
}
if (ix > j)
tokens->end = xmlStrndup(&format[j], ix - j);
}
}
