rtiss_soap4r 2.1.0 → 3.0.0.beta

data/lib/xsd/datatypes.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # XSD4R - XML Schema Datatype implementation.
 # Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
@@ -11,6 +10,7 @@ require 'xsd/qname'
 require 'xsd/charset'
 require 'soap/nestedexception'
 require 'uri'
+require 'date'
 
 ###
 ## XMLSchamaDatatypes general definitions.
@@ -18,1448 +18,1472 @@ require 'uri'
 module XSD
 
 
-Namespace = 'http://www.w3.org/2001/XMLSchema'
-InstanceNamespace = 'http://www.w3.org/2001/XMLSchema-instance'
-
-AttrType = 'type'
-NilValue = 'true'
-
-AnyTypeLiteral = 'anyType'
-AnySimpleTypeLiteral = 'anySimpleType'
-NilLiteral = 'nil'
-StringLiteral = 'string'
-BooleanLiteral = 'boolean'
-DecimalLiteral = 'decimal'
-FloatLiteral = 'float'
-DoubleLiteral = 'double'
-DurationLiteral = 'duration'
-DateTimeLiteral = 'dateTime'
-TimeLiteral = 'time'
-DateLiteral = 'date'
-GYearMonthLiteral = 'gYearMonth'
-GYearLiteral = 'gYear'
-GMonthDayLiteral = 'gMonthDay'
-GDayLiteral = 'gDay'
-GMonthLiteral = 'gMonth'
-HexBinaryLiteral = 'hexBinary'
-Base64BinaryLiteral = 'base64Binary'
-AnyURILiteral = 'anyURI'
-QNameLiteral = 'QName'
-
-NormalizedStringLiteral = 'normalizedString'
-TokenLiteral = 'token'
-LanguageLiteral = 'language'
-NMTOKENLiteral = 'NMTOKEN'
-NMTOKENSLiteral = 'NMTOKENS'
-NameLiteral = 'Name'
-NCNameLiteral = 'NCName'
-IDLiteral = 'ID'
-IDREFLiteral = 'IDREF'
-IDREFSLiteral = 'IDREFS'
-ENTITYLiteral = 'ENTITY'
-ENTITIESLiteral = 'ENTITIES'
-IntegerLiteral = 'integer'
-NonPositiveIntegerLiteral = 'nonPositiveInteger'
-NegativeIntegerLiteral = 'negativeInteger'
-LongLiteral = 'long'
-IntLiteral = 'int'
-ShortLiteral = 'short'
-ByteLiteral = 'byte'
-NonNegativeIntegerLiteral = 'nonNegativeInteger'
-UnsignedLongLiteral = 'unsignedLong'
-UnsignedIntLiteral = 'unsignedInt'
-UnsignedShortLiteral = 'unsignedShort'
-UnsignedByteLiteral = 'unsignedByte'
-PositiveIntegerLiteral = 'positiveInteger'
-
-AttrTypeName = QName.new(InstanceNamespace, AttrType)
-AttrNilName = QName.new(InstanceNamespace, NilLiteral)
-
-AnyTypeName = QName.new(Namespace, AnyTypeLiteral)
-AnySimpleTypeName = QName.new(Namespace, AnySimpleTypeLiteral)
-
-class Error < StandardError; include ::SOAP::NestedException; end
-class ValueSpaceError < Error; end
-
+  Namespace = 'http://www.w3.org/2001/XMLSchema'
+  InstanceNamespace = 'http://www.w3.org/2001/XMLSchema-instance'
+
+  AttrType = 'type'
+  NilValue = 'true'
+
+  AnyTypeLiteral = 'anyType'
+  AnySimpleTypeLiteral = 'anySimpleType'
+  NilLiteral = 'nil'
+  StringLiteral = 'string'
+  BooleanLiteral = 'boolean'
+  DecimalLiteral = 'decimal'
+  FloatLiteral = 'float'
+  DoubleLiteral = 'double'
+  DurationLiteral = 'duration'
+  DateTimeLiteral = 'dateTime'
+  TimeLiteral = 'time'
+  DateLiteral = 'date'
+  GYearMonthLiteral = 'gYearMonth'
+  GYearLiteral = 'gYear'
+  GMonthDayLiteral = 'gMonthDay'
+  GDayLiteral = 'gDay'
+  GMonthLiteral = 'gMonth'
+  HexBinaryLiteral = 'hexBinary'
+  Base64BinaryLiteral = 'base64Binary'
+  AnyURILiteral = 'anyURI'
+  QNameLiteral = 'QName'
+
+  NormalizedStringLiteral = 'normalizedString'
+  TokenLiteral = 'token'
+  LanguageLiteral = 'language'
+  NMTOKENLiteral = 'NMTOKEN'
+  NMTOKENSLiteral = 'NMTOKENS'
+  NameLiteral = 'Name'
+  NCNameLiteral = 'NCName'
+  IDLiteral = 'ID'
+  IDREFLiteral = 'IDREF'
+  IDREFSLiteral = 'IDREFS'
+  ENTITYLiteral = 'ENTITY'
+  ENTITIESLiteral = 'ENTITIES'
+  IntegerLiteral = 'integer'
+  NonPositiveIntegerLiteral = 'nonPositiveInteger'
+  NegativeIntegerLiteral = 'negativeInteger'
+  LongLiteral = 'long'
+  IntLiteral = 'int'
+  ShortLiteral = 'short'
+  ByteLiteral = 'byte'
+  NonNegativeIntegerLiteral = 'nonNegativeInteger'
+  UnsignedLongLiteral = 'unsignedLong'
+  UnsignedIntLiteral = 'unsignedInt'
+  UnsignedShortLiteral = 'unsignedShort'
+  UnsignedByteLiteral = 'unsignedByte'
+  PositiveIntegerLiteral = 'positiveInteger'
+
+  AttrTypeName = QName.new(InstanceNamespace, AttrType)
+  AttrNilName = QName.new(InstanceNamespace, NilLiteral)
+
+  AnyTypeName = QName.new(Namespace, AnyTypeLiteral)
+  AnySimpleTypeName = QName.new(Namespace, AnySimpleTypeLiteral)
+
+  class Error < StandardError; include ::SOAP::NestedException; end
+  class ValueSpaceError < Error; end
+
+
+  ###
+  ## The base class of all datatypes with Namespace.
+  #
+  class NSDBase
+    @@types = []
+
+    attr_accessor :type
+
+    def self.inherited(klass)
+      @@types << klass
+    end
 
-###
-## The base class of all datatypes with Namespace.
-#
-class NSDBase
-  @@types = []
+    def self.types
+      @@types
+    end
 
-  attr_accessor :type
+    def initialize
+    end
 
-  def self.inherited(klass)
-    @@types << klass
+    def init(type)
+      @type = type
+    end
   end
 
-  def self.types
-    @@types
-  end
 
-  def initialize
-  end
+  ###
+  ## The base class of XSD datatypes.
+  #
+  class XSDAnySimpleType < NSDBase
+    include XSD
+    Type = QName.new(Namespace, AnySimpleTypeLiteral)
 
