use std;
use std::borrow::Borrow;
use std::cmp::Eq;
use std::cmp::Ordering;
use std::cmp::PartialEq;
use std::cmp::PartialOrd;
use std::convert::{Into, TryFrom, TryInto};
use std::fmt;
use std::hash::Hash;
use std::hash::Hasher;
use std::path::PathBuf;
use std::rc::Rc;
use abortable_parser;
use crate::build::scope::Scope;
use crate::build::Val;
use crate::error::BuildError;
pub mod printer;
pub mod walk;
pub use walk::Walker;
#[derive(Debug, PartialEq, Clone)]
pub enum TemplatePart {
Str(Vec<char>),
PlaceHolder(usize),
Expression(Expression),
}
macro_rules! enum_type_equality {
( $slf:ident, $r:expr, $( $l:pat ),* ) => {
match $slf {
$(
$l => {
if let $l = $r {
true
} else {
false
}
}
)*
}
}
}
#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
pub struct Position {
pub file: Option<PathBuf>,
pub line: usize,
pub column: usize,
pub offset: usize,
}
impl Position {
pub fn new(line: usize, column: usize, offset: usize) -> Self {
Position {
file: None,
line: line,
column: column,
offset: offset,
}
}
pub fn with_file<P: Into<PathBuf>>(mut self, file: P) -> Self {
self.file = Some(file.into());
self
}
}
impl<'a> From<&'a Position> for Position {
fn from(source: &'a Position) -> Self {
source.clone()
}
}
impl std::fmt::Display for Position {
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
if let Some(ref file) = self.file {
write!(f, "file: {} ", file.to_string_lossy().to_string())?;
}
write!(f, "line: {} column: {}", self.line, self.column)
}
}
#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
pub enum TokenType {
EMPTY,
BOOLEAN,
END,
WS,
COMMENT,
QUOTED,
PIPEQUOTE,
DIGIT,
BAREWORD,
PUNCT,
}
#[derive(Debug, PartialEq, Eq, Clone, PartialOrd, Ord, Hash)]
pub struct Token {
pub typ: TokenType,
pub fragment: String,
pub pos: Position,
}
impl Token {
pub fn new<S: Into<String>, P: Into<Position>>(f: S, typ: TokenType, p: P) -> Self {
Self::new_with_pos(f, typ, p.into())
}
pub fn new_with_pos<S: Into<String>>(f: S, typ: TokenType, pos: Position) -> Self {
Token {
typ: typ,
fragment: f.into(),
pos: pos,
}
}
}
impl abortable_parser::Positioned for Token {
fn line(&self) -> usize {
self.pos.line
}
fn column(&self) -> usize {
self.pos.column
}
}
impl Borrow<str> for Token {
fn borrow(&self) -> &str {
&self.fragment
}
}
macro_rules! value_node {
($v:expr, $p:expr) => {
PositionedItem::new_with_pos($v, $p)
};
}
#[allow(unused_macros)]
macro_rules! make_tok {
(EOF => $i:expr) => {
Token::new("", TokenType::END, &$i)
};
(WS => $i:expr) => {
Token::new("", TokenType::WS, &$i)
};
(CMT => $e:expr, $i:expr) => {
Token::new($e, TokenType::COMMENT, &$i)
};
(QUOT => $e:expr, $i:expr) => {
Token::new($e, TokenType::QUOTED, &$i)
};
(PUNCT => $e:expr, $i:expr) => {
Token::new($e, TokenType::PUNCT, &$i)
};
(DIGIT => $e:expr, $i:expr) => {
Token::new($e, TokenType::DIGIT, &$i)
};
($e:expr, $i:expr) => {
Token::new($e, TokenType::BAREWORD, &$i)
};
}
#[allow(unused_macros)]
macro_rules! make_expr {
($e:expr, $i:expr) => {
Expression::Simple(Value::Symbol(PositionedItem::new_with_pos(
$e.to_string(),
$i,
)))
};
($e:expr => int, $i:expr) => {
Expression::Simple(Value::Int(PositionedItem::new_with_pos($e, $i)))
};
}
pub type FieldList = Vec<(Token, Expression)>;
pub type ShapeTuple = Vec<(Token, Shape)>;
pub type ShapeList = Vec<Shape>;
#[derive(PartialEq, Debug, Clone)]
pub struct FuncShapeDef {
args: Vec<Shape>,
ret: Box<Shape>,
}
#[derive(PartialEq, Debug, Clone)]
pub struct ModuleShapeDef {
items: ShapeTuple,
ret: Box<Shape>,
}
macro_rules! value_enum {
($doc:meta $i:tt, $t:ty, $l:ty, $($extra:tt)*) => {
#[$doc]
#[derive(PartialEq, Debug, Clone)]
pub enum $i {
Empty(Position),
Boolean(PositionedItem<bool>),
Int(PositionedItem<i64>),
Float(PositionedItem<f64>),
Str(PositionedItem<String>),
Symbol(PositionedItem<String>),
Tuple(PositionedItem<$t>),
List($l),
$( $extra )*
}
}
}
value_enum!(
doc="Value types represent the Values that UCG can have."
Value,
FieldList,
ListDef,
);
value_enum!(
doc="Shapes represent the types that UCG values or expressions can have."
Shape,
ShapeTuple,
PositionedItem<ShapeList>,
Func(FuncShapeDef),
Module(ModuleShapeDef),
);
impl Value {
pub fn type_name(&self) -> String {
match self {
&Value::Empty(_) => "EmptyValue".to_string(),
&Value::Boolean(_) => "Boolean".to_string(),
&Value::Int(_) => "Integer".to_string(),
&Value::Float(_) => "Float".to_string(),
&Value::Str(_) => "String".to_string(),
&Value::Symbol(_) => "Symbol".to_string(),
&Value::Tuple(_) => "Tuple".to_string(),
&Value::List(_) => "List".to_string(),
}
}
fn fields_to_string(v: &FieldList) -> String {
let mut buf = String::new();
buf.push_str("{\n");
for ref t in v.iter() {
buf.push_str("\t");
buf.push_str(&t.0.fragment);
buf.push_str("\n");
}
buf.push_str("}");
return buf;
}
fn elems_to_string(v: &Vec<Expression>) -> String {
return format!("{}", v.len());
}
pub fn to_string(&self) -> String {
match self {
&Value::Empty(_) => "EmptyValue".to_string(),
&Value::Boolean(ref b) => format!("{}", b.val),
&Value::Int(ref i) => format!("{}", i.val),
&Value::Float(ref f) => format!("{}", f.val),
&Value::Str(ref s) => format!("{}", s.val),
&Value::Symbol(ref s) => format!("{}", s.val),
&Value::Tuple(ref fs) => format!("{}", Self::fields_to_string(&fs.val)),
&Value::List(ref def) => format!("[{}]", Self::elems_to_string(&def.elems)),
}
}
pub fn pos(&self) -> &Position {
match self {
&Value::Empty(ref pos) => pos,
&Value::Boolean(ref b) => &b.pos,
&Value::Int(ref i) => &i.pos,
&Value::Float(ref f) => &f.pos,
&Value::Str(ref s) => &s.pos,
&Value::Symbol(ref s) => &s.pos,
&Value::Tuple(ref fs) => &fs.pos,
&Value::List(ref def) => &def.pos,
}
}
pub fn type_equal(&self, target: &Self) -> bool {
enum_type_equality!(
self,
target,
&Value::Empty(_),
&Value::Boolean(_),
&Value::Int(_),
&Value::Float(_),
&Value::Str(_),
&Value::Symbol(_),
&Value::Tuple(_),
&Value::List(_)
)
}
fn derive_shape(&self) -> Result<Shape, BuildError> {
let shape = match self {
Value::Empty(p) => Shape::Empty(p.clone()),
Value::Boolean(p) => Shape::Boolean(p.clone()),
Value::Int(p) => Shape::Int(p.clone()),
Value::Float(p) => Shape::Float(p.clone()),
Value::Str(p) => Shape::Str(p.clone()),
Value::Symbol(p) => Shape::Symbol(p.clone()),
Value::Tuple(flds) => {
let mut field_shapes = Vec::new();
for &(ref tok, ref expr) in &flds.val {
field_shapes.push((tok.clone(), expr.try_into()?));
}
Shape::Tuple(PositionedItem::new(field_shapes, flds.pos.clone()))
}
Value::List(flds) => {
let mut field_shapes = Vec::new();
for f in &flds.elems {
field_shapes.push(f.try_into()?);
}
Shape::List(PositionedItem::new(field_shapes, flds.pos.clone()))
}
};
Ok(shape)
}
}
impl TryFrom<&Value> for Shape {
type Error = crate::error::BuildError;
fn try_from(v: &Value) -> Result<Self, Self::Error> {
v.derive_shape()
}
}
#[derive(PartialEq, Debug, Clone)]
pub struct CallDef {
pub funcref: Value,
pub arglist: Vec<Expression>,
pub pos: Position,
}
#[derive(PartialEq, Debug, Clone)]
pub enum CastType {
Int,
Float,
Str,
Bool,
}
impl fmt::Display for CastType {
fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
write!(
w,
"{}",
match self {
CastType::Int => "int",
CastType::Float => "float",
CastType::Bool => "bool",
CastType::Str => "str",
}
)
}
}
#[derive(PartialEq, Debug, Clone)]
pub struct CastDef {
pub cast_type: CastType,
pub target: Box<Expression>,
pub pos: Position,
}
#[derive(PartialEq, Debug, Clone)]
pub struct SelectDef {
pub val: Box<Expression>,
pub default: Option<Box<Expression>>,
pub tuple: FieldList,
pub pos: Position,
}
#[derive(Debug, Clone)]
pub struct PositionedItem<T> {
pub pos: Position,
pub val: T,
}
impl<T: std::fmt::Display> std::fmt::Display for PositionedItem<T> {
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
write!(f, "{}", self.val)
}
}
impl<T> PositionedItem<T> {
pub fn new<P: Into<Position>>(v: T, p: P) -> Self {
Self::new_with_pos(v, p.into())
}
pub fn new_with_pos(v: T, pos: Position) -> Self {
PositionedItem { pos: pos, val: v }
}
}
impl<T: PartialEq> PartialEq for PositionedItem<T> {
fn eq(&self, other: &Self) -> bool {
self.val == other.val
}
}
impl<T: Eq> Eq for PositionedItem<T> {}
impl<T: Ord> Ord for PositionedItem<T> {
fn cmp(&self, other: &Self) -> Ordering {
self.val.cmp(&other.val)
}
}
impl<T: PartialOrd> PartialOrd for PositionedItem<T> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.val.partial_cmp(&other.val)
}
}
impl<T: Hash> Hash for PositionedItem<T> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.val.hash(state);
}
}
impl<'a> From<&'a Token> for PositionedItem<String> {
fn from(t: &'a Token) -> PositionedItem<String> {
PositionedItem {
pos: t.pos.clone(),
val: t.fragment.to_string(),
}
}
}
impl<'a> From<&'a PositionedItem<String>> for PositionedItem<String> {
fn from(t: &PositionedItem<String>) -> PositionedItem<String> {
PositionedItem {
pos: t.pos.clone(),
val: t.val.clone(),
}
}
}
#[derive(PartialEq, Debug, Clone)]
pub struct FuncDef {
pub scope: Option<Scope>,
pub argdefs: Vec<PositionedItem<String>>,
pub fields: Box<Expression>,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub enum BinaryExprType {
Add,
Sub,
Mul,
Div,
Mod,
AND,
OR,
Equal,
GT,
LT,
NotEqual,
GTEqual,
LTEqual,
REMatch,
NotREMatch,
IN,
IS,
DOT,
}
impl BinaryExprType {
pub fn precedence_level(&self) -> u32 {
match self {
BinaryExprType::Equal => 1,
BinaryExprType::NotEqual => 1,
BinaryExprType::GTEqual => 1,
BinaryExprType::LTEqual => 1,
BinaryExprType::GT => 1,
BinaryExprType::LT => 1,
BinaryExprType::REMatch => 1,
BinaryExprType::NotREMatch => 1,
BinaryExprType::IN => 2,
BinaryExprType::IS => 2,
BinaryExprType::Add => 3,
BinaryExprType::Sub => 3,
BinaryExprType::Mul => 4,
BinaryExprType::Div => 4,
BinaryExprType::Mod => 4,
BinaryExprType::AND => 5,
BinaryExprType::OR => 5,
BinaryExprType::DOT => 6,
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct BinaryOpDef {
pub kind: BinaryExprType,
pub left: Box<Expression>,
pub right: Box<Expression>,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub struct CopyDef {
pub selector: Value,
pub fields: FieldList,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub enum FormatArgs {
List(Vec<Expression>),
Single(Box<Expression>),
}
#[derive(Debug, PartialEq, Clone)]
pub struct FormatDef {
pub template: String,
pub args: FormatArgs,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub struct IncludeDef {
pub pos: Position,
pub path: Token,
pub typ: Token,
}
#[derive(Debug, PartialEq, Clone)]
pub struct ListDef {
pub elems: Vec<Expression>,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub enum FuncOpDef {
Reduce(ReduceOpDef),
Map(MapFilterOpDef),
Filter(MapFilterOpDef),
}
#[derive(Debug, PartialEq, Clone)]
pub struct ReduceOpDef {
pub func: Box<Expression>,
pub acc: Box<Expression>,
pub target: Box<Expression>,
pub pos: Position,
}
#[derive(Debug, PartialEq, Clone)]
pub struct MapFilterOpDef {
pub func: Box<Expression>,
pub target: Box<Expression>,
pub pos: Position,
}
impl FuncOpDef {
pub fn pos(&self) -> &Position {
match self {
FuncOpDef::Map(def) => &def.pos,
FuncOpDef::Filter(def) => &def.pos,
FuncOpDef::Reduce(def) => &def.pos,
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct ModuleDef {
pub scope: Option<Scope>,
pub pos: Position,
pub arg_set: FieldList,
pub out_expr: Option<Box<Expression>>,
pub arg_tuple: Option<Rc<Val>>,
pub statements: Vec<Statement>,
}
impl ModuleDef {
pub fn new<P: Into<Position>>(arg_set: FieldList, stmts: Vec<Statement>, pos: P) -> Self {
ModuleDef {
scope: None,
pos: pos.into(),
arg_set: arg_set,
out_expr: None,
arg_tuple: None,
statements: stmts,
}
}
pub fn set_out_expr(&mut self, expr: Expression) {
self.out_expr = Some(Box::new(expr));
}
}
pub struct Rewriter {
base: PathBuf,
}
impl Rewriter {
pub fn new<P: Into<PathBuf>>(base: P) -> Self {
Self { base: base.into() }
}
}
fn normalize_path(p: PathBuf) -> PathBuf {
let mut normalized = PathBuf::new();
for segment in p.components() {
normalized.push(segment);
}
return normalized;
}
impl walk::Walker for Rewriter {
fn visit_expression(&mut self, expr: &mut Expression) {
let main_separator = format!("{}", std::path::MAIN_SEPARATOR);
if let Expression::Include(ref mut def) = expr {
let path = PathBuf::from(&def.path.fragment);
def.path.fragment = normalize_path(self.base.join(path))
.to_string_lossy()
.to_string();
}
if let Expression::Import(ref mut def) = expr {
let path = PathBuf::from(
&def.path
.fragment
.replace("/", &main_separator)
.replace("\\", &main_separator),
);
if path.starts_with(format!("std{}", main_separator)) {
return;
}
def.path.fragment = normalize_path(self.base.join(path))
.to_string_lossy()
.to_string();
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct RangeDef {
pub pos: Position,
pub start: Box<Expression>,
pub step: Option<Box<Expression>>,
pub end: Box<Expression>,
}
#[derive(Debug, PartialEq, Clone)]
pub struct ImportDef {
pub pos: Position,
pub path: Token,
}
#[derive(Debug, PartialEq, Clone)]
pub struct IsDef {
pub pos: Position,
pub target: Box<Expression>,
pub typ: Token,
}
#[derive(Debug, PartialEq, Clone)]
pub struct FailDef {
pub pos: Position,
pub message: Box<Expression>,
}
#[derive(Debug, PartialEq, Clone)]
pub struct NotDef {
pub pos: Position,
pub expr: Box<Expression>,
}
#[derive(Debug, PartialEq, Clone)]
pub struct DebugDef {
pub pos: Position,
pub expr: Box<Expression>,
}
#[derive(Debug, PartialEq, Clone)]
pub enum Expression {
Simple(Value),
Not(NotDef),
Binary(BinaryOpDef),
Copy(CopyDef),
Range(RangeDef),
Grouped(Box<Expression>, Position),
Format(FormatDef),
Include(IncludeDef),
Import(ImportDef),
Call(CallDef),
Cast(CastDef),
Func(FuncDef),
Select(SelectDef),
FuncOp(FuncOpDef),
Module(ModuleDef),
Fail(FailDef),
Debug(DebugDef),
}
impl Expression {
pub fn pos(&self) -> &Position {
match self {
&Expression::Simple(ref v) => v.pos(),
&Expression::Binary(ref def) => &def.pos,
&Expression::Copy(ref def) => &def.pos,
&Expression::Range(ref def) => &def.pos,
&Expression::Grouped(_, ref pos) => pos,
&Expression::Format(ref def) => &def.pos,
&Expression::Call(ref def) => &def.pos,
&Expression::Cast(ref def) => &def.pos,
&Expression::Func(ref def) => &def.pos,
&Expression::Module(ref def) => &def.pos,
&Expression::Select(ref def) => &def.pos,
&Expression::FuncOp(ref def) => def.pos(),
&Expression::Include(ref def) => &def.pos,
&Expression::Import(ref def) => &def.pos,
&Expression::Fail(ref def) => &def.pos,
&Expression::Not(ref def) => &def.pos,
&Expression::Debug(ref def) => &def.pos,
}
}
fn derive_shape(&self) -> Result<Shape, BuildError> {
let shape = match self {
Expression::Simple(ref v) => v.try_into()?,
Expression::Format(def) => {
Shape::Str(PositionedItem::new("".to_owned(), def.pos.clone()))
}
Expression::Not(def) => Shape::Boolean(PositionedItem::new(true, def.pos.clone())),
Expression::Grouped(v, _pos) => v.as_ref().try_into()?,
_ => Shape::Empty(Position::new(0, 0, 0)),
};
Ok(shape)
}
}
impl TryFrom<&Expression> for Shape {
type Error = crate::error::BuildError;
fn try_from(e: &Expression) -> Result<Self, Self::Error> {
e.derive_shape()
}
}
impl fmt::Display for Expression {
fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
match self {
&Expression::Simple(ref v) => {
write!(w, "{}", v.to_string())?;
}
&Expression::Binary(_) => {
write!(w, "<Expr>")?;
}
&Expression::FuncOp(_) => {
write!(w, "<Expr>")?;
}
&Expression::Copy(_) => {
write!(w, "<Copy>")?;
}
&Expression::Range(_) => {
write!(w, "<Range>")?;
}
&Expression::Grouped(_, _) => {
write!(w, "(<Expr>)")?;
}
&Expression::Format(_) => {
write!(w, "<Format Expr>")?;
}
&Expression::Call(_) => {
write!(w, "<FuncCall>")?;
}
&Expression::Cast(_) => {
write!(w, "<Cast>")?;
}
&Expression::Func(_) => {
write!(w, "<Func>")?;
}
&Expression::Module(_) => {
write!(w, "<Module>")?;
}
&Expression::Select(_) => {
write!(w, "<Select>")?;
}
&Expression::Include(_) => {
write!(w, "<Include>")?;
}
&Expression::Import(_) => {
write!(w, "<Include>")?;
}
&Expression::Fail(_) => {
write!(w, "<Fail>")?;
}
&Expression::Not(ref def) => {
write!(w, "!{}", def.expr)?;
}
&Expression::Debug(ref def) => {
write!(w, "!{}", def.expr)?;
}
}
Ok(())
}
}
#[derive(Debug, PartialEq, Clone)]
pub struct LetDef {
pub pos: Position,
pub name: Token,
pub value: Expression,
}
#[derive(Debug, PartialEq, Clone)]
pub enum Statement {
Expression(Expression),
Let(LetDef),
Assert(Position, Expression),
Output(Position, Token, Expression),
Print(Position, Token, Expression),
}
impl Statement {
fn pos(&self) -> &Position {
match self {
Statement::Expression(ref e) => e.pos(),
Statement::Let(ref def) => &def.pos,
Statement::Assert(ref pos, _) => pos,
Statement::Output(ref pos, _, _) => pos,
Statement::Print(ref pos, _, _) => pos,
}
}
}
#[cfg(test)]
mod test;