parse.peg

package toml

type tomlParser Peg {
    toml
}

TOML <- Expression (newline Expression)* newline* !. { _ = buffer }

Expression <- (
    <ws table ws comment? (ws newlineRequired wsnl keyval ws comment?)*> { p.SetTableSource(begin, end) }
  / ws keyval ws comment?
  / ws comment?
  / ws
)

val <- (
    <datetime>    { p.SetTime(begin, end) }
  / <float>       { p.SetFloat(begin, end) }
  / <integer>     { p.SetInteger(begin, end) }
  / <string>      { p.SetString(begin, end) }
  / <boolean>     { p.SetBool(begin, end) }
  / <array>       { p.SetArray(begin, end) }
  / <inlineTable> { p.SetInlineTableSource(begin, end) }
)

ws <- [ \t]*
wsnl <- ([ \t] / newline)*

comment <- '#' (badControl / [\t -\0x10FFFF])*

newline <- ('\r\n' / '\n') { p.Newline() }

newlineRequired <- (
    !newline { p.Error(errNewlineRequired) }
  / newline
)

badControl <- <[\0x7F\0x0B\0xC\0x00-\0x08\0x0E-\0x1F]> {
    p.Error(&rawControlError{p.buffer[begin]})
}

# -------------------------------------------------------------------------
# -- Tables

table <- stdTable / arrayTable

stdTable <- '[' ws <tableKey> ws ']' { p.SetTable(p.buffer, begin, end) }

arrayTable <- '[[' ws <tableKey> ws ']]' { p.SetArrayTable(p.buffer, begin, end) }

keyval <- key ws '=' ws val { p.AddKeyValue() }

key <- bareKey / quotedKey

bareKey <- <bareKeyChar+> { p.SetKey(p.buffer, begin, end) }

bareKeyChar <- badControl / [0-9A-Za-z\-_]

quotedKey <- < '"' basicChar* '"' > { p.SetKey(p.buffer, begin, end) }

tableKey <- tableKeyComp (tableKeySep tableKeyComp)*

tableKeyComp <- key { p.AddTableKey() }

tableKeySep <- ws '.' ws

# -------------------------------------------------------------------------
# -- Inline Tables

inlineTable <- (
    '{' { p.StartInlineTable() }
    ws inlineTableKeyValues? ws
    '}' { p.EndInlineTable() }
)

inlineTableKeyValues <- (
  keyval
  (
      ws inlineTableCommaRequired ws
      keyval
  )*
  ws inlineTableCommaForbidden
)

inlineTableCommaForbidden <- (
    !','
  / ',' { p.Error(errInlineTableCommaAtEnd) }
)

inlineTableCommaRequired <- (
    !',' { p.Error(errInlineTableCommaRequired) }
  / ','
)

# -------------------------------------------------------------------------
# -- Booleans

boolean <- 'true' / 'false'

# -------------------------------------------------------------------------
# -- Numbers

integer <- hexInt / octalInt / binaryInt / decimalInt / ([+\-] decimalInt)

decimalInt <- [1-9] (decimalDigit / '_' decimalDigit)+ / decimalDigit
decimalDigit <- [0-9]

hexInt <- '0x' hexDigit (hexDigit / '_' hexDigit)*
hexDigit <- [[0-9A-F]]

octalInt <- '0o' octalDigit (octalDigit / '_' octalDigit)*
octalDigit <- [0-7]

binaryInt <- '0b' binaryDigit (binaryDigit / '_' octalDigit)*
binaryDigit <- [01]

float <- [+\-]? ('nan' / 'inf' / floatDigits)
floatDigits <- decimalInt (floatFrac floatExp? / floatFrac? floatExp)
floatFrac <- '.' decimalDigit (decimalDigit / '_' decimalDigit)*
floatExp <- [[E]] [\-+]? decimalDigit (decimalDigit / '_' decimalDigit)*

# -------------------------------------------------------------------------
# -- Escape Sequences

escaped <- escape ([btnfr"/\\] / 'u' hexQuad / 'U' hexQuad hexQuad)
escape <- '\\'

hexQuad <- hexDigit hexDigit hexDigit hexDigit

# -------------------------------------------------------------------------
# -- Strings

string <- (
    mlLiteralString
  / literalString
  / mlBasicString
  / basicString
)

basicString <- <'"' basicChar* '"'> { p.SetBasicString(p.buffer, begin, end) }

basicChar <- badControl / basicUnescaped / escaped

# This is basically the full printable range, excluding " and \
basicUnescaped <- [\t -!#-\[\]-\0x10FFFF]

mlBasicString <- '"""' mlBasicBody '"""' { p.SetMultilineBasicString() }

mlBasicBody <- (
    mlBasicBodyChar*
    mlBasicBodyEndQuotes?                # needed for strings like """str"""""
)

mlBasicBodyChar <- (
    !'"""' '"' { p.AddMultilineBasicQuote() }
  / <basicChar / newline> { p.AddMultilineBasicBody(p.buffer, begin, end) }
  / escape newline wsnl
)
mlBasicBodyEndQuotes <- (
    ('""' &'"""') { p.AddMultilineBasicQuote(); p.AddMultilineBasicQuote() }
  / ('"' &'"""')  { p.AddMultilineBasicQuote() }
)

literalString <- "'" <literalChar*> "'" { p.SetLiteralString(p.buffer, begin, end) }

literalChar <- badControl / [\t -&(-\0x10FFFF]

mlLiteralString <- (
    "'''"
    <mlLiteralBody> { p.SetMultilineLiteralString(p.buffer, begin, end) }
    "'''"
)

mlLiteralBody <- (
    (!"'''" (mlLiteralChar / newline))*
    mlLiteralBodyEndQuotes?               # needed for '''str'''''
)

mlLiteralChar <- badControl / [\t -\0x10FFFF]
mlLiteralBodyEndQuotes <- ("''" &"'''") / ("'" &"'''")

# -------------------------------------------------------------------------
# -- Datetimes

datetime <- (fullDate ([[T ]] fullTime)?) / partialTime

partialTime <- timeHour ':' timeMinute ':' timeSecond timeSecfrac?

fullDate <- dateFullYear '-' dateMonth '-' dateMDay
fullTime <- partialTime timeOffset?

dateFullYear <- digitQuad
dateMonth <- digitDual
dateMDay <- digitDual
timeHour <- digitDual
timeMinute <- digitDual
timeSecond <- digitDual
timeSecfrac <- '.' decimalDigit+
timeNumoffset <- [\-+] timeHour ':' timeMinute
timeOffset <- [[Z]] / timeNumoffset

digitDual <- decimalDigit decimalDigit
digitQuad <- digitDual digitDual

# -------------------------------------------------------------------------
# -- Arrays

array <- (
    '[' { p.StartArray() }
    wsnl arrayValues? wsnl
    ']'
)

arrayValues <- (
    (wsnl comment)* wsnl
    val { p.AddArrayVal() }
    (
        (wsnl comment)* wsnl
        arraySep
        (wsnl comment)* wsnl
        val { p.AddArrayVal() }
    )*
    (wsnl comment)* wsnl
    arraySep?
    (wsnl comment)*
)

arraySep <- ','