-  def init(type)
-    @type = type
-  end
-end
+    # @data represents canonical space (ex. Integer: 123).
+    attr_reader :data
+    # @is_nil represents this data is nil or not.
+    attr_accessor :is_nil
 
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-###
-## The base class of XSD datatypes.
-#
-class XSDAnySimpleType < NSDBase
-  include XSD
-  Type = QName.new(Namespace, AnySimpleTypeLiteral)
+    # true or raise
+    def check_lexical_format(value)
+      screen_data(value)
+      true
+    end
 
-  # @data represents canonical space (ex. Integer: 123).
-  attr_reader :data
-  # @is_nil represents this data is nil or not.
-  attr_accessor :is_nil
+    # set accepts a string which follows lexical space (ex. String: "+123"), or
+    # an object which follows canonical space (ex. Integer: 123).
+    def set(value)
+      if value.nil?
+        @is_nil = true
+        @data = nil
+        _set(nil)
+      else
+        @is_nil = false
+        _set(screen_data(value))
+      end
+    end
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    # to_s creates a string which follows lexical space (ex. String: "123").
+    def to_s
+      if @is_nil
+        ""
+      else
+        _to_s
+      end
+    end
 
-  # true or raise
-  def check_lexical_format(value)
-    screen_data(value)
-    true
-  end
+    private
 
-  # set accepts a string which follows lexical space (ex. String: "+123"), or
-  # an object which follows canonical space (ex. Integer: 123).
-  def set(value)
-    if value.nil?
-      @is_nil = true
-      @data = nil
-      _set(nil)
-    else
-      @is_nil = false
-      _set(screen_data(value))
+    def init(type, value)
+      super(type)
+      set(value)
     end
-  end
 
-  # to_s creates a string which follows lexical space (ex. String: "123").
-  def to_s()
-    if @is_nil
-      ""
-    else
-      _to_s
+    # raises ValueSpaceError if check failed
+    def screen_data(value)
+      # Remove null bytes before processing
+      if value.is_a?(String)
+        value = value.gsub("\u0000", '')
+      end
+      value.unpack("C*").pack("C*")
     end
-  end
 
-private
+    def string
+      # For binary data types
+      @data.unpack("H*")[0].tr('A-F', 'a-f').force_encoding("UTF-8")
+    end
 
-  def init(type, value)
-    super(type)
-    set(value)
-  end
+    def _set(value)
+      @data = value
+    end
 
-  # raises ValueSpaceError if check failed
-  def screen_data(value)
-    value
+    def _to_s
+      @data.to_s
+    end
   end
 
-  def _set(value)
-    @data = value
-  end
+  class XSDNil < XSDAnySimpleType
+    Type = QName.new(Namespace, NilLiteral)
+    Value = 'true'
 
-  def _to_s
-    @data.to_s
+    def initialize(value = nil)
+      init(Type, value)
+    end
   end
-end
-
-class XSDNil < XSDAnySimpleType
-  Type = QName.new(Namespace, NilLiteral)
-  Value = 'true'
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
-end
 
+  ###
+  ## Primitive datatypes.
+  #
+  class XSDString < XSDAnySimpleType
+    Type = QName.new(Namespace, StringLiteral)
 
-###
-## Primitive datatypes.
-#
-class XSDString < XSDAnySimpleType
-  Type = QName.new(Namespace, StringLiteral)
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    @@strict_ces_validation = false
 
-  @@strict_ces_validation = false
+    def self.strict_ces_validation=(strict_ces_validation)
+      @@strict_ces_validation = strict_ces_validation
+    end
 
-  def self.strict_ces_validation=(strict_ces_validation)
-    @@strict_ces_validation = strict_ces_validation
-  end
+    def self.strict_ces_validation
+      @@strict_ces_validation
+    end
 
-  def self.strict_ces_validation
-    @@strict_ces_validation
-  end
+    private
 
-private
+    def screen_data(value)
+      if ::XSD::XSDString.strict_ces_validation
+        externalces = XSD::Charset.encoding
+        unless XSD::Charset.is_ces(value, externalces)
+          if value.is_a?(String) && value.include?("\0")
+            message = "#{ type }: cannot accept string with null byte."
+          else
+            message = "#{ type }: cannot accept '#{ value }'."
+          end
 
-  def screen_data(value)
-    if ::XSD::XSDString.strict_ces_validation
-      externalces = XSD::Charset.encoding
-      unless XSD::Charset.is_ces(value, externalces)
-        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+          raise ValueSpaceError.new(message)
+        end
       end
+      value
     end
-    value
   end
-end
 
