RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/composer.rb

@@ -3,7 +3,7 @@ require 'rbyaml/events'
 require 'rbyaml/nodes'
 
 module RbYAML
-  class ComposerError < MarkedYAMLError
+  class ComposerError < YAMLError
   end
 
   class Composer
@@ -42,14 +42,14 @@ module RbYAML
       if @parser.peek_event.__is_alias
         event = @parser.get_event
         anchor = event.anchor
-        raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@anchors.include?(anchor)
+        raise ComposerError.new(nil, "found undefined alias #{anchor}") if !@anchors.include?(anchor)
         return @anchors[anchor]
       end
       event = @parser.peek_event
       anchor = event.anchor
       if !anchor.nil?
         if @anchors.include?(anchor)
-          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @anchors[anchor].start_mark,"second occurence", event.start_mark)
+          raise ComposerError.new("found duplicate anchor #{anchor}; first occurence","second occurence")
         end
       end
       @resolver.descend_resolver(parent,index)
@@ -68,7 +68,7 @@ module RbYAML
       event = @parser.get_event
       tag = event.tag
       tag = @resolver.resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
-      node = ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, event.style)
+      node = ScalarNode.new(tag, event.value,event.style)
       @anchors[anchor] = node if !anchor.nil?
       node
     end
@@ -77,15 +77,14 @@ module RbYAML
       start_event = @parser.get_event
       tag = start_event.tag
       tag = @resolver.resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
