YAML解析器 SnakeYAML.7z

/** * Copyright (c) 2008-2012, http://www.snakeyaml.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.yaml.snakeyaml.scanner; import java.nio.ByteBuffer; import java.nio.charset.CharacterCodingException; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.regex.Pattern; import org.yaml.snakeyaml.error.Mark; import org.yaml.snakeyaml.error.YAMLException; import org.yaml.snakeyaml.reader.StreamReader; import org.yaml.snakeyaml.tokens.AliasToken; import org.yaml.snakeyaml.tokens.AnchorToken; import org.yaml.snakeyaml.tokens.BlockEndToken; import org.yaml.snakeyaml.tokens.BlockEntryToken; import org.yaml.snakeyaml.tokens.BlockMappingStartToken; import org.yaml.snakeyaml.tokens.BlockSequenceStartToken; import org.yaml.snakeyaml.tokens.DirectiveToken; import org.yaml.snakeyaml.tokens.DocumentEndToken; import org.yaml.snakeyaml.tokens.DocumentStartToken; import org.yaml.snakeyaml.tokens.FlowEntryToken; import org.yaml.snakeyaml.tokens.FlowMappingEndToken; import org.yaml.snakeyaml.tokens.FlowMappingStartToken; import org.yaml.snakeyaml.tokens.FlowSequenceEndToken; import org.yaml.snakeyaml.tokens.FlowSequenceStartToken; import org.yaml.snakeyaml.tokens.KeyToken; import org.yaml.snakeyaml.tokens.ScalarToken; import org.yaml.snakeyaml.tokens.StreamEndToken; import org.yaml.snakeyaml.tokens.StreamStartToken; import org.yaml.snakeyaml.tokens.TagToken; import org.yaml.snakeyaml.tokens.TagTuple; import org.yaml.snakeyaml.tokens.Token; import org.yaml.snakeyaml.tokens.ValueToken; import org.yaml.snakeyaml.util.ArrayStack; import org.yaml.snakeyaml.util.UriEncoder; /** * <pre> * Scanner produces tokens of the following types: * STREAM-START * STREAM-END * DIRECTIVE(name, value) * DOCUMENT-START * DOCUMENT-END * BLOCK-SEQUENCE-START * BLOCK-MAPPING-START * BLOCK-END * FLOW-SEQUENCE-START * FLOW-MAPPING-START * FLOW-SEQUENCE-END * FLOW-MAPPING-END * BLOCK-ENTRY * FLOW-ENTRY * KEY * VALUE * ALIAS(value) * ANCHOR(value) * TAG(value) * SCALAR(value, plain, style) * Read comments in the Scanner code for more details. * </pre> */ public final class ScannerImpl implements Scanner { /** * A regular expression matching characters which are not in the hexadecimal * set (0-9, A-F, a-f). */ private final static Pattern NOT_HEXA = Pattern.compile("[^0-9A-Fa-f]"); /** * A mapping from an escaped character in the input stream to the character * that they should be replaced with. * * YAML defines several common and a few uncommon escape sequences. * * @see http://www.yaml.org/spec/current.html#id2517668 */ public final static Map<Character, String> ESCAPE_REPLACEMENTS = new HashMap<Character, String>(); /** * A mapping from a character to a number of bytes to read-ahead for that * escape sequence. These escape sequences are used to handle unicode * escaping in the following formats, where H is a hexadecimal character: * * <pre> * &#92;xHH : escaped 8-bit Unicode character * &#92;uHHHH : escaped 16-bit Unicode character * &#92;UHHHHHHHH : escaped 32-bit Unicode character * </pre> * * @see http://yaml.org/spec/1.1/current.html#id872840 */ public final static Map<Character, Integer> ESCAPE_CODES = new HashMap<Character, Integer>(); static { // ASCII null ESCAPE_REPLACEMENTS.put(Character.valueOf('0'), "\0"); // ASCII bell ESCAPE_REPLACEMENTS.put(Character.valueOf('a'), "\u0007"); // ASCII backspace ESCAPE_REPLACEMENTS.put(Character.valueOf('b'), "\u0008"); // ASCII horizontal tab ESCAPE_REPLACEMENTS.put(Character.valueOf('t'), "\u0009"); // ASCII newline (line feed; &#92;n maps to 0x0A) ESCAPE_REPLACEMENTS.put(Character.valueOf('n'), "\n"); // ASCII vertical tab ESCAPE_REPLACEMENTS.put(Character.valueOf('v'), "\u000B"); // ASCII form-feed ESCAPE_REPLACEMENTS.put(Character.valueOf('f'), "\u000C"); // carriage-return (&#92;r maps to 0x0D) ESCAPE_REPLACEMENTS.put(Character.valueOf('r'), "\r"); // ASCII escape character (Esc) ESCAPE_REPLACEMENTS.put(Character.valueOf('e'), "\u001B"); // ASCII space ESCAPE_REPLACEMENTS.put(Character.valueOf(' '), "\u0020"); // ASCII double-quote ESCAPE_REPLACEMENTS.put(Character.valueOf('"'), "\""); // ASCII backslash ESCAPE_REPLACEMENTS.put(Character.valueOf('\\'), "\\"); // Unicode next line ESCAPE_REPLACEMENTS.put(Character.valueOf('N'), "\u0085"); // Unicode non-breaking-space ESCAPE_REPLACEMENTS.put(Character.valueOf('_'), "\u00A0"); // Unicode line-separator ESCAPE_REPLACEMENTS.put(Character.valueOf('L'), "\u2028"); // Unicode paragraph separator ESCAPE_REPLACEMENTS.put(Character.valueOf('P'), "\u2029"); // 8-bit Unicode ESCAPE_CODES.put(Character.valueOf('x'), 2); // 16-bit Unicode ESCAPE_CODES.put(Character.valueOf('u'), 4); // 32-bit Unicode (Supplementary characters are supported) ESCAPE_CODES.put(Character.valueOf('U'), 8); } private final StreamReader reader; // Had we reached the end of the stream? private boolean done = false; // The number of unclosed '{' and '['. `flow_level == 0` means block // context. private int flowLevel = 0; // List of processed tokens that are not yet emitted. private List<Token> tokens; // Number of tokens that were emitted through the `get_token` method. private int tokensTaken = 0; // The current indentation level. private int indent = -1; // Past indentation levels. private ArrayStack<Integer> indents; // Variables related to simple keys treatment. See PyYAML. /** * <pre> * A simple key is a key that is not denoted by the '?' indicator. * Example of simple keys: * --- * block simple key: value * ? not a simple key: * : { flow simple key: value } * We emit the KEY token before all keys, so when we find a potential * simple key, we try to locate the corresponding ':' indicator. * Simple keys should be limited to a single line and 1024 characters. * * Can a simple key start at the current position? A simple key may * start: * - at the beginning of the line, not counting indentation spaces * (in block context), * - after '{', '[', ',' (in the flow context), * - after '?', ':', '-' (in the block context). * In the block context, this flag also signifies if a block collection * may start at the current position. * </pre> */ private boolean allowSimpleKey = true; /* * Keep track of possible simple keys. This is a dictionary. The key 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, mark) A simple key may start with ALIAS, ANCHOR, TAG, * SCALAR(flow), '[', or '{' tokens. */ private Map<Integer, SimpleKey> possibleSimpleKeys; public ScannerImpl(StreamReader reader) { this.reader = reader; this.tokens = new ArrayList<Token>(100)