-class XSDBoolean < XSDAnySimpleType
-  Type = QName.new(Namespace, BooleanLiteral)
+  class XSDBoolean < XSDAnySimpleType
+    Type = QName.new(Namespace, BooleanLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
-
-private
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def screen_data(value)
-    if value.is_a?(String)
-      str = value.strip
-      if str == 'true' || str == '1'
-	true
-      elsif str == 'false' || str == '0'
-	false
+    private
+
+    def screen_data(value)
+      if value.is_a?(String)
+        str = value.strip
+        if str == 'true' || str == '1'
+          true
+        elsif str == 'false' || str == '0'
+          false
+        else
+          raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+        end
       else
-	raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+        value ? true : false
       end
-    else
-      value ? true : false
     end
   end
-end
 
-class XSDDecimal < XSDAnySimpleType
-  Type = QName.new(Namespace, DecimalLiteral)
+  class XSDDecimal < XSDAnySimpleType
+    Type = QName.new(Namespace, DecimalLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def nonzero?
-    (@number != '0')
-  end
+    def nonzero?
+      (@number != '0')
+    end
 
-private
+    private
 
-  def screen_data(d)
-    if d.is_a?(String)
-      # Integer("00012") => 10 in Ruby.
-      d.sub!(/^([+\-]?)0*(?=\d)/, "\\1")
+    def screen_data(d)
+      if d.is_a?(String)
+        # Integer("00012") => 10 in Ruby.
+        d.sub!(/^([+\-]?)0*(?=\d)/, "\\1")
+      end
+      screen_data_str(d)
     end
-    screen_data_str(d)
-  end
 
-  def screen_data_str(str)
-    /^([+\-]?)(\d*)(?:\.(\d*)?)?$/ =~ str.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
-    end
-    sign = $1 || '+'
-    int_part = $2
-    frac_part = $3
-    int_part = '0' if int_part.empty?
-    frac_part = frac_part ? frac_part.sub(/0+$/, '') : ''
-    point = - frac_part.size
-    number = int_part + frac_part
-    # normalize
-    if sign == '+'
-      sign = ''
-    elsif sign == '-'
-      if number == '0'
-	sign = ''
+    def screen_data_str(str)
+      /^([+\-]?)(\d*)(?:\.(\d*)?)?$/ =~ str.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
       end
+      sign = $1 || '+'
+      int_part = $2
+      frac_part = $3
+      int_part = '0' if int_part.empty?
+      frac_part = frac_part ? frac_part.sub(/0+$/, '') : ''
+      point = - frac_part.size
+      number = int_part + frac_part
+      # normalize
+      if sign == '+'
+        sign = ''
+      elsif sign == '-'
+        if number == '0'
+          sign = ''
+        end
+      end
+      [sign, point, number]
+    end
+
+    def _set(data)
+      if data.nil?
+        @sign = @point = @number = @data = nil
+        return
+      end
+      @sign, @point, @number = data
+      @data = _to_s
+      @data.freeze
     end
-    [sign, point, number]
-  end
 
-  def _set(data)
-    if data.nil?
-      @sign = @point = @number = @data = nil
-      return
+    # 0.0 -> 0; right?
+    def _to_s
+      str = @number.dup
+      if @point.nonzero?
+        str[@number.size + @point, 0] = '.'
+      end
+      @sign + str
     end
-    @sign, @point, @number = data
-    @data = _to_s
-    @data.freeze
   end
 
-  # 0.0 -> 0; right?
-  def _to_s
-    str = @number.dup
-    if @point.nonzero?
-      str[@number.size + @point, 0] = '.'
-    end
-    @sign + str
+  module FloatConstants
+    NaN = 0.0/0.0
+    POSITIVE_INF = +1.0/0.0
+    NEGATIVE_INF = -1.0/0.0
+    POSITIVE_ZERO = +1.0/POSITIVE_INF
+    NEGATIVE_ZERO = -1.0/POSITIVE_INF
+    MIN_POSITIVE_SINGLE = 2.0 ** -149
   end
-end
 
-module FloatConstants
-  NaN = 0.0/0.0
-  POSITIVE_INF = +1.0/0.0
-  NEGATIVE_INF = -1.0/0.0
-  POSITIVE_ZERO = +1.0/POSITIVE_INF
-  NEGATIVE_ZERO = -1.0/POSITIVE_INF
-  MIN_POSITIVE_SINGLE = 2.0 ** -149
-end
+  class XSDFloat < XSDAnySimpleType
+    include FloatConstants
+    Type = QName.new(Namespace, FloatLiteral)
 
-class XSDFloat < XSDAnySimpleType
-  include FloatConstants
-  Type = QName.new(Namespace, FloatLiteral)
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    private
 
-private
-
-  def screen_data(value)
-    # "NaN".to_f => 0 in some environment.  libc?
-    if value.is_a?(Float)
-      return narrow32bit(value)
-    end
-    str = value.to_s.strip
-    if str == 'NaN'
-      NaN
-    elsif str == 'INF'
-      POSITIVE_INF
-    elsif str == '-INF'
-      NEGATIVE_INF
-    else
-      if /^[+\-\.\deE]+$/ !~ str
-	raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+    def screen_data(value)
+      # "NaN".to_f => 0 in some environment.  libc?
+      if value.is_a?(Float)
+        return narrow32bit(value)
       end
-      # Float("-1.4E") might fail on some system.
-      str << '0' if /e$/i =~ str
-      begin
-  	return narrow32bit(Float(str))
-      rescue ArgumentError
-  	raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+      str = value.to_s.strip
+      if str == 'NaN'
+        NaN
+      elsif str == 'INF'
+        POSITIVE_INF
+      elsif str == '-INF'
+        NEGATIVE_INF
+      else
+        if /^[+\-\.\deE]+$/ !~ str
+          raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+        end
+        # Float("-1.4E") might fail on some system.
+        str << '0' if /e$/i =~ str
+        begin
+          return narrow32bit(Float(str))
+        rescue ArgumentError
+          raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+        end
       end
     end
-  end
 
-  def _to_s
-    if @data.nan?
-      'NaN'
-    elsif @data.infinite? == 1
-      'INF'
-    elsif @data.infinite? == -1
-      '-INF'
-    else
-      sign = XSDFloat.positive?(@data) ? '+' : '-'
-      sign + sprintf("%.10g", @data.abs).sub(/[eE]([+-])?0+/) { 'e' + $1 }
+    def _to_s
+      if @data.nan?
+        'NaN'
+      elsif @data.infinite? == 1
+        'INF'
+      elsif @data.infinite? == -1
+        '-INF'
+      else
+        sign = XSDFloat.positive?(@data) ? '+' : '-'
+        sign + sprintf("%.10g", @data.abs).sub(/[eE]([+-])?0+/) { 'e' + $1 }
+      end
     end
-  end
 
-  # Convert to single-precision 32-bit floating point value.
-  def narrow32bit(f)
-    if f.nan? || f.infinite?
-      f
-    elsif f.abs < MIN_POSITIVE_SINGLE
-      XSDFloat.positive?(f) ? POSITIVE_ZERO : NEGATIVE_ZERO
-    else
-      f
+    # Convert to single-precision 32-bit floating point value.
+    def narrow32bit(f)
+      if f.nan? || f.infinite?
+        f
+      elsif f.abs < MIN_POSITIVE_SINGLE
+        XSDFloat.positive?(f) ? POSITIVE_ZERO : NEGATIVE_ZERO
+      else
+        f
+      end
     end
-  end
 
-  def self.positive?(value)
-    (1 / value) > 0.0
+    def self.positive?(value)
+      (1 / value) > 0.0
+    end
   end
-end
 
-# Ruby's Float is double-precision 64-bit floating point value.
-class XSDDouble < XSDAnySimpleType
-  include FloatConstants
-  Type = QName.new(Namespace, DoubleLiteral)
+  # Ruby's Float is double-precision 64-bit floating point value.
+  class XSDDouble < XSDAnySimpleType
+    include FloatConstants
+    Type = QName.new(Namespace, DoubleLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
-
-  def screen_data(value)
-    # "NaN".to_f => 0 in some environment.  libc?
-    if value.is_a?(Float)
-      return value
-    end
-    str = value.to_s.strip
-    if str == 'NaN'
-      NaN
-    elsif str == 'INF'
-      POSITIVE_INF
-    elsif str == '-INF'
-      NEGATIVE_INF
-    else
-      begin
-	return Float(str)
-      rescue ArgumentError
-	# '1.4e' cannot be parsed on some architecture.
-	if /e\z/i =~ str
-	  begin
-	    return Float(str + '0')
-	  rescue ArgumentError
-	    raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
-	  end
-	else
-	  raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
-	end
+    private
+
+    def screen_data(value)
+      # "NaN".to_f => 0 in some environment.  libc?
+      if value.is_a?(Float)
+        return value
+      end
+      str = value.to_s.strip
+      if str == 'NaN'
+        NaN
+      elsif str == 'INF'
+        POSITIVE_INF
+      elsif str == '-INF'
+        NEGATIVE_INF
+      else
+        begin
+          return Float(str)
+        rescue ArgumentError
+          # '1.4e' cannot be parsed on some architecture.
+          if /e\z/i =~ str
+            begin
+              return Float(str + '0')
+            rescue ArgumentError
+              raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+            end
+          else
+            raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+          end
+        end
       end
     end
-  end
 
-  def _to_s
-    if @data.nan?
-      'NaN'
-    elsif @data.infinite? == 1
-      'INF'
-    elsif @data.infinite? == -1
-      '-INF'
-    else
-      sign = (1 / @data > 0.0) ? '+' : '-'
-      sign + sprintf("%.16g", @data.abs).sub(/[eE]([+-])?0+/) { 'e' + $1 }
+    def _to_s
+      if @data.nan?
+        'NaN'
+      elsif @data.infinite? == 1
+        'INF'
+      elsif @data.infinite? == -1
+        '-INF'
+      else
+        sign = (1 / @data > 0.0) ? '+' : '-'
+        sign + sprintf("%.16g", @data.abs).sub(/[eE]([+-])?0+/) { 'e' + $1 }
+      end
     end
   end
-end
 
-class XSDDuration < XSDAnySimpleType
-  Type = QName.new(Namespace, DurationLiteral)
+  class XSDDuration < XSDAnySimpleType
+    Type = QName.new(Namespace, DurationLiteral)
 
-  attr_accessor :sign
-  attr_accessor :year
-  attr_accessor :month
-  attr_accessor :day
-  attr_accessor :hour
-  attr_accessor :min
-  attr_accessor :sec
+    attr_accessor :sign
+    attr_accessor :year
+    attr_accessor :month
+    attr_accessor :day
+    attr_accessor :hour
+    attr_accessor :min
+    attr_accessor :sec
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
-
-  def screen_data(value)
-    /^([+\-]?)P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/ =~ value.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
-    end
-    if $5 and !$6 and !$7 and !$8
-      # allows durations lower than a day such as 'PT5S'.
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
-    end
-    sign = $1
-    year = $2.to_i
-    month = $3.to_i
-    day = $4.to_i
-    hour = $6.to_i
-    min = $7.to_i
-    sec = $8 ? XSDDecimal.new($8) : 0
-    [sign, year, month, day, hour, min, sec]
-  end
+    private
 
-  def _set(data)
-    if data.nil?
-      @sign = @year = @month = @day = @hour = @min = @sec = @data = nil
-      return
+    def screen_data(value)
+      /^([+\-]?)P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/ =~ value.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      if $5 and !$6 and !$7 and !$8
+        # allows durations lower than a day such as 'PT5S'.
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      sign = $1
+      year = $2.to_i
+      month = $3.to_i
+      day = $4.to_i
+      hour = $6.to_i
+      min = $7.to_i
+      sec = $8 ? XSDDecimal.new($8) : 0
+      [sign, year, month, day, hour, min, sec]
+    end
+
+    def _set(data)
+      if data.nil?
+        @sign = @year = @month = @day = @hour = @min = @sec = @data = nil
+        return
+      end
+      @sign, @year, @month, @day, @hour, @min, @sec = data
+      @data = _to_s
+      @data.freeze
     end
-    @sign, @year, @month, @day, @hour, @min, @sec = data
-    @data = _to_s
-    @data.freeze
-  end
 
-  def _to_s
-    str = ''
-    str << @sign if @sign
-    str << 'P'
-    l = ''
-    l << "#{ @year }Y" if @year.nonzero?
-    l << "#{ @month }M" if @month.nonzero?
-    l << "#{ @day }D" if @day.nonzero?
-    r = ''
-    r << "#{ @hour }H" if @hour.nonzero?
-    r << "#{ @min }M" if @min.nonzero?
-    r << "#{ @sec }S" if @sec.nonzero?
-    str << l
-    unless r.empty?
-      str << "T" << r
-    end
-    if l.empty? and r.empty?
-      str << "0D"
-    end
-    str
+    def _to_s
+      str = ''
+      str << @sign if @sign
+      str << 'P'
+      l = ''
+      l << "#{ @year }Y" if @year.nonzero?
+      l << "#{ @month }M" if @month.nonzero?
+      l << "#{ @day }D" if @day.nonzero?
+      r = ''
+      r << "#{ @hour }H" if @hour.nonzero?
+      r << "#{ @min }M" if @min.nonzero?
+      r << "#{ @sec }S" if @sec.nonzero?
+      str << l
+      unless r.empty?
+        str << "T" << r
+      end
+      if l.empty? and r.empty?
+        str << "0D"
+      end
+      str
+    end
   end
-end
 
 
-require 'date'
+  require 'rational'
+  require 'date'
 
-module XSDDateTimeImpl
-  SecInMicro = 1000000 # 1 second = 1 million microseconds
-  DayInSec = 86400	   # 24 Hours/Day * 60 Minutes/Hour * 60 Seconds/Minute
-  DayInMicro = (DayInSec * SecInMicro)
-
-  def to_obj(klass)
-    if klass == Time
-      to_time
-    elsif klass == Date
-      to_date
-    elsif klass == DateTime
-      to_datetime
-    else
-      nil
-    end
-  end
+  module XSDDateTimeImpl
+    DayInSec = 86400	# 24 * 60 * 60
+    DayInMicro = 86400_000_000
 
-  def to_time
-    begin
-      if @data.offset * DayInSec == Time.now.utc_offset
-        d = @data
-        usec = (RUBY_VERSION.to_f >= 1.9) ? (d.sec_fraction * SecInMicro).to_i : (d.sec_fraction * DayInMicro).round
-        Time.local(d.year, d.month, d.mday, d.hour, d.min, d.sec, usec)
+    def to_obj(klass)
+      if klass == Time
+        to_time
+      elsif klass == Date
+        to_date
+      elsif klass == DateTime
+        to_datetime
       else
-        d = @data.newof
-        usec = (RUBY_VERSION.to_f >= 1.9) ? (d.sec_fraction * SecInMicro).to_i : (d.sec_fraction * DayInMicro).round  
-        Time.gm(d.year, d.month, d.mday, d.hour, d.min, d.sec, usec)
+        nil
       end
-    rescue ArgumentError
-      nil
     end
-  end
 
-  def to_date
-    @data.respond_to?(:to_date) ? @data.to_date : Date.new!(@data.class.send(:jd_to_ajd, @data.jd, 0, 0), 0, @data.start)
-  end
+    def to_time
+      begin
+        if @data.offset * DayInSec == Time.now.utc_offset
+          d = @data
+          usec = (d.sec_fraction * DayInMicro).round
+          Time.local(d.year, d.month, d.mday, d.hour, d.min, d.sec, usec)
+        else
+          d = @data.newof
+          usec = (d.sec_fraction * DayInMicro).round
+          Time.gm(d.year, d.month, d.mday, d.hour, d.min, d.sec, usec)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
 
-  def to_datetime
-    data
-  end
+    def to_date
+      Date.jd(@data.jd, @data.start)
+    end
+
+    def to_datetime
+      data
+    end
+
+    def tz2of(str)
+      /^(?:Z|(?:([+\-])(\d\d):(\d\d))?)$/ =~ str
+      sign = $1
+      hour = $2.to_i
+      min = $3.to_i
+
+      of = case sign
+           when '+'
+             of = +(hour.to_r * 60 + min) / 1440	# 24 * 60
+           when '-'
+             of = -(hour.to_r * 60 + min) / 1440	# 24 * 60
+           else
+             0
+           end
+      of
+    end
 
-  def tz2of(str)
-    /^(?:Z|(?:([+\-])(\d\d):(\d\d))?)$/ =~ str
-    sign = $1
-    hour = $2.to_i
-    min = $3.to_i
-
-    of = case sign
-      when '+'
-	of = +(hour.to_r * 60 + min) / 1440	# 24 * 60
-      when '-'
-	of = -(hour.to_r * 60 + min) / 1440	# 24 * 60
+    def of2tz(offset)
+      diffmin = offset * 24 * 60
+      if diffmin.zero?
+        'Z'
       else
-	0
+        ((diffmin < 0) ? '-' : '+') << format('%02d:%02d',
+                                              (diffmin.abs / 60.0).to_i, (diffmin.abs % 60.0).to_i)
       end
-    of
-  end
+    end
 
-  def of2tz(offset)
-    diffmin = offset * 24 * 60
-    if diffmin.zero?
-      'Z'
-    else
-      ((diffmin < 0) ? '-' : '+') << format('%02d:%02d',
-    	(diffmin.abs / 60.0).to_i, (diffmin.abs % 60.0).to_i)
+    def screen_data(t)
+      # convert t to a DateTime as an internal representation.
+      if t.respond_to?(:to_datetime)      # 1.9 or later
+        t.to_datetime
+      elsif t.is_a?(DateTime)
+        t
+      elsif t.is_a?(Date)
+        t = screen_data_str(t)
+        t <<= 12 if t.year < 0
+        t
+      elsif t.is_a?(Time)
+        jd = DateTime.civil_to_jd(t.year, t.mon, t.mday, DateTime::ITALY)
+        fr = DateTime.time_to_day_fraction(t.hour, t.min, [t.sec, 59].min) +
+             t.usec.to_r / DayInMicro
+        of = t.utc_offset.to_r / DayInSec
+        DateTime.new!((jd + fr - of - 0.5), of, DateTime::ITALY)
+      else
+        screen_data_str(t)
+      end
     end
-  end
 
-  def screen_data(t)
-    # convert t to a DateTime as an internal representation.
-    if t.respond_to?(:to_datetime)      # 1.9 or later
-      t.to_datetime
-    elsif t.is_a?(DateTime)
-      t
-    elsif t.is_a?(Date)
-      t = screen_data_str(t)
-      t <<= 12 if t.year < 0
-      t
-    elsif t.is_a?(Time)
-      jd = DateTime.send(:civil_to_jd, t.year, t.mon, t.mday, DateTime::ITALY)
-      fr = DateTime.send(:time_to_day_fraction, t.hour, t.min, [t.sec, 59].min) + t.usec.to_r / DayInMicro
-      of = t.utc_offset.to_r / DayInSec
-      DateTime.new!(DateTime.send(:jd_to_ajd, jd, fr, of), of, DateTime::ITALY)
-    else
-      screen_data_str(t)
+    def add_tz(s)
+      s + of2tz(@data.offset)
     end
   end
 
-  def add_tz(s)
-    s + of2tz(@data.offset)
-  end
-end
+  class XSDDateTime < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, DateTimeLiteral)
 
-class XSDDateTime < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, DateTimeLiteral)
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    private
 
-private
-
-  def screen_data_str(t)
-    /^([+\-]?\d{4,})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d(?:\.(\d*))?)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    if $1 == '0000'
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    year = $1.to_i
-    if year < 0
-      year += 1
-    end
-    mon = $2.to_i
-    mday = $3.to_i
-    hour = $4.to_i
-    min = $5.to_i
-    sec = $6.to_i
-    secfrac = $7
-    zonestr = $8
-    data = DateTime.civil(year, mon, mday, hour, min, sec, tz2of(zonestr))
-    if secfrac
-      diffday = secfrac.to_i.to_r / (10 ** secfrac.size) / DayInSec
-      data += diffday
-      # FYI: new! and jd_to_rjd are not necessary to use if you don't have
-      # exceptional reason.
-    end
-    [data, secfrac]
-  end
+    def screen_data_str(t)
+      /^([+\-]?\d{4,})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d(?:\.(\d*))?)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      if $1 == '0000'
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      year = $1.to_i
+      if year < 0
+        year += 1
+      end
+      mon = $2.to_i
+      mday = $3.to_i
+      hour = $4.to_i
+      min = $5.to_i
+      sec = $6.to_i
+      secfrac = $7
+      zonestr = $8
+      data = DateTime.civil(year, mon, mday, hour, min, sec, tz2of(zonestr))
+      if secfrac
+        diffday = secfrac.to_i.to_r / (10 ** secfrac.size) / DayInSec
+        data += diffday
+        # FYI: new0 and jd_to_rjd are not necessary to use if you don't have
+        # exceptional reason.
+      end
+      [data, secfrac]
+    end
 
