mentat/edn/src/edn.rustpeg

/* 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" whitespace+ "NaN" { Value::Float(OrderedFloat(NAN)) }

pub infinity -> Value =
    "#f" whitespace+ 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]
alphanumeric = [0-9a-zA-Z]
octaldigit = [0-7]
validbase = [3][0-6] / [12][0-9] / [2-9]
hex = [0-9a-fA-F]
sign = "-" / "+"

pub bigint -> Value =
    b:$( sign? digit+ ) "N" {
        Value::BigInteger(b.parse::<BigInt>().unwrap())
    }

pub octalinteger -> Value =
    "0" i:$( octaldigit+ ) {
        Value::Integer(i64::from_str_radix(i, 8).unwrap())
    }

pub hexinteger -> Value =
    "0x" i:$( hex+ ) {
        Value::Integer(i64::from_str_radix(i, 16).unwrap())
    }

pub basedinteger -> Value =
    // Only allow values 2-36
    b:$( validbase ) "r" i:$( alphanumeric+ ) {
        Value::Integer(i64::from_str_radix(i, b.parse::<u32>().unwrap()).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 / octalinteger / hexinteger / basedinteger / 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)*