schala/maaru/src/lib.rs

#![feature(box_patterns)]

extern crate schala_repl;

mod tokenizer;
mod parser;
mod eval;

#[derive(Debug)]
pub struct TokenError {
    pub msg: String,
}

impl TokenError {
    pub fn new(msg: &str) -> TokenError {
        TokenError { msg: msg.to_string() }
    }
}

pub use self::eval::Evaluator as MaaruEvaluator;

pub struct Maaru<'a> {
  evaluator: MaaruEvaluator<'a>
}

impl<'a> Maaru<'a> {
  pub fn new() -> Maaru<'a> {
    Maaru {
      evaluator: MaaruEvaluator::new(None),
    }
  }
}

/*
fn execute_pipeline(&mut self, input: &str, options: &EvalOptions) -> Result<String, String> {
  let mut output = UnfinishedComputation::default();

  let tokens = match tokenizer::tokenize(input) {
    Ok(tokens) => {
      if let Some(_) = options.debug_passes.get("tokens") {
        output.add_artifact(TraceArtifact::new("tokens", format!("{:?}", tokens)));
      }
      tokens
    },
    Err(err) => {
      return output.finish(Err(format!("Tokenization error: {:?}\n", err.msg)))
    }
  };

  let ast = match parser::parse(&tokens, &[]) {
    Ok(ast) => {
      if let Some(_) = options.debug_passes.get("ast") {
        output.add_artifact(TraceArtifact::new("ast", format!("{:?}", ast)));
      }
      ast
    },
    Err(err) => {
      return output.finish(Err(format!("Parse error: {:?}\n", err.msg)))
    }
  };
  let mut evaluation_output = String::new();
  for s in self.evaluator.run(ast).iter() {
    evaluation_output.push_str(s);
  }
  Ok(evaluation_output)
}
*/

/*
impl<'a> ProgrammingLanguageInterface for Maaru<'a> {
  fn get_language_name(&self) -> String {
    "Maaru".to_string()
  }
  fn get_source_file_suffix(&self) -> String {
    format!("maaru")
  }
}
  */