-  def _set(data)
-    if data.nil?
-      @data = @secfrac = nil
-      return
+    def _set(data)
+      if data.nil?
+        @data = @secfrac = nil
+        return
+      end
+      @data, @secfrac = data
     end
-    @data, @secfrac = data
-  end
 
-  def _to_s
-    year = (@data.year > 0) ? @data.year : @data.year - 1
-    s = format('%.4d-%02d-%02dT%02d:%02d:%02d', year, @data.mon, @data.mday, @data.hour, @data.min, @data.sec)
-    if @data.sec_fraction.nonzero?
-      if @secfrac
-        s << ".#{ @secfrac }"
-      elsif (RUBY_VERSION.to_f >= 1.9)
-        s << sprintf("%.16f",@data.sec_fraction.to_f).sub(/^0/, '').sub(/0*$/, '')
-      else
-        s << sprintf("%.16f",(@data.sec_fraction * DayInSec).to_f).sub(/^0/, '').sub(/0*$/, '')
+    def _to_s
+      year = (@data.year > 0) ? @data.year : @data.year - 1
+      s = format('%.4d-%02d-%02dT%02d:%02d:%02d',
+                 year, @data.mon, @data.mday, @data.hour, @data.min, @data.sec)
+      if @data.sec_fraction.nonzero?
+        if @secfrac
+          s << ".#{ @secfrac }"
+        else
+          s << sprintf("%.6f", @data.sec_fraction.to_f).sub(/^0/, '').sub(/0*$/, '')
+        end
       end
