numbers.c

Go to the documentation of this file.

/*
 * numbers.c: Implementation of the XSLT number functions
 *
 * Reference:
 *   http://www.w3.org/TR/1999/REC-xslt-19991116
 *
 * See Copyright for the status of this software.
 *
 * daniel@veillard.com
 * Bjorn Reese <breese@users.sourceforge.net>
 */

#include "precomp.h"

#ifndef FALSE
# define FALSE (0 == 1)
# define TRUE (1 == 1)
#endif

#define SYMBOL_QUOTE        ((xmlChar)'\'')

#define DEFAULT_TOKEN       '0'
#define DEFAULT_SEPARATOR   "."

#define MAX_TOKENS      1024

typedef struct _xsltFormatToken xsltFormatToken;
typedef xsltFormatToken *xsltFormatTokenPtr;
struct _xsltFormatToken {
    xmlChar *separator;
    int      token;
    int      width;
};

typedef struct _xsltFormat xsltFormat;
typedef xsltFormat *xsltFormatPtr;
struct _xsltFormat {
    xmlChar     *start;
    xsltFormatToken  tokens[MAX_TOKENS];
    int          nTokens;
    xmlChar     *end;
};

static char alpha_upper_list[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static char alpha_lower_list[] = "abcdefghijklmnopqrstuvwxyz";
static xsltFormatToken default_token;

/*
 * **** Start temp insert ****
 *
 * The following routine xsltUTF8Charcmp will be replaced with calls to
 * the corresponding libxml routine at a later date (when other
 * inter-library dependencies require it).
 */

static int
xsltUTF8Charcmp(xmlChar *utf1, xmlChar *utf2) {
    int len = xmlUTF8Strsize(utf1, 1);

    if (len < 1)
        return -1;
    if (utf1 == NULL ) {
        if (utf2 == NULL)
            return 0;
        return -1;
    }
    return xmlStrncmp(utf1, utf2, len);
}

static int
xsltIsLetterDigit(int val) {
    return xmlIsBaseCharQ(val) || xmlIsIdeographicQ(val) ||
           xmlIsDigitQ(val);
}

/***** Stop temp insert *****/
/************************************************************************
 *                                  *
 *          Utility functions               *
 *                                  *
 ************************************************************************/

#define IS_SPECIAL(self,letter)         \
    ((xsltUTF8Charcmp((letter), (self)->zeroDigit) == 0)        ||  \
     (xsltUTF8Charcmp((letter), (self)->digit) == 0)        ||  \
     (xsltUTF8Charcmp((letter), (self)->decimalPoint) == 0)  || \
     (xsltUTF8Charcmp((letter), (self)->grouping) == 0)     ||  \
     (xsltUTF8Charcmp((letter), (self)->patternSeparator) == 0))

#define IS_DIGIT_ZERO(x) xsltIsDigitZero(x)
#define IS_DIGIT_ONE(x) xsltIsDigitZero((x)-1)

static int
xsltIsDigitZero(unsigned int ch)
{
    /*
     * Reference: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
     *
     * There a many more digit ranges in newer Unicode versions. These
     * are only the zeros that match Digit in XML 1.0 (IS_DIGIT macro).
     */
    switch (ch) {
    case 0x0030: case 0x0660: case 0x06F0: case 0x0966:
    case 0x09E6: case 0x0A66: case 0x0AE6: case 0x0B66:
    case 0x0C66: case 0x0CE6: case 0x0D66: case 0x0E50:
    case 0x0ED0: case 0x0F20:
    return TRUE;
    default:
    return FALSE;
    }
}

static void
xsltNumberFormatDecimal(xmlBufferPtr buffer,
            double number,
            int digit_zero,
            int width,
            int digitsPerGroup,
            int groupingCharacter,
            int groupingCharacterLen)
{
    /*
     * This used to be
     *  xmlChar temp_string[sizeof(double) * CHAR_BIT * sizeof(xmlChar) + 4];
     * which would be length 68 on x86 arch.  It was changed to be a longer,
     * fixed length in order to try to cater for (reasonable) UTF8
     * separators and numeric characters.  The max UTF8 char size will be
     * 6 or less, so the value used [500] should be *much* larger than needed
     */
    xmlChar temp_string[500];
    xmlChar *pointer;
    xmlChar temp_char[6];
    int i;
    int val;
    int len;

    /* Build buffer from back */
    pointer = &temp_string[sizeof(temp_string)] - 1;    /* last char */
    *pointer = 0;
    i = 0;
    while (pointer > temp_string) {
    if ((i >= width) && (fabs(number) < 1.0))
        break; /* for */
    if ((i > 0) && (groupingCharacter != 0) &&
        (digitsPerGroup > 0) &&
        ((i % digitsPerGroup) == 0)) {
        if (pointer - groupingCharacterLen < temp_string) {
            i = -1;     /* flag error */
        break;
        }
        pointer -= groupingCharacterLen;
        xmlCopyCharMultiByte(pointer, groupingCharacter);
    }

    val = digit_zero + (int)fmod(number, 10.0);
    if (val < 0x80) {           /* shortcut if ASCII */
        if (pointer <= temp_string) {   /* Check enough room */
            i = -1;
        break;
        }
        *(--pointer) = (xmlChar)val;
    }
    else {
    /*
     * Here we have a multibyte character.  It's a little messy,
     * because until we generate the char we don't know how long
     * it is.  So, we generate it into the buffer temp_char, then
     * copy from there into temp_string.
     */
        len = xmlCopyCharMultiByte(temp_char, val);
        if ( (pointer - len) < temp_string ) {
            i = -1;
        break;
        }
        pointer -= len;
        memcpy(pointer, temp_char, len);
    }
    number /= 10.0;
    ++i;
    }
    if (i < 0)
        xsltGenericError(xsltGenericErrorContext,
        "xsltNumberFormatDecimal: Internal buffer size exceeded\n");
    xmlBufferCat(buffer, pointer);
}

static void
xsltNumberFormatAlpha(xsltNumberDataPtr data,
              xmlBufferPtr buffer,
              double number,
              int is_upper)
{
    char temp_string[sizeof(double) * CHAR_BIT * sizeof(xmlChar) + 1];
    char *pointer;
    int i;
    char *alpha_list;
    double alpha_size = (double)(sizeof(alpha_upper_list) - 1);

    /*
     * XSLT 1.0 isn't clear on how to handle zero, but XSLT 2.0 says:
     *
     *     For all format tokens other than the first kind above (one that
     *     consists of decimal digits), there may be implementation-defined
     *     lower and upper bounds on the range of numbers that can be
     *     formatted using this format token; indeed, for some numbering
     *     sequences there may be intrinsic limits. [...] Numbers that fall
     *     outside this range must be formatted using the format token 1.
     *
     * The "a" token has an intrinsic lower limit of 1.
     */
    if (number < 1.0) {
        xsltNumberFormatDecimal(buffer, number, '0', 1,
                                data->digitsPerGroup,
                                data->groupingCharacter,
                                data->groupingCharacterLen);
        return;
    }

    /* Build buffer from back */
    pointer = &temp_string[sizeof(temp_string)];
    *(--pointer) = 0;
    alpha_list = (is_upper) ? alpha_upper_list : alpha_lower_list;

    for (i = 1; i < (int)sizeof(temp_string); i++) {
    number--;
    *(--pointer) = alpha_list[((int)fmod(number, alpha_size))];
    number /= alpha_size;
    if (number < 1.0)
        break; /* for */
    }
    xmlBufferCCat(buffer, pointer);
}

static void
xsltNumberFormatRoman(xsltNumberDataPtr data,
              xmlBufferPtr buffer,
              double number,
              int is_upper)
{
    /*
     * See discussion in xsltNumberFormatAlpha. Also use a reasonable upper
     * bound to avoid denial of service.
     */
    if (number < 1.0 || number > 5000.0) {
        xsltNumberFormatDecimal(buffer, number, '0', 1,
                                data->digitsPerGroup,
                                data->groupingCharacter,
                                data->groupingCharacterLen);
        return;
    }

    /*
     * Based on an example by Jim Walsh
     */
    while (number >= 1000.0) {
    xmlBufferCCat(buffer, (is_upper) ? "M" : "m");
    number -= 1000.0;
    }
    if (number >= 900.0) {
    xmlBufferCCat(buffer, (is_upper) ? "CM" : "cm");
    number -= 900.0;
    }
    while (number >= 500.0) {
    xmlBufferCCat(buffer, (is_upper) ? "D" : "d");
    number -= 500.0;
    }
    if (number >= 400.0) {
    xmlBufferCCat(buffer, (is_upper) ? "CD" : "cd");
    number -= 400.0;
    }
    while (number >= 100.0) {
    xmlBufferCCat(buffer, (is_upper) ? "C" : "c");
    number -= 100.0;
    }
    if (number >= 90.0) {
    xmlBufferCCat(buffer, (is_upper) ? "XC" : "xc");
    number -= 90.0;
    }
    while (number >= 50.0) {
    xmlBufferCCat(buffer, (is_upper) ? "L" : "l");
    number -= 50.0;
    }
    if (number >= 40.0) {
    xmlBufferCCat(buffer, (is_upper) ? "XL" : "xl");
    number -= 40.0;
    }
    while (number >= 10.0) {
    xmlBufferCCat(buffer, (is_upper) ? "X" : "x");
    number -= 10.0;
    }
    if (number >= 9.0) {
    xmlBufferCCat(buffer, (is_upper) ? "IX" : "ix");
    number -= 9.0;
    }
    while (number >= 5.0) {
    xmlBufferCCat(buffer, (is_upper) ? "V" : "v");
    number -= 5.0;
    }
    if (number >= 4.0) {
    xmlBufferCCat(buffer, (is_upper) ? "IV" : "iv");
    number -= 4.0;
    }
    while (number >= 1.0) {
    xmlBufferCCat(buffer, (is_upper) ? "I" : "i");
    number--;
    }
}

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 (!xsltIsLetterDigit(val = xmlStringCurrentChar(NULL, format+ix,
                                                         &len))) {
    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 {
                tokens->tokens[tokens->nTokens].token = '0';
                tokens->tokens[tokens->nTokens].width = 1;
            }
    } else if ( (val == 'A') ||
            (val == 'a') ||
            (val == 'I') ||
            (val == '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 = '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 (xsltIsLetterDigit(val)) {
        ix += len;
        val = xmlStringCurrentChar(NULL, format+ix, &len);
    }

    /*
     * Insert temporary non-alphanumeric final tooken.
     */
    j = ix;
    while (!xsltIsLetterDigit(val)) {
        if (val == 0)
        break; /* while */
        ix += len;
        val = xmlStringCurrentChar(NULL, format+ix, &len);
    }
    if (ix > j)
        tokens->end = xmlStrndup(&format[j], ix - j);
    }
}

static void
xsltNumberFormatInsertNumbers(xsltNumberDataPtr data,
                  double *numbers,
                  int numbers_max,
                  xsltFormatPtr tokens,
                  xmlBufferPtr buffer)
{
    int i = 0;
    double number;
    xsltFormatTokenPtr token;

    /*
     * Handle initial non-alphanumeric token
     */
    if (tokens->start != NULL)
     xmlBufferCat(buffer, tokens->start);

    for (i = 0; i < numbers_max; i++) {
    /* Insert number */
    number = numbers[(numbers_max - 1) - i];
        /* Round to nearest like XSLT 2.0 */
        number = floor(number + 0.5);
        /*
         * XSLT 1.0 isn't clear on how to handle negative numbers, but XSLT
         * 2.0 says:
         *
         *     It is a non-recoverable dynamic error if any undiscarded item
         *     in the atomized sequence supplied as the value of the value
         *     attribute of xsl:number cannot be converted to an integer, or
         *     if the resulting integer is less than 0 (zero).
         */
        if (number < 0.0) {
            xsltTransformError(NULL, NULL, NULL,
                    "xsl-number : negative value\n");
            /* Recover by treating negative values as zero. */
            number = 0.0;
        }
    if (i < tokens->nTokens) {
      /*
       * The "n"th format token will be used to format the "n"th
       * number in the list
       */
      token = &(tokens->tokens[i]);
    } else if (tokens->nTokens > 0) {
      /*
       * If there are more numbers than format tokens, then the
       * last format token will be used to format the remaining
       * numbers.
       */
      token = &(tokens->tokens[tokens->nTokens - 1]);
    } else {
      /*
       * If there are no format tokens, then a format token of
       * 1 is used to format all numbers.
       */
      token = &default_token;
    }

    /* Print separator, except for the first number */
    if (i > 0) {
        if (token->separator != NULL)
        xmlBufferCat(buffer, token->separator);
        else
        xmlBufferCCat(buffer, DEFAULT_SEPARATOR);
    }

    switch (xmlXPathIsInf(number)) {
    case -1:
        xmlBufferCCat(buffer, "-Infinity");
        break;
    case 1:
        xmlBufferCCat(buffer, "Infinity");
        break;
    default:
        if (xmlXPathIsNaN(number)) {
        xmlBufferCCat(buffer, "NaN");
        } else {

        switch (token->token) {
        case 'A':
            xsltNumberFormatAlpha(data, buffer, number, TRUE);
            break;
        case 'a':
            xsltNumberFormatAlpha(data, buffer, number, FALSE);
            break;
        case 'I':
            xsltNumberFormatRoman(data, buffer, number, TRUE);
            break;
        case 'i':
            xsltNumberFormatRoman(data, buffer, number, FALSE);
            break;
        default:
            if (IS_DIGIT_ZERO(token->token)) {
            xsltNumberFormatDecimal(buffer,
                        number,
                        token->token,
                        token->width,
                        data->digitsPerGroup,
                        data->groupingCharacter,
                        data->groupingCharacterLen);
            }
            break;
        }
        }

    }
    }

    /*
     * Handle final non-alphanumeric token
     */
    if (tokens->end != NULL)
     xmlBufferCat(buffer, tokens->end);

}

static int
xsltTestCompMatchCount(xsltTransformContextPtr context,
                       xmlNodePtr node,
                       xsltCompMatchPtr countPat,
                       xmlNodePtr cur)
{
    if (countPat != NULL) {
        return xsltTestCompMatchList(context, node, countPat);
    }
    else {
        /*
         * 7.7 Numbering
         *
         * If count attribute is not specified, then it defaults to the
         * pattern that matches any node with the same node type as the
         * current node and, if the current node has an expanded-name, with
         * the same expanded-name as the current node.
         */
        if (node->type != cur->type)
            return 0;
        if (node->type == XML_NAMESPACE_DECL)
            /*
             * Namespace nodes have no preceding siblings and no parents
             * that are namespace nodes. This means that node == cur.
             */
            return 1;
        /* TODO: Skip node types without expanded names like text nodes. */
        if (!xmlStrEqual(node->name, cur->name))
            return 0;
        if (node->ns == cur->ns)
            return 1;
        if ((node->ns == NULL) || (cur->ns == NULL))
            return 0;
        return (xmlStrEqual(node->ns->href, cur->ns->href));
    }
}

static int
xsltNumberFormatGetAnyLevel(xsltTransformContextPtr context,
                xmlNodePtr node,
                xsltCompMatchPtr countPat,
                xsltCompMatchPtr fromPat,
                double *array)
{
    int amount = 0;
    int cnt = 0;
    xmlNodePtr cur = node;

    while (cur != NULL) {
    /* process current node */
    if (xsltTestCompMatchCount(context, cur, countPat, node))
        cnt++;
    if ((fromPat != NULL) &&
        xsltTestCompMatchList(context, cur, fromPat)) {
        break; /* while */
    }

    /* Skip to next preceding or ancestor */
    if ((cur->type == XML_DOCUMENT_NODE) ||
#ifdef LIBXML_DOCB_ENABLED
            (cur->type == XML_DOCB_DOCUMENT_NODE) ||
#endif
            (cur->type == XML_HTML_DOCUMENT_NODE))
        break; /* while */

        if (cur->type == XML_NAMESPACE_DECL) {
            /*
            * The XPath module stores the parent of a namespace node in
            * the ns->next field.
            */
            cur = (xmlNodePtr) ((xmlNsPtr) cur)->next;
        } else if (cur->type == XML_ATTRIBUTE_NODE) {
            cur = cur->parent;
        } else {
            while ((cur->prev != NULL) && ((cur->prev->type == XML_DTD_NODE) ||
                   (cur->prev->type == XML_XINCLUDE_START) ||
                   (cur->prev->type == XML_XINCLUDE_END)))
                cur = cur->prev;
            if (cur->prev != NULL) {
                for (cur = cur->prev; cur->last != NULL; cur = cur->last);
            } else {
                cur = cur->parent;
            }
        }
    }

    array[amount++] = (double) cnt;

    return(amount);
}

static int
xsltNumberFormatGetMultipleLevel(xsltTransformContextPtr context,
                 xmlNodePtr node,
                 xsltCompMatchPtr countPat,
                 xsltCompMatchPtr fromPat,
                 double *array,
                 int max)
{
    int amount = 0;
    int cnt;
    xmlNodePtr oldCtxtNode;
    xmlNodePtr ancestor;
    xmlNodePtr preceding;
    xmlXPathParserContextPtr parser;

    oldCtxtNode = context->xpathCtxt->node;
    parser = xmlXPathNewParserContext(NULL, context->xpathCtxt);
    if (parser) {
    /* ancestor-or-self::*[count] */
    ancestor = node;
    while ((ancestor != NULL) && (ancestor->type != XML_DOCUMENT_NODE)) {
        if ((fromPat != NULL) &&
        xsltTestCompMatchList(context, ancestor, fromPat))
        break; /* for */

            /*
             * The xmlXPathNext* iterators require that the context node is
             * set to the start node. Calls to xsltTestCompMatch* may also
             * leave the context node in an undefined state, so make sure
             * that the context node is reset before each iterator invocation.
             */

        if (xsltTestCompMatchCount(context, ancestor, countPat, node)) {
        /* count(preceding-sibling::*) */
        cnt = 1;
                context->xpathCtxt->node = ancestor;
                preceding = xmlXPathNextPrecedingSibling(parser, ancestor);
                while (preceding != NULL) {
                if (xsltTestCompMatchCount(context, preceding, countPat,
                                               node))
            cnt++;
                    context->xpathCtxt->node = ancestor;
                    preceding =
                        xmlXPathNextPrecedingSibling(parser, preceding);
        }
        array[amount++] = (double)cnt;
        if (amount >= max)
            break; /* for */
        }
            context->xpathCtxt->node = node;
            ancestor = xmlXPathNextAncestor(parser, ancestor);
    }
    xmlXPathFreeParserContext(parser);
    }
    context->xpathCtxt->node = oldCtxtNode;
    return amount;
}

static int
xsltNumberFormatGetValue(xmlXPathContextPtr context,
             xmlNodePtr node,
             const xmlChar *value,
             double *number)
{
    int amount = 0;
    xmlBufferPtr pattern;
    xmlXPathObjectPtr obj;

    pattern = xmlBufferCreate();
    if (pattern != NULL) {
    xmlBufferCCat(pattern, "number(");
    xmlBufferCat(pattern, value);
    xmlBufferCCat(pattern, ")");
    context->node = node;
    obj = xmlXPathEvalExpression(xmlBufferContent(pattern),
                     context);
    if (obj != NULL) {
        *number = obj->floatval;
        amount++;
        xmlXPathFreeObject(obj);
    }
    xmlBufferFree(pattern);
    }
    return amount;
}

void
xsltNumberFormat(xsltTransformContextPtr ctxt,
         xsltNumberDataPtr data,
         xmlNodePtr node)
{
    xmlBufferPtr output = NULL;
    int amount, i;
    double number;
    xsltFormat tokens;

    if (data->format != NULL) {
        xsltNumberFormatTokenize(data->format, &tokens);
    }
    else {
        xmlChar *format;

    /* The format needs to be recomputed each time */
        if (data->has_format == 0)
            return;
    format = xsltEvalAttrValueTemplate(ctxt, data->node,
                         (const xmlChar *) "format",
                         XSLT_NAMESPACE);
        if (format == NULL)
            return;
        xsltNumberFormatTokenize(format, &tokens);
    xmlFree(format);
    }

    output = xmlBufferCreate();
    if (output == NULL)
    goto XSLT_NUMBER_FORMAT_END;

    /*
     * Evaluate the XPath expression to find the value(s)
     */
    if (data->value) {
    amount = xsltNumberFormatGetValue(ctxt->xpathCtxt,
                      node,
                      data->value,
                      &number);
    if (amount == 1) {
        xsltNumberFormatInsertNumbers(data,
                      &number,
                      1,
                      &tokens,
                      output);
    }

    } else if (data->level) {

    if (xmlStrEqual(data->level, (const xmlChar *) "single")) {
        amount = xsltNumberFormatGetMultipleLevel(ctxt,
                              node,
                              data->countPat,
                              data->fromPat,
                              &number,
                              1);
        if (amount == 1) {
        xsltNumberFormatInsertNumbers(data,
                          &number,
                          1,
                          &tokens,
                          output);
        }
    } else if (xmlStrEqual(data->level, (const xmlChar *) "multiple")) {
        double numarray[1024];
        int max = sizeof(numarray)/sizeof(numarray[0]);
        amount = xsltNumberFormatGetMultipleLevel(ctxt,
                              node,
                              data->countPat,
                              data->fromPat,
                              numarray,
                              max);
        if (amount > 0) {
        xsltNumberFormatInsertNumbers(data,
                          numarray,
                          amount,
                          &tokens,
                          output);
        }
    } else if (xmlStrEqual(data->level, (const xmlChar *) "any")) {
        amount = xsltNumberFormatGetAnyLevel(ctxt,
                         node,
                         data->countPat,
                         data->fromPat,
                         &number);
        if (amount > 0) {
        xsltNumberFormatInsertNumbers(data,
                          &number,
                          1,
                          &tokens,
                          output);
        }
    }

        /*
         * Unlike `match` patterns, `count` and `from` patterns can contain
         * variable references, so we have to clear the pattern match
         * cache if the "direct" matching algorithm was used.
         */
        if (data->countPat != NULL)
            xsltCompMatchClearCache(ctxt, data->countPat);
        if (data->fromPat != NULL)
            xsltCompMatchClearCache(ctxt, data->fromPat);
    }
    /* Insert number as text node */
    xsltCopyTextString(ctxt, ctxt->insert, xmlBufferContent(output), 0);

    xmlBufferFree(output);

XSLT_NUMBER_FORMAT_END:
    if (tokens.start != NULL)
    xmlFree(tokens.start);
    if (tokens.end != NULL)
    xmlFree(tokens.end);
    for (i = 0;i < tokens.nTokens;i++) {
    if (tokens.tokens[i].separator != NULL)
        xmlFree(tokens.tokens[i].separator);
    }
}

static int
xsltFormatNumberPreSuffix(xsltDecimalFormatPtr self, xmlChar **format, xsltFormatNumberInfoPtr info)
{
    /* will hold total length of prefix/suffix without quote characters */
    int count=0;
    int len;

    while (1) {
    /*
     * prefix / suffix ends at end of string or at
     * first 'special' character
     */
    if (**format == 0)
        return count;
    /* if next character 'escaped' just count it */
    if (**format == SYMBOL_QUOTE) {
        if (*++(*format) == 0)
        return -1;
    }
    else if (IS_SPECIAL(self, *format))
        return count;
    /*
     * else treat percent/per-mille as special cases,
     * depending on whether +ve or -ve
     */
    else {
        /*
         * for +ve prefix/suffix, allow only a
         * single occurence of either
         */
        if (xsltUTF8Charcmp(*format, self->percent) == 0) {
        if (info->is_multiplier_set)
            return -1;
        info->multiplier = 100;
        info->is_multiplier_set = TRUE;
        } else if (xsltUTF8Charcmp(*format, self->permille) == 0) {
        if (info->is_multiplier_set)
            return -1;
        info->multiplier = 1000;
        info->is_multiplier_set = TRUE;
        }
    }

    if ((len=xmlUTF8Strsize(*format, 1)) < 1)
        return -1;
    count += len;
    *format += len;
    }
}

xmlXPathError
xsltFormatNumberConversion(xsltDecimalFormatPtr self,
               xmlChar *format,
               double number,
               xmlChar **result)
{
    xmlXPathError status = XPATH_EXPRESSION_OK;
    xmlBufferPtr buffer;
    xmlChar *the_format, *prefix = NULL, *suffix = NULL;
    xmlChar *nprefix, *nsuffix = NULL;
    int     prefix_length, suffix_length = 0, nprefix_length, nsuffix_length;
    double  scale;
    int     j, len = 0;
    int     self_grouping_len;
    xsltFormatNumberInfo format_info;
    /*
     * delayed_multiplier allows a 'trailing' percent or
     * permille to be treated as suffix
     */
    int     delayed_multiplier = 0;
    /* flag to show no -ve format present for -ve number */
    char    default_sign = 0;
    /* flag to show error found, should use default format */
    char    found_error = 0;

    if (xmlStrlen(format) <= 0) {
    xsltTransformError(NULL, NULL, NULL,
                "xsltFormatNumberConversion : "
        "Invalid format (0-length)\n");
    }
    *result = NULL;
    switch (xmlXPathIsInf(number)) {
    case -1:
        if (self->minusSign == NULL)
        *result = xmlStrdup(BAD_CAST "-");
        else
        *result = xmlStrdup(self->minusSign);
        /* Intentional fall-through */
    case 1:
        if ((self == NULL) || (self->infinity == NULL))
        *result = xmlStrcat(*result, BAD_CAST "Infinity");
        else
        *result = xmlStrcat(*result, self->infinity);
        return(status);
    default:
        if (xmlXPathIsNaN(number)) {
        if ((self == NULL) || (self->noNumber == NULL))
            *result = xmlStrdup(BAD_CAST "NaN");
        else
            *result = xmlStrdup(self->noNumber);
        return(status);
        }
    }

    buffer = xmlBufferCreate();
    if (buffer == NULL) {
    return XPATH_MEMORY_ERROR;
    }

    format_info.integer_hash = 0;
    format_info.integer_digits = 0;
    format_info.frac_digits = 0;
    format_info.frac_hash = 0;
    format_info.group = -1;
    format_info.multiplier = 1;
    format_info.add_decimal = FALSE;
    format_info.is_multiplier_set = FALSE;
    format_info.is_negative_pattern = FALSE;

    the_format = format;

    /*
     * First we process the +ve pattern to get percent / permille,
     * as well as main format
     */
    prefix = the_format;
    prefix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
    if (prefix_length < 0) {
    found_error = 1;
    goto OUTPUT_NUMBER;
    }

    /*
     * Here we process the "number" part of the format.  It gets
     * a little messy because of the percent/per-mille - if that
     * appears at the end, it may be part of the suffix instead
     * of part of the number, so the variable delayed_multiplier
     * is used to handle it
     */
    self_grouping_len = xmlStrlen(self->grouping);
    while ((*the_format != 0) &&
       (xsltUTF8Charcmp(the_format, self->decimalPoint) != 0) &&
       (xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) {

    if (delayed_multiplier != 0) {
        format_info.multiplier = delayed_multiplier;
        format_info.is_multiplier_set = TRUE;
        delayed_multiplier = 0;
    }
    if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
        if (format_info.integer_digits > 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        format_info.integer_hash++;
        if (format_info.group >= 0)
        format_info.group++;
    } else if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
        format_info.integer_digits++;
        if (format_info.group >= 0)
        format_info.group++;
    } else if ((self_grouping_len > 0) &&
        (!xmlStrncmp(the_format, self->grouping, self_grouping_len))) {
        /* Reset group count */
        format_info.group = 0;
        the_format += self_grouping_len;
        continue;
    } else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 100;
    } else  if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 1000;
    } else
        break; /* while */

    if ((len=xmlUTF8Strsize(the_format, 1)) < 1) {
        found_error = 1;
        goto OUTPUT_NUMBER;
    }
    the_format += len;

    }

    /* We have finished the integer part, now work on fraction */
    if ( (*the_format != 0) &&
         (xsltUTF8Charcmp(the_format, self->decimalPoint) == 0) ) {
        format_info.add_decimal = TRUE;
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
    the_format += len;  /* Skip over the decimal */
    }

    while (*the_format != 0) {

    if (xsltUTF8Charcmp(the_format, self->zeroDigit) == 0) {
        if (format_info.frac_hash != 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        format_info.frac_digits++;
    } else if (xsltUTF8Charcmp(the_format, self->digit) == 0) {
        format_info.frac_hash++;
    } else if (xsltUTF8Charcmp(the_format, self->percent) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 100;
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
        goto OUTPUT_NUMBER;
        }
        the_format += len;
        continue; /* while */
    } else if (xsltUTF8Charcmp(the_format, self->permille) == 0) {
        if (format_info.is_multiplier_set) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        delayed_multiplier = 1000;
        if  ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
        goto OUTPUT_NUMBER;
        }
        the_format += len;
        continue; /* while */
    } else if (xsltUTF8Charcmp(the_format, self->grouping) != 0) {
        break; /* while */
    }
    if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
        found_error = 1;
        goto OUTPUT_NUMBER;
    }
    the_format += len;
    if (delayed_multiplier != 0) {
        format_info.multiplier = delayed_multiplier;
        delayed_multiplier = 0;
        format_info.is_multiplier_set = TRUE;
    }
    }

    /*
     * If delayed_multiplier is set after processing the
     * "number" part, should be in suffix
     */
    if (delayed_multiplier != 0) {
    the_format -= len;
    delayed_multiplier = 0;
    }

    suffix = the_format;
    suffix_length = xsltFormatNumberPreSuffix(self, &the_format, &format_info);
    if ( (suffix_length < 0) ||
     ((*the_format != 0) &&
      (xsltUTF8Charcmp(the_format, self->patternSeparator) != 0)) ) {
    found_error = 1;
    goto OUTPUT_NUMBER;
    }

    /*
     * We have processed the +ve prefix, number part and +ve suffix.
     * If the number is -ve, we must substitute the -ve prefix / suffix
     */
    if (number < 0) {
        /*
     * Note that j is the number of UTF8 chars before the separator,
     * not the number of bytes! (bug 151975)
     */
        j =  xmlUTF8Strloc(format, self->patternSeparator);
    if (j < 0) {
    /* No -ve pattern present, so use default signing */
        default_sign = 1;
    }
    else {
        /* Skip over pattern separator (accounting for UTF8) */
        the_format = (xmlChar *)xmlUTF8Strpos(format, j + 1);
        /*
         * Flag changes interpretation of percent/permille
         * in -ve pattern
         */
        format_info.is_negative_pattern = TRUE;
        format_info.is_multiplier_set = FALSE;

        /* First do the -ve prefix */
        nprefix = the_format;
        nprefix_length = xsltFormatNumberPreSuffix(self,
                    &the_format, &format_info);
        if (nprefix_length<0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }

        while (*the_format != 0) {
        if ( (xsltUTF8Charcmp(the_format, (self)->percent) == 0) ||
             (xsltUTF8Charcmp(the_format, (self)->permille)== 0) ) {
            if (format_info.is_multiplier_set) {
            found_error = 1;
            goto OUTPUT_NUMBER;
            }
            format_info.is_multiplier_set = TRUE;
            delayed_multiplier = 1;
        }
        else if (IS_SPECIAL(self, the_format))
            delayed_multiplier = 0;
        else
            break; /* while */
        if ((len = xmlUTF8Strsize(the_format, 1)) < 1) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
        the_format += len;
        }
        if (delayed_multiplier != 0) {
        format_info.is_multiplier_set = FALSE;
        the_format -= len;
        }

        /* Finally do the -ve suffix */
        if (*the_format != 0) {
        nsuffix = the_format;
        nsuffix_length = xsltFormatNumberPreSuffix(self,
                    &the_format, &format_info);
        if (nsuffix_length < 0) {
            found_error = 1;
            goto OUTPUT_NUMBER;
        }
        }
        else
        nsuffix_length = 0;
        if (*the_format != 0) {
        found_error = 1;
        goto OUTPUT_NUMBER;
        }
        /*
         * Here's another Java peculiarity:
         * if -ve prefix/suffix == +ve ones, discard & use default
         */
        if ((nprefix_length != prefix_length) ||
        (nsuffix_length != suffix_length) ||
        ((nprefix_length > 0) &&
         (xmlStrncmp(nprefix, prefix, prefix_length) !=0 )) ||
        ((nsuffix_length > 0) &&
         (xmlStrncmp(nsuffix, suffix, suffix_length) !=0 ))) {
        prefix = nprefix;
        prefix_length = nprefix_length;
        suffix = nsuffix;
        suffix_length = nsuffix_length;
        } /* else {
        default_sign = 1;
        }
        */
    }
    }

