146 lines
4.2 KiB
Text
146 lines
4.2 KiB
Text
/* vim: set filetype=rust.rustpeg */
|
|
|
|
// Copyright 2016 Mozilla
|
|
//
|
|
// 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.
|
|
|
|
use std::collections::{BTreeSet, BTreeMap, LinkedList};
|
|
use std::iter::FromIterator;
|
|
use std::f64::{NAN, INFINITY, NEG_INFINITY};
|
|
|
|
use num::BigInt;
|
|
use ordered_float::OrderedFloat;
|
|
use types;
|
|
use types::Value;
|
|
|
|
// Goal: Be able to parse https://github.com/edn-format/edn
|
|
// Also extensible to help parse http://docs.datomic.com/query.html
|
|
|
|
// Debugging hint: test using `cargo test --features peg/trace -- --nocapture`
|
|
// to trace where the parser is failing
|
|
|
|
// TODO: Support tagged elements
|
|
// TODO: Support discard
|
|
|
|
pub nil -> Value =
|
|
"nil" { Value::Nil }
|
|
|
|
pub nan -> Value =
|
|
"#f" __ "NaN" { Value::Float(OrderedFloat(NAN)) }
|
|
|
|
pub infinity -> Value =
|
|
"#f" __ s:$(sign) "Infinity" {
|
|
Value::Float(OrderedFloat(if s == "+" { INFINITY } else { NEG_INFINITY }))
|
|
}
|
|
|
|
pub boolean -> Value =
|
|
"true" { Value::Boolean(true) } /
|
|
"false" { Value::Boolean(false) }
|
|
|
|
digit = [0-9]
|
|
sign = "-" / "+"
|
|
|
|
pub bigint -> Value =
|
|
b:$( sign? digit+ ) "N" {
|
|
Value::BigInteger(b.parse::<BigInt>().unwrap())
|
|
}
|
|
|
|
pub integer -> Value =
|
|
i:$( sign? digit+ ) {
|
|
Value::Integer(i.parse::<i64>().unwrap())
|
|
}
|
|
|
|
frac = sign? digit+ "." digit+
|
|
exp = sign? digit+ ("e" / "E") sign? digit+
|
|
frac_exp = sign? digit+ "." digit+ ("e" / "E") sign? digit+
|
|
|
|
// The order here is important - frac_exp must come before (exp / frac) or the
|
|
// parser assumes exp or frac when the float is really a frac_exp and fails
|
|
pub float -> Value =
|
|
f:$( frac_exp / exp / frac ) {
|
|
Value::Float(OrderedFloat(f.parse::<f64>().unwrap()))
|
|
}
|
|
|
|
// TODO: \newline, \return, \space and \tab
|
|
special_char = quote / tab
|
|
quote = "\\\""
|
|
tab = "\\tab"
|
|
char = [^"] / special_char
|
|
|
|
pub text -> Value =
|
|
"\"" t:$( char* ) "\"" {
|
|
Value::Text(t.to_string())
|
|
}
|
|
|
|
namespace_divider = "."
|
|
namespace_separator = "/"
|
|
|
|
// TODO: Be more picky here
|
|
// Keywords follow the rules of symbols, except they can (and must) begin with :
|
|
// e.g. :fred or :my/fred. See https://github.com/edn-format/edn#keywords
|
|
symbol_char_initial = [a-z] / [A-Z] / [0-9] / [*!_?$%&=<>]
|
|
symbol_char_subsequent = [a-z] / [A-Z] / [0-9] / [-*!_?$%&=<>]
|
|
|
|
symbol_namespace = symbol_char_initial symbol_char_subsequent* (namespace_divider symbol_char_subsequent+)*
|
|
symbol_name = ( symbol_char_initial+ / "." ) ( symbol_char_subsequent* / "." )
|
|
|
|
keyword_prefix = ":"
|
|
|
|
pub symbol -> Value =
|
|
ns:( sns:$(symbol_namespace) namespace_separator {
|
|
sns
|
|
})? n:$(symbol_name) {
|
|
types::to_symbol(ns, n)
|
|
}
|
|
|
|
pub keyword -> Value =
|
|
keyword_prefix ns:( sns:$(symbol_namespace) namespace_separator {
|
|
sns
|
|
})? n:$(symbol_name) {
|
|
types::to_keyword(ns, n)
|
|
}
|
|
|
|
pub list -> Value =
|
|
"(" __ v:(value)* __ ")" {
|
|
Value::List(LinkedList::from_iter(v))
|
|
}
|
|
|
|
pub vector -> Value =
|
|
"[" __ v:(value)* __ "]" {
|
|
Value::Vector(v)
|
|
}
|
|
|
|
pub set -> Value =
|
|
"#{" __ v:(value)* __ "}" {
|
|
Value::Set(BTreeSet::from_iter(v))
|
|
}
|
|
|
|
pair -> (Value, Value) =
|
|
k:(value) v:(value) {
|
|
(k, v)
|
|
}
|
|
|
|
pub map -> Value =
|
|
"{" __ v:(pair)* __ "}" {
|
|
Value::Map(BTreeMap::from_iter(v))
|
|
}
|
|
|
|
// It's important that float comes before integer or the parser assumes that
|
|
// floats are integers and fails to parse
|
|
pub value -> Value =
|
|
__ v:(nil / nan / infinity / boolean / float / bigint / integer / text / keyword / symbol / list / vector / map / set) __ {
|
|
v
|
|
}
|
|
|
|
// Clojure (and thus EDN) regards commas as whitespace, and thus the two-element vectors [1 2] and
|
|
// [1,,,,2] are equivalent, as are the maps {:a 1, :b 2} and {:a 1 :b 2}.
|
|
whitespace = (" " / "\r" / "\n" / "\t" / ",")
|
|
comment = ";" [^\r\n]* ("\r" / "\n")?
|
|
|
|
__ = (whitespace / comment)*
|