Initial commit

Author: Techno-coder

.gitignore

@@ -0,0 +1,2 @@
+/target
+**/*.rs.bk

Cargo.lock

@@ -0,0 +1,5 @@
+[package]
+name = "lexica"
+version = "0.1.0"
+authors = ["Techno-coder <[email protected]>"]
+edition = "2018"

Cargo.toml

@@ -0,0 +1 @@
+nightly

rust-toolchain

@@ -0,0 +1,37 @@
+use std::fmt;
+
+pub struct IndentWriter<'a, T> {
+	inner: &'a mut T,
+	on_new_line: bool,
+}
+
+impl<'a, T> IndentWriter<'a, T> where T: fmt::Write {
+	pub fn wrap(inner: &'a mut T) -> Self {
+		Self { inner, on_new_line: true }
+	}
+}
+
+impl<'a, T> fmt::Write for IndentWriter<'a, T> where T: fmt::Write {
+	fn write_str(&mut self, mut s: &str) -> Result<(), fmt::Error> {
+		while !s.is_empty() {
+			if self.on_new_line {
+				self.inner.write_char('\t')?;
+			}
+
+			let split = match s.find('\n') {
+				Some(position) => {
+					self.on_new_line = true;
+					position + 1
+				}
+				None => {
+					self.on_new_line = false;
+					s.len()
+				}
+			};
+
+			self.inner.write_str(&s[..split])?;
+			s = &s[split..];
+		}
+		Ok(())
+	}
+}

src/compiler/mod.rs

@@ -0,0 +1,4 @@
+pub use self::indent_writer::*;
+
+mod indent_writer;
+

src/display/indent_writer.rs

@@ -0,0 +1,59 @@
+use std::collections::HashMap;
+use std::marker::PhantomData;
+
+use crate::node::Identifier;
+
+use super::NodeConstruct;
+
+#[derive(Debug, Default)]
+pub struct Context<'a> {
+	bindings: HashMap<Identifier<'a>, i64>,
+	evaluations: HashMap<EvaluationKey<'a>, i64>,
+}
+
+impl<'a> Context<'a> {
+	pub fn register_binding(&mut self, identifier: Identifier<'a>, value: i64) {
+		self.bindings.insert(identifier, value);
+	}
+
+	pub fn invalidate_binding(&mut self, identifier: &Identifier<'a>) {
+		self.bindings.remove(identifier);
+	}
+
+	pub fn binding_value(&self, identifier: &Identifier<'a>) -> &i64 {
+		self.bindings.get(identifier)
+		    .expect(&format!("Binding does not exist for {:?}", identifier))
+	}
+
+	pub fn cache_evaluation(&mut self, node: &'a NodeConstruct, value: i64) {
+		self.evaluations.insert(EvaluationKey::resolve(node), value);
+	}
+
+	pub fn invalidate_evaluation(&mut self, node: &'a NodeConstruct) {
+		self.evaluations.remove(&EvaluationKey::resolve(node));
+	}
+
+	pub fn has_evaluated(&self, node: &'a NodeConstruct) -> bool {
+		self.evaluations.contains_key(&EvaluationKey::resolve(node))
+	}
+
+	pub fn evaluation(&self, node: &'a NodeConstruct) -> &i64 {
+		self.evaluations.get(&EvaluationKey::resolve(node))
+		    .expect(&format!("Evaluation does not exist for {:?}", node))
+	}
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+struct EvaluationKey<'a> {
+	pointer: *const usize,
+	lifetime: PhantomData<&'a NodeConstruct<'a>>,
+}
+
+impl<'a> EvaluationKey<'a> {
+	pub fn resolve(node: &'a NodeConstruct) -> Self {
+		EvaluationKey {
+			pointer: node as *const NodeConstruct as *const _,
+			lifetime: PhantomData,
+		}
+	}
+}

src/display/mod.rs

@@ -0,0 +1,44 @@
+use super::{Dependency, Direction};
+
+#[derive(Debug)]
+pub struct DependencyBuffer<'a> {
+	buffer: Vec<Dependency<'a>>,
+	split_index: usize,
+	direction: Direction,
+}
+
+impl<'a> DependencyBuffer<'a> {
+	pub fn new(buffer: Vec<Dependency<'a>>, direction: Direction) -> Self {
+		let split_index = match direction {
+			Direction::Advance => 0,
+			Direction::Reverse => buffer.len() + 1,
+		};
+		Self { buffer, split_index, direction }
+	}
+
+	/// Advances the cursor and returns the next node construct
+	/// Cursor holds if changing direction
+	pub fn advance(&mut self) -> Option<&Dependency<'a>> {
+		match self.direction {
+			Direction::Advance => self.split_index += 1,
+			Direction::Reverse => self.direction = Direction::Advance
+		}
+		self.buffer.get(self.split_index - 1)
+	}
+
+	/// Advances the cursor in reverse and returns the next node construct
+	/// Cursor holds if changing direction
+	pub fn reverse(&mut self) -> Option<&Dependency<'a>> {
+		if self.direction == Direction::Advance {
+			self.direction = Direction::Reverse;
+			self.split_index += 1;
+		}
+
+		if self.split_index > 1 {
+			self.split_index -= 1;
+			self.buffer.get(self.split_index - 1)
+		} else {
+			None
+		}
+	}
+}

src/interpreter/context.rs

@@ -0,0 +1,22 @@
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum Direction {
+	Advance,
+	Reverse,
+}
+
+impl Direction {
+	pub fn compose(&self, other: &Direction) -> Direction {
+		if self == other {
+			Direction::Advance
+		} else {
+			Direction::Reverse
+		}
+	}
+
+	pub fn invert(&self) -> Direction {
+		match self {
+			Direction::Advance => Direction::Reverse,
+			Direction::Reverse => Direction::Advance,
+		}
+	}
+}

src/interpreter/dependency_buffer.rs

@@ -0,0 +1 @@
+pub enum InterpreterError {}

src/interpreter/direction.rs

@@ -0,0 +1,103 @@
+pub use self::context::*;
+pub use self::dependency_buffer::*;
+pub use self::direction::*;
+pub use self::error::*;
+pub use self::node_construct::*;
+pub use self::runtime::*;
+
+mod context;
+mod node_construct;
+mod runtime;
+mod error;
+mod dependency_buffer;
+mod direction;
+
+pub fn construct() -> crate::node::Function<'static> {
+	use crate::node::*;
+	Function {
+		parameters: vec![
+			Variable {
+				identifier: Identifier("n"),
+				data_type: Some(DataType(Identifier("u32"))),
+				is_mutable: false,
+			}
+		],
+		statements: vec![
+			Statement::Binding(Binding {
+				variable: Variable {
+					identifier: Identifier("first"),
+					data_type: None,
+					is_mutable: true,
+				},
+				expression: Expression::LiteralInteger(1),
+			}),
+			Statement::Binding(Binding {
+				variable: Variable {
+					identifier: Identifier("second"),
+					data_type: None,
+					is_mutable: true,
+				},
+				expression: Expression::LiteralInteger(1),
+			}),
+			Statement::Binding(Binding {
+				variable: Variable {
+					identifier: Identifier("counter"),
+					data_type: None,
+					is_mutable: true,
+				},
+				expression: Expression::LiteralInteger(1),
+			}),
+			Statement::ConditionalLoop(ConditionalLoop {
+				start_condition: Some(Expression::BinaryOperation(Box::new(BinaryOperation {
+					left: Expression::Variable(Identifier("counter")),
+					right: Expression::LiteralInteger(1),
+					operator: BinaryOperator::Equal,
+				}))),
+				end_condition: Expression::BinaryOperation(Box::new(BinaryOperation {
+					left: Expression::Variable(Identifier("counter")),
+					right: Expression::Variable(Identifier("n")),
+					operator: BinaryOperator::Equal,
+				})),
+				statements: vec![
+					Statement::Binding(Binding {
+						variable: Variable {
+							identifier: Identifier("summation"),
+							data_type: None,
+							is_mutable: false,
+						},
+						expression: Expression::BinaryOperation(Box::new(BinaryOperation {
+							left: Expression::Variable(Identifier("first")),
+							right: Expression::Variable(Identifier("second")),
+							operator: BinaryOperator::Plus,
+						})),
+					}),
+					Statement::Swap(Swap {
+						left: Identifier("first"),
+						right: Identifier("second"),
+					}),
+					Statement::Swap(Swap {
+						left: Identifier("second"),
+						right: Identifier("summation"),
+					}),
+					Statement::ExplicitDrop(ExplicitDrop {
+						identifier: Identifier("summation"),
+						expression: Expression::BinaryOperation(Box::new(BinaryOperation {
+							left: Expression::Variable(Identifier("second")),
+							right: Expression::Variable(Identifier("first")),
+							operator: BinaryOperator::Minus,
+						})),
+					}),
+					Statement::Mutation(Mutation::AddAssign(
+						Identifier("counter"),
+						Expression::LiteralInteger(1),
+					)),
+				],
+			}),
+			Statement::ExplicitDrop(ExplicitDrop {
+				identifier: Identifier("n"),
+				expression: Expression::Variable(Identifier("counter")),
+			}),
+		],
+		return_value: Expression::Variable(Identifier("second")),
+	}
+}

src/interpreter/error.rs

@@ -0,0 +1,41 @@
+use std::fmt::{Debug, Display};
+
+use super::{Context, Direction};
+
+pub trait NodeConstruct<'a>: Debug + Display {
+	/// Nodes that are to be evaluated before this node is executed
+	/// These nodes are only evaluated in advance mode
+	fn dependencies(&'a self, _context: &mut Context<'a>) -> Vec<Dependency<'a>> { Vec::new() }
+	fn execute(&'a self, context: &mut Context<'a>) -> Result<ExecutionStep, ()>;
+
+	/// Nodes that are to be evaluated before this node is reversed starting from the last
+	/// These nodes are only evaluated in reverse mode and the direction should be
+	/// as if they were evaluated in advance mode
+	fn reverse_dependencies(&'a self, _context: &mut Context<'a>) -> Vec<Dependency<'a>> { Vec::new() }
+	fn reverse(&'a self, context: &mut Context<'a>) -> Result<ExecutionStep, ()>;
+}
+
+#[derive(Debug, Clone)]
+pub struct Dependency<'a> {
+	pub node: &'a NodeConstruct<'a>,
+	pub direction: Direction,
+}
+
+impl<'a> Dependency<'a> {
+	/// Specifies the node is to be executed by advancing
+	pub fn advance(node: &'a NodeConstruct<'a>) -> Self {
+		Self { node, direction: Direction::Advance }
+	}
+
+	/// Specifies the node is to be executed in reverse
+	pub fn reverse(node: &'a NodeConstruct<'a>) -> Self {
+		Self { node, direction: Direction::Reverse }
+	}
+}
+
+#[derive(Debug)]
+pub enum ExecutionStep {
+	Void,
+	Repeat,
+	Value(i64),
+}