Initial Fuel HLL

.gitignore

@@ -1,6 +1,7 @@
 # Generated by Cargo
 # will have compiled files and executables
-/target/
+**/*/target/
+target
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html

Cargo.toml

@@ -1,9 +1,3 @@
-[package]
-name = "hll"
-version = "0.1.0"
-authors = ["Alex <[email protected]>"]
-edition = "2018"
+[workspace]
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
+members = ["parser", "hllc"]

hllc/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "hllc"
+version = "0.1.0"
+authors = ["Alex Hansen <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+parser = { path = "../parser" }
+structopt = "0.3"
+source-span = "2.2"
+termcolor = "1.1"
+line-col = "0.2"

hllc/src/main.rs

@@ -0,0 +1,89 @@
+#![allow(warnings)]
+use line_col::LineColLookup;
+use parser::parse;
+use source_span::{
+    fmt::{Color, Formatter, Style},
+    Position, SourceBuffer, Span, DEFAULT_METRICS,
+};
+use std::fs;
+use std::fs::File;
+use std::io::prelude::*;
+use std::io::{self, Write};
+use std::path::PathBuf;
+use structopt::StructOpt;
+use termcolor::{BufferWriter, Color as TermColor, ColorChoice, ColorSpec, WriteColor};
+
+#[derive(Debug, StructOpt)]
+#[structopt(name = "example", about = "An example of StructOpt usage.")]
+struct Opt {
+    /// Input file
+    #[structopt(parse(from_os_str))]
+    input: PathBuf,
+
+    /// Output file, stdout if not present
+    #[structopt(short = "o", parse(from_os_str))]
+    output: Option<PathBuf>,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {
+    let opt = Opt::from_args();
+    let content = fs::read_to_string(opt.input)?;
+
+    let res = parse(&content);
+
+    match res {
+        Ok(output) => {
+            if let Some(output) = opt.output {
+                let mut file = File::create(output)?;
+                file.write_all(content.as_bytes())?;
+            } else {
+                println!("{:#?}", output);
+            }
+        }
+        Err(e) => format_err(&content, e),
+    }
+
+    Ok(())
+}
+
+fn format_err(input: &str, err: parser::CompileError) {
+    let metrics = DEFAULT_METRICS;
+    let chars = input.chars().map(|x| -> Result<_, ()> { Ok(x) });
+
+    let metrics = source_span::DEFAULT_METRICS;
+    let buffer = source_span::SourceBuffer::new(chars, Position::default(), metrics);
+
+    let mut fmt = Formatter::with_margin_color(Color::Blue);
+
+    for c in buffer.iter() {
+        let c = c.unwrap(); // report eventual errors.
+    }
+
+    let (start_pos, end_pos) = err.span();
+    let lookup = LineColLookup::new(input);
+    let (start_line, start_col) = lookup.get(start_pos);
+    let (end_line, end_col) = lookup.get(end_pos - 1);
+
+    let err_start = Position::new(start_line - 1, start_col - 1);
+    let err_end = Position::new(end_line - 1, end_col - 1);
+    let err_span = Span::new(err_start, err_end, err_end.next_column());
+    fmt.add(err_span, Some(err.to_friendly_error_string()), Style::Error);
+
+    let formatted = fmt.render(buffer.iter(), buffer.span(), &metrics).unwrap();
+    fmt.add(
+        buffer.span(),
+        Some("this is the whole program\nwhat a nice program!".to_string()),
+        Style::Error,
+    );
+
+    println!("{}", formatted);
+    write_red("Aborting due to previous error.").unwrap();
+}
+
+fn write_red(txt: &str) -> io::Result<()> {
+    let bufwtr = BufferWriter::stderr(ColorChoice::Always);
+    let mut buffer = bufwtr.buffer();
+    buffer.set_color(ColorSpec::new().set_fg(Some(TermColor::Red)))?;
+    writeln!(&mut buffer, "{}", txt)?;
+    bufwtr.print(&buffer)
+}

parser/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "parser"
+version = "0.1.0"
+authors = ["Alex <[email protected]>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+pest = "2.0"
+pest_derive = "2.0"
+thiserror = "1.0"
+either = "1.6"

parser/src/ast/expression.rs

@@ -0,0 +1,150 @@
+use crate::ast::Literal;
+use crate::error::CompileError;
+use crate::parser::{HllParser, Rule};
+use either::Either;
+use pest::iterators::Pair;
+
+#[derive(Debug, Clone)]
+pub(crate) enum Expression<'sc> {
+    Literal(Literal<'sc>),
+    FunctionApplication {
+        name: &'sc str,
+        arguments: Vec<Expression<'sc>>,
+    },
+    VariableExpression {
+        name: &'sc str,
+    },
+    Unit,
+    Array {
+        contents: Vec<Expression<'sc>>,
+    },
+}
+
+impl<'sc> Expression<'sc> {
+    pub(crate) fn parse_from_pair(expr: Pair<'sc, Rule>) -> Result<Self, CompileError<'sc>> {
+        let expr_for_debug = expr.clone();
+        let mut expr_iter = expr.into_inner();
+        // first expr is always here
+        let first_expr = expr_iter.next().unwrap();
+        let first_expr = Expression::parse_from_pair_inner(first_expr)?;
+        let mut expr_or_op_buf: Vec<Either<Op, Expression>> =
+            vec![Either::Right(first_expr.clone())];
+        // sometimes exprs are followed by ops in the same expr
+        while let Some(op) = expr_iter.next() {
+            let op_str = op.as_str();
+            let op = parse_op(op)?;
+            // an op is necessarily followed by an expression
+            let next_expr = match expr_iter.next() {
+                Some(o) => Expression::parse_from_pair_inner(o)?,
+                None => {
+                    return Err(CompileError::ExpectedExprAfterOp {
+                        op: op_str,
+                        span: expr_for_debug.as_span(),
+                    })
+                }
+            };
+            // pushing these into a vec in this manner so we can re-associate according to order of
+            // operations later
+            expr_or_op_buf.push(Either::Left(op));
+            expr_or_op_buf.push(Either::Right(next_expr));
+            /*
+             * TODO
+             * strategy: keep parsing until we have all of the op expressions
+             * re-associate the expr tree with operator precedence
+             */
+        }
+        if expr_or_op_buf.len() == 1 {
+            Ok(first_expr)
+        } else {
+            eprintln!("Haven't yet implemented operator precedence");
+            Err(CompileError::Unimplemented(
+                Rule::op,
+                expr_for_debug.into_span(),
+            ))
+        }
+    }
+
+    pub(crate) fn parse_from_pair_inner(expr: Pair<'sc, Rule>) -> Result<Self, CompileError<'sc>> {
+        let parsed = match expr.as_rule() {
+            Rule::literal_value => Expression::Literal(Literal::parse_from_pair(expr)?),
+            Rule::func_app => {
+                let mut func_app_parts = expr.into_inner();
+                let name = func_app_parts.next().unwrap().as_str();
+                let arguments = func_app_parts.next();
+                let arguments = arguments.map(|x| {
+                    x.into_inner()
+                        .map(|x| Expression::parse_from_pair_inner(x))
+                        .collect::<Result<Vec<_>, _>>()
+                });
+                let arguments = arguments.unwrap_or_else(|| Ok(Vec::new()))?;
+
+                Expression::FunctionApplication { name, arguments }
+            }
+            Rule::var_exp => {
+                let mut var_exp_parts = expr.into_inner();
+                Expression::VariableExpression {
+                    name: var_exp_parts.next().unwrap().as_str(),
+                }
+            }
+            Rule::array_exp => {
+                let mut array_exps = expr.into_inner();
+                Expression::Array {
+                    contents: array_exps
+                        .into_iter()
+                        .map(|expr| Expression::parse_from_pair(expr))
+                        .collect::<Result<_, _>>()?,
+                }
+            }
+            a => {
+                eprintln!(
+                    "Unimplemented expr: {:?} ({:?}) ({:?})",
+                    a,
+                    expr.as_str(),
+                    expr.as_span()
+                );
+                return Err(CompileError::Unimplemented(a, expr.as_span()));
+            }
+        };
+        Ok(parsed)
+    }
+}
+
+fn parse_op<'sc>(op: Pair<'sc, Rule>) -> Result<Op, CompileError<'sc>> {
+    use Op::*;
+    Ok(match op.as_str() {
+        "+" => Add,
+        "-" => Subtract,
+        "/" => Divide,
+        "*" => Multiply,
+        "%" => Modulo,
+        "||" => Or,
+        "&&" => And,
+        "==" => Equals,
+        "!=" => NotEquals,
+        "^" => Xor,
+        "|" => BinaryOr,
+        "&" => BinaryAnd,
+        a => {
+            return Err(CompileError::ExpectedOp {
+                op: a,
+                span: op.as_span(),
+            })
+        }
+    })
+}
+
+#[derive(Debug)]
+enum Op {
+    Add,
+    Subtract,
+    Divide,
+    Multiply,
+    Modulo,
+    Or,
+    And,
+    Equals,
+    NotEquals,
+    Xor,
+    BinaryOr,
+    BinaryAnd,
+}

