parser_peg.peg

use std::prelude::v1::*;
use std::str::FromStr;
use std::{u8, u32, f64};
use std::{vec, write};

use super::builtins::exports as builtins;
use super::constants::exports as constants;
use super::values_tests::exports as tests;
use super::values::exports as values;




pub value -> values::Value = abbreviation / list / array / values / atom
pub value_sequence -> Vec<values::Value> = space? values : value ** (space?) space? { values }

atom -> values::Value = boolean / number / symbol / character / string / bytes / constant

list -> values::Value = list_empty / list_proper / list_dotted
list_proper -> values::Value = "(" space? elements : value ** space space? ")" { builtins::list_collect (elements, Some (true)) }
list_dotted -> values::Value = "(" space? elements : value ++ space space "." space last : value space? ")" { builtins::list_collect_dotted (elements, Some (last), Some (true)) }
list_empty -> values::Value = ( "(" space? ")" / "#null" ) { builtins::list_empty () }

array -> values::Value = ( "#array" / "#" ) "(" space? elements : value ** space space? ")" {?
	#[ cfg ( feature = "vonuvoli_values_array" ) ]
	let outcome = Ok (values::array_immutable_new (elements) .into ());
	#[ cfg ( not ( feature = "vonuvoli_values_array" ) ) ]
	let outcome = Err ("arrays not supported");
	outcome
}

values -> values::Value = ( "#values" / "#" ) "(" space? elements : value ** space space? ")" {?
	#[ cfg ( feature = "vonuvoli_values_values" ) ]
	let outcome = Ok (values::values_new_from_vec (elements) .into ());
	#[ cfg ( not ( feature = "vonuvoli_values_values" ) ) ]
	let outcome = Err ("values not supported");
	outcome
}

abbreviation -> values::Value = abbreviation : abbreviation_prefix whitespace? value : value { builtins::list_collect (vec! [abbreviation, value], Some (true)) }
abbreviation_prefix -> values::Value = value : $( "'" / "`" / ",@" / "," ) {?
		match value {
			"'" => Ok (values::symbol_clone_str ("quote").into ()),
			"`" => Ok (values::symbol_clone_str ("quasiquote").into ()),
			"," => Ok (values::symbol_clone_str ("unquote").into ()),
			",@" => Ok (values::symbol_clone_str ("unquote-splicing").into ()),
			_ => Err ("a2007ac4"),
		}
	}

boolean -> values::Value = boolean_true / boolean_false
boolean_true -> values::Value = "#true" { constants::TRUE.into () } / "#t" { constants::TRUE.into () }
boolean_false -> values::Value = "#false" { constants::FALSE.into () } / "#f" { constants::FALSE.into () }

number -> values::Value = value : ( number_real / number_integer ) !symbol_character_glyph { value.into () }
number_sign = ( "+" / "-" )

