///|
priv struct Parser {
tokens : Triples
reports : Array[Report]
mut next : Int
mut parsed_position : Position
}
///|
let dummy_position : Position = Position::{
fname: "",
lnum: 1,
bol: 0,
cnum: 0,
}
///|
fn parse_config_document(
name : String,
source : String,
) -> (Ast, Array[@basic.Report]) {
let lex_result = @lexer.tokens_from_string(source, comment=false, name~)
let reports : Array[Report] = []
for error in lex_result.errors {
let (start, end, err) = error
reports.push(Report::{ loc: Location::{ start, end }, msg: err.to_string() })
}
let parser = Parser::{
tokens: lex_result.tokens,
reports,
next: 0,
parsed_position: first_position(lex_result.tokens),
}
let start = parser.peek_spos()
parser.parsed_position = start
let fields = parser.parse_top_fields()
let loc = Location::{ start, end: parser.parsed_position }
(Ast::Obj(fields, loc), parser.reports)
}
///|
fn first_position(tokens : Triples) -> Position {
match tokens.get(0) {
Some((_, start, _)) => start
None => dummy_position
}
}
///|
fn is_layout(token : Token) -> Bool {
match token {
NEWLINE | COMMENT(_) | SEMI(_) => true
_ => false
}
}
///|
fn Parser::peek(self : Parser, nth? : Int = 0) -> Triple {
let mut offset = 0
let mut step = 0
while self.tokens.get(self.next + offset) is Some((token, _, _) as triple) {
if is_layout(token) {
offset += 1
continue
}
if step == nth {
return triple
}
step += 1
offset += 1
}
match self.tokens.last() {
Some(last) => last
None => (EOF, dummy_position, dummy_position)
}
}
///|
fn Parser::consume(self : Parser) -> Triple {
while self.tokens.get(self.next) is Some((token, _, _) as triple) {
self.next += 1
if is_layout(token) {
continue
}
self.parsed_position = triple.2
return triple
}
(EOF, dummy_position, dummy_position)
}
///|
fn Parser::skip(self : Parser) -> Unit {
ignore(self.consume())
}
///|
fn Parser::peek_token(self : Parser, nth? : Int = 0) -> Token {
self.peek(nth~).0
}
///|
fn Parser::peek_kind(self : Parser, nth? : Int = 0) -> TokenKind {
self.peek(nth~).0.kind()
}
///|
fn Parser::peek_spos(self : Parser, nth? : Int = 0) -> Position {
self.peek(nth~).1
}
///|
fn Parser::peek_location(self : Parser) -> Location {
let (_, start, end) = self.peek()
Location::{ start, end }
}
///|
fn Parser::loc_start_with(self : Parser, start : Position) -> Location {
Location::{ start, end: self.parsed_position }
}
///|
fn Parser::consume_if(self : Parser, expected : TokenKind) -> Bool {
if self.peek_kind() == expected {
self.skip()
true
} else {
false
}
}
///|
fn Parser::report_here(self : Parser, msg : String) -> Unit {
self.reports.push(Report::{ loc: self.peek_location(), msg })
}
///|
fn Parser::parse_top_fields(self : Parser) -> Array[ConfigField] {
let fields : Array[ConfigField] = []
while self.peek_kind() != TK_EOF {
let before = self.next
match self.parse_identifier() {
None => {
self.report_here("expected field name")
if self.peek_kind() != TK_EOF {
self.skip()
}
}
Some((key, key_loc)) => {
if !self.consume_if(TK_EQUAL) {
self.report_here("expected `=` after field name")
}
let value = self.parse_value()
fields.push(ConfigField::{ key, key_loc, value })
}
}
if self.next == before && self.peek_kind() != TK_EOF {
self.skip()
}
}
fields
}
///|
fn Parser::parse_object_fields(self : Parser) -> Array[ConfigField] {
let fields : Array[ConfigField] = []
if self.consume_if(TK_RBRACE) {
return fields
}
while self.peek_kind() != TK_EOF {
match self.parse_identifier() {
None => {
self.report_here("expected object field name")
if self.peek_kind() != TK_EOF {
self.skip()
}
}
Some((key, key_loc)) => {
if !self.consume_if(TK_COLON) {
self.report_here("expected `:` after object field name")
}
let value = self.parse_value()
fields.push(ConfigField::{ key, key_loc, value })
if self.consume_if(TK_RBRACE) {
return fields
}
if self.consume_if(TK_COMMA) {
if self.consume_if(TK_RBRACE) {
return fields
}
} else if self.peek_kind() != TK_EOF {
self.report_here("expected `,` or `}` after object field")
}
}
}
}
self.report_here("unterminated object")
fields
}
///|
fn Parser::parse_array_items(self : Parser) -> Array[Ast] {
let items : Array[Ast] = []
if self.consume_if(TK_RBRACKET) {
return items
}
while self.peek_kind() != TK_EOF {
items.push(self.parse_value())
if self.consume_if(TK_RBRACKET) {
return items
}
if self.consume_if(TK_COMMA) {
if self.consume_if(TK_RBRACKET) {
return items
}
} else if self.peek_kind() != TK_EOF {
self.report_here("expected `,` or `]` after array item")
}
}
self.report_here("unterminated array")
items
}
///|
fn Parser::parse_value(self : Parser) -> Ast {
let loc = self.peek_location()
match self.peek_token() {
TRUE => {
self.skip()
Ast::Bool(true, loc)
}
FALSE => {
self.skip()
Ast::Bool(false, loc)
}
STRING(value) => {
self.skip()
Ast::Str(decode_config_string(value), loc)
}
MULTILINE_STRING(value) => {
self.skip()
Ast::Str(value, loc)
}
INT(value) => {
self.skip()
Ast::Int(value, loc)
}
MINUS => self.parse_negative_int()
LBRACE => {
let start = self.peek_spos()
self.skip()
let fields = self.parse_object_fields()
Ast::Obj(fields, self.loc_start_with(start))
}
LBRACKET => {
let start = self.peek_spos()
self.skip()
let items = self.parse_array_items()
Ast::Arr(items, self.loc_start_with(start))
}
LIDENT(word) => {
self.skip()
self.reports.push(Report::{ loc, msg: "unsupported value: " + word })
Ast::Str(word, loc)
}
FLOAT(_) | DOUBLE(_) as token => {
self.skip()
self.reports.push(Report::{
loc,
msg: "unsupported value: " + token.to_expect_string(),
})
Ast::Str("", loc)
}
EOF => {
self.report_here("expected value")
Ast::Str("", loc)
}
_ => {
self.report_here("expected value")
if self.peek_kind() != TK_EOF {
self.skip()
}
Ast::Str("", loc)
}
}
}
///|
fn decode_config_string(value : String) -> String {
let builder = StringBuilder::new()
let mut escaped = false
for _, ch in value {
if escaped {
match ch {
'"' => builder.write_char('"')
'\\' => builder.write_char('\\')
'n' => builder.write_char('\n')
't' => builder.write_char('\t')
_ => {
builder.write_char('\\')
builder.write_char(ch)
}
}
escaped = false
} else if ch == '\\' {
escaped = true
} else {
builder.write_char(ch)
}
}
if escaped {
builder.write_char('\\')
}
builder.to_string()
}
///|
fn Parser::parse_negative_int(self : Parser) -> Ast {
let start = self.peek_spos()
self.skip()
match self.peek_token() {
INT(value) => {
self.skip()
Ast::Int("-" + value, self.loc_start_with(start))
}
_ => {
self.report_here("expected digits after `-`")
Ast::Int("-", self.loc_start_with(start))
}
}
}
///|
fn Parser::parse_identifier(self : Parser) -> (String, ConfigLoc)? {
let loc = self.peek_location()
match self.peek_token() {
LIDENT(name) => {
self.skip()
Some((name, loc))
}
PACKAGE => {
self.skip()
Some(("package", loc))
}
_ => None
}
}