mirror of https://github.com/status-im/NimYAML.git
1551 lines
53 KiB
Nim
1551 lines
53 KiB
Nim
# NimYAML - YAML implementation in Nim
|
|
# (c) Copyright 2015 Felix Krause
|
|
#
|
|
# See the file "copying.txt", included in this
|
|
# distribution, for details about the copyright.
|
|
|
|
type
|
|
FastParseState = enum
|
|
fpInitial, fpBlockAfterObject, fpBlockAfterPlainScalar, fpBlockObjectStart,
|
|
fpExpectDocEnd, fpFlow, fpFlowAfterObject, fpAfterDocument
|
|
|
|
ScalarType = enum
|
|
stFlow, stLiteral, stFolded
|
|
|
|
LexedDirective = enum
|
|
ldYaml, ldTag, ldUnknown
|
|
|
|
YamlContext = enum
|
|
cBlock, cFlow
|
|
|
|
ChompType = enum
|
|
ctKeep, ctClip, ctStrip
|
|
|
|
const
|
|
space = {' ', '\t'}
|
|
lineEnd = {'\l', '\c', EndOfFile}
|
|
spaceOrLineEnd = {' ', '\t', '\l', '\c', EndOfFile}
|
|
digits = {'0'..'9'}
|
|
flowIndicators = {'[', ']', '{', '}', ','}
|
|
|
|
UTF8NextLine = toUTF8(0x85.Rune)
|
|
UTF8NonBreakingSpace = toUTF8(0xA0.Rune)
|
|
UTF8LineSeparator = toUTF8(0x2028.Rune)
|
|
UTF8ParagraphSeparator = toUTF8(0x2029.Rune)
|
|
UnknownIndentation = int.low
|
|
|
|
proc newYamlParser*(tagLib: TagLibrary = initExtendedTagLibrary(),
|
|
callback: WarningCallback = nil): YamlParser =
|
|
new(result)
|
|
result.tagLib = tagLib
|
|
result.callback = callback
|
|
result.content = ""
|
|
result.after = ""
|
|
result.tagUri = ""
|
|
result.ancestry = newSeq[FastParseLevel]()
|
|
|
|
proc getLineNumber*(p: YamlParser): int = p.lexer.lineNumber
|
|
|
|
proc getColNumber*(p: YamlParser): int = p.tokenstart + 1 # column is 1-based
|
|
|
|
proc getLineContent*(p: YamlParser, marker: bool = true): string =
|
|
result = p.lexer.getCurrentLine(false)
|
|
if marker: result.add(repeat(' ', p.tokenstart) & "^\n")
|
|
|
|
template debug(message: string) {.dirty.} =
|
|
when defined(yamlDebug):
|
|
try: styledWriteLine(stdout, fgBlue, message)
|
|
except IOError: discard
|
|
|
|
template debugFail() {.dirty.} =
|
|
when not defined(release):
|
|
echo "internal error at line: ", instantiationInfo().line
|
|
assert(false)
|
|
|
|
proc generateError(p: YamlParser, message: string):
|
|
ref YamlParserError {.raises: [].} =
|
|
result = newException(YamlParserError, message)
|
|
result.line = p.lexer.lineNumber
|
|
result.column = p.tokenstart + 1
|
|
result.lineContent = p.getLineContent(true)
|
|
|
|
proc generateError(lx: BaseLexer, message: string):
|
|
ref YamlParserError {.raises: [].} =
|
|
result = newException(YamlParserError, message)
|
|
result.line = lx.lineNumber
|
|
result.column = lx.bufpos + 1
|
|
result.lineContent = lx.getCurrentLine(false) &
|
|
repeat(' ', lx.getColNumber(lx.bufpos)) & "^\n"
|
|
|
|
proc addMultiple(s: var string, c: char, num: int) {.raises: [], inline.} =
|
|
for i in 1..num:
|
|
s.add(c)
|
|
|
|
proc reset(buffer: var string) {.raises: [], inline.} = buffer.setLen(0)
|
|
|
|
proc initLevel(k: FastParseLevelKind): FastParseLevel {.raises: [], inline.} =
|
|
FastParseLevel(kind: k, indentation: UnknownIndentation)
|
|
|
|
proc emptyScalar(p: YamlParser): YamlStreamEvent {.raises: [], inline.} =
|
|
result = scalarEvent("", p.tag, p.anchor)
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
|
|
proc currentScalar(p: YamlParser): YamlStreamEvent {.raises: [], inline.} =
|
|
result = YamlStreamEvent(kind: yamlScalar, scalarTag: p.tag,
|
|
scalarAnchor: p.anchor, scalarContent: p.content)
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
|
|
template yieldLevelEnd() {.dirty.} =
|
|
case p.level.kind
|
|
of fplSequence: yield endSeqEvent()
|
|
of fplMapKey: yield endMapEvent()
|
|
of fplMapValue, fplSinglePairValue:
|
|
yield emptyScalar(p)
|
|
yield endMapEvent()
|
|
of fplScalar:
|
|
if scalarType != stFlow:
|
|
case chomp
|
|
of ctKeep:
|
|
if p.content.len == 0: p.newlines.inc(-1)
|
|
p.content.addMultiple('\l', p.newlines)
|
|
of ctClip:
|
|
if p.content.len != 0: p.content.add('\l')
|
|
of ctStrip: discard
|
|
yield currentScalar(p)
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
of fplUnknown:
|
|
if p.ancestry.len > 1:
|
|
yield emptyScalar(p) # don't yield scalar for empty doc
|
|
of fplSinglePairKey, fplDocument: debugFail()
|
|
|
|
template handleLineEnd(insideDocument: bool) {.dirty.} =
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '\l': p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
of '\c': p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
of EndOfFile:
|
|
when insideDocument: closeEverything()
|
|
return
|
|
else: discard
|
|
p.newlines.inc()
|
|
|
|
template handleObjectEnd(nextState: FastParseState) {.dirty.} =
|
|
p.level = p.ancestry.pop()
|
|
if p.level.kind == fplSinglePairValue:
|
|
yield endMapEvent()
|
|
p.level = p.ancestry.pop()
|
|
state = if p.level.kind == fplDocument: fpExpectDocEnd else: nextState
|
|
case p.level.kind
|
|
of fplMapKey: p.level.kind = fplMapValue
|
|
of fplSinglePairKey: p.level.kind = fplSinglePairValue
|
|
of fplMapValue: p.level.kind = fplMapKey
|
|
of fplSequence, fplDocument: discard
|
|
of fplUnknown, fplScalar, fplSinglePairValue: debugFail()
|
|
|
|
proc objectStart(p: YamlParser, k: static[YamlStreamEventKind],
|
|
single: bool = false): YamlStreamEvent {.raises: [].} =
|
|
assert(p.level.kind == fplUnknown)
|
|
when k == yamlStartMap:
|
|
result = startMapEvent(p.tag, p.anchor)
|
|
if single:
|
|
debug("started single-pair map at " &
|
|
(if p.level.indentation == UnknownIndentation: $p.indentation else:
|
|
$p.level.indentation))
|
|
p.level.kind = fplSinglePairKey
|
|
else:
|
|
debug("started map at " &
|
|
(if p.level.indentation == UnknownIndentation: $p.indentation else:
|
|
$p.level.indentation))
|
|
p.level.kind = fplMapKey
|
|
else:
|
|
result = startSeqEvent(p.tag, p.anchor)
|
|
debug("started sequence at " &
|
|
(if p.level.indentation == UnknownIndentation: $p.indentation else:
|
|
$p.level.indentation))
|
|
p.level.kind = fplSequence
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
if p.level.indentation == UnknownIndentation:
|
|
p.level.indentation = p.indentation
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
|
|
template closeMoreIndentedLevels(atSequenceItem: bool = false) {.dirty.} =
|
|
while p.level.kind != fplDocument:
|
|
let parent = p.ancestry[p.ancestry.high]
|
|
if parent.indentation >= p.indentation:
|
|
when atSequenceItem:
|
|
if (p.indentation == p.level.indentation and
|
|
p.level.kind == fplSequence) or
|
|
(p.indentation == parent.indentation and
|
|
p.level.kind == fplUnknown and parent.kind != fplSequence):
|
|
break
|
|
debug("Closing because parent.indentation (" & $parent.indentation &
|
|
") >= indentation(" & $p.indentation & ")")
|
|
yieldLevelEnd()
|
|
handleObjectEnd(state)
|
|
else: break
|
|
if p.level.kind == fplDocument: state = fpExpectDocEnd
|
|
|
|
template closeEverything() {.dirty.} =
|
|
p.indentation = 0
|
|
closeMoreIndentedLevels()
|
|
case p.level.kind
|
|
of fplUnknown: discard p.ancestry.pop()
|
|
of fplDocument: discard
|
|
else:
|
|
yieldLevelEnd()
|
|
discard p.ancestry.pop()
|
|
yield endDocEvent()
|
|
|
|
template handleBlockSequenceIndicator() {.dirty.} =
|
|
p.startToken()
|
|
case p.level.kind
|
|
of fplUnknown: yield p.objectStart(yamlStartSeq)
|
|
of fplSequence:
|
|
if p.level.indentation != p.indentation:
|
|
raise p.generateError("Invalid p.indentation of block sequence indicator")
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
else: raise p.generateError("Illegal sequence item in map")
|
|
p.lexer.skipWhitespace()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
|
|
template handleMapKeyIndicator() {.dirty.} =
|
|
p.startToken()
|
|
case p.level.kind
|
|
of fplUnknown: yield p.objectStart(yamlStartMap)
|
|
of fplMapValue:
|
|
if p.level.indentation != p.indentation:
|
|
raise p.generateError("Invalid p.indentation of map key indicator")
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
p.level.kind = fplMapKey
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplMapKey:
|
|
if p.level.indentation != p.indentation:
|
|
raise p.generateError("Invalid p.indentation of map key indicator")
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplSequence:
|
|
raise p.generateError("Unexpected map key indicator (expected '- ')")
|
|
of fplScalar:
|
|
raise p.generateError(
|
|
"Unexpected map key indicator (expected multiline scalar end)")
|
|
of fplSinglePairKey, fplSinglePairValue, fplDocument: debugFail()
|
|
p.lexer.skipWhitespace()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
|
|
template handleMapValueIndicator() {.dirty.} =
|
|
p.startToken()
|
|
case p.level.kind
|
|
of fplUnknown:
|
|
if p.level.indentation == UnknownIndentation:
|
|
yield p.objectStart(yamlStartMap)
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
else: yield emptyScalar(p)
|
|
p.ancestry[p.ancestry.high].kind = fplMapValue
|
|
of fplMapKey:
|
|
if p.level.indentation != p.indentation:
|
|
raise p.generateError("Invalid p.indentation of map key indicator")
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
p.level.kind = fplMapValue
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplMapValue:
|
|
if p.level.indentation != p.indentation:
|
|
raise p.generateError("Invalid p.indentation of map key indicator")
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplSequence:
|
|
raise p.generateError("Unexpected map value indicator (expected '- ')")
|
|
of fplScalar:
|
|
raise p.generateError(
|
|
"Unexpected map value indicator (expected multiline scalar end)")
|
|
of fplSinglePairKey, fplSinglePairValue, fplDocument: debugFail()
|
|
p.lexer.skipWhitespace()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
|
|
proc initDocValues(p: YamlParser) {.raises: [].} =
|
|
p.shorthands = initTable[string, string]()
|
|
p.anchors = initTable[string, AnchorId]()
|
|
p.shorthands["!"] = "!"
|
|
p.shorthands["!!"] = "tag:yaml.org,2002:"
|
|
p.nextAnchorId = 0.AnchorId
|
|
p.level = initLevel(fplUnknown)
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
p.ancestry.add(FastParseLevel(kind: fplDocument, indentation: -1))
|
|
|
|
proc startToken(p: YamlParser) {.raises: [], inline.} =
|
|
p.tokenstart = p.lexer.getColNumber(p.lexer.bufpos)
|
|
|
|
proc anchorName(p: YamlParser) {.raises: [].} =
|
|
debug("lex: anchorName")
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
let c = p.lexer.buf[p.lexer.bufpos]
|
|
case c
|
|
of spaceOrLineEnd, '[', ']', '{', '}', ',': break
|
|
else: p.content.add(c)
|
|
|
|
proc handleAnchor(p: YamlParser) {.raises: [YamlParserError].} =
|
|
p.startToken()
|
|
if p.level.kind != fplUnknown: raise p.generateError("Unexpected token")
|
|
if p.anchor != yAnchorNone:
|
|
raise p.generateError("Only one anchor is allowed per node")
|
|
p.content.reset()
|
|
p.anchorName()
|
|
p.anchor = p.nextAnchorId
|
|
p.anchors[p.content] = p.anchor
|
|
p.nextAnchorId = AnchorId(int(p.nextAnchorId) + 1)
|
|
|
|
template handleAlias() {.dirty.} =
|
|
p.startToken()
|
|
if p.level.kind != fplUnknown: raise p.generateError("Unexpected token")
|
|
if p.anchor != yAnchorNone or p.tag != yTagQuestionMark:
|
|
raise p.generateError("Alias may not have anchor or tag")
|
|
p.content.reset()
|
|
p.anchorName()
|
|
var id: AnchorId
|
|
try: id = p.anchors[p.content]
|
|
except KeyError: raise p.generateError("Unknown anchor")
|
|
yield aliasEvent(id)
|
|
handleObjectEnd(fpBlockAfterObject)
|
|
|
|
template leaveFlowLevel() {.dirty.} =
|
|
flowdepth.inc(-1)
|
|
if flowdepth == 0:
|
|
yieldLevelEnd()
|
|
handleObjectEnd(fpBlockAfterObject)
|
|
else:
|
|
yieldLevelEnd()
|
|
handleObjectEnd(fpFlowAfterObject)
|
|
|
|
template handlePossibleMapStart(flow: bool = false,
|
|
single: bool = false) {.dirty.} =
|
|
if p.level.indentation == UnknownIndentation:
|
|
var flowDepth = 0
|
|
var pos = p.lexer.bufpos
|
|
var recentJsonStyle = false
|
|
while pos < p.lexer.bufpos + 1024:
|
|
case p.lexer.buf[pos]
|
|
of ':':
|
|
if flowDepth == 0 and (p.lexer.buf[pos + 1] in spaceOrLineEnd or
|
|
recentJsonStyle):
|
|
yield p.objectStart(yamlStartMap, single)
|
|
break
|
|
of lineEnd: break
|
|
of '[', '{': flowDepth.inc()
|
|
of '}', ']':
|
|
flowDepth.inc(-1)
|
|
if flowDepth < 0: break
|
|
of '?', ',':
|
|
if flowDepth == 0: break
|
|
of '#':
|
|
if p.lexer.buf[pos - 1] in space: break
|
|
of '"':
|
|
pos.inc()
|
|
while p.lexer.buf[pos] notin {'"', EndOfFile, '\l', '\c'}:
|
|
if p.lexer.buf[pos] == '\\': pos.inc()
|
|
pos.inc()
|
|
if p.lexer.buf[pos] != '"': break
|
|
of '\'':
|
|
pos.inc()
|
|
while p.lexer.buf[pos] notin {'\'', '\l', '\c', EndOfFile}:
|
|
pos.inc()
|
|
of '&', '*', '!':
|
|
if pos == p.lexer.bufpos or p.lexer.buf[p.lexer.bufpos] in space:
|
|
pos.inc()
|
|
while p.lexer.buf[pos] notin spaceOrLineEnd:
|
|
pos.inc()
|
|
continue
|
|
else: discard
|
|
if flow and p.lexer.buf[pos] notin space:
|
|
recentJsonStyle = p.lexer.buf[pos] in {']', '}', '\'', '"'}
|
|
pos.inc()
|
|
if p.level.indentation == UnknownIndentation:
|
|
p.level.indentation = p.indentation
|
|
|
|
template handleBlockItemStart() {.dirty.} =
|
|
case p.level.kind
|
|
of fplUnknown: handlePossibleMapStart()
|
|
of fplSequence:
|
|
raise p.generateError(
|
|
"Unexpected token (expected block sequence indicator)")
|
|
of fplMapKey:
|
|
p.ancestry.add(p.level)
|
|
p.level = FastParseLevel(kind: fplUnknown, indentation: p.indentation)
|
|
of fplMapValue:
|
|
yield emptyScalar(p)
|
|
p.level.kind = fplMapKey
|
|
p.ancestry.add(p.level)
|
|
p.level = FastParseLevel(kind: fplUnknown, indentation: p.indentation)
|
|
of fplScalar, fplSinglePairKey, fplSinglePairValue, fplDocument: debugFail()
|
|
|
|
template handleFlowItemStart() {.dirty.} =
|
|
if p.level.kind == fplUnknown and
|
|
p.ancestry[p.ancestry.high].kind == fplSequence:
|
|
handlePossibleMapStart(true, true)
|
|
|
|
proc finishLine(lexer: var BaseLexer) {.raises: [], inline.} =
|
|
debug("lex: finishLine")
|
|
while lexer.buf[lexer.bufpos] notin lineEnd:
|
|
lexer.bufpos.inc()
|
|
|
|
proc skipWhitespace(lexer: var BaseLexer) {.raises: [], inline.} =
|
|
debug("lex: skipWhitespace")
|
|
while lexer.buf[lexer.bufpos] in space: lexer.bufpos.inc()
|
|
|
|
# TODO: {.raises: [].}
|
|
proc skipWhitespaceCommentsAndNewlines(lexer: var BaseLexer) {.inline.} =
|
|
debug("lex: skipWhitespaceCommentsAndNewlines")
|
|
if lexer.buf[lexer.bufpos] != '#':
|
|
while true:
|
|
case lexer.buf[lexer.bufpos]
|
|
of space: lexer.bufpos.inc()
|
|
of '\l': lexer.bufpos = lexer.handleLF(lexer.bufpos)
|
|
of '\c': lexer.bufpos = lexer.handleCR(lexer.bufpos)
|
|
of '#': # also skip comments
|
|
lexer.bufpos.inc()
|
|
while lexer.buf[lexer.bufpos] notin lineEnd:
|
|
lexer.bufpos.inc()
|
|
else: break
|
|
|
|
proc skipIndentation(lexer: var BaseLexer) {.raises: [], inline.} =
|
|
debug("lex: skipIndentation")
|
|
while lexer.buf[lexer.bufpos] == ' ': lexer.bufpos.inc()
|
|
|
|
proc directiveName(lexer: var BaseLexer, directive: var LexedDirective)
|
|
{.raises: [].} =
|
|
debug("lex: directiveName")
|
|
directive = ldUnknown
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'Y':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'A':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'M':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'L':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] in spaceOrLineEnd:
|
|
directive = ldYaml
|
|
elif lexer.buf[lexer.bufpos] == 'T':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'A':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] == 'G':
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] in spaceOrLineEnd:
|
|
directive = ldTag
|
|
while lexer.buf[lexer.bufpos] notin spaceOrLineEnd:
|
|
lexer.bufpos.inc()
|
|
|
|
proc yamlVersion(lexer: var BaseLexer, o: var string)
|
|
{.raises: [YamlParserError], inline.} =
|
|
debug("lex: yamlVersion")
|
|
while lexer.buf[lexer.bufpos] in space: lexer.bufpos.inc()
|
|
var c = lexer.buf[lexer.bufpos]
|
|
if c notin digits: raise lexer.generateError("Invalid YAML version number")
|
|
o.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
while c in digits:
|
|
lexer.bufpos.inc()
|
|
o.add(c)
|
|
c = lexer.buf[lexer.bufpos]
|
|
if lexer.buf[lexer.bufpos] != '.':
|
|
raise lexer.generateError("Invalid YAML version number")
|
|
o.add('.')
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
if c notin digits: raise lexer.generateError("Invalid YAML version number")
|
|
o.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
while c in digits:
|
|
o.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
if lexer.buf[lexer.bufpos] notin spaceOrLineEnd:
|
|
raise lexer.generateError("Invalid YAML version number")
|
|
|
|
proc lineEnding(p: YamlParser) {.raises: [YamlParserError], inline.} =
|
|
debug("lex: lineEnding")
|
|
if p.lexer.buf[p.lexer.bufpos] notin lineEnd:
|
|
while p.lexer.buf[p.lexer.bufpos] in space: p.lexer.bufpos.inc()
|
|
if p.lexer.buf[p.lexer.bufpos] in lineEnd: discard
|
|
elif p.lexer.buf[p.lexer.bufpos] == '#':
|
|
while p.lexer.buf[p.lexer.bufpos] notin lineEnd: p.lexer.bufpos.inc()
|
|
else:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected comment or line end)")
|
|
|
|
proc tagShorthand(lexer: var BaseLexer, shorthand: var string) {.inline.} =
|
|
debug("lex: tagShorthand")
|
|
while lexer.buf[lexer.bufpos] in space: lexer.bufpos.inc()
|
|
assert lexer.buf[lexer.bufpos] == '!'
|
|
shorthand.add('!')
|
|
lexer.bufpos.inc()
|
|
var c = lexer.buf[lexer.bufpos]
|
|
if c in spaceOrLineEnd: discard
|
|
else:
|
|
while c != '!':
|
|
case c
|
|
of 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '-':
|
|
shorthand.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
else: raise lexer.generateError("Illegal character in tag shorthand")
|
|
shorthand.add(c)
|
|
lexer.bufpos.inc()
|
|
if lexer.buf[lexer.bufpos] notin spaceOrLineEnd:
|
|
raise lexer.generateError("Missing space after tag shorthand")
|
|
|
|
proc tagUriMapping(lexer: var BaseLexer, uri: var string)
|
|
{.raises: [YamlParserError].} =
|
|
debug("lex: tagUriMapping")
|
|
while lexer.buf[lexer.bufpos] in space:
|
|
lexer.bufpos.inc()
|
|
var c = lexer.buf[lexer.bufpos]
|
|
if c == '!':
|
|
uri.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
while c notin spaceOrLineEnd:
|
|
case c
|
|
of 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '#', ';', '/', '?', ':', '@', '&',
|
|
'-', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')':
|
|
uri.add(c)
|
|
lexer.bufpos.inc()
|
|
c = lexer.buf[lexer.bufpos]
|
|
else: raise lexer.generateError("Invalid tag uri")
|
|
|
|
proc directivesEndMarker(lexer: var BaseLexer, success: var bool)
|
|
{.raises: [].} =
|
|
debug("lex: directivesEndMarker")
|
|
success = true
|
|
for i in 0..2:
|
|
if lexer.buf[lexer.bufpos + i] != '-':
|
|
success = false
|
|
break
|
|
if success: success = lexer.buf[lexer.bufpos + 3] in spaceOrLineEnd
|
|
|
|
proc documentEndMarker(lexer: var BaseLexer, success: var bool) {.raises: [].} =
|
|
debug("lex: documentEndMarker")
|
|
success = true
|
|
for i in 0..2:
|
|
if lexer.buf[lexer.bufpos + i] != '.':
|
|
success = false
|
|
break
|
|
if success: success = lexer.buf[lexer.bufpos + 3] in spaceOrLineEnd
|
|
|
|
proc unicodeSequence(lexer: var BaseLexer, length: int):
|
|
string {.raises: [YamlParserError].} =
|
|
debug("lex: unicodeSequence")
|
|
var unicodeChar = 0.int
|
|
for i in countup(0, length - 1):
|
|
lexer.bufpos.inc()
|
|
let
|
|
digitPosition = length - i - 1
|
|
c = lexer.buf[lexer.bufpos]
|
|
case c
|
|
of EndOFFile, '\l', '\c':
|
|
raise lexer.generateError("Unfinished unicode escape sequence")
|
|
of '0' .. '9':
|
|
unicodeChar = unicodechar or (int(c) - 0x30) shl (digitPosition * 4)
|
|
of 'A' .. 'F':
|
|
unicodeChar = unicodechar or (int(c) - 0x37) shl (digitPosition * 4)
|
|
of 'a' .. 'f':
|
|
unicodeChar = unicodechar or (int(c) - 0x57) shl (digitPosition * 4)
|
|
else:
|
|
raise lexer.generateError(
|
|
"Invalid character in unicode escape sequence")
|
|
return toUTF8(Rune(unicodeChar))
|
|
|
|
proc byteSequence(lexer: var BaseLexer): char {.raises: [YamlParserError].} =
|
|
debug("lex: byteSequence")
|
|
var charCode = 0.int8
|
|
for i in 0 .. 1:
|
|
lexer.bufpos.inc()
|
|
let
|
|
digitPosition = int8(1 - i)
|
|
c = lexer.buf[lexer.bufpos]
|
|
case c
|
|
of EndOfFile, '\l', 'r':
|
|
raise lexer.generateError("Unfinished octet escape sequence")
|
|
of '0' .. '9':
|
|
charCode = charCode or (int8(c) - 0x30.int8) shl (digitPosition * 4)
|
|
of 'A' .. 'F':
|
|
charCode = charCode or (int8(c) - 0x37.int8) shl (digitPosition * 4)
|
|
of 'a' .. 'f':
|
|
charCode = charCode or (int8(c) - 0x57.int8) shl (digitPosition * 4)
|
|
else:
|
|
raise lexer.generateError("Invalid character in octet escape sequence")
|
|
return char(charCode)
|
|
|
|
# TODO: {.raises: [].}
|
|
proc processQuotedWhitespace(p: YamlParser, newlines: var int) =
|
|
p.after.reset()
|
|
block outer:
|
|
while true:
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of ' ', '\t': p.after.add(p.lexer.buf[p.lexer.bufpos])
|
|
of '\l':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
break
|
|
of '\c':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
break
|
|
else:
|
|
p.content.add(p.after)
|
|
break outer
|
|
p.lexer.bufpos.inc()
|
|
while true:
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of ' ', '\t': discard
|
|
of '\l':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
newlines.inc()
|
|
continue
|
|
of '\c':
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
newlines.inc()
|
|
continue
|
|
else:
|
|
if newlines == 0: discard
|
|
elif newlines == 1: p.content.add(' ')
|
|
else: p.content.addMultiple('\l', newlines - 1)
|
|
break
|
|
p.lexer.bufpos.inc()
|
|
|
|
# TODO: {.raises: [YamlParserError].}
|
|
proc doubleQuotedScalar(p: YamlParser) =
|
|
debug("lex: doubleQuotedScalar")
|
|
p.lexer.bufpos.inc()
|
|
while true:
|
|
var c = p.lexer.buf[p.lexer.bufpos]
|
|
case c
|
|
of EndOfFile:
|
|
raise p.lexer.generateError("Unfinished double quoted string")
|
|
of '\\':
|
|
p.lexer.bufpos.inc()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of EndOfFile:
|
|
raise p.lexer.generateError("Unfinished escape sequence")
|
|
of '0': p.content.add('\0')
|
|
of 'a': p.content.add('\x07')
|
|
of 'b': p.content.add('\x08')
|
|
of '\t', 't': p.content.add('\t')
|
|
of 'n': p.content.add('\l')
|
|
of 'v': p.content.add('\v')
|
|
of 'f': p.content.add('\f')
|
|
of 'r': p.content.add('\c')
|
|
of 'e': p.content.add('\e')
|
|
of ' ': p.content.add(' ')
|
|
of '"': p.content.add('"')
|
|
of '/': p.content.add('/')
|
|
of '\\': p.content.add('\\')
|
|
of 'N': p.content.add(UTF8NextLine)
|
|
of '_': p.content.add(UTF8NonBreakingSpace)
|
|
of 'L': p.content.add(UTF8LineSeparator)
|
|
of 'P': p.content.add(UTF8ParagraphSeparator)
|
|
of 'x': p.content.add(p.lexer.unicodeSequence(2))
|
|
of 'u': p.content.add(p.lexer.unicodeSequence(4))
|
|
of 'U': p.content.add(p.lexer.unicodeSequence(8))
|
|
of '\l', '\c':
|
|
var newlines = 0
|
|
p.processQuotedWhitespace(newlines)
|
|
continue
|
|
else: raise p.lexer.generateError("Illegal character in escape sequence")
|
|
of '"':
|
|
p.lexer.bufpos.inc()
|
|
break
|
|
of '\l', '\c', '\t', ' ':
|
|
var newlines = 1
|
|
p.processQuotedWhitespace(newlines)
|
|
continue
|
|
else: p.content.add(c)
|
|
p.lexer.bufpos.inc()
|
|
|
|
# TODO: {.raises: [].}
|
|
proc singleQuotedScalar(p: YamlParser) =
|
|
debug("lex: singleQuotedScalar")
|
|
p.lexer.bufpos.inc()
|
|
while true:
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '\'':
|
|
p.lexer.bufpos.inc()
|
|
if p.lexer.buf[p.lexer.bufpos] == '\'': p.content.add('\'')
|
|
else: break
|
|
of EndOfFile: raise p.lexer.generateError("Unfinished single quoted string")
|
|
of '\l', '\c', '\t', ' ':
|
|
var newlines = 1
|
|
p.processQuotedWhitespace(newlines)
|
|
continue
|
|
else: p.content.add(p.lexer.buf[p.lexer.bufpos])
|
|
p.lexer.bufpos.inc()
|
|
|
|
proc isPlainSafe(lexer: BaseLexer, index: int, context: YamlContext): bool
|
|
{.raises: [].} =
|
|
case lexer.buf[lexer.bufpos + 1]
|
|
of spaceOrLineEnd: result = false
|
|
of flowIndicators: result = context == cBlock
|
|
else: result = true
|
|
|
|
|
|
# tried this for performance optimization, but it didn't optimize any
|
|
# performance. keeping it around for future reference.
|
|
#const
|
|
# plainCharOut = {'!', '\"', '$'..'9', ';'..'\xFF'}
|
|
# plainCharIn = {'!', '\"', '$'..'+', '-'..'9', ';'..'Z', '\\', '^'..'z',
|
|
# '|', '~'..'\xFF'}
|
|
#template isPlainChar(c: char, context: YamlContext): bool =
|
|
# when context == cBlock: c in plainCharOut
|
|
# else: c in plainCharIn
|
|
|
|
proc plainScalar(p: YamlParser, context: static[YamlContext]) {.raises: [].} =
|
|
debug("lex: plainScalar")
|
|
p.content.add(p.lexer.buf[p.lexer.bufpos])
|
|
block outer:
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
let c = p.lexer.buf[p.lexer.bufpos]
|
|
case c
|
|
of ' ', '\t':
|
|
p.after.setLen(1)
|
|
p.after[0] = c
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
let c2 = p.lexer.buf[p.lexer.bufpos]
|
|
case c2
|
|
of ' ', '\t': p.after.add(c2)
|
|
of lineEnd: break outer
|
|
of ':':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, context):
|
|
p.content.add(p.after & ':')
|
|
break
|
|
else: break outer
|
|
of '#': break outer
|
|
of flowIndicators:
|
|
if context == cBlock:
|
|
p.content.add(p.after)
|
|
p.content.add(c2)
|
|
break
|
|
else: break outer
|
|
else:
|
|
p.content.add(p.after)
|
|
p.content.add(c2)
|
|
break
|
|
of flowIndicators:
|
|
when context == cFlow: break
|
|
else: p.content.add(c)
|
|
of lineEnd: break
|
|
of ':':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, context): p.content.add(':')
|
|
else: break outer
|
|
else: p.content.add(c)
|
|
debug("lex: \"" & p.content & '\"')
|
|
|
|
proc continueMultilineScalar(p: YamlParser) {.raises: [].} =
|
|
p.content.add(if p.newlines == 1: " " else: repeat('\l', p.newlines - 1))
|
|
p.startToken()
|
|
p.plainScalar(cBlock)
|
|
|
|
template handleFlowPlainScalar() {.dirty.} =
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.plainScalar(cFlow)
|
|
if p.lexer.buf[p.lexer.bufpos] in {'{', '}', '[', ']', ',', ':', '#'}:
|
|
discard
|
|
else:
|
|
p.newlines = 0
|
|
while true:
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of ':':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cFlow):
|
|
if p.newlines == 1:
|
|
p.content.add(' ')
|
|
p.newlines = 0
|
|
elif p.newlines > 1:
|
|
p.content.addMultiple(' ', p.newlines - 1)
|
|
p.newlines = 0
|
|
p.plainScalar(cFlow)
|
|
break
|
|
of '#', EndOfFile: break
|
|
of '\l':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
of '\c':
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
of flowIndicators: break
|
|
of ' ', '\t': p.lexer.skipWhitespace()
|
|
else:
|
|
if p.newlines == 1:
|
|
p.content.add(' ')
|
|
p.newlines = 0
|
|
elif p.newlines > 1:
|
|
p.content.addMultiple(' ', p.newlines - 1)
|
|
p.newlines = 0
|
|
p.plainScalar(cFlow)
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpFlowAfterObject)
|
|
|
|
proc tagHandle(p: YamlParser, shorthandEnd: var int)
|
|
{.raises: [YamlParserError].} =
|
|
debug("lex: tagHandle")
|
|
shorthandEnd = 0
|
|
p.content.add(p.lexer.buf[p.lexer.bufpos])
|
|
var i = 0
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
i.inc()
|
|
let c = p.lexer.buf[p.lexer.bufpos]
|
|
case c
|
|
of spaceOrLineEnd:
|
|
if shorthandEnd == -1:
|
|
raise p.lexer.generateError("Unclosed verbatim tag")
|
|
break
|
|
of '!':
|
|
if shorthandEnd == -1 and i == 2:
|
|
p.content.add(c)
|
|
continue
|
|
elif shorthandEnd != 0:
|
|
raise p.lexer.generateError("Illegal character in tag suffix")
|
|
shorthandEnd = i
|
|
p.content.add(c)
|
|
of 'a' .. 'z', 'A' .. 'Z', '0' .. '9', '#', ';', '/', '?', ':', '@', '&',
|
|
'-', '=', '+', '$', '_', '.', '~', '*', '\'', '(', ')':
|
|
p.content.add(c)
|
|
of ',':
|
|
if shortHandEnd > 0: break # ',' after shorthand is flow indicator
|
|
p.content.add(c)
|
|
of '<':
|
|
if i == 1:
|
|
shorthandEnd = -1
|
|
p.content.reset()
|
|
else: raise p.lexer.generateError("Illegal character in tag handle")
|
|
of '>':
|
|
if shorthandEnd == -1:
|
|
p.lexer.bufpos.inc()
|
|
if p.lexer.buf[p.lexer.bufpos] notin spaceOrLineEnd:
|
|
raise p.lexer.generateError("Missing space after verbatim tag handle")
|
|
break
|
|
else: raise p.lexer.generateError("Illegal character in tag handle")
|
|
of '%':
|
|
if shorthandEnd != 0: p.content.add(p.lexer.byteSequence())
|
|
else: raise p.lexer.generateError("Illegal character in tag handle")
|
|
else: raise p.lexer.generateError("Illegal character in tag handle")
|
|
|
|
proc handleTagHandle(p: YamlParser) {.raises: [YamlParserError].} =
|
|
p.startToken()
|
|
if p.level.kind != fplUnknown: raise p.generateError("Unexpected tag handle")
|
|
if p.tag != yTagQuestionMark:
|
|
raise p.generateError("Only one tag handle is allowed per node")
|
|
p.content.reset()
|
|
var
|
|
shorthandEnd: int
|
|
p.tagHandle(shorthandEnd)
|
|
if shorthandEnd != -1:
|
|
try:
|
|
p.tagUri.reset()
|
|
p.tagUri.add(p.shorthands[p.content[0..shorthandEnd]])
|
|
p.tagUri.add(p.content[shorthandEnd + 1 .. ^1])
|
|
except KeyError:
|
|
raise p.generateError(
|
|
"Undefined tag shorthand: " & p.content[0..shorthandEnd])
|
|
try: p.tag = p.tagLib.tags[p.tagUri]
|
|
except KeyError: p.tag = p.tagLib.registerUri(p.tagUri)
|
|
else:
|
|
try: p.tag = p.tagLib.tags[p.content]
|
|
except KeyError: p.tag = p.tagLib.registerUri(p.content)
|
|
|
|
proc consumeLineIfEmpty(p: YamlParser, newlines: var int): bool =
|
|
result = true
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of ' ', '\t': discard
|
|
of '\l':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
break
|
|
of '\c':
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
break
|
|
of '#', EndOfFile:
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
break
|
|
else:
|
|
result = false
|
|
break
|
|
|
|
template startScalar(t: ScalarType) {.dirty.} =
|
|
p.newlines = 0
|
|
p.level.kind = fplScalar
|
|
scalarType = t
|
|
|
|
template blockScalarHeader() {.dirty.} =
|
|
debug("lex: blockScalarHeader")
|
|
chomp = ctClip
|
|
p.level.indentation = UnknownIndentation
|
|
if p.tag == yTagQuestionMark: p.tag = yTagExclamationMark
|
|
let t = if p.lexer.buf[p.lexer.bufpos] == '|': stLiteral else: stFolded
|
|
while true:
|
|
p.lexer.bufpos.inc()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '+':
|
|
if chomp != ctClip:
|
|
raise p.lexer.generateError("Only one chomping indicator is allowed")
|
|
chomp = ctKeep
|
|
of '-':
|
|
if chomp != ctClip:
|
|
raise p.lexer.generateError("Only one chomping indicator is allowed")
|
|
chomp = ctStrip
|
|
of '1'..'9':
|
|
if p.level.indentation != UnknownIndentation:
|
|
raise p.lexer.generateError("Only one p.indentation indicator is allowed")
|
|
p.level.indentation = p.ancestry[p.ancestry.high].indentation +
|
|
ord(p.lexer.buf[p.lexer.bufpos]) - ord('\x30')
|
|
of spaceOrLineEnd: break
|
|
else:
|
|
raise p.lexer.generateError(
|
|
"Illegal character in block scalar header: '" &
|
|
p.lexer.buf[p.lexer.bufpos] & "'")
|
|
recentWasMoreIndented = false
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
startScalar(t)
|
|
p.content.reset()
|
|
|
|
template blockScalarLine() {.dirty.} =
|
|
debug("lex: blockScalarLine")
|
|
if p.indentation < p.level.indentation:
|
|
if p.lexer.buf[p.lexer.bufpos] == '#':
|
|
# skip all following comment lines
|
|
while p.indentation > p.ancestry[p.ancestry.high].indentation:
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
p.newlines.inc(-1)
|
|
p.lexer.skipIndentation()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
if p.indentation > p.ancestry[p.ancestry.high].indentation:
|
|
raise p.lexer.generateError(
|
|
"Invalid content in block scalar after comments")
|
|
closeMoreIndentedLevels()
|
|
else:
|
|
raise p.lexer.generateError(
|
|
"Invalid p.indentation (expected p.indentation of at least " &
|
|
$p.level.indentation & " spaces)")
|
|
else:
|
|
if p.level.indentation == UnknownIndentation:
|
|
if p.lexer.buf[p.lexer.bufpos] in lineEnd:
|
|
handleLineEnd(true)
|
|
continue
|
|
else:
|
|
p.level.indentation = p.indentation
|
|
p.content.addMultiple('\l', p.newlines)
|
|
elif p.indentation > p.level.indentation or
|
|
p.lexer.buf[p.lexer.bufpos] == '\t':
|
|
p.content.addMultiple('\l', p.newlines)
|
|
recentWasMoreIndented = true
|
|
p.content.addMultiple(' ', p.indentation - p.level.indentation)
|
|
elif scalarType == stFolded:
|
|
if recentWasMoreIndented:
|
|
recentWasMoreIndented = false
|
|
p.newlines.inc()
|
|
if p.newlines == 0: discard
|
|
elif p.newlines == 1: p.content.add(' ')
|
|
else: p.content.addMultiple('\l', p.newlines - 1)
|
|
else: p.content.addMultiple('\l', p.newlines)
|
|
p.newlines = 0
|
|
while p.lexer.buf[p.lexer.bufpos] notin lineEnd:
|
|
p.content.add(p.lexer.buf[p.lexer.bufpos])
|
|
p.lexer.bufpos.inc()
|
|
handleLineEnd(true)
|
|
|
|
proc parse*(p: YamlParser, s: Stream): YamlStream =
|
|
p.content.reset()
|
|
p.after.reset()
|
|
p.tagUri.reset()
|
|
p.ancestry.setLen(0)
|
|
var backend = iterator(): YamlStreamEvent =
|
|
var
|
|
state = fpInitial
|
|
flowdepth: int = 0
|
|
explicitFlowKey: bool
|
|
scalarType: ScalarType
|
|
recentWasMoreIndented: bool
|
|
chomp: ChompType
|
|
|
|
p.lexer.open(s)
|
|
p.initDocValues()
|
|
|
|
while true:
|
|
case state
|
|
of fpInitial:
|
|
debug("state: initial")
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '%':
|
|
var ld: LexedDirective
|
|
p.startToken()
|
|
p.lexer.directiveName(ld)
|
|
case ld
|
|
of ldYaml:
|
|
var version = ""
|
|
p.startToken()
|
|
p.lexer.yamlVersion(version)
|
|
if version != "1.2":
|
|
if p.callback != nil:
|
|
p.callback(p.lexer.lineNumber, p.getColNumber(),
|
|
p.getLineContent(),
|
|
"Version is not 1.2, but " & version)
|
|
discard
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
of ldTag:
|
|
var shorthand = ""
|
|
p.tagUri.reset()
|
|
p.startToken()
|
|
p.lexer.tagShorthand(shorthand)
|
|
p.lexer.tagUriMapping(p.tagUri)
|
|
p.shorthands[shorthand] = p.tagUri
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
of ldUnknown:
|
|
if p.callback != nil:
|
|
p.callback(p.lexer.lineNumber, p.getColNumber(),
|
|
p.getLineContent(), "Unknown directive")
|
|
p.lexer.finishLine()
|
|
handleLineEnd(false)
|
|
of ' ', '\t':
|
|
if not p.consumeLineIfEmpty(p.newlines):
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
yield startDocEvent()
|
|
state = fpBlockObjectStart
|
|
of '\l': p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
of '\c': p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
of EndOfFile: return
|
|
of '#':
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
of '-':
|
|
var success: bool
|
|
p.startToken()
|
|
p.lexer.directivesEndMarker(success)
|
|
yield startDocEvent()
|
|
if success:
|
|
p.lexer.bufpos.inc(3)
|
|
state = fpBlockObjectStart
|
|
else:
|
|
yield startDocEvent()
|
|
state = fpBlockObjectStart
|
|
of fpBlockAfterPlainScalar:
|
|
debug("state: blockAfterPlainScalar")
|
|
p.lexer.skipWhitespace()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '\l':
|
|
if p.level.kind notin {fplUnknown, fplScalar}:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected scalar")
|
|
startScalar(stFlow)
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
state = fpBlockObjectStart
|
|
of '\c':
|
|
if p.level.kind notin {fplUnknown, fplScalar}:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected scalar")
|
|
startScalar(stFlow)
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
state = fpBlockObjectStart
|
|
else:
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpBlockAfterObject)
|
|
of fpBlockAfterObject:
|
|
debug("state: blockAfterObject")
|
|
p.lexer.skipWhitespace()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of EndOfFile:
|
|
closeEverything()
|
|
break
|
|
of '\l':
|
|
state = fpBlockObjectStart
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
of '\c':
|
|
state = fpBlockObjectStart
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
of ':':
|
|
case p.level.kind
|
|
of fplUnknown: yield p.objectStart(yamlStartMap)
|
|
of fplMapKey:
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
p.level.kind = fplMapValue
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplMapValue:
|
|
p.level.kind = fplMapValue
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
of fplSequence:
|
|
p.startToken()
|
|
raise p.generateError("Illegal token (expected sequence item)")
|
|
of fplScalar:
|
|
p.startToken()
|
|
raise p.generateError(
|
|
"Multiline scalars may not be implicit map keys")
|
|
of fplSinglePairKey, fplSinglePairValue, fplDocument: debugFail()
|
|
p.lexer.bufpos.inc()
|
|
p.lexer.skipWhitespace()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
state = fpBlockObjectStart
|
|
of '#':
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
state = fpBlockObjectStart
|
|
else:
|
|
p.startToken()
|
|
raise p.generateError(
|
|
"Illegal token (expected ':', comment or line end)")
|
|
of fpBlockObjectStart:
|
|
debug("state: blockObjectStart")
|
|
p.lexer.skipIndentation()
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
if p.indentation == 0:
|
|
var success: bool
|
|
p.lexer.directivesEndMarker(success)
|
|
if success:
|
|
p.lexer.bufpos.inc(3)
|
|
closeEverything()
|
|
p.initDocValues()
|
|
yield startDocEvent()
|
|
continue
|
|
p.lexer.documentEndMarker(success)
|
|
if success:
|
|
closeEverything()
|
|
p.lexer.bufpos.inc(3)
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
state = fpAfterDocument
|
|
continue
|
|
if p.indentation <= p.ancestry[p.ancestry.high].indentation:
|
|
if p.lexer.buf[p.lexer.bufpos] in lineEnd:
|
|
handleLineEnd(true)
|
|
continue
|
|
elif p.lexer.buf[p.lexer.bufpos] == '#':
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
continue
|
|
elif p.lexer.buf[p.lexer.bufpos] == '-' and not
|
|
p.lexer.isPlainSafe(p.lexer.bufpos + 1, cBlock):
|
|
closeMoreIndentedLevels(true)
|
|
else: closeMoreIndentedLevels()
|
|
elif p.indentation <= p.level.indentation and
|
|
p.lexer.buf[p.lexer.bufpos] in lineEnd:
|
|
handleLineEnd(true)
|
|
continue
|
|
if p.level.kind == fplScalar and scalarType != stFlow:
|
|
blockScalarLine()
|
|
continue
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '\l':
|
|
p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
if p.level.kind == fplUnknown:
|
|
p.level.indentation = UnknownIndentation
|
|
of '\c':
|
|
p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
p.newlines.inc()
|
|
if p.level.kind == fplUnknown:
|
|
p.level.indentation = UnknownIndentation
|
|
of EndOfFile:
|
|
closeEverything()
|
|
return
|
|
of '#':
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
if p.level.kind == fplUnknown:
|
|
p.level.indentation = UnknownIndentation
|
|
of '\'':
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.singleQuotedScalar()
|
|
if p.tag == yTagQuestionMark: p.tag = yTagExclamationMark
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpBlockAfterObject)
|
|
of '"':
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.doubleQuotedScalar()
|
|
if p.tag == yTagQuestionMark: p.tag = yTagExclamationMark
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpBlockAfterObject)
|
|
of '|', '>':
|
|
blockScalarHeader()
|
|
continue
|
|
of '-':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cBlock):
|
|
if p.level.kind == fplScalar:
|
|
p.continueMultilineScalar()
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.plainScalar(cBlock)
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
p.lexer.bufpos.inc()
|
|
handleBlockSequenceIndicator()
|
|
of '!':
|
|
handleBlockItemStart()
|
|
p.handleTagHandle()
|
|
of '&':
|
|
handleBlockItemStart()
|
|
p.handleAnchor()
|
|
of '*':
|
|
handleBlockItemStart()
|
|
handleAlias()
|
|
of '[', '{':
|
|
handleBlockItemStart()
|
|
state = fpFlow
|
|
of '?':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cBlock):
|
|
if p.level.kind == fplScalar:
|
|
p.continueMultilineScalar()
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.plainScalar(cBlock)
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
p.lexer.bufpos.inc()
|
|
handleMapKeyIndicator()
|
|
of ':':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cBlock):
|
|
if p.level.kind == fplScalar:
|
|
p.continueMultilineScalar()
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.plainScalar(cBlock)
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
p.lexer.bufpos.inc()
|
|
handleMapValueIndicator()
|
|
of '@', '`':
|
|
raise p.lexer.generateError(
|
|
"Reserved characters cannot start a plain scalar")
|
|
of '\t':
|
|
if p.level.kind == fplScalar:
|
|
p.lexer.skipWhitespace()
|
|
p.continueMultilineScalar()
|
|
state = fpBlockAfterPlainScalar
|
|
else: raise p.lexer.generateError("\\t cannot start any token")
|
|
else:
|
|
if p.level.kind == fplScalar:
|
|
p.continueMultilineScalar()
|
|
state = fpBlockAfterPlainScalar
|
|
else:
|
|
handleBlockItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.plainScalar(cBlock)
|
|
state = fpBlockAfterPlainScalar
|
|
of fpExpectDocEnd:
|
|
debug("state: expectDocEnd")
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '-':
|
|
var success: bool
|
|
p.lexer.directivesEndMarker(success)
|
|
if success:
|
|
p.lexer.bufpos.inc(3)
|
|
yield endDocEvent()
|
|
discard p.ancestry.pop()
|
|
p.initDocValues()
|
|
yield startDocEvent()
|
|
state = fpBlockObjectStart
|
|
else:
|
|
raise p.generateError("Unexpected content (expected document end)")
|
|
of '.':
|
|
var isDocumentEnd: bool
|
|
p.startToken()
|
|
p.lexer.documentEndMarker(isDocumentEnd)
|
|
if isDocumentEnd:
|
|
closeEverything()
|
|
p.lexer.bufpos.inc(3)
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
state = fpAfterDocument
|
|
else:
|
|
raise p.generateError("Unexpected content (expected document end)")
|
|
of ' ', '\t', '#':
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
of '\l': p.lexer.bufpos = p.lexer.handleLF(p.lexer.bufpos)
|
|
of '\c': p.lexer.bufpos = p.lexer.handleCR(p.lexer.bufpos)
|
|
of EndOfFile:
|
|
yield endDocEvent()
|
|
break
|
|
else:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected content (expected document end)")
|
|
of fpAfterDocument:
|
|
debug("state: afterDocument")
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '.':
|
|
var isDocumentEnd: bool
|
|
p.startToken()
|
|
p.lexer.documentEndMarker(isDocumentEnd)
|
|
if isDocumentEnd:
|
|
p.lexer.bufpos.inc(3)
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
else:
|
|
p.initDocValues()
|
|
yield startDocEvent()
|
|
state = fpBlockObjectStart
|
|
of '#':
|
|
p.lineEnding()
|
|
handleLineEnd(false)
|
|
of '\t', ' ':
|
|
if not p.consumeLineIfEmpty(p.newlines):
|
|
p.indentation = p.lexer.getColNumber(p.lexer.bufpos)
|
|
p.initDocValues()
|
|
yield startDocEvent()
|
|
state = fpBlockObjectStart
|
|
of EndOfFile: break
|
|
else:
|
|
p.initDocValues()
|
|
state = fpInitial
|
|
of fpFlow:
|
|
debug("state: flow")
|
|
p.lexer.skipWhitespaceCommentsAndNewlines()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of '{':
|
|
handleFlowItemStart()
|
|
yield p.objectStart(yamlStartMap)
|
|
flowdepth.inc()
|
|
p.lexer.bufpos.inc()
|
|
explicitFlowKey = false
|
|
of '[':
|
|
handleFlowItemStart()
|
|
yield p.objectStart(yamlStartSeq)
|
|
flowdepth.inc()
|
|
p.lexer.bufpos.inc()
|
|
of '}':
|
|
assert(p.level.kind == fplUnknown)
|
|
p.level = p.ancestry.pop()
|
|
case p.level.kind
|
|
of fplMapValue:
|
|
yield emptyScalar(p)
|
|
p.level.kind = fplMapKey
|
|
of fplMapKey:
|
|
if p.tag != yTagQuestionMark or p.anchor != yAnchorNone or
|
|
explicitFlowKey:
|
|
yield emptyScalar(p)
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
of fplSequence:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected ']')")
|
|
of fplSinglePairValue:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected ']')")
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.lexer.bufpos.inc()
|
|
leaveFlowLevel()
|
|
of ']':
|
|
assert(p.level.kind == fplUnknown)
|
|
p.level = p.ancestry.pop()
|
|
case p.level.kind
|
|
of fplSequence:
|
|
if p.tag != yTagQuestionMark or p.anchor != yAnchorNone:
|
|
yield emptyScalar(p)
|
|
of fplSinglePairValue:
|
|
yield emptyScalar(p)
|
|
p.level = p.ancestry.pop()
|
|
yield endMapEvent()
|
|
assert(p.level.kind == fplSequence)
|
|
of fplMapKey, fplMapValue:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected '}')")
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.lexer.bufpos.inc()
|
|
leaveFlowLevel()
|
|
of ',':
|
|
assert(p.level.kind == fplUnknown)
|
|
p.level = p.ancestry.pop()
|
|
case p.level.kind
|
|
of fplSequence: yield emptyScalar(p)
|
|
of fplMapValue:
|
|
yield emptyScalar(p)
|
|
p.level.kind = fplMapKey
|
|
explicitFlowKey = false
|
|
of fplMapKey:
|
|
yield emptyScalar(p)
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
explicitFlowKey = false
|
|
of fplSinglePairValue:
|
|
yield emptyScalar(p)
|
|
p.level = p.ancestry.pop()
|
|
yield endMapEvent()
|
|
assert(p.level.kind == fplSequence)
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
p.lexer.bufpos.inc()
|
|
of ':':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cFlow):
|
|
handleFlowItemStart()
|
|
handleFlowPlainScalar()
|
|
else:
|
|
p.level = p.ancestry.pop()
|
|
case p.level.kind
|
|
of fplSequence:
|
|
yield startMapEvent(p.tag, p.anchor)
|
|
debug("started single-pair map at " &
|
|
(if p.level.indentation == UnknownIndentation:
|
|
$p.indentation else: $p.level.indentation))
|
|
p.tag = yTagQuestionMark
|
|
p.anchor = yAnchorNone
|
|
if p.level.indentation == UnknownIndentation:
|
|
p.level.indentation = p.indentation
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplSinglePairValue)
|
|
yield scalarEvent("")
|
|
of fplMapValue, fplSinglePairValue:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected ',')")
|
|
of fplMapKey:
|
|
yield emptyScalar(p)
|
|
p.level.kind = fplMapValue
|
|
of fplSinglePairKey:
|
|
yield emptyScalar(p)
|
|
p.level.kind = fplSinglePairValue
|
|
of fplUnknown, fplScalar, fplDocument: debugFail()
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
p.lexer.bufpos.inc()
|
|
of '\'':
|
|
handleFlowItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.singleQuotedScalar()
|
|
if p.tag == yTagQuestionMark: p.tag = yTagExclamationMark
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpFlowAfterObject)
|
|
of '"':
|
|
handleFlowItemStart()
|
|
p.content.reset()
|
|
p.startToken()
|
|
p.doubleQuotedScalar()
|
|
if p.tag == yTagQuestionMark: p.tag = yTagExclamationMark
|
|
yield currentScalar(p)
|
|
handleObjectEnd(fpFlowAfterObject)
|
|
of '!':
|
|
handleFlowItemStart()
|
|
p.handleTagHandle()
|
|
of '&':
|
|
handleFlowItemStart()
|
|
p.handleAnchor()
|
|
of '*':
|
|
handleAlias()
|
|
state = fpFlowAfterObject
|
|
of '?':
|
|
if p.lexer.isPlainSafe(p.lexer.bufpos + 1, cFlow):
|
|
handleFlowItemStart()
|
|
handleFlowPlainScalar()
|
|
elif explicitFlowKey:
|
|
p.startToken()
|
|
raise p.generateError("Duplicate '?' in flow mapping")
|
|
elif p.level.kind == fplUnknown:
|
|
case p.ancestry[p.ancestry.high].kind
|
|
of fplMapKey, fplMapValue, fplDocument: discard
|
|
of fplSequence: yield p.objectStart(yamlStartMap, true)
|
|
else:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token")
|
|
explicitFlowKey = true
|
|
p.lexer.bufpos.inc()
|
|
else:
|
|
explicitFlowKey = true
|
|
p.lexer.bufpos.inc()
|
|
else:
|
|
handleFlowItemStart()
|
|
handleFlowPlainScalar()
|
|
of fpFlowAfterObject:
|
|
debug("state: flowAfterObject")
|
|
p.lexer.skipWhitespaceCommentsAndNewlines()
|
|
case p.lexer.buf[p.lexer.bufpos]
|
|
of ']':
|
|
case p.level.kind
|
|
of fplSequence: discard
|
|
of fplMapKey, fplMapValue:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected '}')")
|
|
of fplSinglePairValue:
|
|
p.level = p.ancestry.pop()
|
|
assert(p.level.kind == fplSequence)
|
|
yield endMapEvent()
|
|
of fplScalar, fplUnknown, fplSinglePairKey, fplDocument: debugFail()
|
|
p.lexer.bufpos.inc()
|
|
leaveFlowLevel()
|
|
of '}':
|
|
case p.level.kind
|
|
of fplMapKey, fplMapValue: discard
|
|
of fplSequence, fplSinglePairValue:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected ']')")
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.lexer.bufpos.inc()
|
|
leaveFlowLevel()
|
|
of ',':
|
|
case p.level.kind
|
|
of fplSequence: discard
|
|
of fplMapValue:
|
|
yield scalarEvent("", yTagQuestionMark, yAnchorNone)
|
|
p.level.kind = fplMapKey
|
|
explicitFlowKey = false
|
|
of fplSinglePairValue:
|
|
p.level = p.ancestry.pop()
|
|
assert(p.level.kind == fplSequence)
|
|
yield endMapEvent()
|
|
of fplMapKey: explicitFlowKey = false
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
state = fpFlow
|
|
p.lexer.bufpos.inc()
|
|
of ':':
|
|
case p.level.kind
|
|
of fplSequence, fplMapKey:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected token (expected ',')")
|
|
of fplMapValue, fplSinglePairValue: discard
|
|
of fplUnknown, fplScalar, fplSinglePairKey, fplDocument: debugFail()
|
|
p.ancestry.add(p.level)
|
|
p.level = initLevel(fplUnknown)
|
|
state = fpFlow
|
|
p.lexer.bufpos.inc()
|
|
of '#':
|
|
p.lineEnding()
|
|
handleLineEnd(true)
|
|
of EndOfFile:
|
|
p.startToken()
|
|
raise p.generateError("Unclosed flow content")
|
|
else:
|
|
p.startToken()
|
|
raise p.generateError("Unexpected content (expected flow indicator)")
|
|
try: result = initYamlStream(backend)
|
|
except Exception: debugFail() # compiler error |