Index: pyyaml/branches/working-on-emitter/lib/yaml/parser.py
===================================================================
--- pyyaml/branches/working-on-emitter/lib/yaml/parser.py	(revision 121)
+++ pyyaml/branches/working-on-emitter/lib/yaml/parser.py	(revision 127)
@@ -131,5 +131,6 @@
         # Parse start of stream.
         token = self.scanner.get()
-        yield StreamStartEvent(token.start_mark, token.end_mark)
+        yield StreamStartEvent(token.start_mark, token.end_mark,
+                encoding=token.encoding)
 
         # Parse implicit document.
@@ -139,5 +140,5 @@
             token = self.scanner.peek()
             start_mark = end_mark = token.start_mark
-            yield DocumentStartEvent(start_mark, end_mark)
+            yield DocumentStartEvent(start_mark, end_mark, implicit=True)
             for event in self.parse_block_node():
                 yield event
@@ -153,5 +154,5 @@
             token = self.scanner.peek()
             start_mark = token.start_mark
-            self.process_directives()
+            version, tags = self.process_directives()
             if not self.scanner.check(DocumentStartToken):
                 raise ParserError(None, None,
@@ -161,5 +162,6 @@
             token = self.scanner.get()
             end_mark = token.end_mark
-            yield DocumentStartEvent(start_mark, end_mark)
+            yield DocumentStartEvent(start_mark, end_mark,
+                    implicit=False, version=version, tags=tags)
             if self.scanner.check(DirectiveToken,
                     DocumentStartToken, DocumentEndToken, StreamEndToken):
@@ -202,7 +204,12 @@
                             token.start_mark)
                 self.tag_handles[handle] = prefix
+        version_value = self.yaml_version
+        tags_value = None
+        if self.tag_handles:
+            tags_value = self.tag_handles.copy()
         for key in self.DEFAULT_TAGS:
             if key not in self.tag_handles:
                 self.tag_handles[key] = self.DEFAULT_TAGS[key]
+        return version_value, tags_value
 
     def parse_block_node(self):
@@ -233,17 +240,20 @@
             if self.scanner.check(AnchorToken):
                 token = self.scanner.get()
-                start_mark = end_mark = token.start_mark
+                start_mark = token.start_mark
+                end_mark = token.end_mark
                 anchor = token.value
                 if self.scanner.check(TagToken):
                     token = self.scanner.get()
-                    end_mark = tag_mark = token.start_mark
+                    tag_mark = token.start_mark
+                    end_mark = token.end_mark
                     tag = token.value
             elif self.scanner.check(TagToken):
                 token = self.scanner.get()
-                start_mark = end_mark = tag_mark = token.start_mark
+                start_mark = tag_mark = token.start_mark
+                end_mark = token.end_mark
                 tag = token.value
                 if self.scanner.check(AnchorToken):
                     token = self.scanner.get()
-                    end_mark = token.start_mark
+                    end_mark = token.end_mark
                     anchor = token.value
             if tag is not None:
@@ -262,10 +272,11 @@
                     tag = u'!'
             if start_mark is None:
-                start_mark = self.scanner.peek().start_mark
+                start_mark = end_mark = self.scanner.peek().start_mark
             event = None
             collection_events = None
             if indentless_sequence and self.scanner.check(BlockEntryToken):
                 end_mark = self.scanner.peek().end_mark
-                event = SequenceEvent(anchor, tag, start_mark, end_mark)
+                event = SequenceEvent(anchor, tag, start_mark, end_mark,
+                        flow=False, compact=False)
                 collection_events = self.parse_indentless_sequence()
             else:
@@ -274,21 +285,33 @@
                     end_mark = token.end_mark
                     event = ScalarEvent(anchor, tag, token.value,
-                            start_mark, end_mark)
+                            start_mark, end_mark,
+                            implicit=(tag is None), style=token.style)
                 elif self.scanner.check(FlowSequenceStartToken):
                     end_mark = self.scanner.peek().end_mark
-                    event = SequenceEvent(anchor, tag, start_mark, end_mark)
+                    event = SequenceEvent(anchor, tag, start_mark, end_mark,
+                            flow=True)
                     collection_events = self.parse_flow_sequence()
                 elif self.scanner.check(FlowMappingStartToken):
                     end_mark = self.scanner.peek().end_mark
-                    event = MappingEvent(anchor, tag, start_mark, end_mark)
+                    event = MappingEvent(anchor, tag, start_mark, end_mark,
+                            flow=True)
                     collection_events = self.parse_flow_mapping()
                 elif block and self.scanner.check(BlockSequenceStartToken):
                     end_mark = self.scanner.peek().start_mark
-                    event = SequenceEvent(anchor, tag, start_mark, end_mark)
+                    compact = self.scanner.peek().inline
+                    event = SequenceEvent(anchor, tag, start_mark, end_mark,
+                            flow=False, compact=compact)
                     collection_events = self.parse_block_sequence()
                 elif block and self.scanner.check(BlockMappingStartToken):
                     end_mark = self.scanner.peek().start_mark
-                    event = MappingEvent(anchor, tag, start_mark, end_mark)
+                    compact = self.scanner.peek().inline
+                    event = MappingEvent(anchor, tag, start_mark, end_mark,
+                            flow=False, compact=compact)
                     collection_events = self.parse_block_mapping()
+                elif anchor is not None or tag is not None:
+                    # Empty scalars are allowed even if a tag or an anchor is
+                    # specified.
+                    event = ScalarEvent(anchor, tag, u'', start_mark, end_mark,
+                            implicit=False, style='')
                 else:
                     if block:
@@ -385,5 +408,6 @@
                 token = self.scanner.get()
                 yield MappingEvent(None, u'!',
-                        token.start_mark, token.end_mark)
+                        token.start_mark, token.end_mark,
+                        flow=True, compact=True)
                 if not self.scanner.check(ValueToken,
                         FlowEntryToken, FlowSequenceEndToken):
@@ -461,4 +485,4 @@
 
     def process_empty_scalar(self, mark):
-        return ScalarEvent(None, None, u'', mark, mark)
-
+        return ScalarEvent(None, None, u'', mark, mark, implicit=True)
+