schala/schala-repl/src/lib.rs

#![feature(link_args)]
#![feature(slice_patterns, box_patterns, box_syntax, proc_macro_hygiene, decl_macro)]
#![feature(plugin)]
extern crate getopts;
extern crate linefeed;
extern crate itertools;
extern crate colored;

#[macro_use]
extern crate serde_derive;
extern crate serde_json;
extern crate includedir;
extern crate phf;

use std::collections::HashSet;
use std::path::Path;
use std::fs::File;
use std::io::Read;
use std::process::exit;

mod repl;
mod language;

pub use language::{ProgrammingLanguageInterface,
ComputationRequest, ComputationResponse,
LangMetaRequest, LangMetaResponse,
DebugResponse, DebugAsk, GlobalOutputStats};

include!(concat!(env!("OUT_DIR"), "/static.rs"));
const VERSION_STRING: &'static str = "0.1.0";

pub fn start_repl(langs: Vec<Box<dyn ProgrammingLanguageInterface>>) {
  let options = command_line_options().parse(std::env::args()).unwrap_or_else(|e| {
    println!("{:?}", e);
    exit(1);
  });

  if options.opt_present("help") {
    println!("{}", command_line_options().usage("Schala metainterpreter"));
    exit(0);
  }

  match options.free[..] {
    [] | [_] => {
      let mut repl = repl::Repl::new(langs);
      repl.run_repl();
    }
    [_, ref filename, ..] => {
      run_noninteractive(filename, langs);
    }
  };
}

fn run_noninteractive(filename: &str, languages: Vec<Box<dyn ProgrammingLanguageInterface>>) {
  let path = Path::new(filename);
  let ext = path.extension().and_then(|e| e.to_str()).unwrap_or_else(|| {
    println!("Source file lacks extension");
    exit(1);
  });
  let mut language = Box::new(languages.into_iter().find(|lang| lang.get_source_file_suffix() == ext)
    .unwrap_or_else(|| {
      println!("Extension .{} not recognized", ext);
      exit(1);
    }));

  let mut source_file = File::open(path).unwrap();
  let mut buffer = String::new();
  source_file.read_to_string(&mut buffer).unwrap();

  let request = ComputationRequest {
    source: &buffer,
    debug_requests: HashSet::new(),
  };

  let response = language.run_computation(request);
  match response.main_output {
    Ok(s) => println!("{}", s),
    Err(s) => println!("{}", s)
  };
}


fn command_line_options() -> getopts::Options {
  let mut options = getopts::Options::new();
  options.optflag("h",
                  "help",
                  "Show help text");
  options.optflag("w",
                  "webapp",
                  "Start up web interpreter");
  options
}