Index: /pyyaml/trunk/tests/test_yaml.py =================================================================== --- /pyyaml/trunk/tests/test_yaml.py (revision 58) +++ /pyyaml/trunk/tests/test_yaml.py (revision 116) @@ -2,5 +2,5 @@ import unittest -from test_marker import * +from test_mark import * from test_reader import * from test_canonical import * Index: /pyyaml/trunk/tests/data/test_mark.marks =================================================================== --- /pyyaml/trunk/tests/data/test_mark.marks (revision 116) +++ /pyyaml/trunk/tests/data/test_mark.marks (revision 116) @@ -0,0 +1,38 @@ +--- +*The first line. +The last line. +--- +The first*line. +The last line. +--- +The first line.* +The last line. +--- +The first line. +*The last line. +--- +The first line. +The last*line. +--- +The first line. +The last line.* +--- +The first line. +*The selected line. +The last line. +--- +The first line. +The selected*line. +The last line. +--- +The first line. +The selected line.* +The last line. +--- +*The only line. +--- +The only*line. +--- +The only line.* +--- +Loooooooooooooooooooooooooooooooooooooooooooooong*Liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine Index: yaml/trunk/tests/data/test_marker.markers =================================================================== --- /pyyaml/trunk/tests/data/test_marker.markers (revision 39) +++ (revision ) @@ -1,38 +1,0 @@ ---- -*The first line. -The last line. ---- -The first*line. -The last line. ---- -The first line.* -The last line. ---- -The first line. -*The last line. ---- -The first line. -The last*line. ---- -The first line. -The last line.* ---- -The first line. -*The selected line. -The last line. ---- -The first line. -The selected*line. -The last line. ---- -The first line. -The selected line.* -The last line. ---- -*The only line. ---- -The only*line. ---- -The only line.* ---- -Loooooooooooooooooooooooooooooooooooooooooooooong*Liiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiine Index: /pyyaml/trunk/tests/test_mark.py =================================================================== --- /pyyaml/trunk/tests/test_mark.py (revision 116) +++ /pyyaml/trunk/tests/test_mark.py (revision 116) @@ -0,0 +1,34 @@ + +import test_appliance + +from yaml.reader import Mark + +class TestMark(test_appliance.TestAppliance): + + def _testMarks(self, test_name, marks_filename): + inputs = file(marks_filename, 'rb').read().split('---\n')[1:] + for input in inputs: + index = 0 + line = 0 + column = 0 + while input[index] != '*': + if input[index] == '\n': + line += 1 + column = 0 + else: + column += 1 + index += 1 + mark = Mark(test_name, line, column, unicode(input), index) + snippet = mark.get_snippet(indent=2, max_length=79) + #print "INPUT:" + #print input + #print "SNIPPET:" + #print snippet + self.failUnless(isinstance(snippet, str)) + self.failUnlessEqual(snippet.count('\n'), 1) + data, pointer = snippet.split('\n') + self.failUnless(len(data) < 82) + self.failUnlessEqual(data[len(pointer)-1], '*') + +TestMark.add_tests('testMarks', '.marks') + Index: yaml/trunk/tests/test_marker.py =================================================================== --- /pyyaml/trunk/tests/test_marker.py (revision 47) +++ (revision ) @@ -1,34 +1,0 @@ - -import test_appliance - -from yaml.reader import Marker - -class TestMarker(test_appliance.TestAppliance): - - def _testMarkers(self, test_name, markers_filename): - inputs = file(markers_filename, 'rb').read().split('---\n')[1:] - for input in inputs: - index = 0 - line = 0 - column = 0 - while input[index] != '*': - if input[index] == '\n': - line += 1 - column = 0 - else: - column += 1 - index += 1 - marker = Marker(test_name, line, column, unicode(input), index) - snippet = marker.get_snippet(indent=2, max_length=79) - #print "INPUT:" - #print input - #print "SNIPPET:" - #print snippet - self.failUnless(isinstance(snippet, str)) - self.failUnlessEqual(snippet.count('\n'), 1) - data, pointer = snippet.split('\n') - self.failUnless(len(data) < 82) - self.failUnlessEqual(data[len(pointer)-1], '*') - -TestMarker.add_tests('testMarkers', '.markers') - Index: /pyyaml/trunk/lib/yaml/reader.py =================================================================== --- /pyyaml/trunk/lib/yaml/reader.py (revision 52) +++ /pyyaml/trunk/lib/yaml/reader.py (revision 116) @@ -4,5 +4,5 @@ # We define two classes here. # -# Marker(source, line, column) +# Mark(source, line, column) # It's just a record and its only use is producing nice error messages. # Parser does not use it for any other purposes. @@ -18,5 +18,5 @@ __all__ = ['Reader', 'ReaderError'] -from error import YAMLError, Marker +from error import YAMLError, Mark import codecs, re @@ -143,10 +143,10 @@ self.column += 1 - def get_marker(self): + def get_mark(self): if self.stream is None: - return Marker(self.name, self.line, self.column, + return Mark(self.name, self.line, self.column, self.buffer, self.pointer) else: - return Marker(self.name, self.line, self.column, None, None) + return Mark(self.name, self.line, self.column, None, None) def determine_encoding(self): Index: /pyyaml/trunk/lib/yaml/tokens.py =================================================================== --- /pyyaml/trunk/lib/yaml/tokens.py (revision 52) +++ /pyyaml/trunk/lib/yaml/tokens.py (revision 116) @@ -1,10 +1,10 @@ class Token: - def __init__(self, start_marker, end_marker): - self.start_marker = start_marker - self.end_marker = end_marker + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark def __repr__(self): attributes = [key for key in self.__dict__ - if not key.endswith('_marker')] + if not key.endswith('_mark')] attributes.sort() arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) @@ -17,9 +17,9 @@ class DirectiveToken(Token): id = '' - def __init__(self, name, value, start_marker, end_marker): + def __init__(self, name, value, start_mark, end_mark): self.name = name self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class DocumentStartToken(Token): @@ -67,29 +67,29 @@ class AliasToken(Token): id = '' - def __init__(self, value, start_marker, end_marker): + def __init__(self, value, start_mark, end_mark): self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class AnchorToken(Token): id = '' - def __init__(self, value, start_marker, end_marker): + def __init__(self, value, start_mark, end_mark): self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class TagToken(Token): id = '' - def __init__(self, value, start_marker, end_marker): + def __init__(self, value, start_mark, end_mark): self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class ScalarToken(Token): id = '' - def __init__(self, value, plain, start_marker, end_marker): + def __init__(self, value, plain, start_mark, end_mark): self.value = value self.plain = plain - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark Index: /pyyaml/trunk/lib/yaml/events.py =================================================================== --- /pyyaml/trunk/lib/yaml/events.py (revision 53) +++ /pyyaml/trunk/lib/yaml/events.py (revision 116) @@ -1,10 +1,10 @@ class Event: - def __init__(self, start_marker, end_marker): - self.start_marker = start_marker - self.end_marker = end_marker + def __init__(self, start_mark, end_mark): + self.start_mark = start_mark + self.end_mark = end_mark def __repr__(self): attributes = [key for key in self.__dict__ - if not key.endswith('_marker')] + if not key.endswith('_mark')] attributes.sort() arguments = ', '.join(['%s=%r' % (key, getattr(self, key)) @@ -13,8 +13,8 @@ class NodeEvent(Event): - def __init__(self, anchor, start_marker, end_marker): + def __init__(self, anchor, start_mark, end_mark): self.anchor = anchor - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class AliasEvent(NodeEvent): @@ -22,17 +22,17 @@ class ScalarEvent(NodeEvent): - def __init__(self, anchor, tag, value, start_marker, end_marker): + def __init__(self, anchor, tag, value, start_mark, end_mark): self.anchor = anchor self.tag = tag self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class CollectionEvent(NodeEvent): - def __init__(self, anchor, tag, start_marker, end_marker): + def __init__(self, anchor, tag, start_mark, end_mark): self.anchor = anchor self.tag = tag - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark class SequenceEvent(CollectionEvent): Index: /pyyaml/trunk/lib/yaml/constructor.py =================================================================== --- /pyyaml/trunk/lib/yaml/constructor.py (revision 59) +++ /pyyaml/trunk/lib/yaml/constructor.py (revision 116) @@ -71,5 +71,5 @@ raise ConstructorError(None, None, "expected a scalar node, but found %s" % node.id, - node.start_marker) + node.start_mark) return node.value @@ -78,5 +78,5 @@ raise ConstructorError(None, None, "expected a sequence node, but found %s" % node.id, - node.start_marker) + node.start_mark) return [self.construct_object(child) for child in node.value] @@ -85,5 +85,5 @@ raise ConstructorError(None, None, "expected a mapping node, but found %s" % node.id, - node.start_marker) + node.start_mark) mapping = {} merge = None @@ -91,6 +91,6 @@ if key_node.tag == u'tag:yaml.org,2002:merge': if merge is not None: - raise ConstructorError("while constructing a mapping", node.start_marker, - "found duplicate merge key", key_node.start_marker) + raise ConstructorError("while constructing a mapping", node.start_mark, + "found duplicate merge key", key_node.start_mark) value_node = node.value[key_node] if isinstance(value_node, MappingNode): @@ -101,17 +101,17 @@ if not isinstance(subnode, MappingNode): raise ConstructorError("while constructing a mapping", - node.start_marker, + node.start_mark, "expected a mapping for merging, but found %s" - % subnode.id, subnode.start_marker) + % subnode.id, subnode.start_mark) merge.append(self.construct_mapping(subnode)) merge.reverse() else: - raise ConstructorError("while constructing a mapping", node.start_marker, + raise ConstructorError("while constructing a mapping", node.start_mark, "expected a mapping or list of mappings for merging, but found %s" - % value_node.id, value_node.start_marker) + % value_node.id, value_node.start_mark) elif key_node.tag == u'tag:yaml.org,2002:value': if '=' in mapping: - raise ConstructorError("while construction a mapping", node.start_marker, - "found duplicate value key", key_node.start_marker) + raise ConstructorError("while construction a mapping", node.start_mark, + "found duplicate value key", key_node.start_mark) value = self.construct_object(node.value[key_node]) mapping['='] = value @@ -121,9 +121,9 @@ duplicate_key = key in mapping except TypeError, exc: - raise ConstructorError("while constructing a mapping", node.start_marker, - "found unacceptable key (%s)" % exc, key_node.start_marker) + raise ConstructorError("while constructing a mapping", node.start_mark, + "found unacceptable key (%s)" % exc, key_node.start_mark) if duplicate_key: - raise ConstructorError("while constructing a mapping", node.start_marker, - "found duplicate key", key_node.start_marker) + raise ConstructorError("while constructing a mapping", node.start_mark, + "found duplicate key", key_node.start_mark) value = self.construct_object(node.value[key_node]) mapping[key] = value @@ -139,5 +139,5 @@ raise ConstructorError(None, None, "expected a mapping node, but found %s" % node.id, - node.start_marker) + node.start_mark) pairs = [] for key_node in node.value: @@ -235,5 +235,5 @@ except (binascii.Error, UnicodeEncodeError), exc: raise ConstructorError(None, None, - "failed to decode base64 data: %s" % exc, node.start_marker) + "failed to decode base64 data: %s" % exc, node.start_mark) timestamp_regexp = re.compile( @@ -272,16 +272,16 @@ # CPU-expensive. if not isinstance(node, SequenceNode): - raise ConstructorError("while constructing an ordered map", node.start_marker, - "expected a sequence, but found %s" % node.id, node.start_marker) + raise ConstructorError("while constructing an ordered map", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) omap = [] for subnode in node.value: if not isinstance(subnode, MappingNode): - raise ConstructorError("while constructing an ordered map", node.start_marker, + raise ConstructorError("while constructing an ordered map", node.start_mark, "expected a mapping of length 1, but found %s" % subnode.id, - subnode.start_marker) + subnode.start_mark) if len(subnode.value) != 1: - raise ConstructorError("while constructing an ordered map", node.start_marker, + raise ConstructorError("while constructing an ordered map", node.start_mark, "expected a single mapping item, but found %d items" % len(subnode.value), - subnode.start_marker) + subnode.start_mark) key_node = subnode.value.keys()[0] key = self.construct_object(key_node) @@ -293,16 +293,16 @@ # Note: the same code as `construct_yaml_omap`. if not isinstance(node, SequenceNode): - raise ConstructorError("while constructing pairs", node.start_marker, - "expected a sequence, but found %s" % node.id, node.start_marker) + raise ConstructorError("while constructing pairs", node.start_mark, + "expected a sequence, but found %s" % node.id, node.start_mark) pairs = [] for subnode in node.value: if not isinstance(subnode, MappingNode): - raise ConstructorError("while constructing pairs", node.start_marker, + raise ConstructorError("while constructing pairs", node.start_mark, "expected a mapping of length 1, but found %s" % subnode.id, - subnode.start_marker) + subnode.start_mark) if len(subnode.value) != 1: - raise ConstructorError("while constructing pairs", node.start_marker, + raise ConstructorError("while constructing pairs", node.start_mark, "expected a single mapping item, but found %d items" % len(subnode.value), - subnode.start_marker) + subnode.start_mark) key_node = subnode.value.keys()[0] key = self.construct_object(key_node) @@ -331,5 +331,5 @@ raise ConstructorError(None, None, "could not determine a constructor for the tag %r" % node.tag.encode('utf-8'), - node.start_marker) + node.start_mark) Constructor.add_constructor( @@ -403,5 +403,5 @@ raise ConstructorError(None, None, "found undefined constructor for the tag %r" - % node.tag.encode('utf-8'), node.start_marker) + % node.tag.encode('utf-8'), node.start_mark) from_yaml = classmethod(from_yaml) Index: /pyyaml/trunk/lib/yaml/composer.py =================================================================== --- /pyyaml/trunk/lib/yaml/composer.py (revision 57) +++ /pyyaml/trunk/lib/yaml/composer.py (revision 116) @@ -42,11 +42,11 @@ if anchor not in self.all_anchors: raise ComposerError(None, None, "found undefined alias %r" - % anchor.encode('utf-8'), event.start_marker) + % anchor.encode('utf-8'), event.start_mark) if anchor not in self.complete_anchors: collection_event = self.all_anchors[anchor] raise ComposerError("while composing a collection", - collection_event.start_marker, + collection_event.start_mark, "found recursive anchor %r" % anchor.encode('utf-8'), - event.start_marker) + event.start_mark) return self.complete_anchors[anchor] event = self.parser.peek() @@ -55,6 +55,6 @@ if anchor in self.all_anchors: raise ComposerError("found duplicate anchor %r; first occurence" - % anchor.encode('utf-8'), self.all_anchors[anchor].start_marker, - "second occurence", event.start_marker) + % anchor.encode('utf-8'), self.all_anchors[anchor].start_mark, + "second occurence", event.start_mark) self.all_anchors[anchor] = event if self.parser.check(ScalarEvent): @@ -71,5 +71,5 @@ event = self.parser.get() return ScalarNode(event.tag, event.value, - event.start_marker, event.end_marker) + event.start_mark, event.end_mark) def compose_sequence_node(self): @@ -80,5 +80,5 @@ end_event = self.parser.get() return SequenceNode(start_event.tag, value, - start_event.start_marker, end_event.end_marker) + start_event.start_mark, end_event.end_mark) def compose_mapping_node(self): @@ -90,9 +90,9 @@ item_value = self.compose_node() if item_key in value: - raise ComposerError("while composing a mapping", start_event.start_marker, - "found duplicate key", key_event.start_marker) + raise ComposerError("while composing a mapping", start_event.start_mark, + "found duplicate key", key_event.start_mark) value[item_key] = item_value end_event = self.parser.get() return MappingNode(start_event.tag, value, - start_event.start_marker, end_event.end_marker) + start_event.start_mark, end_event.end_mark) Index: /pyyaml/trunk/lib/yaml/nodes.py =================================================================== --- /pyyaml/trunk/lib/yaml/nodes.py (revision 55) +++ /pyyaml/trunk/lib/yaml/nodes.py (revision 116) @@ -1,9 +1,9 @@ class Node: - def __init__(self, tag, value, start_marker, end_marker): + def __init__(self, tag, value, start_mark, end_mark): self.tag = tag self.value = value - self.start_marker = start_marker - self.end_marker = end_marker + self.start_mark = start_mark + self.end_mark = end_mark def __repr__(self): value = self.value Index: /pyyaml/trunk/lib/yaml/error.py =================================================================== --- /pyyaml/trunk/lib/yaml/error.py (revision 53) +++ /pyyaml/trunk/lib/yaml/error.py (revision 116) @@ -1,6 +1,6 @@ -__all__ = ['Marker', 'YAMLError', 'MarkedYAMLError'] +__all__ = ['Mark', 'YAMLError', 'MarkedYAMLError'] -class Marker: +class Mark: def __init__(self, name, line, column, buffer, pointer): @@ -47,31 +47,31 @@ class MarkedYAMLError(YAMLError): - def __init__(self, context=None, context_marker=None, - problem=None, problem_marker=None): + def __init__(self, context=None, context_mark=None, + problem=None, problem_mark=None): self.context = context - self.context_marker = context_marker + self.context_mark = context_mark self.problem = problem - self.problem_marker = problem_marker + self.problem_mark = problem_mark def __str__(self): lines = [] - #for (place, marker) in [(self.context, self.context_marker), - # (self.problem, self.problem_marker)]: + #for (place, mark) in [(self.context, self.context_mark), + # (self.problem, self.problem_mark)]: # if place is not None: # lines.append(place) - # if marker is not None: - # lines.append(str(marker)) + # if mark is not None: + # lines.append(str(mark)) if self.context is not None: lines.append(self.context) - if self.context_marker is not None \ - and (self.problem is None or self.problem_marker is None - or self.context_marker.name != self.problem_marker.name - or self.context_marker.line != self.problem_marker.line - or self.context_marker.column != self.problem_marker.column): - lines.append(str(self.context_marker)) + if self.context_mark is not None \ + and (self.problem is None or self.problem_mark is None + or self.context_mark.name != self.problem_mark.name + or self.context_mark.line != self.problem_mark.line + or self.context_mark.column != self.problem_mark.column): + lines.append(str(self.context_mark)) if self.problem is not None: lines.append(self.problem) - if self.problem_marker is not None: - lines.append(str(self.problem_marker)) + if self.problem_mark is not None: + lines.append(str(self.problem_mark)) return '\n'.join(lines) Index: /pyyaml/trunk/lib/yaml/scanner.py =================================================================== --- /pyyaml/trunk/lib/yaml/scanner.py (revision 60) +++ /pyyaml/trunk/lib/yaml/scanner.py (revision 116) @@ -35,5 +35,5 @@ # See below simple keys treatment. - def __init__(self, token_number, required, index, line, column, marker): + def __init__(self, token_number, required, index, line, column, mark): self.token_number = token_number self.required = required @@ -41,5 +41,5 @@ self.line = line self.column = column - self.marker = marker + self.mark = mark class Scanner: @@ -103,5 +103,5 @@ # is `flow_level`; there can be no more that one possible simple key # for each level. The value is a SimpleKey record: - # (token_number, required, index, line, column, marker) + # (token_number, required, index, line, column, mark) # A simple key may start with ALIAS, ANCHOR, TAG, SCALAR(flow), # '[', or '{' tokens. @@ -262,5 +262,5 @@ raise ScannerError("while scanning for the next token", None, "found character %r that cannot start any token" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) # Simple keys treatment. @@ -293,6 +293,6 @@ or self.reader.index-key.index > 1024: if key.required: - raise ScannerError("while scanning a simple key", key.marker, - "could not found expected ':'", self.reader.get_marker()) + raise ScannerError("while scanning a simple key", key.mark, + "could not found expected ':'", self.reader.get_mark()) del self.possible_simple_keys[level] @@ -317,7 +317,7 @@ line = self.reader.line column = self.reader.column - marker = self.reader.get_marker() + mark = self.reader.get_mark() key = SimpleKey(token_number, required, - index, line, column, marker) + index, line, column, mark) self.possible_simple_keys[self.flow_level] = key @@ -330,6 +330,6 @@ assert not key.required #if key.required: - # raise ScannerError("while scanning a simple key", key.marker, - # "could not found expected ':'", self.reader.get_marker()) + # raise ScannerError("while scanning a simple key", key.mark, + # "could not found expected ':'", self.reader.get_mark()) # Indentation functions. @@ -346,11 +346,11 @@ raise ScannerError(None, None, "invalid intendation or unclosed '[' or '{'", - self.reader.get_marker()) + self.reader.get_mark()) # In block context, we may need to issue the BLOCK-END tokens. while self.indent > column: - marker = self.reader.get_marker() + mark = self.reader.get_mark() self.indent = self.indents.pop() - self.tokens.append(BlockEndToken(marker, marker)) + self.tokens.append(BlockEndToken(mark, mark)) def add_indent(self, column): @@ -374,8 +374,8 @@ # Read the token. - marker = self.reader.get_marker() + mark = self.reader.get_mark() # Add END. - self.tokens.append(StreamEndToken(marker, marker)) + self.tokens.append(StreamEndToken(mark, mark)) # The reader is ended. @@ -411,8 +411,8 @@ # Add DOCUMENT-START or DOCUMENT-END. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward(3) - end_marker = self.reader.get_marker() - self.tokens.append(TokenClass(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_sequence_start(self): @@ -434,8 +434,8 @@ # Add FLOW-SEQUENCE-START or FLOW-MAPPING-START. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(TokenClass(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_sequence_end(self): @@ -457,8 +457,8 @@ # Add FLOW-SEQUENCE-END or FLOW-MAPPING-END. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(TokenClass(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(TokenClass(start_mark, end_mark)) def fetch_flow_entry(self): @@ -471,8 +471,8 @@ # Add FLOW-ENTRY. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(FlowEntryToken(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(FlowEntryToken(start_mark, end_mark)) def fetch_block_entry(self): @@ -485,10 +485,10 @@ raise ScannerError(None, None, "sequence entries are not allowed here", - self.reader.get_marker()) + self.reader.get_mark()) # We may need to add BLOCK-SEQUENCE-START. if self.add_indent(self.reader.column): - marker = self.reader.get_marker() - self.tokens.append(BlockSequenceStartToken(marker, marker)) + mark = self.reader.get_mark() + self.tokens.append(BlockSequenceStartToken(mark, mark)) # It's an error for the block entry to occur in the flow context, @@ -504,8 +504,8 @@ # Add BLOCK-ENTRY. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(BlockEntryToken(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(BlockEntryToken(start_mark, end_mark)) def fetch_key(self): @@ -518,10 +518,10 @@ raise ScannerError(None, None, "mapping keys are not allowed here", - self.reader.get_marker()) + self.reader.get_mark()) # We may need to add BLOCK-MAPPING-START. if self.add_indent(self.reader.column): - marker = self.reader.get_marker() - self.tokens.append(BlockMappingStartToken(marker, marker)) + mark = self.reader.get_mark() + self.tokens.append(BlockMappingStartToken(mark, mark)) # Simple keys are allowed after '?' in the block context. @@ -532,8 +532,8 @@ # Add KEY. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(KeyToken(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(KeyToken(start_mark, end_mark)) def fetch_value(self): @@ -546,5 +546,5 @@ del self.possible_simple_keys[self.flow_level] self.tokens.insert(key.token_number-self.tokens_taken, - KeyToken(key.marker, key.marker)) + KeyToken(key.mark, key.mark)) # If this key starts a new block mapping, we need to add @@ -553,5 +553,5 @@ if self.add_indent(key.column): self.tokens.insert(key.token_number-self.tokens_taken, - BlockMappingStartToken(key.marker, key.marker)) + BlockMappingStartToken(key.mark, key.mark)) # There cannot be two simple keys one after another. @@ -571,5 +571,5 @@ raise ScannerError(None, None, "mapping values are not allowed here", - self.reader.get_marker()) + self.reader.get_mark()) # Simple keys are allowed after ':' in the block context. @@ -580,8 +580,8 @@ # Add VALUE. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - end_marker = self.reader.get_marker() - self.tokens.append(ValueToken(start_marker, end_marker)) + end_mark = self.reader.get_mark() + self.tokens.append(ValueToken(start_mark, end_mark)) def fetch_alias(self): @@ -774,22 +774,22 @@ def scan_directive(self): # See the specification for details. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() self.reader.forward() - name = self.scan_directive_name(start_marker) + name = self.scan_directive_name(start_mark) value = None if name == u'YAML': - value = self.scan_yaml_directive_value(start_marker) - end_marker = self.reader.get_marker() + value = self.scan_yaml_directive_value(start_mark) + end_mark = self.reader.get_mark() elif name == u'TAG': - value = self.scan_tag_directive_value(start_marker) - end_marker = self.reader.get_marker() + value = self.scan_tag_directive_value(start_mark) + end_mark = self.reader.get_mark() else: - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() while self.reader.peek() not in u'\0\r\n\x85\u2028\u2029': self.reader.forward() - self.scan_directive_ignored_line(start_marker) - return DirectiveToken(name, value, start_marker, end_marker) - - def scan_directive_name(self, start_marker): + self.scan_directive_ignored_line(start_mark) + return DirectiveToken(name, value, start_mark, end_mark) + + def scan_directive_name(self, start_mark): # See the specification for details. length = 0 @@ -800,42 +800,42 @@ ch = self.reader.peek(length) if not length: - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected alphabetic or numeric character, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) value = self.reader.prefix(length) self.reader.forward(length) ch = self.reader.peek() if ch not in u'\0 \r\n\x85\u2028\u2029': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected alphabetic or numeric character, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) return value - def scan_yaml_directive_value(self, start_marker): + def scan_yaml_directive_value(self, start_mark): # See the specification for details. while self.reader.peek() == u' ': self.reader.forward() - major = self.scan_yaml_directive_number(start_marker) + major = self.scan_yaml_directive_number(start_mark) if self.reader.peek() != '.': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected a digit or '.', but found %r" % self.reader.peek().encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) self.reader.forward() - minor = self.scan_yaml_directive_number(start_marker) + minor = self.scan_yaml_directive_number(start_mark) if self.reader.peek() not in u'\0 \r\n\x85\u2028\u2029': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected a digit or ' ', but found %r" % self.reader.peek().encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) return (major, minor) - def scan_yaml_directive_number(self, start_marker): + def scan_yaml_directive_number(self, start_mark): # See the specification for details. ch = self.reader.peek() if not (u'0' <= ch <= '9'): - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected a digit, but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) length = 0 while u'0' <= self.reader.peek(length) <= u'9': @@ -845,35 +845,35 @@ return value - def scan_tag_directive_value(self, start_marker): + def scan_tag_directive_value(self, start_mark): # See the specification for details. while self.reader.peek() == u' ': self.reader.forward() - handle = self.scan_tag_directive_handle(start_marker) + handle = self.scan_tag_directive_handle(start_mark) while self.reader.peek() == u' ': self.reader.forward() - prefix = self.scan_tag_directive_prefix(start_marker) + prefix = self.scan_tag_directive_prefix(start_mark) return (handle, prefix) - def scan_tag_directive_handle(self, start_marker): - # See the specification for details. - value = self.scan_tag_handle('directive', start_marker) + def scan_tag_directive_handle(self, start_mark): + # See the specification for details. + value = self.scan_tag_handle('directive', start_mark) ch = self.reader.peek() if ch != u' ': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected ' ', but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) return value - def scan_tag_directive_prefix(self, start_marker): - # See the specification for details. - value = self.scan_tag_uri('directive', start_marker) + def scan_tag_directive_prefix(self, start_mark): + # See the specification for details. + value = self.scan_tag_uri('directive', start_mark) ch = self.reader.peek() if ch not in u'\0 \r\n\x85\u2028\u2029': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected ' ', but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) return value - def scan_directive_ignored_line(self, start_marker): + def scan_directive_ignored_line(self, start_mark): # See the specification for details. while self.reader.peek() == u' ': @@ -884,7 +884,7 @@ ch = self.reader.peek() if ch not in u'\0\r\n\x85\u2028\u2029': - raise ScannerError("while scanning a directive", start_marker, + raise ScannerError("while scanning a directive", start_mark, "expected a comment or a line break, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) self.scan_line_break() @@ -898,5 +898,5 @@ # [ *alias , "value" ] # Therefore we restrict aliases to numbers and ASCII letters. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() indicator = self.reader.peek() if indicator == '*': @@ -912,29 +912,29 @@ ch = self.reader.peek(length) if not length: - raise ScannerError("while scanning an %s" % name, start_marker, + raise ScannerError("while scanning an %s" % name, start_mark, "expected alphabetic or numeric character, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) value = self.reader.prefix(length) self.reader.forward(length) ch = self.reader.peek() if ch not in u'\0 \t\r\n\x85\u2028\u2029?:,]}%@`': - raise ScannerError("while scanning an %s" % name, start_marker, + raise ScannerError("while scanning an %s" % name, start_mark, "expected alphabetic or numeric character, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) - end_marker = self.reader.get_marker() - return TokenClass(value, start_marker, end_marker) + % ch.encode('utf-8'), self.reader.get_mark()) + end_mark = self.reader.get_mark() + return TokenClass(value, start_mark, end_mark) def scan_tag(self): # See the specification for details. - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() ch = self.reader.peek(1) if ch == u'<': handle = None self.reader.forward(2) - suffix = self.scan_tag_uri('tag', start_marker) + suffix = self.scan_tag_uri('tag', start_mark) if self.reader.peek() != u'>': - raise ScannerError("while parsing a tag", start_marker, + raise ScannerError("while parsing a tag", start_mark, "expected '>', but found %r" % self.reader.peek().encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) self.reader.forward() elif ch in u'\0 \t\r\n\x85\u2028\u2029': @@ -953,17 +953,17 @@ handle = u'!' if use_handle: - handle = self.scan_tag_handle('tag', start_marker) + handle = self.scan_tag_handle('tag', start_mark) else: handle = u'!' self.reader.forward() - suffix = self.scan_tag_uri('tag', start_marker) + suffix = self.scan_tag_uri('tag', start_mark) ch = self.reader.peek() if ch not in u'\0 \r\n\x85\u2028\u2029': - raise ScannerError("while scanning a tag", start_marker, + raise ScannerError("while scanning a tag", start_mark, "expected ' ', but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) value = (handle, suffix) - end_marker = self.reader.get_marker() - return TagToken(value, start_marker, end_marker) + end_mark = self.reader.get_mark() + return TagToken(value, start_mark, end_mark) def scan_block_scalar(self, folded): @@ -971,10 +971,10 @@ chunks = [] - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() # Scan the header. self.reader.forward() - chomping, increment = self.scan_block_scalar_indicators(start_marker) - self.scan_block_scalar_ignored_line(start_marker) + chomping, increment = self.scan_block_scalar_indicators(start_mark) + self.scan_block_scalar_ignored_line(start_mark) # Determine the indentation level and go to the first non-empty line. @@ -983,9 +983,9 @@ min_indent = 1 if increment is None: - breaks, max_indent, end_marker = self.scan_block_scalar_indentation() + breaks, max_indent, end_mark = self.scan_block_scalar_indentation() indent = max(min_indent, max_indent) else: indent = min_indent+increment-1 - breaks, end_marker = self.scan_block_scalar_breaks(indent) + breaks, end_mark = self.scan_block_scalar_breaks(indent) line_break = u'' @@ -1000,5 +1000,5 @@ self.reader.forward(length) line_break = self.scan_line_break() - breaks, end_marker = self.scan_block_scalar_breaks(indent) + breaks, end_mark = self.scan_block_scalar_breaks(indent) if self.reader.column == indent and self.reader.peek() != u'\0': # Unfortunately, folding rules are ambiguous. @@ -1034,7 +1034,7 @@ # We are done. - return ScalarToken(u''.join(chunks), False, start_marker, end_marker) - - def scan_block_scalar_indicators(self, start_marker): + return ScalarToken(u''.join(chunks), False, start_mark, end_mark) + + def scan_block_scalar_indicators(self, start_mark): # See the specification for details. chomping = None @@ -1051,14 +1051,14 @@ increment = int(ch) if increment == 0: - raise ScannerError("while scanning a block scalar", start_marker, + raise ScannerError("while scanning a block scalar", start_mark, "expected indentation indicator in the range 1-9, but found 0", - self.reader.get_marker()) + self.reader.get_mark()) self.reader.forward() elif ch in u'0123456789': increment = int(ch) if increment == 0: - raise ScannerError("while scanning a block scalar", start_marker, + raise ScannerError("while scanning a block scalar", start_mark, "expected indentation indicator in the range 1-9, but found 0", - self.reader.get_marker()) + self.reader.get_mark()) self.reader.forward() ch = self.reader.peek() @@ -1071,10 +1071,10 @@ ch = self.reader.peek() if ch not in u'\0 \r\n\x85\u2028\u2029': - raise ScannerError("while scanning a block scalar", start_marker, + raise ScannerError("while scanning a block scalar", start_mark, "expected chomping or indentation indicators, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) return chomping, increment - def scan_block_scalar_ignored_line(self, start_marker): + def scan_block_scalar_ignored_line(self, start_mark): # See the specification for details. while self.reader.peek() == u' ': @@ -1085,7 +1085,7 @@ ch = self.reader.peek() if ch not in u'\0\r\n\x85\u2028\u2029': - raise ScannerError("while scanning a block scalar", start_marker, + raise ScannerError("while scanning a block scalar", start_mark, "expected a comment or a line break, but found %r" - % ch.encode('utf-8'), self.reader.get_marker()) + % ch.encode('utf-8'), self.reader.get_mark()) self.scan_line_break() @@ -1094,32 +1094,32 @@ chunks = [] max_indent = 0 - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() while self.reader.peek() in u' \r\n\x85\u2028\u2029': if self.reader.peek() != u' ': chunks.append(self.scan_line_break()) - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() else: self.reader.forward() if self.reader.column > max_indent: max_indent = self.reader.column - return chunks, max_indent, end_marker + return chunks, max_indent, end_mark def scan_block_scalar_breaks(self, indent): # See the specification for details. chunks = [] - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() while self.reader.column < indent and self.reader.peek() == u' ': self.reader.forward() while self.reader.peek() in u'\r\n\x85\u2028\u2029': chunks.append(self.scan_line_break()) - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() while self.reader.column < indent and self.reader.peek() == u' ': self.reader.forward() - return chunks, end_marker + return chunks, end_mark def scan_flow_scalar(self, double): # See the specification for details. chunks = [] - start_marker = self.reader.get_marker() + start_mark = self.reader.get_mark() indent = self.indent+1 if indent == 0: @@ -1127,11 +1127,11 @@ quote = self.reader.peek() self.reader.forward() - chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_marker)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_mark)) while self.reader.peek() != quote: - chunks.extend(self.scan_flow_scalar_spaces(double, indent, start_marker)) - chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_marker)) + chunks.extend(self.scan_flow_scalar_spaces(double, indent, start_mark)) + chunks.extend(self.scan_flow_scalar_non_spaces(double, indent, start_mark)) self.reader.forward() - end_marker = self.reader.get_marker() - return ScalarToken(u''.join(chunks), False, start_marker, end_marker) + end_mark = self.reader.get_mark() + return ScalarToken(u''.join(chunks), False, start_mark, end_mark) ESCAPE_REPLACEMENTS = { @@ -1161,5 +1161,5 @@ } - def scan_flow_scalar_non_spaces(self, double, indent, start_marker): + def scan_flow_scalar_non_spaces(self, double, indent, start_mark): # See the specification for details. chunks = [] @@ -1189,7 +1189,7 @@ for k in range(length): if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': - raise ScannerError("while scanning a double-quoted scalar", start_marker, + raise ScannerError("while scanning a double-quoted scalar", start_mark, "expected escape sequence of %d hexdecimal numbers, but found %r" % - (length, self.reader.peek(k).encode('utf-8')), self.reader.get_marker()) + (length, self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) code = int(self.reader.prefix(length), 16) chunks.append(unichr(code)) @@ -1197,12 +1197,12 @@ elif ch in u'\r\n\x85\u2028\u2029': self.scan_line_break() - chunks.extend(self.scan_flow_scalar_breaks(double, indent, start_marker)) + chunks.extend(self.scan_flow_scalar_breaks(double, indent, start_mark)) else: - raise ScannerError("while scanning a double-quoted scalar", start_marker, - "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_marker()) + raise ScannerError("while scanning a double-quoted scalar", start_mark, + "found unknown escape character %r" % ch.encode('utf-8'), self.reader.get_mark()) else: return chunks - def scan_flow_scalar_spaces(self, double, indent, start_marker): + def scan_flow_scalar_spaces(self, double, indent, start_mark): # See the specification for details. chunks = [] @@ -1214,9 +1214,9 @@ ch = self.reader.peek() if ch == u'\0': - raise ScannerError("while scanning a quoted scalar", start_marker, - "found unexpected end of stream", self.reader.get_marker()) + raise ScannerError("while scanning a quoted scalar", start_mark, + "found unexpected end of stream", self.reader.get_mark()) elif ch in u'\r\n\x85\u2028\u2029': line_break = self.scan_line_break() - breaks = self.scan_flow_scalar_breaks(double, indent, start_marker) + breaks = self.scan_flow_scalar_breaks(double, indent, start_mark) if line_break != u'\n': chunks.append(line_break) @@ -1228,5 +1228,5 @@ return chunks - def scan_flow_scalar_breaks(self, double, indent, start_marker): + def scan_flow_scalar_breaks(self, double, indent, start_mark): # See the specification for details. chunks = [] @@ -1239,8 +1239,8 @@ if indent == 1: s = '' - raise ScannerError("while scanning a quoted scalar", start_marker, + raise ScannerError("while scanning a quoted scalar", start_mark, "expected %d space%s indentation, but found %r" % (indent, s, self.reader.peek().encode('utf-8')), - self.reader.get_marker()) + self.reader.get_mark()) while self.reader.peek() in u' \t': self.reader.forward() @@ -1256,6 +1256,6 @@ # We also keep track of the `allow_simple_key` flag here. chunks = [] - start_marker = self.reader.get_marker() - end_marker = start_marker + start_mark = self.reader.get_mark() + end_mark = start_mark indent = self.indent+1 if indent == 0: @@ -1280,10 +1280,10 @@ chunks.append(self.reader.prefix(length)) self.reader.forward(length) - end_marker = self.reader.get_marker() + end_mark = self.reader.get_mark() spaces = self.scan_plain_spaces(indent) if not spaces or self.reader.peek() == u'#' \ or self.reader.column < indent: break - return ScalarToken(u''.join(chunks), True, start_marker, end_marker) + return ScalarToken(u''.join(chunks), True, start_mark, end_mark) def scan_plain_spaces(self, indent): @@ -1316,5 +1316,5 @@ return chunks - def scan_tag_handle(self, name, start_marker): + def scan_tag_handle(self, name, start_mark): # See the specification for details. # For some strange reasons, the specification does not allow '_' in @@ -1322,7 +1322,7 @@ ch = self.reader.peek() if ch != u'!': - raise ScannerError("while scanning a %s" % name, start_marker, + raise ScannerError("while scanning a %s" % name, start_mark, "expected '!', but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) length = 1 ch = self.reader.peek(length) @@ -1334,7 +1334,7 @@ if ch != u'!': self.reader.forward(length) - raise ScannerError("while scanning a %s" % name, start_marker, + raise ScannerError("while scanning a %s" % name, start_mark, "expected '!', but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) length += 1 value = self.reader.prefix(length) @@ -1342,5 +1342,5 @@ return value - def scan_tag_uri(self, name, start_marker): + def scan_tag_uri(self, name, start_mark): # See the specification for details. # Note: we do not check if URI is well-formed. @@ -1354,5 +1354,5 @@ self.reader.forward(length) length = 0 - chunks.append(self.scan_uri_escapes(name, start_marker)) + chunks.append(self.scan_uri_escapes(name, start_mark)) else: length += 1 @@ -1363,20 +1363,20 @@ length = 0 if not chunks: - raise ScannerError("while parsing a %s" % name, start_marker, + raise ScannerError("while parsing a %s" % name, start_mark, "expected URI, but found %r" % ch.encode('utf-8'), - self.reader.get_marker()) + self.reader.get_mark()) return u''.join(chunks) - def scan_uri_escapes(self, name, start_marker): + def scan_uri_escapes(self, name, start_mark): # See the specification for details. bytes = [] - marker = self.reader.get_marker() + mark = self.reader.get_mark() while self.reader.peek() == u'%': self.reader.forward() for k in range(2): if self.reader.peek(k) not in u'0123456789ABCDEFabcdef': - raise ScannerError("while scanning a %s" % name, start_marker, + raise ScannerError("while scanning a %s" % name, start_mark, "expected URI escape sequence of 2 hexdecimal numbers, but found %r" % - (self.reader.peek(k).encode('utf-8')), self.reader.get_marker()) + (self.reader.peek(k).encode('utf-8')), self.reader.get_mark()) bytes.append(chr(int(self.reader.prefix(2), 16))) self.reader.forward(2) @@ -1384,5 +1384,5 @@ value = unicode(''.join(bytes), 'utf-8') except UnicodeDecodeError, exc: - raise ScannerError("while scanning a %s" % name, start_marker, str(exc), marker) + raise ScannerError("while scanning a %s" % name, start_mark, str(exc), mark) return value Index: /pyyaml/trunk/lib/yaml/parser.py =================================================================== --- /pyyaml/trunk/lib/yaml/parser.py (revision 57) +++ /pyyaml/trunk/lib/yaml/parser.py (revision 116) @@ -143,9 +143,9 @@ "expected '', but found %r" % self.scanner.peek().id, - self.scanner.peek().start_marker) + self.scanner.peek().start_mark) token = self.scanner.get() if self.scanner.check(DirectiveToken, DocumentStartToken, DocumentEndToken, StreamEndToken): - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) else: for event in self.parse_block_node(): @@ -156,5 +156,5 @@ # Parse end of stream. token = self.scanner.get() - yield StreamEndEvent(token.start_marker, token.end_marker) + yield StreamEndEvent(token.start_mark, token.end_mark) def process_directives(self): @@ -167,10 +167,10 @@ if self.yaml_version is not None: raise ParserError(None, None, - "found duplicate YAML directive", token.start_marker) + "found duplicate YAML directive", token.start_mark) major, minor = token.value if major != 1: raise ParserError(None, None, "found incompatible YAML document (version 1.* is required)", - token.start_marker) + token.start_mark) self.yaml_version = token.value elif token.name == u'TAG': @@ -179,5 +179,5 @@ raise ParserError(None, None, "duplicate tag handle %r" % handle.encode('utf-8'), - token.start_marker) + token.start_mark) self.tag_handles[handle] = prefix for key in self.DEFAULT_TAGS: @@ -205,24 +205,24 @@ if self.scanner.check(AliasToken): token = self.scanner.get() - yield AliasEvent(token.value, token.start_marker, token.end_marker) + yield AliasEvent(token.value, token.start_mark, token.end_mark) else: anchor = None tag = None - start_marker = end_marker = tag_marker = None + start_mark = end_mark = tag_mark = None if self.scanner.check(AnchorToken): token = self.scanner.get() - start_marker = end_marker = token.start_marker + start_mark = end_mark = token.start_mark anchor = token.value if self.scanner.check(TagToken): token = self.scanner.get() - end_marker = tag_marker = token.start_marker + end_mark = tag_mark = token.start_mark tag = token.value elif self.scanner.check(TagToken): token = self.scanner.get() - start_marker = end_marker = tag_marker = token.start_marker + start_mark = end_mark = tag_mark = token.start_mark tag = token.value if self.scanner.check(AnchorToken): token = self.scanner.get() - end_marker = token.start_marker + end_mark = token.start_mark anchor = token.value if tag is not None: @@ -230,7 +230,7 @@ if handle is not None: if handle not in self.tag_handles: - raise ParserError("while parsing a node", start_marker, + raise ParserError("while parsing a node", start_mark, "found undefined tag handle %r" % handle.encode('utf-8'), - tag_marker) + tag_mark) tag = self.tag_handles[handle]+suffix else: @@ -240,33 +240,33 @@ self.scanner.peek().plain): tag = u'!' - if start_marker is None: - start_marker = self.scanner.peek().start_marker + if start_mark is None: + start_mark = self.scanner.peek().start_mark event = None collection_events = None if indentless_sequence and self.scanner.check(BlockEntryToken): - end_marker = self.scanner.peek().end_marker - event = SequenceEvent(anchor, tag, start_marker, end_marker) + end_mark = self.scanner.peek().end_mark + event = SequenceEvent(anchor, tag, start_mark, end_mark) collection_events = self.parse_indentless_sequence() else: if self.scanner.check(ScalarToken): token = self.scanner.get() - end_marker = token.end_marker + end_mark = token.end_mark event = ScalarEvent(anchor, tag, token.value, - start_marker, end_marker) + start_mark, end_mark) elif self.scanner.check(FlowSequenceStartToken): - end_marker = self.scanner.peek().end_marker - event = SequenceEvent(anchor, tag, start_marker, end_marker) + end_mark = self.scanner.peek().end_mark + event = SequenceEvent(anchor, tag, start_mark, end_mark) collection_events = self.parse_flow_sequence() elif self.scanner.check(FlowMappingStartToken): - end_marker = self.scanner.peek().end_marker - event = MappingEvent(anchor, tag, start_marker, end_marker) + end_mark = self.scanner.peek().end_mark + event = MappingEvent(anchor, tag, start_mark, end_mark) collection_events = self.parse_flow_mapping() elif block and self.scanner.check(BlockSequenceStartToken): - end_marker = self.scanner.peek().start_marker - event = SequenceEvent(anchor, tag, start_marker, end_marker) + end_mark = self.scanner.peek().start_mark + event = SequenceEvent(anchor, tag, start_mark, end_mark) collection_events = self.parse_block_sequence() elif block and self.scanner.check(BlockMappingStartToken): - end_marker = self.scanner.peek().start_marker - event = MappingEvent(anchor, tag, start_marker, end_marker) + end_mark = self.scanner.peek().start_mark + event = MappingEvent(anchor, tag, start_mark, end_mark) collection_events = self.parse_block_mapping() else: @@ -276,7 +276,7 @@ node = 'flow' token = self.scanner.peek() - raise ParserError("while scanning a %s node" % node, start_marker, + raise ParserError("while scanning a %s node" % node, start_mark, "expected the node content, but found %r" % token.id, - token.start_marker) + token.start_mark) yield event if collection_events is not None: @@ -287,5 +287,5 @@ # BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END token = self.scanner.get() - start_marker = token.start_marker + start_mark = token.start_mark while self.scanner.check(BlockEntryToken): token = self.scanner.get() @@ -294,11 +294,11 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) if not self.scanner.check(BlockEndToken): token = self.scanner.peek() - raise ParserError("while scanning a block collection", start_marker, - "expected , but found %r" % token.id, token.start_marker) - token = self.scanner.get() - yield CollectionEndEvent(token.start_marker, token.end_marker) + raise ParserError("while scanning a block collection", start_mark, + "expected , but found %r" % token.id, token.start_mark) + token = self.scanner.get() + yield CollectionEndEvent(token.start_mark, token.end_mark) def parse_indentless_sequence(self): @@ -311,7 +311,7 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) token = self.scanner.peek() - yield CollectionEndEvent(token.start_marker, token.start_marker) + yield CollectionEndEvent(token.start_mark, token.start_mark) def parse_block_mapping(self): @@ -321,5 +321,5 @@ # BLOCK-END token = self.scanner.get() - start_marker = token.start_marker + start_mark = token.start_mark while self.scanner.check(KeyToken, ValueToken): if self.scanner.check(KeyToken): @@ -329,5 +329,5 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) if self.scanner.check(ValueToken): token = self.scanner.get() @@ -336,14 +336,14 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) else: token = self.scanner.peek() - yield self.process_empty_scalar(token.start_marker) + yield self.process_empty_scalar(token.start_mark) if not self.scanner.check(BlockEndToken): token = self.scanner.peek() - raise ParserError("while scanning a block mapping", start_marker, - "expected , but found %r" % token.id, token.start_marker) - token = self.scanner.get() - yield CollectionEndEvent(token.start_marker, token.end_marker) + raise ParserError("while scanning a block mapping", start_mark, + "expected , but found %r" % token.id, token.start_mark) + token = self.scanner.get() + yield CollectionEndEvent(token.start_mark, token.end_mark) def parse_flow_sequence(self): @@ -359,10 +359,10 @@ # generate an inline mapping (set syntax). token = self.scanner.get() - start_marker = token.start_marker + start_mark = token.start_mark while not self.scanner.check(FlowSequenceEndToken): if self.scanner.check(KeyToken): token = self.scanner.get() yield MappingEvent(None, u'!', - token.start_marker, token.end_marker) + token.start_mark, token.end_mark) if not self.scanner.check(ValueToken, FlowEntryToken, FlowSequenceEndToken): @@ -370,5 +370,5 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) if self.scanner.check(ValueToken): token = self.scanner.get() @@ -377,10 +377,10 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) else: token = self.scanner.peek() - yield self.process_empty_scalar(token.start_marker) + yield self.process_empty_scalar(token.start_mark) token = self.scanner.peek() - yield CollectionEndEvent(token.start_marker, token.start_marker) + yield CollectionEndEvent(token.start_mark, token.start_mark) else: for event in self.parse_flow_node(): @@ -388,10 +388,10 @@ if not self.scanner.check(FlowEntryToken, FlowSequenceEndToken): token = self.scanner.peek() - raise ParserError("while scanning a flow sequence", start_marker, - "expected ',' or ']', but got %r" % token.id, token.start_marker) + raise ParserError("while scanning a flow sequence", start_mark, + "expected ',' or ']', but got %r" % token.id, token.start_mark) if self.scanner.check(FlowEntryToken): self.scanner.get() token = self.scanner.get() - yield CollectionEndEvent(token.start_marker, token.end_marker) + yield CollectionEndEvent(token.start_mark, token.end_mark) def parse_flow_mapping(self): @@ -402,5 +402,5 @@ # flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)? token = self.scanner.get() - start_marker = token.start_marker + start_mark = token.start_mark while not self.scanner.check(FlowMappingEndToken): if self.scanner.check(KeyToken): @@ -411,5 +411,5 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) if self.scanner.check(ValueToken): token = self.scanner.get() @@ -418,26 +418,26 @@ yield event else: - yield self.process_empty_scalar(token.end_marker) + yield self.process_empty_scalar(token.end_mark) else: token = self.scanner.peek() - yield self.process_empty_scalar(token.start_marker) + yield self.process_empty_scalar(token.start_mark) else: for event in self.parse_flow_node(): yield event - yield self.process_empty_scalar(self.scanner.peek().start_marker) + yield self.process_empty_scalar(self.scanner.peek().start_mark) if not self.scanner.check(FlowEntryToken, FlowMappingEndToken): token = self.scanner.peek() - raise ParserError("while scanning a flow mapping", start_marker, - "expected ',' or '}', but got %r" % token.id, token.start_marker) + raise ParserError("while scanning a flow mapping", start_mark, + "expected ',' or '}', but got %r" % token.id, token.start_mark) if self.scanner.check(FlowEntryToken): self.scanner.get() if not self.scanner.check(FlowMappingEndToken): token = self.scanner.peek() - raise ParserError("while scanning a flow mapping", start_marker, - "expected '}', but found %r" % token.id, token.start_marker) - token = self.scanner.get() - yield CollectionEndEvent(token.start_marker, token.end_marker) - - def process_empty_scalar(self, marker): - return ScalarEvent(None, None, u'', marker, marker) - + raise ParserError("while scanning a flow mapping", start_mark, + "expected '}', but found %r" % token.id, token.start_mark) + token = self.scanner.get() + yield CollectionEndEvent(token.start_mark, token.end_mark) + + def process_empty_scalar(self, mark): + return ScalarEvent(None, None, u'', mark, mark) +