number_integer -> values::Value = number_integer_2 / number_integer_8 / number_integer_10 / number_integer_16
number_integer_2 -> values::Value = ( "#b" / "#B" ) value : $( number_sign? [0-1]+ ) {? i64::from_str_radix (value, 2) .map (|value| values::number_i64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_integer_8 -> values::Value = ( "#o" / "#O" ) value : $( number_sign? [0-7]+ ) {? i64::from_str_radix (value, 8) .map (|value| values::number_i64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_integer_10 -> values::Value = ( "#d" / "#D" )? value : $( number_sign? [0-9]+ ) {? i64::from_str_radix (value, 10) .map (|value| values::number_i64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_integer_16 -> values::Value = ( "#x" / "#X" ) value : $( number_sign? ( [0-9a-fA-F]+ ) ) {? i64::from_str_radix (value, 16) .map (|value| values::number_i64 (value) .into ()) .map_err (|_| "invalid real syntax") }

number_real -> values::Value = number_real_variant_1 / number_real_variant_2 / number_real_variant_3 / number_real_variant_4 / number_real_inf / number_real_nan / number_real_epsilon
number_real_variant_1 -> values::Value = value : $( number_sign? [0-9]+ "." [0-9]+ number_real_exponent? ) {? f64::from_str (value) .map (|value| values::number_f64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_real_variant_2 -> values::Value = value : $( number_sign? [0-9]+ "." number_real_exponent? ) {? f64::from_str (value) .map (|value| values::number_f64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_real_variant_3 -> values::Value = value : $( number_sign? "." [0-9]+ number_real_exponent? ) {? f64::from_str (value) .map (|value| values::number_f64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_real_variant_4 -> values::Value = value : $( number_sign? [0-9]+ number_real_exponent ) {? f64::from_str (value) .map (|value| values::number_f64 (value) .into ()) .map_err (|_| "invalid real syntax") }
number_real_inf -> values::Value = number_real_inf_positive / number_real_inf_negative
number_real_inf_positive -> values::Value = (&"+" number_sign)? "inf" ".0"? { constants::INF_POSITIVE.into () }
number_real_inf_negative -> values::Value = &"-" number_sign "inf" ".0"? { constants::INF_NEGATIVE.into () }
number_real_nan -> values::Value = number_real_nan_positive / number_real_nan_negative
number_real_nan_positive -> values::Value = (&"+" number_sign)? "nan" ".0"? { constants::NAN_POSITIVE.into () }
number_real_nan_negative -> values::Value = &"-" number_sign "nan" ".0"? { constants::NAN_NEGATIVE.into () }
number_real_epsilon -> values::Value = number_real_epsilon_positive / number_real_epsilon_negative
number_real_epsilon_positive -> values::Value = (&"+" number_sign)? "epsilon" ".0"? { constants::EPSILON_POSITIVE.into () }
number_real_epsilon_negative -> values::Value = &"-" number_sign "epsilon" ".0"? { constants::EPSILON_NEGATIVE.into () }
number_real_exponent = ( "e" / "E" ) number_sign? [0-9]+

character -> values::Value = character_glyph / character_escaped / character_named
character_glyph -> values::Value = "#\\" glyph : $( . ) !atom {?
	#[ cfg ( feature = "vonuvoli_values_string" ) ]
	let outcome = Ok (values::character (glyph.chars () .next () .expect ("36da249a")) .into ());
	#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
	let outcome = Err ("strings are not supported");
	outcome
}
character_escaped -> values::Value = ( "#\\x" / "#\\X" ) value : $( [0-9a-fA-F]+ ) {?
	#[ cfg ( feature = "vonuvoli_values_string" ) ]
	let outcome = u32::from_str_radix (value, 16) .map_err (|_| "invalid character syntax") .and_then (|value| char::from_u32 (value) .ok_or ("invalid character value")) .map (|character| values::character (character) .into ());
	#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
	let outcome = Err ("strings are not supported");
	outcome
}
character_named -> values::Value = "#\\" value : $( "alarm" / "backspace" / "delete" / "escape" / "newline" / "null" / "return" / "space" / "tab" ) {?
		#[ cfg ( feature = "vonuvoli_values_string" ) ]
		let outcome = match value {
			"alarm" => Ok (values::character (7 as char) .into ()),
			"backspace" => Ok (values::character (8 as char) .into ()),
			"delete" => Ok (values::character (127 as char) .into ()),
			"escape" => Ok (values::character (27 as char) .into ()),
			"newline" => Ok (values::character (10 as char) .into ()),
			"null" => Ok (values::character (0 as char) .into ()),
			"return" => Ok (values::character (13 as char) .into ()),
			"space" => Ok (values::character (32 as char) .into ()),
			"tab" => Ok (values::character (9 as char) .into ()),
			_ => Err ("fcfc68be"),
		};
		#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
		let outcome = Err ("strings are not supported");
		outcome
	}

symbol -> values::Value = symbol_multiple_characters / symbol_single_character / symbol_string
symbol_single_character -> values::Value = !"." value : $( symbol_character_glyph ) { values::symbol_clone_str (value) .into () }
symbol_multiple_characters -> values::Value = value : $( symbol_character_glyph symbol_character_glyph+ ) { values::symbol_clone_str (value) .into () }
symbol_character_glyph = [a-zA-Z] / [!$%&*/:<=>?^_~] / [0-9] / [@.+-]

symbol_string -> values::Value = "|" elements : symbol_string_character* "|" { values::symbol_clone_characters (elements.as_slice ()) .into () }
symbol_string_character -> char = symbol_string_character_glyph / string_character_escaped / string_character_named
symbol_string_character_glyph -> char = glyph : $( [^|\\] ) { glyph.chars () .next () .expect ("56031166") }

string -> values::Value = string_quoted / string_array / string_document
string_quoted -> values::Value = "\"" elements : string_character* "\"" {?
		#[ cfg ( feature = "vonuvoli_values_string" ) ]
		let outcome = Ok (values::string_immutable_clone_characters (elements.as_slice ()) .into ());
		#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
		let outcome = Err ("strings are not supported");
		outcome
	}
string_character -> char = string_character_glyph / string_character_escaped / string_character_named
string_character_glyph -> char = glyph : $( [^"\\] ) { glyph.chars () .next () .expect ("61d18567") }
string_character_escaped -> char = ( "\\x" / "\\X" ) value : $( [0-9a-fA-F]+ ) ";" {? u32::from_str_radix (value, 16) .map_err (|_| "invalid character syntax") .and_then (|value| char::from_u32 (value) .ok_or ("invalid character value")) }
string_character_named -> char = "\\" value : $( "a" / "b" / "t" / "n" / "r" / "\\" / "\"" / "|" ) {?
		match value {
			"a" => Ok (7 as char),
			"b" => Ok (8 as char),
			"n" => Ok (10 as char),
			"r" => Ok (13 as char),
			"t" => Ok (9 as char),
			"\\" => Ok ('\\'),
			"\"" => Ok ('"'),
			"|" => Ok ('|'),
			_ => Err ("285687fe"),
		}
	}
string_array -> values::Value = "#string" "(" space? elements : string_array_character ** space space?  ")" {?
		#[ cfg ( feature = "vonuvoli_values_string" ) ]
		let outcome = Ok (values::string_immutable_clone_characters (elements.as_slice ()) .into ());
		#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
		let outcome = Err ("strings are not supported");
		outcome
	}
string_array_character -> char = value : $( [0-9]+ ) {? u32::from_str (value) .map_err (|_| "invalid character syntax") .and_then (|value| char::from_u32 (value) .ok_or ("invalid character value")) }

string_document -> values::Value =
				"#<<<" [ \t]* [\n]
				lines : ( $( [ \t]* !">>>#" [^\n]* ) ) ** [\n]
				[\n] [ \t]* ">>>#"
	{?
		#[ cfg ( feature = "vonuvoli_values_string" ) ]
		let outcome = {
			if lines.is_empty () {
				Ok (values::string_immutable_new_empty () .into ())
			} else {
				let mut error = None;
				let (padding, padding_text) = if let Some (first_line) = lines.first () {
					let mut padding = 0;
					for (offset, character) in first_line.char_indices () {
						match character {
							' ' | '\t' =>
								padding = offset + 1,
							_ =>
								break,
						}
					}
					let (padding_text, _) = first_line.split_at (padding);
					(padding, padding_text)
				} else {
					if error.is_none () {
						error = Some (Err ("4634f63b"));
					}
					(0, "")
				};
				let mut trimmed_lines = Vec::with_capacity (lines.len ());
				for line in lines.iter () {
					if ! line.is_char_boundary (padding) {
						if error.is_none () {
							error = Some (Err ("d9b907c8"));
						}
						break;
					}
					let (line_padding, line_rest) = line.split_at (padding);
					if ! str::eq (line_padding, padding_text) {
						if error.is_none () {
							error = Some (Err ("c2292111"));
						}
						break;
					}
					if line_rest.is_empty () && trimmed_lines.is_empty () {
						continue;
					}
					trimmed_lines.push (line_rest);
				}
				loop {
					if let Some (last_line) = trimmed_lines.pop () {
						if ! last_line.is_empty () {
							trimmed_lines.push (last_line);
							break;
						}
					} else {
						break;
					}
				}
				if let Some (error) = error {
					error
				} else {
					let mut string = String::with_capacity (128 * trimmed_lines.len ());
					for line in trimmed_lines {
						string.push_str (line);
						string.push ('\n');
					}
					let string = values::string_immutable_new (string);
					Ok (string.into ())
				}
			}
		};
		#[ cfg ( not ( feature = "vonuvoli_values_string" ) ) ]
		let outcome = Err ("strings are not supported");
		outcome
	}

bytes -> values::Value = bytes_quoted / bytes_array
bytes_quoted -> values::Value = ( "#u8" / "#U8" / "#bytes" ) "\"" elements : string_character* "\"" {?
		#[ cfg ( feature = "vonuvoli_values_bytes" ) ]
		let outcome = Ok (values::bytes_immutable_clone_characters (elements.as_slice ()) .into ());
		#[ cfg ( not ( feature = "vonuvoli_values_bytes" ) ) ]
		let outcome = Err ("strings are not supported");
		outcome
	}
bytes_array -> values::Value = ( "#u8" / "#U8" / "#bytes" ) "(" space? elements : bytes_byte ** space space?  ")" {?
	#[ cfg ( feature = "vonuvoli_values_bytes" ) ]
	let outcome = Ok (values::bytes_immutable_new (elements) .into ());
	#[ cfg ( not ( feature = "vonuvoli_values_bytes" ) ) ]
	let outcome = Err ("bytes not supported");
	outcome
}
bytes_byte -> u8 = value : $( [0-9]+ ) {? u8::from_str (value) .map_err (|_| "invalid byte syntax") }

constant -> values::Value = "#void" { constants::VOID.into () } / "#undefined" { constants::UNDEFINED.into () }

comment = #quiet< comment_line+ / comment_nested+ / comment_value+ >
comment_line = #quiet< ";" [^\n]* "\n" >
comment_nested = #quiet< "#|" ( !("#|" / "|#") . )* comment_nested* ( !("#|" / "|#") . )* "|#" >
comment_value = "#;" whitespace? value

whitespace = #quiet< [ \t\n]+ >
space = ( whitespace / comment )+




pub script -> Vec<values::Value> = space? values : value ** (space?) space? { values }




pub tests -> Vec<tests::TestCase> = space? tests : test* space? { tests }

pub test -> tests::TestCase = space? test : test_case ( "//" space? value space? )? space? { test }
test_case -> tests::TestCase = value : value space? "=>" space? action : test_action space? { tests::TestCase { expression : value, action : action, verbosity : tests::TestVerbosity::Default } }
test_action -> tests::TestAction =
		( "!debug" space value ) { tests::TestAction::Debug } /
		( "!fixme" space value ) { tests::TestAction::Skip } /
		"!ignore" { tests::TestAction::Ignore } /
		value : value { tests::TestAction::Expect (value) }