+      add_tz(s)
     end
-    add_tz(s)
   end
-end
 
-class XSDTime < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, TimeLiteral)
+  class XSDTime < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, TimeLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^(\d\d):(\d\d):(\d\d(?:\.(\d*))?)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    hour = $1.to_i
-    min = $2.to_i
-    sec = $3.to_i
-    secfrac = $4
-    zonestr = $5
-    data = DateTime.civil(1, 1, 1, hour, min, sec, tz2of(zonestr))
-    if secfrac
-      diffday = secfrac.to_i.to_r / (10 ** secfrac.size) / DayInSec
-      data += diffday
+    def screen_data_str(t)
+      /^(\d\d):(\d\d):(\d\d(?:\.(\d*))?)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      hour = $1.to_i
+      min = $2.to_i
+      sec = $3.to_i
+      secfrac = $4
+      zonestr = $5
+      data = DateTime.civil(1, 1, 1, hour, min, sec, tz2of(zonestr))
+      if secfrac
+        diffday = secfrac.to_i.to_r / (10 ** secfrac.size) / DayInSec
+        data += diffday
+      end
+      [data, secfrac]
     end
-    [data, secfrac]
-  end
 
-  def _set(data)
-    if data.nil?
-      @data = @secfrac = nil
-      return
+    def _set(data)
+      if data.nil?
+        @data = @secfrac = nil
+        return
+      end
+      @data, @secfrac = data
     end