parser/src/ast/function_declaration.rs

@@ -0,0 +1,100 @@
+use crate::ast::Expression;
+use crate::{CodeBlock, CompileError, Rule};
+use either::Either;
+use pest::iterators::Pair;
+
+#[derive(Debug)]
+pub(crate) struct FunctionDeclaration<'sc> {
+    pub(crate) name: &'sc str,
+    pub(crate) body: CodeBlock<'sc>,
+    pub(crate) parameters: Vec<FunctionParameter<'sc>>,
+    pub(crate) span: pest::Span<'sc>,
+    pub(crate) return_type: TypeInfo<'sc>,
+}
+
+impl<'sc> FunctionDeclaration<'sc> {
+    pub(crate) fn parse_from_pair(pair: Pair<'sc, Rule>) -> Result<Self, CompileError<'sc>> {
+        let mut parts = pair.clone().into_inner();
+        let mut signature = parts.next().unwrap().into_inner();
+        let _fn_keyword = signature.next().unwrap();
+        let name = signature.next().unwrap().as_str();
+        let parameters = signature.next().unwrap();
+        let parameters = FunctionParameter::list_from_pairs(parameters.into_inner())?;
+        let return_type_signal = signature.next();
+        let return_type = match return_type_signal {
+            Some(_) => TypeInfo::parse_from_pair(signature.next().unwrap())?,
+            None => TypeInfo::Unit,
+        };
+        let body = parts.next().unwrap();
+        let body = CodeBlock::parse_from_pair(body)?;
+        Ok(FunctionDeclaration {
+            name,
+            parameters,
+            body,
+            span: pair.as_span(),
+            return_type,
+        })
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct FunctionParameter<'sc> {
+    name: &'sc str,
+    r#type: TypeInfo<'sc>,
+}
+
+impl<'sc> FunctionParameter<'sc> {
+    pub(crate) fn list_from_pairs(
+        pairs: impl Iterator<Item = Pair<'sc, Rule>>,
+    ) -> Result<Vec<FunctionParameter<'sc>>, CompileError<'sc>> {
+        pairs
+            .map(|pair: Pair<'sc, Rule>| {
+                let mut parts = pair.clone().into_inner();
+                let name = parts.next().unwrap().as_str();
+                let r#type = if name == "self" {
+                    TypeInfo::SelfType
+                } else {
+                    TypeInfo::parse_from_pair_inner(parts.next().unwrap())?
+                };
+                Ok(FunctionParameter { name, r#type })
+            })
+            .collect()
+    }
+}
+
+/// Type information without an associated value, used for type inferencing and definition.
+#[derive(Debug)]
+pub(crate) enum TypeInfo<'sc> {
+    String,
+    UnsignedInteger(IntegerBits),
+    Boolean,
+    Generic { name: &'sc str },
+    Unit,
+    SelfType,
+}
+#[derive(Debug)]
+pub(crate) enum IntegerBits {
+    Eight,
+    Sixteen,
+    ThirtyTwo,
+    SixtyFour,
+}
+
+impl<'sc> TypeInfo<'sc> {
+    pub(crate) fn parse_from_pair(input: Pair<'sc, Rule>) -> Result<Self, CompileError<'sc>> {
+        let mut r#type = input.into_inner();
+        Self::parse_from_pair_inner(r#type.next().unwrap())
+    }
+    pub(crate) fn parse_from_pair_inner(input: Pair<'sc, Rule>) -> Result<Self, CompileError<'sc>> {
+        Ok(match input.as_str() {
+            "u8" => TypeInfo::UnsignedInteger(IntegerBits::Eight),
+            "u16" => TypeInfo::UnsignedInteger(IntegerBits::Sixteen),
+            "u32" => TypeInfo::UnsignedInteger(IntegerBits::ThirtyTwo),
+            "u64" => TypeInfo::UnsignedInteger(IntegerBits::SixtyFour),
+            "bool" => TypeInfo::Boolean,
+            "string" => TypeInfo::String,
+            "unit" => TypeInfo::Unit,
+            other => TypeInfo::Generic { name: other },
+        })
+    }
+}