-      node = SequenceNode.new(tag,[],start_event.start_mark,nil,start_event.flow_style)
+      node = SequenceNode.new(tag,[],start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
       index = 0
       while !@parser.peek_event.__is_sequence_end
         node.value << compose_node(node,index)
         index += 1
       end
-      end_event = @parser.get_event
-      node.end_mark = end_event.end_mark
+      @parser.get_event
       node
     end
 
@@ -93,19 +92,18 @@ module RbYAML
       start_event = @parser.get_event
       tag = start_event.tag
       tag = @resolver.resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
-      node = MappingNode.new(tag, {},start_event.start_mark,nil,start_event.flow_style)
+      node = MappingNode.new(tag, {},start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
       while !@parser.peek_event.__is_mapping_end
         key_event = @parser.peek_event
         item_key = compose_node(node,nil)
         if node.value.include?(item_key)
-          raise ComposerError.new("while composing a mapping", start_event.start_mark,"found duplicate key", key_event.start_mark)
+          raise ComposerError.new("while composing a mapping","found duplicate key")
         end
         item_value = compose_node(node,item_key)
         node.value[item_key] = item_value
       end
-      end_event = @parser.get_event
-      node.end_mark = end_event.end_mark
+      @parser.get_event
       node
     end
   end

data/lib/rbyaml/{composer.rb.~1.2.~ → composer.rb.~1.3.~}

@@ -6,13 +6,15 @@ module RbYAML
   class ComposerError < MarkedYAMLError
   end
 
-  module Composer
-    def initialize_composer
+  class Composer
+    def initialize(parser,resolver)
+      @parser = parser
+      @resolver = resolver
       @anchors = {}
     end
 
     def check_node
-      !check_event(StreamEndEvent)
+      !@parser.peek_event.__is_stream_end
     end
 
     def get_node
@@ -25,75 +27,76 @@ module RbYAML
 
     def compose_document
       # Drop the STREAM-START event.
-      get_event if check_event(StreamStartEvent)
-      get_event
+      @parser.get_event if @parser.peek_event.__is_stream_start
+      # Drop the DOCUMENT-START event.
+      @parser.get_event
       # Compose the root node.
       node = compose_node(nil,nil)
       # Drop the DOCUMENT-END event.
-      get_event
+      @parser.get_event
       @anchors = {}
       node
     end
 
     def compose_node(parent,index)
-      if check_event(AliasEvent)
-        event = get_event
+      if @parser.peek_event.__is_alias
+        event = @parser.get_event
         anchor = event.anchor
         raise ComposerError.new(nil, nil, "found undefined alias #{anchor}", event.start_mark) if !@anchors.include?(anchor)
         return @anchors[anchor]
       end
-      event = peek_event
+      event = @parser.peek_event
       anchor = event.anchor
       if !anchor.nil?
         if @anchors.include?(anchor)
           raise ComposerError.new("found duplicate anchor #{anchor}; first occurence", @anchors[anchor].start_mark,"second occurence", event.start_mark)
         end
       end
-      descend_resolver(parent,index)
-      if check_event(ScalarEvent)
+      @resolver.descend_resolver(parent,index)
+      if @parser.peek_event.__is_scalar
         node = compose_scalar_node(anchor)
-      elsif check_event(SequenceStartEvent)
+      elsif @parser.peek_event.__is_sequence_start
         node = compose_sequence_node(anchor)
-      elsif check_event(MappingStartEvent)
+      elsif @parser.peek_event.__is_mapping_start
         node = compose_mapping_node(anchor)
       end
-      ascend_resolver
+      @resolver.ascend_resolver
       node
     end
 
     def compose_scalar_node(anchor)
-      event = get_event
+      event = @parser.get_event
       tag = event.tag
-      tag = resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(ScalarNode,event.value,event.implicit) if tag.nil? || tag == "!"
       node = ScalarNode.new(tag, event.value,event.start_mark, event.end_mark, event.style)
       @anchors[anchor] = node if !anchor.nil?
       node
     end
 
     def compose_sequence_node(anchor)
-      start_event = get_event
+      start_event = @parser.get_event
       tag = start_event.tag
-      tag = resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(SequenceNode,nil,start_event.implicit) if tag.nil? || tag == "!"
       node = SequenceNode.new(tag,[],start_event.start_mark,nil,start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
       index = 0
-      while !check_event(SequenceEndEvent)
+      while !@parser.peek_event.__is_sequence_end
         node.value << compose_node(node,index)
         index += 1
       end
-      end_event = get_event
+      end_event = @parser.get_event
       node.end_mark = end_event.end_mark
       node
     end
 
     def compose_mapping_node(anchor)
-      start_event = get_event
+      start_event = @parser.get_event
       tag = start_event.tag
-      tag = resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
+      tag = @resolver.resolve(MappingNode,nil,start_event.implicit) if tag.nil? || tag == "!"
       node = MappingNode.new(tag, {},start_event.start_mark,nil,start_event.flow_style)
       @anchors[anchor] = node if !anchor.nil?
-      while !check_event(MappingEndEvent)
-        key_event = peek_event
+      while !@parser.peek_event.__is_mapping_end
+        key_event = @parser.peek_event
         item_key = compose_node(node,nil)
         if node.value.include?(item_key)
           raise ComposerError.new("while composing a mapping", start_event.start_mark,"found duplicate key", key_event.start_mark)
@@ -101,7 +104,7 @@ module RbYAML
         item_value = compose_node(node,item_key)
         node.value[item_key] = item_value
       end
-      end_event = get_event
+      end_event = @parser.get_event
       node.end_mark = end_event.end_mark
       node
     end

data/lib/rbyaml/constants.rb

@@ -0,0 +1,95 @@
+require 'rbyaml/emitter'
+require 'rbyaml/serializer'
+require 'rbyaml/representer'
+require 'rbyaml/resolver'
+
+module RbYAML
+  #
+  # Constants
+  #
+  VERSION = '0.20'
+  SUPPORTED_YAML_VERSIONS = ['1.0','1.1']
+
+  LINE_BR_REG = /[\n\x85]|(?:\r[^\n])/
+  NON_PRINTABLE_RE = /[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\xFF]/
+
+  ENDING = /^---[\0 \t\r\n\x85]$/
+  START = /^\.\.\.[\0 \t\r\n\x85]$/
+  NULL_OR_OTHER = "\0 \t\r\n\x85"
+  #    BEG = /^([^\0 \t\r\n\x85\-?:,\[\]{}#&*!|>'"%@`]|([\-?:][^\0 \t\r\n\x85]))/    #Since current SYCK handles this one wrong, we have to allow backtick right now.
+  BEG = /^([^\0 \t\r\n\x85\-?:,\[\]{}#&*!|>'"%@]|([\-?:][^\0 \t\r\n\x85]))/    
+  NULL_OR_LINEBR = "\0\r\n\x85"
+  ALPHA_REG = /[-0-9A-Za-z_]/
+  NULL_BL_LINEBR = "\0 \r\n\x85"
+  NULL_BL_T_LINEBR = NULL_OR_OTHER
+  NON_ALPHA = /[^-0-9A-Za-z_]/   
+  NON_ALPHA_OR_NUM = "\0 \t\r\n\x85?:,]}%@`"
+  NULL_T_BL_LINEBR = NULL_OR_OTHER
+  BLANK_T = " \t"
+  PLUS_MIN = /[+-]/
+  BLANK_OR_LINEBR = " \r\n\x85"
+  FULL_LINEBR = "\r\n\x85"
+  UNESCAPES = {
+    "0"  =>   "\0",
+    "a"  =>   "\x07",
+    "b"  =>   "\x08",
+    "t"  =>   "\x09",
+    "\t" =>   "\x09",
+    "n"  =>   "\x0A",
+    "v"  =>   "\x0B",
+    "f"  =>   "\x0C",
+    "r"  =>   "\x0D",
+    "e"  =>   "\x1B",
+    " "  =>   "\x20",
+    '"'  =>   '"',
+    "\\" =>   "\\",
+    "N"  =>   "\x85",
+    "_"  =>   "\xA0"
+  }
+  
+  ESCAPE_CODES = {
+    'x' =>   2
+  }
+
+
+  ESCAPE_REPLACEMENTS = {
+    ?\0   =>   "0",
+    ?\x07 =>   "a",
+    ?\x08 =>   "b",
+    ?\x09 =>   "t",
+    ?\x0A =>   "n",
+    ?\x0B =>   "v",
+    ?\x0C =>   "f",
+    ?\x0D =>   "r",
+    ?\x1B =>   "e",
+    ?"    =>   "\"",
+    ?\\   =>   "\\",
+    ?\x85 =>   "N",
+    ?\xA0 =>   "_"
+  }
+  
+  SPACES_AND_STUFF = "'\"\\\0 \t\r\n\x85"
+  DOUBLE_ESC = "\"\\"
+  NOT_HEXA = /[^0-9A-Fa-f]/
+  R_flowzero = /[\0 \t\r\n\x85]|(:[\0 \t\r\n\x28])/
+  R_flownonzero = /[\0 \t\r\n\x85\[\]{},:?]/
+  S4 = "\0 \t\r\n\x28[]{}"
+  END_OR_START = /^(---|\.\.\.)[\0 \t\r\n\x85]$/
+  STRANGE_CHR = /[\]\[\-';\/?:@&=+$,.!~*()%\w]/
+  HEXA_REG = /[0-9A-Fa-f]/
+  
+  #
+  # Default settings
+  #
+  DEFAULTS = {
+    :Indent => 2, :UseHeader => false, :UseVersion => false, :Version => '1.1',
+    :ExplicitStart => true, :ExplicitEnd => false,
+    :SortKeys => false, :AnchorFormat => 'id%03d', :ExplicitTypes => false,
+    :Canonical => false,
+    :WidthType => 'absolute', :BestWidth => 80,
+    :UseBlock => false, :UseFold => false, :Encoding => :None,
+    :UsePlain => false, :UseSingle => false, :UseDouble => false,
+    :Emitter => RbYAML::Emitter, :Serializer => RbYAML::Serializer, 
+    :Representer => RbYAML::Representer, :Resolver => RbYAML::Resolver
+  }
+end

data/lib/rbyaml/constructor.rb

@@ -1,5 +1,7 @@
 require 'base64'
-require 'set'
+require 'date'
+
+require 'rbyaml/util'
 
 require 'rbyaml/error'
 require 'rbyaml/nodes'
@@ -13,7 +15,7 @@ end
 
 class Proc
   def __call(obj,*args)
-    call(*args)
+    call(obj,*args)
   end
 end
 
@@ -25,7 +27,7 @@ end
 
 
 module RbYAML
-  class ConstructorError < MarkedYAMLError
+  class ConstructorError < YAMLError
   end
   
   class BaseConstructor
@@ -33,6 +35,31 @@ module RbYAML
     @@yaml_multi_constructors = {}
     @@yaml_multi_regexps = {}
     
+    def get_yaml_constructor(key)
+      @@yaml_constructors[key]
+    end
+      
+    def get_yaml_multi_constructor(key)
+      @@yaml_multi_constructors[key]
+    end
+    
+    def get_yaml_multi_regexp(key)
+      @@yaml_multi_regexps[key]
+    end
+      
+    def get_yaml_multi_regexps
+      @@yaml_multi_regexps
+    end
+    
+    def self.add_constructor(tag, constructor)
+      @@yaml_constructors[tag] = constructor
+    end
+
+    def self.add_multi_constructor(tag_prefix, multi_constructor)
+      @@yaml_multi_constructors[tag_prefix] = multi_constructor
+      @@yaml_multi_regexps[tag_prefix] = Regexp.new("^"+Regexp.escape(tag_prefix))
+    end
+
     def initialize(composer)
       @composer = composer
       @constructed_objects = {}
@@ -62,107 +89,127 @@ module RbYAML
       @recursive_objects = {}
       data
     end
+
+    class RecursiveProxy
+      attr_writer :value
+      def method_missing(*args)
+        @value.send(*args)
+      end
+      def class
+        @value.class
+      end
+      def to_s
+        @value.to_s
+      end
+    end
     
     def construct_object(node)
       return @constructed_objects[node] if @constructed_objects.include?(node)
-      raise ConstructorError.new(nil,nil,"found recursive nod",node.start_mark) if @recursive_objects.include?(node)
-      @recursive_objects[node] = nil
-      constructor = @@yaml_constructors[node.tag]
+      @constructed_objects[node] = RecursiveProxy.new
+      constructor = get_yaml_constructor(node.tag)
       if !constructor
         ruby_cls = RbYAML::tagged_classes[node.tag]
         if ruby_cls && (ruby_cls.method_defined?(:yaml_initialize) || ruby_cls.respond_to?(:yaml_new))
-          constructor = lambda { |node| send(:construct_ruby_object,ruby_cls,node) }
+          constructor = lambda { |obj,node| send(:construct_ruby_object,ruby_cls,node) }
         else
           through = true
-          for tag_prefix,reg in @@yaml_multi_regexps
+          for tag_prefix,reg in get_yaml_multi_regexps
             if reg =~ node.tag
               tag_suffix = node.tag[tag_prefix.length..-1]
-              constructor = lambda { |node| @@yaml_multi_constructors[tag_prefix].__call(self,tag_suffix, node) }
+              constructor = lambda { |obj, node| get_yaml_multi_constructor(tag_prefix).__call(self,tag_suffix, node) }
               through = false
               break
             end
           end
           if through
-            ctor = @@yaml_multi_constructors[nil] || @@yaml_constructors[nil]
+            ctor = get_yaml_multi_constructor(nil)
             if ctor
-              constructor = lambda { |node| ctor.__call(self,node.tag,node) }
+              constructor = lambda { |obj, node| ctor.__call(self,node.tag,node) }
             else
-              constructor = lambda { |node| construct_primitive(node) }
+              ctor = get_yaml_constructor(nil)
+              if ctor
+                constructor = lambda { |obj, node| ctor.__call(self,node)}
+              else
+                constructor = lambda { |obj, node| construct_primitive(node) }
+              end
             end
           end
         end
       end
       data = constructor.__call(self,node)
+      @constructed_objects[node].value = data
       @constructed_objects[node] = data
-      @recursive_objects.delete(node)
       data
     end
 
     def construct_primitive(node)
       if node.__is_scalar
-        construct_scalar(node)
+        str(node)
       elsif node.__is_sequence
-        construct_sequence(node)
+        seq(node)
       elsif node.__is_mapping
-        construct_mapping(node)
+        map(node)
       else
         puts node.tag
       end
     end
     
-    def construct_scalar(node)
+    def str(node)
       if !node.__is_scalar
         if node.__is_mapping
           for key_node in node.value.keys
             if key_node.tag == "tag:yaml.org,2002:value"
-              return construct_scalar(node.value[key_node])
+              return str(node.value[key_node])
             end
           end
         end
-        raise ConstructorError.new(nil, nil,"expected a scalar node, but found #{node.tid}",node.start_mark)
+        raise ConstructorError.new(nil,"expected a scalar node, but found #{node.tid}")
       end
       node.value
     end
 
-    def construct_sequence(node)
-      raise ConstructorError.new(nil,nil,"expected a sequence node, but found #{node.tid}",node.start_mark) if !node.__is_sequence
+    def construct_private_type(node)
+      PrivateType.new(node.tag,node.value)
+    end
+
+    def seq(node)
+      raise ConstructorError.new(nil,"expected a sequence node, but found #{node.tid}") if !node.__is_sequence
       node.value.map {|child| construct_object(child) }
     end
 
-    def construct_mapping(node)
-      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !node.__is_mapping
+    def map(node)
+      raise ConstructorError.new(nil,"expected a mapping node, but found #{node.tid}") if !node.__is_mapping
       mapping = {}
       merge = nil
       for key_node,value_node in node.value
         if key_node.tag == "tag:yaml.org,2002:merge"
-          raise ConstructorError.new("while constructing a mapping", node.start_mark,"found duplicate merge key", key_node.start_mark) if !merge.nil?
+          raise ConstructorError.new("while constructing a mapping","found duplicate merge key") if !merge.nil?
           if value_node.__is_mapping
-            merge = [construct_mapping(value_node)]
+            merge = [map(value_node)]
           elsif value_node.__is_sequence
             merge = []
             for subnode in value_node.value
               if !subnode.__is_mapping
-                raise ConstructorError.new("while constructing a mapping",node.start_mark,"expected a mapping for merging, but found #{subnode.tid}", subnode.start_mark)
+                raise ConstructorError.new("while constructing a mapping","expected a mapping for merging, but found #{subnode.tid}")
               end
-              merge.unshift(construct_mapping(subnode))
+              merge.unshift(map(subnode))
             end
           else
-            raise ConstructorError.new("while constructing a mapping", node.start_mark,"expected a mapping or list of mappings for merging, but found #{value_node.tid}", value_node.start_mark)
+            raise ConstructorError.new("while constructing a mapping","expected a mapping or list of mappings for merging, but found #{value_node.tid}")
           end
         elsif key_node.tag == "tag:yaml.org,2002:value"
-          raise ConstructorError.new("while construction a mapping", node.start_mark,"found duplicate value key", key_node.start_mark) if mapping.include?("=")
+          raise ConstructorError.new("while construction a mapping","found duplicate value key") if mapping.include?("=")
           value = construct_object(value_node)
           mapping["="] = value
         else
           key = construct_object(key_node)
-#          raise ConstructorError.new("while constructing a mapping", node.start_mark,"found duplicate key", key_node.start_mark) if mapping.include?(key)
+          value = construct_object(value_node)
+          mapping[key] = value
         end
-        value = construct_object(value_node)
-        mapping[key] = value
       end
       if !merge.nil?
         merge << mapping
-        mapping = {}
+        mapping = { }
         for submapping in merge
           mapping.merge!(submapping)
         end
@@ -171,29 +218,49 @@ module RbYAML
     end
 
     def construct_pairs(node)
-      raise ConstructorError.new(nil,nil,"expected a mapping node, but found #{node.tid}",node.start_mark) if !node.__is_mapping
+      raise ConstructorError.new(nil,"expected a mapping node, but found #{node.tid}") if !node.__is_mapping
       node.value.collect {|key_node,value_node| [construct_object(key_node), construct_object(value_node)] }
     end
+  end
 
+  class SafeConstructor < BaseConstructor
+    @@yaml_safe_constructors = {}
+    @@yaml_safe_multi_constructors = {}
+    @@yaml_safe_multi_regexps = {}
+    
+    def get_yaml_constructor(key)
+      @@yaml_safe_constructors[key] || super(key)
+    end
+      
+    def get_yaml_multi_constructor(key)
+      @@yaml_safe_multi_constructors[key] || super(key)
+    end
+    
+    def get_yaml_multi_regexp(key)
+      @@yaml_safe_multi_regexps[key] || super(key)
+    end
+      
+    def get_yaml_multi_regexps
+      super.update(@@yaml_safe_multi_regexps)
+    end
+    
     def self.add_constructor(tag, constructor)
-      @@yaml_constructors[tag] = constructor
+      @@yaml_safe_constructors[tag] = constructor
     end
 
     def self.add_multi_constructor(tag_prefix, multi_constructor)
-      @@yaml_multi_constructors[tag_prefix] = multi_constructor
-      @@yaml_multi_regexps[tag_prefix] = Regexp.new("^"+Regexp.escape(tag_prefix))
+      @@yaml_safe_multi_constructors[tag_prefix] = multi_constructor
+      @@yaml_safe_multi_regexps[tag_prefix] = Regexp.new("^"+Regexp.escape(tag_prefix))
     end
-  end
 
-  class SafeConstructor < BaseConstructor
     def construct_yaml_null(node)
-      construct_scalar(node)
+      str(node)
       nil
     end
     
     BOOL_VALUES = {
-      "y" =>       true,
-      "n" =>       false,
+#      "y" =>       true,
+#      "n" =>       false,
       "yes" =>     true,
       "no" =>      false,
       "true" =>    true,
@@ -203,12 +270,12 @@ module RbYAML
     }
 
     def construct_yaml_bool(node)
-      value = construct_scalar(node)
+      value = str(node)
       BOOL_VALUES[value.downcase]
     end
     
     def construct_yaml_int(node)
-      value = construct_scalar(node).to_s
+      value = str(node).to_s
       value = value.gsub(/_/, '')
       sign = +1
       first = value[0]
@@ -249,7 +316,7 @@ module RbYAML
     NAN_VALUE = 0.0/0.0
     
     def construct_yaml_float(node)
-      value = construct_scalar(node).to_s
+      value = str(node).to_s
       value = value.gsub(/_/, '')
       sign = +1
       first = value[0]
@@ -278,15 +345,22 @@ module RbYAML
     end
 
     def construct_yaml_binary(node)
-      value = construct_scalar(node)
-      Base64.decode64(value.to_s)
+      value = str(node)
+      Base64.decode64(value.split(/[\n\x85]|(?:\r[^\n])/).to_s)
     end
 
     TIMESTAMP_REGEXP = /^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:(?:[Tt]|[ \t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\.([0-9]*))?(?:[ \t]*(?:Z|([-+][0-9][0-9]?)(?::([0-9][0-9])?)?))?)?$/
+
+    YMD_REGEXP = /^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)$/
     
     def construct_yaml_timestamp(node)
-      value = construct_scalar(node)
-      match = TIMESTAMP_REGEXP.match(node.value)
+      if (match = YMD_REGEXP.match(node.value))
+        values = match.captures.map {|val| val.to_i}
+        return Date.new(values[0],values[1],values[2])
+      end
+      unless (match = TIMESTAMP_REGEXP.match(node.value))
+        return construct_private_type(node)
+      end
       values = match.captures.map {|val| val.to_i}
       fraction = values[6]
       if fraction != 0
@@ -302,14 +376,13 @@ module RbYAML
     def construct_yaml_omap(node)
       # Note: we do not check for duplicate keys, because its too
       # CPU-expensive.
-      raise ConstructorError.new("while constructing an ordered map", node.start_mark,
-                                 "expected a sequence, but found #{node.tid}", node.start_mark) if !node.__is_sequence
+      raise ConstructorError.new("while constructing an ordered map","expected a sequence, but found #{node.tid}") if !node.__is_sequence
       omap = []
       for subnode in node.value
-        raise ConstructorError.new("while constructing an ordered map", node.start_mark,
-                                   "expected a mapping of length 1, but found #{subnode.tid}",subnode.start_mark) if !subnode.__is_mapping
-        raise ConstructorError.new("while constructing an ordered map", node.start_mark,
-                                   "expected a single mapping item, but found #{subnode.value.length} items",subnode.start_mark) if subnode.value.length != 1
+        raise ConstructorError.new("while constructing an ordered map", 
+                                   "expected a mapping of length 1, but found #{subnode.tid}") if !subnode.__is_mapping
+        raise ConstructorError.new("while constructing an ordered map",
+                                   "expected a single mapping item, but found #{subnode.value.length} items") if subnode.value.length != 1
         key_node = subnode.value.keys[0]
         key = construct_object(key_node)
         value = construct_object(subnode.value[key_node])
@@ -323,69 +396,87 @@ module RbYAML
     end
 
     def construct_yaml_set(node)
-      Set.new(construct_mapping(node).keys)
+      Set.new(map(node).keys)
     end
     
     def construct_yaml_str(node)
-      construct_scalar(node).to_s
+      val = str(node).to_s
+      val.empty? ? nil : val
     end
 
     def construct_yaml_seq(node)
-      construct_sequence(node)
+      seq(node)
     end
     
     def construct_yaml_map(node)
-      construct_mapping(node)
+      map(node)
     end
 
     def construct_yaml_object(node, cls)
-      mapping = construct_mapping(node)
+      mapping = map(node)
       data = cls.new
       mapping.each {|key,val| data.instance_variable_set("@#{key}",val)}
       data
     end
 
     def construct_undefined(node)
-      raise ConstructorError.new(nil,nil,"could not determine a constructor for the tag #{node.tag}",node.start_mark)
+      raise ConstructorError.new(nil,"could not determine a constructor for the tag #{node.tag}")
     end
+  end
+  
+  SafeConstructor.add_constructor('tag:yaml.org,2002:null',:construct_yaml_null)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:bool',:construct_yaml_bool)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:int',:construct_yaml_int)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:float',:construct_yaml_float)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:binary',:construct_yaml_binary)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:timestamp',:construct_yaml_timestamp)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:omap',:construct_yaml_omap)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:pairs',:construct_yaml_pairs)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:set',:construct_yaml_set)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:str',:construct_yaml_str)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:seq',:construct_yaml_seq)
+  SafeConstructor.add_constructor('tag:yaml.org,2002:map',:construct_yaml_map)
+  SafeConstructor.add_constructor(nil,:construct_private_type)
 