-    @data, @secfrac = data
-  end
 
-  def _to_s
-    s = format('%02d:%02d:%02d', @data.hour, @data.min, @data.sec)
-    if @data.sec_fraction.nonzero?
-      if @secfrac
-  	s << ".#{ @secfrac }"
-      else
-	s << sprintf("%.16f",
-          (@data.sec_fraction * DayInSec).to_f).sub(/^0/, '').sub(/0*$/, '')
+    def _to_s
+      s = format('%02d:%02d:%02d', @data.hour, @data.min, @data.sec)
+      if @data.sec_fraction.nonzero?
+        if @secfrac
+          s << ".#{ @secfrac }"
+        else
+          s << sprintf("%.16f",
+                       (@data.sec_fraction * DayInSec).to_f).sub(/^0/, '').sub(/0*$/, '')
+        end
       end
+      add_tz(s)
     end
-    add_tz(s)
   end
-end
 
-class XSDDate < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, DateLiteral)
+  class XSDDate < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, DateLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^([+\-]?\d{4,})-(\d\d)-(\d\d)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    year = $1.to_i
-    if year < 0
-      year += 1
+    def screen_data_str(t)
+      /^([+\-]?\d{4,})-(\d\d)-(\d\d)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      year = $1.to_i
+      if year < 0
+        year += 1
+      end
+      mon = $2.to_i
+      mday = $3.to_i
+      zonestr = $4
+      DateTime.civil(year, mon, mday, 0, 0, 0, tz2of(zonestr))
     end
