Roll libxslt to 891681e3e948f31732229f53cb6db7215f740fc7

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 219 matching lines @@
 xsltNumberFormatAlpha(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);
 
+    if (number < 1.0)
+        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 (fabs(number) < 1.0)
+        if (number < 1.0)
             break; /* for */
     }
     xmlBufferCCat(buffer, pointer);
 }
 
 static void
 xsltNumberFormatRoman(xmlBufferPtr buffer,
                       double number,
                       int is_upper)
 {
@@ skipping 265 matching lines @@
 
     /*
      * 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,
-                            xmlDocPtr doc,
-                            xmlNodePtr elem)
+                            double *array)
 {
     int amount = 0;
     int cnt = 0;
     xmlNodePtr cur;
 
     /* 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 (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 (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
@@ skipping 16 matching lines @@
 
     return(amount);
 }
 
 static int
 xsltNumberFormatGetMultipleLevel(xsltTransformContextPtr context,
                                  xmlNodePtr node,
                                  xsltCompMatchPtr countPat,
                                  xsltCompMatchPtr fromPat,
                                  double *array,
-                                 int max,
-                                 xmlDocPtr doc,
-                                 xmlNodePtr elem)
+                                 int max)
 {
     int amount = 0;
     int cnt;
     xmlNodePtr ancestor;
     xmlNodePtr preceding;
     xmlXPathParserContextPtr parser;
 
     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 ((fromPat != NULL) &&
                 xsltTestCompMatchList(context, ancestor, fromPat))
                 break; /* for */
 
-            if ((countPat == NULL && node->type == ancestor->type &&
-                xmlStrEqual(node->name, ancestor->name)) ||
-                xsltTestCompMatchList(context, ancestor, countPat)) {
+            if (xsltTestCompMatchCount(context, ancestor, countPat, node)) {
                 /* count(preceding-sibling::*) */
-                cnt = 0;
-                for (preceding = ancestor;
+                cnt = 1;
+                for (preceding =
+                        xmlXPathNextPrecedingSibling(parser, ancestor);
                      preceding != NULL;
                      preceding =
                         xmlXPathNextPrecedingSibling(parser, preceding)) {
-                    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++;
-                    }
+
+                    if (xsltTestCompMatchCount(context, preceding, countPat,
+                                               node))
+                        cnt++;
                 }
                 array[amount++] = (double)cnt;
                 if (amount >= max)
                     break; /* for */
             }
         }
         xmlXPathFreeParserContext(parser);
     }
     return amount;
 }
@@ skipping 36 matching lines @@
  */
 void
 xsltNumberFormat(xsltTransformContextPtr ctxt,
                  xsltNumberDataPtr data,
                  xmlNodePtr node)
 {
     xmlBufferPtr output = NULL;
     int amount, i;
     double number;
     xsltFormat tokens;
-    int tempformat = 0;
 
-    if ((data->format == NULL) && (data->has_format != 0)) {
-        data->format = xsltEvalAttrValueTemplate(ctxt, data->node,
+    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);
-        tempformat = 1;
-    }
-    if (data->format == NULL) {
-        return;
+        if (format == NULL)
+            return;
+        xsltNumberFormatTokenize(format, &tokens);
+        xmlFree(format);
     }
 
     output = xmlBufferCreate();
     if (output == NULL)
         goto XSLT_NUMBER_FORMAT_END;
 
-    xsltNumberFormatTokenize(data->format, &tokens);
-
     /*
      * 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,
-                                                      data->doc,
-                                                      data->node);
+                                                      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,
-                                                      data->doc,
-                                                      data->node);
+                                                      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,
-                                                 data->doc,
-                                                 data->node);
+                                                 &number);
             if (amount > 0) {
                 xsltNumberFormatInsertNumbers(data,
                                               &number,
                                               1,
                                               &tokens,
                                               output);
             }
         }
     }
     /* 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);
     }
-
-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) {
         /*
@@ skipping 483 matching lines @@
             j += len - 1;       /* length of symbol less length of escape */
         } else
             xmlBufferAdd(buffer, &pchar, 1);
     }
 
     *result = xmlStrdup(xmlBufferContent(buffer));
     xmlBufferFree(buffer);
     return status;
 }