-    def construct_ruby_object(cls,node)
-      val = construct_primitive(node)
-      if cls.respond_to?(:yaml_new)
-        obj = cls.yaml_new(cls,node.tag,val)
-      else
-        obj = cls.allocate
-        obj.yaml_initialize(node.tag,val)
-      end
-      obj
+  class Constructor < SafeConstructor
+    @@yaml_main_constructors = {}
+    @@yaml_main_multi_constructors = {}
+    @@yaml_main_multi_regexps = {}
+    
+    def get_yaml_constructor(key)
+      @@yaml_main_constructors[key] || super(key)
+    end
+      
+    def get_yaml_multi_constructor(key)
+      @@yaml_main_multi_constructors[key] || super(key)
+    end
+    
+    def get_yaml_multi_regexp(key)
+      @@yaml_main_multi_regexps[key] || super(key)
+    end
+      
+    def get_yaml_multi_regexps
+      super.update(@@yaml_main_multi_regexps)
+    end
+    
+    def self.add_constructor(tag, constructor)
+      @@yaml_main_constructors[tag] = constructor
+    end
+
+    def self.add_multi_constructor(tag_prefix, multi_constructor)
+      @@yaml_main_multi_constructors[tag_prefix] = multi_constructor
+      @@yaml_main_multi_regexps[tag_prefix] = Regexp.new("^"+Regexp.escape(tag_prefix))
     end
 
     def construct_ruby(tag,node)
       obj_class = Object
       tag.split( "::" ).each { |c| obj_class = obj_class.const_get( c ) } if tag
       o = obj_class.allocate
-      mapping = construct_mapping(node)
+      mapping = map(node)
       mapping.each {|key,val| o.instance_variable_set("@#{key}",val)}
       o
     end
   end
-  
-  SafeConstructor::add_constructor('tag:yaml.org,2002:null',:construct_yaml_null)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:bool',:construct_yaml_bool)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:int',:construct_yaml_int)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:float',:construct_yaml_float)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:binary',:construct_yaml_binary)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:timestamp',:construct_yaml_timestamp)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:omap',:construct_yaml_omap)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:pairs',:construct_yaml_pairs)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:set',:construct_yaml_set)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:str',:construct_yaml_str)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:seq',:construct_yaml_seq)
-  BaseConstructor::add_constructor('tag:yaml.org,2002:map',:construct_yaml_map)
-  BaseConstructor::add_constructor(nil,:construct_undefined)
-
-  BaseConstructor::add_multi_constructor("!ruby/object:",:construct_ruby)
 
-  class Constructor < SafeConstructor
-  end
+  Constructor.add_multi_constructor("!ruby/object:",:construct_ruby)
 end