//! Parses the output of Rust `Debug` strings into reflected values of
//! type `Val`. (See `engine::reflect` module).
//!
//! We use this parse as a non-intrusive mechanism for
//! building the values in the reflected DCG, which consists of
//! crawling user-defined data structures, and following their
//! articulations. We use the values' `Debug` strings to do this
//! traversal.
use std::fmt::Debug;
use crate::adapton::reflect::{Loc,Path,Val,ArtContent,Const};
use crate::adapton::engine::{Name, name_of_str, name_of_string};
/// _Balanced tokens_: Tokens that must be balanced with a left and
/// right instance and well-nested balanced tokens between them.
#[derive(Debug, Eq, PartialEq)]
enum BalTok {
Paren,
Bracket,
Brace
}
/// _Tokens_: The unit of input for parsing Rust `Debug` strings
/// into reflected `Val` values.
#[derive(Debug, Eq, PartialEq)]
enum Tok {
/// Left (and right) balanced tokens
Left(BalTok),
/// Right (and left) balanced tokens
Right(BalTok),
/// Constant values that can immediately be injected into reflected `Val` type
Const(Const),
/// Identifers name fields of structs and constructors (of enums and structs)
Ident(String),
/// Colons separate field names from field values in structs. Co
Colon,
/// Commas separate arguments to a constructor; for struct constructors, they separate fields
Comma,
}
/// Transform most(*) Rust data that derives `Debug` into a reflected
/// `Val`.
///
/// This parsing logic handles user-defined `struct` and `enum`
/// types, tuples and vectors. It recognizes the `Debug` output of
/// these structures and parses them into trees of type
/// `Val`. Importantly, it recognizes articulations in this `Debug`
/// output and parses those into reflected locations (of type `Loc`)
/// and articulations (of type `Art`). The reflected `DCG` maps
/// reflected articulations (whose reflected locations are of type
/// `Loc`) to reflected nodes that contain more reflected values.
///
/// (*) Note: Though this parsing logic handles vectors, tuples and
/// user-defined data types, this parsing logic is probably
/// incomplete for all of Rust's standard collections. (It does not
/// yet handle `HashMap<_,_>` debug output, or anything else of this
/// complexity as of yet).
pub fn parse_val <V:Debug> (v:&V) -> Val {
let s = format!("{:?}", v);
//println!("reflect_val({:?})", v);
let toks = lex(s.into_bytes());
//println!("toks = {:?}", toks);
parse_toks(toks)
}
/// Tokenize the characters of input into lexical tokens of type `Tok`
fn lex (mut chars: Vec<u8>) -> Vec<Tok> {
let mut toks = vec![];
chars.reverse(); // TODO rewrite to avoid this
loop {
match chars.pop() {
None => return toks,
Some(c) => {
let c : char = c as char ;
if c == ' ' { continue }
else if c == ':' { toks.push(Tok::Colon); continue }
else if c == ',' { toks.push(Tok::Comma); continue }
else if c == '{' { toks.push(Tok::Left (BalTok::Brace)); continue }
else if c == '[' { toks.push(Tok::Left (BalTok::Bracket)); continue }
else if c == '(' { toks.push(Tok::Left (BalTok::Paren)); continue }
else if c == '}' { toks.push(Tok::Right(BalTok::Brace)); continue }
else if c == ']' { toks.push(Tok::Right(BalTok::Bracket)); continue }
else if c == ')' { toks.push(Tok::Right(BalTok::Paren)); continue }
else if c == '"' {
let mut string_chars = vec![];
loop {
match chars.pop() {
None => break,
Some(c) => {
let c : char = c as char ;
if c == '"' { break } else {
string_chars.push(c);
continue
}
}
}
};
toks.push(Tok::Const(Const::String(
string_chars.into_iter().collect()
)));
continue
}
else if c == '-' || (c >= '0' && c <= '9') {
let mut digs = vec![c];
loop {
match chars.pop() {
None => break,
Some(c) => {
let c : char = c as char ;
if c >= '0' && c <= '9' {
digs.push(c);
continue
} else {
chars.push(c as u8);
break
}
}
}
};
if c == '-' {
let s : String = digs.into_iter().collect();
toks.push(Tok::Const(Const::Num(
isize::from_str_radix(s.as_str(), 10).unwrap()
)));
} else {
let s : String = digs.into_iter().collect();
toks.push(Tok::Const(Const::Nat(
usize::from_str_radix(s.as_str(), 10).unwrap()
)));
}
continue
}
else if (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c == '_')
{
let mut ident = vec![c];
loop {
match chars.pop() {
None => break,
Some(c) => {
let c : char = c as char ;
if (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') ||
(c == '_')
{
ident.push(c);
continue
} else {
chars.push(c as u8);
break
}
}
}
};
toks.push(Tok::Ident( ident.into_iter().collect() ));
continue
}
}
}
} ;
}
/// Parse a sequence of fields (appending to `fields`) until right
/// balanced token `bal`. Return fields and remaining tokens.
fn parse_fields (mut toks:Vec<Tok>, mut fields:Vec<(Name, Val)>, bal:Tok) -> (Vec<(Name, Val)>, Vec<Tok>) {
match toks.pop() {
None => panic!("parse_vals: expected more vals, or end of sequence; but no more tokens"),
Some(t) => {
if t == bal { (fields, toks) }
else if t == Tok::Comma {
return parse_fields(toks, fields, bal)
} else {
match t {
Tok::Ident(i) => {
let toks = expect_tok(toks, Tok::Colon);
let (v, toks) = parse_val_rec(toks);
fields.push((name_of_string(i), v));
return parse_fields(toks, fields, bal)
}
t => {
panic!("parse_fields: expected identifier, but found {:?}", t)
}
}
}
}
}
}
/// Parse a sequence of values (appending to `vals`) until right
/// balanced token `bal`. Return fields and remaining tokens.
fn parse_vals (mut toks:Vec<Tok>, mut vals:Vec<Val>, bal:Tok) -> (Vec<Val>, Vec<Tok>) {
match toks.pop() {
None => panic!("parse_vals: expected more vals, or end of sequence; but no more tokens"),
Some(t) => {
if t == bal { (vals, toks) }
else if t == Tok::Comma {
return parse_vals(toks, vals, bal)
}
else {
toks.push(t);
let (v, toks) = parse_val_rec(toks);
vals.push(v);
return parse_vals(toks, vals, bal)
}
}
}
}
/// Expect next token to be `tok` and panic otherwise.
fn expect_tok (mut toks: Vec<Tok>, tok:Tok) -> Vec<Tok> {
match toks.pop() {
None => panic!("expected token `{:?}`, but, no more tokens", tok),
Some(t) => {
if t == tok { toks }
else { panic!("expected token `{:?}`, but instead found token `{:?}`", tok, t) }
}
}
}
fn parse_toks(mut toks:Vec<Tok>) -> Val {
toks.reverse();
let (v, toks) = parse_val_rec(toks);
assert!(toks.len() == 0);
v
}
fn path_of_val ( p:&Val ) -> Path {
match *p {
Val::Vec( ref vs ) => vs.iter().map( name_of_val ).collect(),
_ => panic!("expected a vector of values representing names"),
}
}
fn name_of_val ( n:&Val ) -> Name {
use crate::engine::*;
match *n {
Val::Constr( ref cons_name, ref cons_args ) => {
if *cons_name == name_of_str("Unit") {
name_unit()
}
else if *cons_name == name_of_str("Hash64") {
name_of_hash64( 0 ) // TODO/XXX
}
else if *cons_name == name_of_str("String") {
name_of_string( match cons_args[0] {
Val::Const( Const::String( ref s ) ) => s.clone(),
_ => panic!("expected a String"),
})
}
else if *cons_name == name_of_str("Usize") {
name_of_usize( match cons_args[0] {
Val::Const( Const::Nat( ref n ) ) => n.clone(),
_ => panic!("expected a Nat"),
})
}
else if *cons_name == name_of_str("Isize") {
panic!("")
}
else if *cons_name == name_of_str("Pair") {
let n1 = name_of_val( & cons_args[0] );
let n2 = name_of_val( & cons_args[1] );
name_pair(n1, n2)
}
else if *cons_name == name_of_str("ForkL") {
let n = name_of_val( & cons_args[0] );
name_fork(n).0
}
else if *cons_name == name_of_str("ForkR") {
let n = name_of_val( & cons_args[0] );
name_fork(n).1
}
else {
unreachable!()
}
},
Val::Name(ref n) => n.clone(),
_ => panic!("expected a constructor for a NameSym")
}
}
fn name_option_of_val ( n:&Val ) -> Option<Name> {
use crate::engine::*;
match *n {
Val::Constr( ref cons_name, ref cons_args ) => {
if *cons_name == name_of_str("Unit") {
Some(name_unit())
}
else if *cons_name == name_of_str("Hash64") {
Some(name_of_hash64( 0 )) // XXX \ TODO -- We are actually missing the hash here!
}
else if *cons_name == name_of_str("String") {
if cons_args.len() < 1 { None } else {
match cons_args[0] {
Val::Const( Const::String( ref s ) ) =>
Some(name_of_string( s.clone() )),
_ => None,
}}
}
else if *cons_name == name_of_str("Usize") {
if cons_args.len() < 1 { None } else {
match cons_args[0] {
Val::Const( Const::Nat( ref n ) ) => Some( name_of_usize( n.clone() ) ),
_ => None,
}}
}
else if *cons_name == name_of_str("Isize") {
panic!("TODO")
}
else if *cons_name == name_of_str("Pair") {
if cons_args.len() < 2 { None } else {
let n1 = name_option_of_val( & cons_args[0] );
let n2 = name_option_of_val( & cons_args[1] );
if cons_args.len() < 2 { None } else {
match (n1,n2) {
(Some(n1),Some(n2)) => Some(name_pair(n1, n2)),
(_, _) => None,
}}}
}
else if *cons_name == name_of_str("ForkL") {
if cons_args.len() < 1 { None } else {
let n = name_option_of_val( & cons_args[0] );
match n {
None => None,
Some(n) => Some(name_fork(n).0)
}}
}
else if *cons_name == name_of_str("ForkR") {
if cons_args.len() < 1 { None } else {
let n = name_option_of_val( & cons_args[0] );
match n {
None => None,
Some(n) => Some(name_fork(n).1)
}}
}
else { None }
},
Val::Name(ref n) => Some(n.clone()),
_ => None,
}
}
/// Attempts to parse a reflected value into an `Art` value case,
/// which consists of parsing a location represented as a `Val`
/// structure into a `Loc` represented as a Rust data type (in the
/// `reflect` module). If it fails to parse a value into an art, it
/// returns None.
fn parse_art_val ( i:&String, fields:&Vec<(Name, Val)> ) -> Option<Val> {
if i == "Art" && fields.len() == 1 {
match fields[0] {
(ref nf, ref vf) =>
if *nf == name_of_str("art") {
// OK: it's a struct called Art with exactly one field
// called art. We are going to parse this into an Art.
match *vf {
Val::Struct( ref j, ref ws ) =>
if *j == name_of_str("Loc")
&& ws.len() == 2
&& ws[0].0 == name_of_str("path")
&& ws[1].0 == name_of_str("id")
{
// Now we are confident that the rest ought to parse.
// Any further parse errors are panics.
let path = path_of_val( & ws[0].1 );
let name = name_of_val( & ws[1].1 );
Some( Val::Art(Loc{path:path, name:name}, ArtContent::Unknown) )
}
else {
None
},
_ => None,
}
} else { None }
}} else { None }
}
/// Parse a value from the tokens `toks` and return it. Panic if the next tokens do not parse into value.
fn parse_val_rec (mut toks:Vec<Tok>) -> (Val, Vec<Tok>) {
//println!("{:?}", toks);
let (v, toks) = match toks.pop() {
None => panic!("expected value; but, no more tokens"),
Some(Tok::Right(r)) => panic!("expected value, but found {:?} instead", Tok::Right(r)),
Some(Tok::Comma) => panic!("expected value, but found Comma instead"),
Some(Tok::Colon) => panic!("expected value, but found Colon instead"),
Some(Tok::Left(BalTok::Bracket)) => {
// Parse a vector: Begins with '[', then a list of comma-separated values, then ']'.
let (vs, toks) = parse_vals(toks, vec![], Tok::Right(BalTok::Bracket));
(Val::Vec(vs), toks)
},
Some(Tok::Left(BalTok::Paren)) => {
// Parse a tuple: Begins with '(', then a list of comma-separated values, then ')'.
let (vs, toks) = parse_vals(toks, vec![], Tok::Right(BalTok::Paren));
(Val::Tuple(vs), toks)
},
Some(Tok::Left(l)) => panic!("expected value, but found {:?} instead", Tok::Left(l)),
Some(Tok::Ident(i)) => {
match toks.pop() {
None => {
// Constructors with no arguments (e.g., Nil)
(Val::Constr(name_of_string(i), vec![]), toks)
}
Some(Tok::Left(BalTok::Brace)) => {
//println!("parsing struct: {:?}", i);
let (fields, toks) = parse_fields(toks, vec![], Tok::Right(BalTok::Brace));
let art_op = parse_art_val(&i, &fields);
let v = match art_op {
Some(a) => a,
None => Val::Struct(name_of_string(i.clone()), fields.clone())
};
(v, toks)
}
Some(Tok::Left(BalTok::Paren)) => {
//println!("parsing constructor: {:?}", i);
let (vs, toks) = parse_vals(toks, vec![], Tok::Right(BalTok::Paren));
let v = Val::Constr(name_of_string(i), vs);
match name_option_of_val(&v) {
Some(n) => (Val::Name(n), toks),
None => (v, toks)
}
},
Some(Tok::Comma) => {
toks.push(Tok::Comma);
(Val::Constr(name_of_string(i), vec![]), toks)
},
Some(Tok::Right(baltok)) => {
toks.push(Tok::Right(baltok));
(Val::Constr(name_of_string(i), vec![]), toks)
},
Some(t) => {
panic!("expected left balanced token, or comma, but instead found token {:?}", t)
}}},
Some(Tok::Const(Const::Nat(n))) => (Val::Const(Const::Nat(n)), toks),
Some(Tok::Const(Const::Num(n))) => (Val::Const(Const::Num(n)), toks),
Some(Tok::Const(Const::String(s))) => (Val::Const(Const::String(s)), toks)
};
(v,toks)
}