zaphar/ucg
1
0
Fork 0
mirror of https://github.com/zaphar/ucg.git synced 2025-07-23 18:29:50 -04:00
Code Issues Packages Projects Releases Wiki Activity

Revert "WIP: Track the positions of our tokens and AST elements."

Browse Source 
This reverts commit b4ec44323b25f7532964a543ac52e905349dc314.
This commit is contained in:
Jeremy Wall 2017-09-18 18:32:47 -05:00
parent b4ec44323b
commit 6c3662d361
2 changed files with 33 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
src/ast.rs
View File

@ -14,19 +14,7 @@
use std::collections::HashSet;
use std::borrow::Borrow;
#[derive(Debug,PartialEq,Clone)]
pub struct Position {
pub line: usize,
pub column: usize,
}
#[derive(Debug,PartialEq,Clone)]
pub struct LocatedNode<N> {
pub pos: Position,
pub node: N,
}
pub type FieldList = Vec<(String, LocatedNode<Expression>)>; // str is expected to be a symbol
pub type FieldList = Vec<(String, Expression)>; // str is expected to be a symbol
pub type SelectorList = Vec<String>; // str is expected to always be a symbol.
/// Value represents a Value in the UCG parsed AST.
@ -83,15 +71,15 @@ impl Value {
#[derive(PartialEq,Debug,Clone)]
pub struct CallDef {
pub macroref: SelectorList,
pub arglist: Vec<LocatedNode<Expression>>,
pub arglist: Vec<Expression>,
}
/// SelectDef selects a value from a tuple with a default if the value doesn't
/// exist.
#[derive(PartialEq,Debug,Clone)]
pub struct SelectDef {
pub val: Box<LocatedNode<Expression>>,
pub default: Box<LocatedNode<Expression>>,
pub val: Box<Expression>,
pub default: Box<Expression>,
pub tuple: FieldList,
}
@ -106,7 +94,7 @@ pub struct MacroDef {
}
impl MacroDef {
fn validate_value_symbols<'a>(&'a self, stack: &mut Vec<&'a LocatedNode<Expression>>, val: &'a Value) -> HashSet<String> {
fn validate_value_symbols<'a>(&'a self, stack: &mut Vec<&'a Expression>, val: &'a Value) -> HashSet<String> {
let mut bad_symbols = HashSet::new();
if let &Value::Symbol(ref name) = val {
let mut ok = true;
@ -146,56 +134,56 @@ impl MacroDef {
stack.push(expr);
while stack.len() > 0 {
match stack.pop().unwrap() {
&LocatedNode{pos: _, node: Expression::Add(ref bexpr)} => {
&Expression::Add(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&LocatedNode{pos: _, node: Expression::Sub(ref bexpr)} => {
&Expression::Sub(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&LocatedNode{pos: _, node: Expression::Mul(ref bexpr)} => {
&Expression::Mul(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&LocatedNode{pos: _, node: Expression::Div(ref bexpr)} => {
&Expression::Div(ref bexpr) => {
let mut syms_set = self.validate_value_symbols(&mut stack, &bexpr.0);
bad_symbols.extend(syms_set.drain());
stack.push(&bexpr.1);
},
&LocatedNode{pos: _, node: Expression::Grouped(ref expr)} => {
&Expression::Grouped(ref expr) => {
stack.push(expr);
},
&LocatedNode{pos: _, node: Expression::Format(_, ref exprs)} => {
&Expression::Format(_, ref exprs) => {
for arg_expr in exprs.iter() {
stack.push(arg_expr);
}
},
&LocatedNode{pos: _, node: Expression::Select(ref def)} => {
&Expression::Select(ref def) => {
stack.push(def.default.borrow());
stack.push(def.val.borrow());
for &(_, ref expr) in def.tuple.iter() {
stack.push(expr);
}
},
&LocatedNode{pos: _, node: Expression::Copy(_, ref fields)} => {
&Expression::Copy(_, ref fields) => {
for &(_, ref expr) in fields.iter() {
stack.push(expr);
}
},
&LocatedNode{pos: _, node: Expression::Call(ref def)} => {
&Expression::Call(ref def) => {
for expr in def.arglist.iter() {
stack.push(expr);
}
}
&LocatedNode{pos: _, node: Expression::Simple(ref val)} => {
&Expression::Simple(ref val) => {
let mut syms_set = self.validate_value_symbols(&mut stack, val);
bad_symbols.extend(syms_set.drain());
},
&LocatedNode{pos: _, node: Expression::Macro(_)} => {
&Expression::Macro(_) => {
// noop
continue;
},
@ -211,7 +199,7 @@ impl MacroDef {
/// BinaryExpression represents an expression with a left and a right side.
#[derive(Debug,PartialEq,Clone)]
pub struct BinaryExpression(pub Value, pub Box<LocatedNode<Expression>>);
pub struct BinaryExpression(pub Value, pub Box<Expression>);
/// Expression encodes an expression. Expressions compute a value from operands.
#[derive(Debug,PartialEq,Clone)]
@ -228,9 +216,9 @@ pub enum Expression {
// Complex Expressions
Copy(SelectorList, FieldList),
Grouped(Box<LocatedNode<Expression>>),
Grouped(Box<Expression>),
Format(String, Vec<LocatedNode<Expression>>),
Format(String, Vec<Expression>),
Call(CallDef),
@ -242,12 +230,12 @@ pub enum Expression {
#[derive(Debug,PartialEq)]
pub enum Statement {
// simple expression
Expression(LocatedNode<Expression>),
Expression(Expression),
// Named bindings
Let {
name: String,
value: LocatedNode<Expression>,
value: Expression,
},
// Include a file.
@ -261,16 +249,6 @@ pub enum Statement {
mod ast_test {
use super::*;
fn wrapNode(expr: Expression) -> LocatedNode<Expression> {
LocatedNode{
pos: Position{
line: 0,
column: 0,
},
node: expr,
}
}
#[test]
pub fn test_macro_validation_happy_path() {
let def = MacroDef{
@ -278,9 +256,9 @@ mod ast_test {
"foo".to_string()
],
fields: vec![
("f1".to_string(), wrapNode(Expression::Add(BinaryExpression(
("f1".to_string(), Expression::Add(BinaryExpression(
Value::Symbol("foo".to_string()),
Box::new(wrapNode(Expression::Simple(Value::Int(1)))))))),
Box::new(Expression::Simple(Value::Int(1)))))),
],
};
assert!(def.validate_symbols().unwrap() == ());
@ -293,9 +271,9 @@ mod ast_test {
"foo".to_string()
],
fields: vec![
("f1".to_string(), wrapNode(Expression::Add(BinaryExpression(
("f1".to_string(), Expression::Add(BinaryExpression(
Value::Symbol("bar".to_string()),
Box::new(wrapNode(Expression::Simple(Value::Int(1)))))))),
Box::new(Expression::Simple(Value::Int(1)))))),
],
};
let mut expected = HashSet::new();
@ -310,9 +288,9 @@ mod ast_test {
"foo".to_string()
],
fields: vec![
("f1".to_string(), wrapNode(Expression::Add(BinaryExpression(
("f1".to_string(), Expression::Add(BinaryExpression(
Value::Selector(vec!["foo".to_string(), "quux".to_string()]),
Box::new(wrapNode(Expression::Simple(Value::Int(1)))))))),
Box::new(Expression::Simple(Value::Int(1)))))),
],
};
assert!(def.validate_symbols().unwrap() == ());
@ -325,9 +303,9 @@ mod ast_test {
"foo".to_string()
],
fields: vec![
("f1".to_string(), wrapNode(Expression::Add(BinaryExpression(
("f1".to_string(), Expression::Add(BinaryExpression(
Value::Selector(vec!["bar".to_string(), "quux".to_string()]),
Box::new(wrapNode(Expression::Simple(Value::Int(1)))))))),
Box::new(Expression::Simple(Value::Int(1)))))),
],
};
let mut expected = HashSet::new();

8
src/parse.rs
View File

@ -154,7 +154,7 @@ named!(value<Value>, alt!(number | quoted_value | symbol | tuple));
named!(
#[doc="Capture a field and value pair composed of `<symbol> = <value>,`"],
field_value<(String, LocatedNode<Expression>) >,
field_value<(String, Expression) >,
do_parse!(
field: field >>
ws!(equal) >>
@ -189,18 +189,18 @@ named!(macro_word, tag!("macro"));
named!(import_word, tag!("import"));
named!(as_word, tag!("as"));
fn value_to_expression(v: Value) -> ParseResult<LocatedNode<Expression>> {
fn value_to_expression(v: Value) -> ParseResult<Expression> {
Ok(Expression::Simple(v))
}
named!(simple_expression<LocatedNode<Expression>>,
named!(simple_expression<Expression>,
map_res!(
value,
value_to_expression
)
);
fn tuple_to_add_expression(tpl: (Value, LocatedNode<Expression>)) -> ParseResult<LocatedNode<Expression>> {
fn tuple_to_add_expression(tpl: (Value, Expression)) -> ParseResult<Expression> {
Ok(Expression::Add(BinaryExpression(tpl.0, Box::new(tpl.1))))
}