-    mon = $2.to_i
-    mday = $3.to_i
-    zonestr = $4
-    DateTime.civil(year, mon, mday, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    year = (@data.year > 0) ? @data.year : @data.year - 1
-    s = format('%.4d-%02d-%02d', year, @data.mon, @data.mday)
-    add_tz(s)
+    def _to_s
+      year = (@data.year > 0) ? @data.year : @data.year - 1
+      s = format('%.4d-%02d-%02d', year, @data.mon, @data.mday)
+      add_tz(s)
+    end
   end
-end
 
-class XSDGYearMonth < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, GYearMonthLiteral)
+  class XSDGYearMonth < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, GYearMonthLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^([+\-]?\d{4,})-(\d\d)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    year = $1.to_i
-    if year < 0
-      year += 1
+    def screen_data_str(t)
+      /^([+\-]?\d{4,})-(\d\d)(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      year = $1.to_i
+      if year < 0
+        year += 1
+      end
+      mon = $2.to_i
+      zonestr = $3
+      DateTime.civil(year, mon, 1, 0, 0, 0, tz2of(zonestr))
     end
-    mon = $2.to_i
-    zonestr = $3
-    DateTime.civil(year, mon, 1, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    year = (@data.year > 0) ? @data.year : @data.year - 1
-    s = format('%.4d-%02d', year, @data.mon)
-    add_tz(s)
+    def _to_s
+      year = (@data.year > 0) ? @data.year : @data.year - 1
+      s = format('%.4d-%02d', year, @data.mon)
+      add_tz(s)
+    end
   end
-end
 
-class XSDGYear < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, GYearLiteral)
+  class XSDGYear < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, GYearLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^([+\-]?\d{4,})(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
-    end
-    year = $1.to_i
-    if year < 0
-      year += 1
+    def screen_data_str(t)
+      /^([+\-]?\d{4,})(Z|(?:([+\-])(\d\d):(\d\d))?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      year = $1.to_i
+      if year < 0
+        year += 1
+      end
+      zonestr = $2
+      DateTime.civil(year, 1, 1, 0, 0, 0, tz2of(zonestr))
     end
-    zonestr = $2
-    DateTime.civil(year, 1, 1, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    year = (@data.year > 0) ? @data.year : @data.year - 1
-    s = format('%.4d', year)
-    add_tz(s)
+    def _to_s
+      year = (@data.year > 0) ? @data.year : @data.year - 1
+      s = format('%.4d', year)
+      add_tz(s)
+    end
   end
-end
 
-class XSDGMonthDay < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, GMonthDayLiteral)
+  class XSDGMonthDay < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, GMonthDayLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^--(\d\d)-(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+    def screen_data_str(t)
+      /^--(\d\d)-(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      mon = $1.to_i
+      mday = $2.to_i
+      zonestr = $3
+      DateTime.civil(1, mon, mday, 0, 0, 0, tz2of(zonestr))
     end
-    mon = $1.to_i
-    mday = $2.to_i
-    zonestr = $3
-    DateTime.civil(1, mon, mday, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    s = format('--%02d-%02d', @data.mon, @data.mday)
-    add_tz(s)
+    def _to_s
+      s = format('--%02d-%02d', @data.mon, @data.mday)
+      add_tz(s)
+    end
   end
-end
 
-class XSDGDay < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, GDayLiteral)
+  class XSDGDay < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, GDayLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^---(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+    def screen_data_str(t)
+      /^---(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      mday = $1.to_i
+      zonestr = $2
+      DateTime.civil(1, 1, mday, 0, 0, 0, tz2of(zonestr))
     end
-    mday = $1.to_i
-    zonestr = $2
-    DateTime.civil(1, 1, mday, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    s = format('---%02d', @data.mday)
-    add_tz(s)
+    def _to_s
+      s = format('---%02d', @data.mday)
+      add_tz(s)
+    end
   end
-end
 
-class XSDGMonth < XSDAnySimpleType
-  include XSDDateTimeImpl
-  Type = QName.new(Namespace, GMonthLiteral)
+  class XSDGMonth < XSDAnySimpleType
+    include XSDDateTimeImpl
+    Type = QName.new(Namespace, GMonthLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data_str(t)
-    /^--(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+    def screen_data_str(t)
+      /^--(\d\d)(Z|(?:[+\-]\d\d:\d\d)?)?$/ =~ t.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ t }'.")
+      end
+      mon = $1.to_i
+      zonestr = $2
+      DateTime.civil(1, mon, 1, 0, 0, 0, tz2of(zonestr))
     end
-    mon = $1.to_i
-    zonestr = $2
-    DateTime.civil(1, mon, 1, 0, 0, 0, tz2of(zonestr))
-  end
 
-  def _to_s
-    s = format('--%02d', @data.mon)
-    add_tz(s)
+    def _to_s
+      s = format('--%02d', @data.mon)
+      add_tz(s)
+    end
   end
-end
 
-class XSDHexBinary < XSDAnySimpleType
-  Type = QName.new(Namespace, HexBinaryLiteral)
+  class XSDHexBinary < XSDAnySimpleType
+    Type = QName.new(Namespace, HexBinaryLiteral)
 
-  # String in Ruby could be a binary.
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    # String in Ruby could be a binary.
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def set_encoded(value)
-    if /^[0-9a-fA-F]*$/ !~ value
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+    def set_encoded(value)
+      if /^[0-9a-fA-F]*$/ !~ value
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      @data = String.new(value).strip
+      @is_nil = false
     end
-    @data = String.new(value).strip
-    @is_nil = false
-  end
 
-  def string
-    [@data].pack("H*")
-  end
+    def string
+      [@data].pack("H*")
+    end
 
-private
+    private
 
-  def screen_data(value)
-    value.unpack("H*")[0].tr('a-f', 'A-F')
+    def screen_data(value)
+      value.unpack("H*")[0].tr('a-f', 'A-F')
+    end
   end
-end
 
-class XSDBase64Binary < XSDAnySimpleType
-  Type = QName.new(Namespace, Base64BinaryLiteral)
+  class XSDBase64Binary < XSDAnySimpleType
+    Type = QName.new(Namespace, Base64BinaryLiteral)
 
-  # String in Ruby could be a binary.
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    # String in Ruby could be a binary.
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-  def set_encoded(value)
-    if /^[A-Za-z0-9+\/=]*$/ !~ value
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+    def set_encoded(value)
+      if /^[A-Za-z0-9+\/=]*$/ !~ value
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      @data = String.new(value).strip
+      @is_nil = false
     end
-    @data = String.new(value).strip
-    @is_nil = false
-  end
 
-  def string
-    @data.unpack("m")[0]
-  end
+    def string
+      @data.unpack("m")[0]
+    end
 
-private
+    private
 
-  def screen_data(value)
-    [value].pack("m").strip
+    def screen_data(value)
+      [value].pack("m").strip
+    end
   end
-end
 
-class XSDAnyURI < XSDAnySimpleType
-  Type = QName.new(Namespace, AnyURILiteral)
+  class XSDAnyURI < XSDAnySimpleType
+    Type = QName.new(Namespace, AnyURILiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data(value)
-    begin
-      URI.parse(value.to_s.strip)
-    rescue URI::InvalidURIError
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.", $!)
+    def screen_data(value)
+      begin
+        URI.parse(value.to_s.strip)
+      rescue URI::InvalidURIError
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.", $!)
+      end
     end
   end
-end
 
-class XSDQName < XSDAnySimpleType
-  Type = QName.new(Namespace, QNameLiteral)
+  class XSDQName < XSDAnySimpleType
+    Type = QName.new(Namespace, QNameLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data(value)
-    /^(?:([^:]+):)?([^:]+)$/ =~ value.to_s.strip
-    unless Regexp.last_match
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+    def screen_data(value)
+      /^(?:([^:]+):)?([^:]+)$/ =~ value.to_s.strip
+      unless Regexp.last_match
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      prefix = $1
+      localpart = $2
+      [prefix, localpart]
     end
-    prefix = $1
-    localpart = $2
-    [prefix, localpart]
-  end
 
-  def _set(data)
-    if data.nil?
-      @prefix = @localpart = @data = nil
-      return
+    def _set(data)
+      if data.nil?
+        @prefix = @localpart = @data = nil
+        return
+      end
+      @prefix, @localpart = data
+      @data = _to_s
+      @data.freeze
     end
-    @prefix, @localpart = data
-    @data = _to_s
-    @data.freeze
-  end
 
-  def _to_s
-    if @prefix
-      "#{ @prefix }:#{ @localpart }"
-    else
-      "#{ @localpart }"
+    def _to_s
+      if @prefix
+        "#{ @prefix }:#{ @localpart }"
+      else
+        "#{ @localpart }"
+      end
     end
   end
-end
 
 
-###
-## Derived types
-#
-class XSDNormalizedString < XSDString
-  Type = QName.new(Namespace, NormalizedStringLiteral)
+  ###
+  ## Derived types
+  #
+  class XSDNormalizedString < XSDString
+    Type = QName.new(Namespace, NormalizedStringLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data(value)
-    super
-    if /[\t\r\n]/ =~ value
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+    def screen_data(value)
+      super
+      if /[\t\r\n]/ =~ value
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      value
     end
-    value
   end
-end
 
-class XSDToken < XSDNormalizedString
-  Type = QName.new(Namespace, TokenLiteral)
+  class XSDToken < XSDNormalizedString
+    Type = QName.new(Namespace, TokenLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def screen_data(value)
-    super
-    if /\A / =~ value or / \Z/ =~ value or value.index('  ')
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
-    end
-    value
-  end
-end
+    def screen_data(value)
+      # Remove null bytes before processing
+      if value.is_a?(String)
+        raise XSD::ValueSpaceError.new("#{ type }: cannot accept string with null byte.") if value.include?("\0")
+        value = value.gsub("\u0000", '')
+      end
+
+      value = value.unpack("C*").pack("C*")
 
-class XSDLanguage < XSDToken
-  Type = QName.new(Namespace, LanguageLiteral)
+      super
 
-  def initialize(value = nil)
-    init(Type, value)
+      if /\A / =~ value or / \Z/ =~ value or value.index('  ')
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      value
+    end
   end
 
-private
+  class XSDLanguage < XSDToken
+    Type = QName.new(Namespace, LanguageLiteral)
 
-  def screen_data(value)
-    super
-    # RFC 3066 syntax check
-    if /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})?\z/ !~ value
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+    def initialize(value = nil)
+      init(Type, value)
     end
-    value
-  end
-end
 
-class XSDNMTOKEN < XSDToken
-  Type = QName.new(Namespace, NMTOKENLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # RFC 3066 syntax check
+      if /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})?\z/ !~ value
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ value }'.")
+      end
+      value
+    end
   end
 
-private
+  class XSDNMTOKEN < XSDToken
+    Type = QName.new(Namespace, NMTOKENLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDNMTOKENS < XSDNMTOKEN
-  Type = QName.new(Namespace, NMTOKENSLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDNMTOKENS < XSDNMTOKEN
+    Type = QName.new(Namespace, NMTOKENSLiteral)
 
-  def screen_data(value)
-    # derived by list
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDName < XSDToken
-  Type = QName.new(Namespace, NameLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      # derived by list
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDName < XSDToken
+    Type = QName.new(Namespace, NameLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDNCName < XSDName
-  Type = QName.new(Namespace, NCNameLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDNCName < XSDName
+    Type = QName.new(Namespace, NCNameLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDID < XSDNCName
-  Type = QName.new(Namespace, IDLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDID < XSDNCName
+    Type = QName.new(Namespace, IDLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDIDREF < XSDNCName
-  Type = QName.new(Namespace, IDREFLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDIDREF < XSDNCName
+    Type = QName.new(Namespace, IDREFLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDIDREFS < XSDIDREF
-  Type = QName.new(Namespace, IDREFSLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDIDREFS < XSDIDREF
+    Type = QName.new(Namespace, IDREFSLiteral)
 
-  def screen_data(value)
-    # derived by list
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDENTITY < XSDNCName
-  Type = QName.new(Namespace, ENTITYLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      # derived by list
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDENTITY < XSDNCName
+    Type = QName.new(Namespace, ENTITYLiteral)
 
-  def screen_data(value)
-    super
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDENTITIES < XSDENTITY
-  Type = QName.new(Namespace, ENTITIESLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      super
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDENTITIES < XSDENTITY
+    Type = QName.new(Namespace, ENTITIESLiteral)
 
-  def screen_data(value)
-    # derived by list
-    # TODO: check lexical space and convert to a value
-    value
-  end
-end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-class XSDInteger < XSDDecimal
-  Type = QName.new(Namespace, IntegerLiteral)
+    private
 
-  def initialize(value = nil)
-    init(Type, value)
+    def screen_data(value)
+      # derived by list
+      # TODO: check lexical space and convert to a value
+      value
+    end
   end
 
-private
+  class XSDInteger < XSDDecimal
+    Type = QName.new(Namespace, IntegerLiteral)
 
-  def screen_data_str(str)
-    begin
-      data = Integer(str)
-    rescue ArgumentError
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+    def initialize(value = nil)
+      init(Type, value)
     end
-    unless validate(data)
-      raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+
+    private
+
+    def screen_data_str(str)
+      begin
+        data = Integer(str)
+      rescue ArgumentError
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.", $!)
+      end
+      unless validate(data)
+        raise ValueSpaceError.new("#{ type }: cannot accept '#{ str }'.")
+      end
+      data
     end
-    data
-  end
 
-  def _set(value)
-    @data = value
-  end
+    def _set(value)
+      @data = value
+    end
 
-  def _to_s()
-    @data.to_s
-  end
+    def _to_s
+      @data.to_s
+    end
 
-  def validate(v)
-    max = maxinclusive
-    min = mininclusive
-    (max.nil? or v <= max) and (min.nil? or v >= min)
-  end
+    def validate(v)
+      max = maxinclusive
+      min = mininclusive
+      (max.nil? or v <= max) and (min.nil? or v >= min)
+    end
 
-  def maxinclusive
-    nil
-  end
+    def maxinclusive
+      nil
+    end
 
-  def mininclusive
-    nil
-  end
+    def mininclusive
+      nil
+    end
 
-  PositiveMinInclusive = 1
-  def positive(v)
-    PositiveMinInclusive <= v
+    PositiveMinInclusive = 1
+    def positive(v)
+      PositiveMinInclusive <= v
+    end
   end
-end
 
-class XSDNonPositiveInteger < XSDInteger
-  Type = QName.new(Namespace, NonPositiveIntegerLiteral)
+  class XSDNonPositiveInteger < XSDInteger
+    Type = QName.new(Namespace, NonPositiveIntegerLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    0
-  end
+    def maxinclusive
+      0
+    end
 
-  def mininclusive
-    nil
+    def mininclusive
+      nil
+    end
   end
-end
 
-class XSDNegativeInteger < XSDNonPositiveInteger
-  Type = QName.new(Namespace, NegativeIntegerLiteral)
+  class XSDNegativeInteger < XSDNonPositiveInteger
+    Type = QName.new(Namespace, NegativeIntegerLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    -1
-  end
+    def maxinclusive
+      -1
+    end
 
-  def mininclusive
-    nil
+    def mininclusive
+      nil
+    end
   end
-end
 
-class XSDLong < XSDInteger
-  Type = QName.new(Namespace, LongLiteral)
+  class XSDLong < XSDInteger
+    Type = QName.new(Namespace, LongLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +9223372036854775807
-  end
+    def maxinclusive
+      +9223372036854775807
+    end
 
-  def mininclusive
-    -9223372036854775808
+    def mininclusive
+      -9223372036854775808
+    end
   end
-end
 
-class XSDInt < XSDLong
-  Type = QName.new(Namespace, IntLiteral)
+  class XSDInt < XSDLong
+    Type = QName.new(Namespace, IntLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +2147483647
-  end
+    def maxinclusive
+      +2147483647
+    end
 
-  def mininclusive
-    -2147483648
+    def mininclusive
+      -2147483648
+    end
   end
-end
 
-class XSDShort < XSDInt
-  Type = QName.new(Namespace, ShortLiteral)
+  class XSDShort < XSDInt
+    Type = QName.new(Namespace, ShortLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +32767
-  end
+    def maxinclusive
+      +32767
+    end
 
-  def mininclusive
-    -32768
+    def mininclusive
+      -32768
+    end
   end
-end
 
-class XSDByte < XSDShort
-  Type = QName.new(Namespace, ByteLiteral)
+  class XSDByte < XSDShort
+    Type = QName.new(Namespace, ByteLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +127
-  end
+    def maxinclusive
+      +127
+    end
 
-  def mininclusive
-    -128
+    def mininclusive
+      -128
+    end
   end
-end
 
-class XSDNonNegativeInteger < XSDInteger
-  Type = QName.new(Namespace, NonNegativeIntegerLiteral)
+  class XSDNonNegativeInteger < XSDInteger
+    Type = QName.new(Namespace, NonNegativeIntegerLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    nil
-  end
+    def maxinclusive
+      nil
+    end
 
-  def mininclusive
-    0
+    def mininclusive
+      0
+    end
   end
-end
 
-class XSDUnsignedLong < XSDNonNegativeInteger
-  Type = QName.new(Namespace, UnsignedLongLiteral)
+  class XSDUnsignedLong < XSDNonNegativeInteger
+    Type = QName.new(Namespace, UnsignedLongLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +18446744073709551615
-  end
+    def maxinclusive
+      +18446744073709551615
+    end
 
-  def mininclusive
-    0
+    def mininclusive
+      0
+    end
   end
-end
 
-class XSDUnsignedInt < XSDUnsignedLong
-  Type = QName.new(Namespace, UnsignedIntLiteral)
+  class XSDUnsignedInt < XSDUnsignedLong
+    Type = QName.new(Namespace, UnsignedIntLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +4294967295
-  end
+    def maxinclusive
+      +4294967295
+    end
 
-  def mininclusive
-    0
+    def mininclusive
+      0
+    end
   end
-end
 
-class XSDUnsignedShort < XSDUnsignedInt
-  Type = QName.new(Namespace, UnsignedShortLiteral)
+  class XSDUnsignedShort < XSDUnsignedInt
+    Type = QName.new(Namespace, UnsignedShortLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +65535
-  end
+    def maxinclusive
+      +65535
+    end
 
-  def mininclusive
-    0
+    def mininclusive
+      0
+    end
   end
-end
 
-class XSDUnsignedByte < XSDUnsignedShort
-  Type = QName.new(Namespace, UnsignedByteLiteral)
+  class XSDUnsignedByte < XSDUnsignedShort
+    Type = QName.new(Namespace, UnsignedByteLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    +255
-  end
+    def maxinclusive
+      +255
+    end
 
-  def mininclusive
-    0
+    def mininclusive
+      0
+    end
   end
-end
 
-class XSDPositiveInteger < XSDNonNegativeInteger
-  Type = QName.new(Namespace, PositiveIntegerLiteral)
+  class XSDPositiveInteger < XSDNonNegativeInteger
+    Type = QName.new(Namespace, PositiveIntegerLiteral)
 
-  def initialize(value = nil)
-    init(Type, value)
-  end
+    def initialize(value = nil)
+      init(Type, value)
+    end
 
-private
+    private
 
-  def maxinclusive
-    nil
-  end
+    def maxinclusive
+      nil
+    end
 
-  def mininclusive
-    1
+    def mininclusive
+      1
+    end
   end
-end
 
 
 end