Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxslt/libxslt/numbers.c

 /*
  * 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>
@@ skipping 175 matching lines @@
         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) = 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;
             }
@@ skipping 17 matching lines @@
     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);
 
     /* 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 (fabs(number) < 1.0)
             break; /* for */
     }
     xmlBufferCCat(buffer, pointer);
 }
 
@@ skipping 75 matching lines @@
 
     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)) ) {
+              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++) {
@@ skipping 176 matching lines @@
      * Handle final non-alphanumeric token
      */
     if (tokens->end != NULL)
          xmlBufferCat(buffer, tokens->end);
 
 }
 
 static int
 xsltNumberFormatGetAnyLevel(xsltTransformContextPtr context,
                             xmlNodePtr node,
-                            const xmlChar *count,
-                            const xmlChar *from,
+                            xsltCompMatchPtr countPat,
+                            xsltCompMatchPtr fromPat,
                             double *array,
                             xmlDocPtr doc,
                             xmlNodePtr elem)
 {
     int amount = 0;
     int cnt = 0;
     xmlNodePtr cur;
-    xsltCompMatchPtr countPat = NULL;
-    xsltCompMatchPtr fromPat = NULL;
 
-    if (count != NULL)
-        countPat = xsltCompilePattern(count, doc, elem, NULL, context);
-    if (from != NULL)
-        fromPat = xsltCompilePattern(from, doc, elem, NULL, context);
-        
     /* select the starting node */
     switch (node->type) {
         case XML_ELEMENT_NODE:
             cur = node;
             break;
         case XML_ATTRIBUTE_NODE:
             cur = ((xmlAttrPtr) node)->parent;
             break;
         case XML_TEXT_NODE:
         case XML_PI_NODE:
         case XML_COMMENT_NODE:
             cur = node->parent;
             break;
         default:
             cur = NULL;
             break;
     }
 
     while (cur != NULL) {
         /* process current node */
-        if (count == NULL) {
+        if (countPat == NULL) {
             if ((node->type == cur->type) &&
                 /* FIXME: must use expanded-name instead of local name */
                 xmlStrEqual(node->name, cur->name)) {
                     if ((node->ns == cur->ns) ||
                         ((node->ns != NULL) &&
                          (cur->ns != NULL) &&
                          (xmlStrEqual(node->ns->href,
                              cur->ns->href) )))
                         cnt++;
             }
         } else {
             if (xsltTestCompMatchList(context, cur, countPat))
                 cnt++;
         }
-        if ((from != NULL) &&
+        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 */
 
         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;
 
-    if (countPat != NULL)
-        xsltFreeCompMatchList(countPat);
-    if (fromPat != NULL)
-        xsltFreeCompMatchList(fromPat);
     return(amount);
 }
 
 static int
 xsltNumberFormatGetMultipleLevel(xsltTransformContextPtr context,
                                  xmlNodePtr node,
-                                 const xmlChar *count,
-                                 const xmlChar *from,
+                                 xsltCompMatchPtr countPat,
+                                 xsltCompMatchPtr fromPat,
                                  double *array,
                                  int max,
                                  xmlDocPtr doc,
                                  xmlNodePtr elem)
 {
     int amount = 0;
     int cnt;
     xmlNodePtr ancestor;
     xmlNodePtr preceding;
     xmlXPathParserContextPtr parser;
-    xsltCompMatchPtr countPat;
-    xsltCompMatchPtr fromPat;
 
-    if (count != NULL)
-        countPat = xsltCompilePattern(count, doc, elem, NULL, context);
-    else
-        countPat = NULL;
-    if (from != NULL)
-        fromPat = xsltCompilePattern(from, doc, elem, NULL, context);
-    else
-        fromPat = NULL;
     context->xpathCtxt->node = node;
     parser = xmlXPathNewParserContext(NULL, context->xpathCtxt);
     if (parser) {
         /* ancestor-or-self::*[count] */
         for (ancestor = node;
              (ancestor != NULL) && (ancestor->type != XML_DOCUMENT_NODE);
              ancestor = xmlXPathNextAncestor(parser, ancestor)) {
-            
-            if ((from != NULL) &&
+
+            if ((fromPat != NULL) &&
                 xsltTestCompMatchList(context, ancestor, fromPat))
                 break; /* for */
-            
-            if ((count == NULL && node->type == ancestor->type && 
+
+            if ((countPat == NULL && node->type == ancestor->type &&
                 xmlStrEqual(node->name, ancestor->name)) ||
                 xsltTestCompMatchList(context, ancestor, countPat)) {
                 /* count(preceding-sibling::*) */
                 cnt = 0;
                 for (preceding = ancestor;
                      preceding != NULL;
-                     preceding = 
+                     preceding =
                         xmlXPathNextPrecedingSibling(parser, preceding)) {
-                    if (count == NULL) {
+                    if (countPat == NULL) {
                         if ((preceding->type == ancestor->type) &&
                             xmlStrEqual(preceding->name, ancestor->name)){
                             if ((preceding->ns == ancestor->ns) ||
                                 ((preceding->ns != NULL) &&
                                  (ancestor->ns != NULL) &&
                                  (xmlStrEqual(preceding->ns->href,
                                      ancestor->ns->href) )))
                                 cnt++;
                         }
                     } else {
                         if (xsltTestCompMatchList(context, preceding,
                                                   countPat))
                             cnt++;
                     }
                 }
                 array[amount++] = (double)cnt;
                 if (amount >= max)
                     break; /* for */
             }
         }
         xmlXPathFreeParserContext(parser);
     }
-    xsltFreeCompMatchList(countPat);
-    xsltFreeCompMatchList(fromPat);
     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;
@@ skipping 48 matching lines @@
                                           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->count,
-                                                      data->from,
+                                                      data->countPat,
+                                                      data->fromPat,
                                                       &number,
                                                       1,
                                                       data->doc,
                                                       data->node);
             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->count,
-                                                      data->from,
+                                                      data->countPat,
+                                                      data->fromPat,
                                                       numarray,
                                                       max,
                                                       data->doc,
                                                       data->node);
             if (amount > 0) {
                 xsltNumberFormatInsertNumbers(data,
                                               numarray,
                                               amount,
                                               &tokens,
                                               output);
             }
         } else if (xmlStrEqual(data->level, (const xmlChar *) "any")) {
             amount = xsltNumberFormatGetAnyLevel(ctxt,
                                                  node,
-                                                 data->count,
-                                                 data->from,
-                                                 &number, 
+                                                 data->countPat,
+                                                 data->fromPat,
+                                                 &number,
                                                  data->doc,
                                                  data->node);
             if (amount > 0) {
                 xsltNumberFormatInsertNumbers(data,
                                               &number,
                                               1,
                                               &tokens,
                                               output);
             }
         }
     }
     /* Insert number as text node */
     xsltCopyTextString(ctxt, ctxt->insert, xmlBufferContent(output), 0);
 
     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);
     }
-    
+
 XSLT_NUMBER_FORMAT_END:
     if (tempformat == 1) {
         /* The format need to be recomputed each time */
         data->format = NULL;
     }
     if (output != NULL)
         xmlBufferFree(output);
 }
 
 static int
 xsltFormatNumberPreSuffix(xsltDecimalFormatPtr self, xmlChar **format, xsltFormatNumberInfoPtr info)
 {
     int count=0;        /* will hold total length of prefix/suffix */
     int len;
 
     while (1) {
-        /* 
-         * prefix / suffix ends at end of string or at 
-         * first 'special' character 
+        /*
+         * 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 
+         * depending on whether +ve or -ve
          */
         else {
             /*
-             * for +ve prefix/suffix, allow only a 
-             * single occurence of either 
+             * 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=xsltUTF8Size(*format)) < 1)
             return -1;
         count += len;
         *format += len;
     }
 }
-            
+
 /**
  * xsltFormatNumberConversion:
  * @self: the decimal format
  * @format: the format requested
  * @number: the value to format
  * @result: the place to ouput the result
  *
  * format-number() uses the JDK 1.1 DecimalFormat class:
  *
  * http://java.sun.com/products/jdk/1.1/docs/api/java.text.DecimalFormat.html
@@ skipping 38 matching lines @@
     xmlXPathError status = XPATH_EXPRESSION_OK;
     xmlBufferPtr buffer;
     xmlChar *the_format, *prefix = NULL, *suffix = NULL;
     xmlChar *nprefix, *nsuffix = NULL;
     xmlChar pchar;
     int     prefix_length, suffix_length = 0, nprefix_length, nsuffix_length;
     double  scale;
     int     j, len;
     int     self_grouping_len;
     xsltFormatNumberInfo format_info;
-    /* 
+    /*
      * delayed_multiplier allows a 'trailing' percent or
-     * permille to be treated as suffix 
+     * 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 : "
@@ skipping 35 matching lines @@
     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 
+     * 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 
+    /*
+     * 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 
+     * 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;
             }
@@ skipping 17 matching lines @@
             }
             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=xsltUTF8Size(the_format)) < 1) {
             found_error = 1;
             goto OUTPUT_NUMBER;
         }
         the_format += len;
 
     }
 
     /* We have finished the integer part, now work on fraction */
     if (xsltUTF8Charcmp(the_format, self->decimalPoint) == 0) {
         format_info.add_decimal = TRUE;
         the_format += xsltUTF8Size(the_format); /* 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) {
@@ skipping 27 matching lines @@
             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 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) && 
+         ((*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 
+            /*
+             * 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);
+            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;
@@ skipping 13 matching lines @@
                 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, 
+                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) && 
+                (nsuffix_length != suffix_length) ||
+                ((nprefix_length > 0) &&
                  (xmlStrncmp(nprefix, prefix, prefix_length) !=0 )) ||
-                ((nsuffix_length > 0) && 
+                ((nsuffix_length > 0) &&
                  (xmlStrncmp(nsuffix, suffix, suffix_length) !=0 ))) {
-                prefix = nprefix;
+                prefix = nprefix;
                 prefix_length = nprefix_length;
                 suffix = nsuffix;
                 suffix_length = nsuffix_length;
             } /* else {
                 default_sign = 1;
             }
             */
         }
     }
 
@@ skipping 25 matching lines @@
             prefix += len;
             j += len - 1;       /* length of symbol less length of quote */
         } else
             xmlBufferAdd(buffer, &pchar, 1);
     }
 
     /* 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) && 
+    if ((self->grouping != NULL) &&
         (self->grouping[0] != 0)) {
-        
+
         len = xmlStrlen(self->grouping);
         pchar = xsltGetUTF8Char(self->grouping, &len);
         xsltNumberFormatDecimal(buffer, floor(number), self->zeroDigit[0],
                                 format_info.integer_digits,
                                 format_info.group,
                                 pchar, 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, xsltUTF8Size(self->zeroDigit));
     }
 
     /* 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, 
-                         xsltUTF8Size(self->decimalPoint));
+            xmlBufferAdd(buffer, self->decimalPoint,
+                         xsltUTF8Size(self->decimalPoint));
     }
     else {
       number -= floor(number);
         if ((number != 0) || (format_info.frac_digits != 0)) {
             xmlBufferAdd(buffer, self->decimalPoint,
-                         xsltUTF8Size(self->decimalPoint));
+                         xsltUTF8Size(self->decimalPoint));
             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; j++) {
         if ((pchar = *suffix++) == SYMBOL_QUOTE) {
             len = xsltUTF8Size(suffix);
             xmlBufferAdd(buffer, suffix, len);
             suffix += len;
             j += len - 1;       /* length of symbol less length of escape */
         } else
             xmlBufferAdd(buffer, &pchar, 1);
     }
 
     *result = xmlStrdup(xmlBufferContent(buffer));
     xmlBufferFree(buffer);
     return status;
 }