Roll libxml to 8effcb578e0590cc01bbcab0f9dccefc6bdbcdbd

third_party/libxml/src/xmlschemastypes.c

 /*
  * schemastypes.c : implementation of the XML Schema Datatypes
  *             definition and validity checking
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */
 
 #define IN_LIBXML
@@ skipping 44 matching lines @@
 
 #define IS_WSP_BLANK_CH(c) IS_BLANK_CH(c)
 
 /* Date value */
 typedef struct _xmlSchemaValDate xmlSchemaValDate;
 typedef xmlSchemaValDate *xmlSchemaValDatePtr;
 struct _xmlSchemaValDate {
     long                year;
     unsigned int        mon     :4;     /* 1 <=  mon    <= 12   */
     unsigned int        day     :5;     /* 1 <=  day    <= 31   */
-    unsigned int        hour    :5;     /* 0 <=  hour   <= 23   */
+    unsigned int        hour    :5;     /* 0 <=  hour   <= 24   */
     unsigned int        min     :6;     /* 0 <=  min    <= 59   */
     double              sec;
     unsigned int        tz_flag :1;     /* is tzo explicitely set? */
     signed int          tzo     :12;    /* -1440 <= tzo <= 1440;
                                            currently only -840 to +840 are needed */
 };
 
 /* Duration value */
 typedef struct _xmlSchemaValDuration xmlSchemaValDuration;
 typedef xmlSchemaValDuration *xmlSchemaValDurationPtr;
@@ skipping 1056 matching lines @@
         (IS_LEAP(yr) ? daysInMonthLeap[mon - 1] : daysInMonth[mon - 1])
 
 #define VALID_MDAY(dt)                                          \
         (IS_LEAP(dt->year) ?                                    \
             (dt->day <= daysInMonthLeap[dt->mon - 1]) :         \
             (dt->day <= daysInMonth[dt->mon - 1]))
 
 #define VALID_DATE(dt)                                          \
         (VALID_YEAR(dt->year) && VALID_MONTH(dt->mon) && VALID_MDAY(dt))
 
+#define VALID_END_OF_DAY(dt)                                    \
+        ((dt)->hour == 24 && (dt)->min == 0 && (dt)->sec == 0)
+
 #define VALID_TIME(dt)                                          \
-        (VALID_HOUR(dt->hour) && VALID_MIN(dt->min) &&          \
-         VALID_SEC(dt->sec) && VALID_TZO(dt->tzo))
+        (((VALID_HOUR(dt->hour) && VALID_MIN(dt->min) &&        \
+          VALID_SEC(dt->sec)) || VALID_END_OF_DAY(dt)) &&       \
+         VALID_TZO(dt->tzo))
 
 #define VALID_DATETIME(dt)                                      \
         (VALID_DATE(dt) && VALID_TIME(dt))
 
 #define SECS_PER_MIN            (60)
 #define SECS_PER_HOUR           (60 * SECS_PER_MIN)
 #define SECS_PER_DAY            (24 * SECS_PER_HOUR)
 
 static const long dayInYearByMonth[12] =
         { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
@@ skipping 193 matching lines @@
 _xmlSchemaParseTime (xmlSchemaValDatePtr dt, const xmlChar **str) {
     const xmlChar *cur = *str;
     int ret = 0;
     int value = 0;
 
     PARSE_2_DIGITS(value, cur, ret);
     if (ret != 0)
         return ret;
     if (*cur != ':')
         return 1;
-    if (!VALID_HOUR(value))
+    if (!VALID_HOUR(value) && value != 24 /* Allow end-of-day hour */)
         return 2;
     cur++;
 
     /* the ':' insures this string is xs:time */
     dt->hour = value;
 
     PARSE_2_DIGITS(value, cur, ret);
     if (ret != 0)
         return ret;
     if (!VALID_MIN(value))
         return 2;
     dt->min = value;
 
     if (*cur != ':')
         return 1;
     cur++;
 
     PARSE_FLOAT(dt->sec, cur, ret);
     if (ret != 0)
         return ret;
 
-    if ((!VALID_SEC(dt->sec)) || (!VALID_TZO(dt->tzo)))
+    if (!VALID_TIME(dt))
         return 2;
 
     *str = cur;
     return 0;
 }
 
 /**
  * _xmlSchemaParseTimeZone:
  * @dt:  pointer to a date structure
  * @str: pointer to the string to analyze
@@ skipping 3905 matching lines @@
  */
 static int
 xmlSchemaValidateFacetInternal(xmlSchemaFacetPtr facet,
                                xmlSchemaWhitespaceValueType fws,
                                xmlSchemaValType valType,
                                const xmlChar *value,
                                xmlSchemaValPtr val,
                                xmlSchemaWhitespaceValueType ws)
 {
     int ret;
+    int stringType;
 
     if (facet == NULL)
         return(-1);
 
     switch (facet->type) {
         case XML_SCHEMA_FACET_PATTERN:
             /*
             * NOTE that for patterns, the @value needs to be the normalized
             * value, *not* the lexical initial value or the canonical value.
             */
             if (value == NULL)
                 return(-1);
-            ret = xmlRegexpExec(facet->regexp, value);
+            /*
+            * If string-derived type, regexp must be tested on the value space of
+            * the datatype.
+            * See https://www.w3.org/TR/xmlschema-2/#rf-pattern
+            */
+            stringType = val && ((val->type >= XML_SCHEMAS_STRING && val->type <= XML_SCHEMAS_NORMSTRING)
+                              || (val->type >= XML_SCHEMAS_TOKEN && val->type <= XML_SCHEMAS_NCNAME));
+            ret = xmlRegexpExec(facet->regexp,
+                                (stringType && val->value.str) ? val->value.str : value);
             if (ret == 1)
                 return(0);
             if (ret == 0)
                 return(XML_SCHEMAV_CVC_PATTERN_VALID);
             return(ret);
         case XML_SCHEMA_FACET_MAXEXCLUSIVE:
             ret = xmlSchemaCompareValues(val, facet->val);
             if (ret == -2)
                 return(-1);
             if (ret == -1)
@@ skipping 801 matching lines @@
 xmlSchemaGetValType(xmlSchemaValPtr val)
 {
     if (val == NULL)
         return(XML_SCHEMAS_UNKNOWN);
     return (val->type);
 }
 
 #define bottom_xmlschemastypes
 #include "elfgcchack.h"
 #endif /* LIBXML_SCHEMAS_ENABLED */