OUTPUT_NUMBER:
    if (found_error != 0) {
    xsltTransformError(NULL, NULL, NULL,
                "xsltFormatNumberConversion : "
        "error in format string '%s', using default\n", format);
    default_sign = (number < 0.0) ? 1 : 0;
    prefix_length = suffix_length = 0;
    format_info.integer_hash = 0;
    format_info.integer_digits = 1;
    format_info.frac_digits = 1;
    format_info.frac_hash = 4;
    format_info.group = -1;
    format_info.multiplier = 1;
    format_info.add_decimal = TRUE;
    }

    /* Ready to output our number.  First see if "default sign" is required */
    if (default_sign != 0)
    xmlBufferAdd(buffer, self->minusSign, xmlUTF8Strsize(self->minusSign, 1));

    /* Put the prefix into the buffer */
    for (j = 0; j < prefix_length; ) {
    if (*prefix == SYMBOL_QUOTE)
            prefix++;
        len = xmlUTF8Strsize(prefix, 1);
        xmlBufferAdd(buffer, prefix, len);
        prefix += len;
        j += len;
    }

    /* Next do the integer part of the number */
    number = fabs(number) * (double)format_info.multiplier;
    scale = pow(10.0, (double)(format_info.frac_digits + format_info.frac_hash));
    number = floor((scale * number + 0.5)) / scale;
    if ((self->grouping != NULL) &&
        (self->grouping[0] != 0)) {
        int gchar;

    len = xmlStrlen(self->grouping);
    gchar = xsltGetUTF8Char(self->grouping, &len);
    xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.integer_digits,
                format_info.group,
                gchar, len);
    } else
    xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.integer_digits,
                format_info.group,
                ',', 1);

    /* Special case: java treats '.#' like '.0', '.##' like '.0#', etc. */
    if ((format_info.integer_digits + format_info.integer_hash +
     format_info.frac_digits == 0) && (format_info.frac_hash > 0)) {
        ++format_info.frac_digits;
    --format_info.frac_hash;
    }

    /* Add leading zero, if required */
    if ((floor(number) == 0) &&
    (format_info.integer_digits + format_info.frac_digits == 0)) {
        xmlBufferAdd(buffer, self->zeroDigit, xmlUTF8Strsize(self->zeroDigit, 1));
    }

    /* Next the fractional part, if required */
    if (format_info.frac_digits + format_info.frac_hash == 0) {
        if (format_info.add_decimal)
        xmlBufferAdd(buffer, self->decimalPoint,
             xmlUTF8Strsize(self->decimalPoint, 1));
    }
    else {
      number -= floor(number);
    if ((number != 0) || (format_info.frac_digits != 0)) {
        xmlBufferAdd(buffer, self->decimalPoint,
             xmlUTF8Strsize(self->decimalPoint, 1));
        number = floor(scale * number + 0.5);
        for (j = format_info.frac_hash; j > 0; j--) {
        if (fmod(number, 10.0) >= 1.0)
            break; /* for */
        number /= 10.0;
        }
        xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                format_info.frac_digits + j,
                0, 0, 0);
    }
    }
    /* Put the suffix into the buffer */
    for (j = 0; j < suffix_length; ) {
    if (*suffix == SYMBOL_QUOTE)
            suffix++;
        len = xmlUTF8Strsize(suffix, 1);
        xmlBufferAdd(buffer, suffix, len);
        suffix += len;
        j += len;
    }

    *result = xmlStrdup(xmlBufferContent(buffer));
    xmlBufferFree(buffer);
    return status;
}