main.rs

main.rs

extern crate protobuf;
mod pubsub;
mod msg;

// use protobuf::Message;
use pubsub::{pub_msg, sub};

extern crate v8worker2;
use v8worker2::v8worker;
use std::fs::File;
use std::io::prelude::*;
use std::env;

pub fn cb(_worker: *mut v8worker::V8Worker, _data: &mut [u8], _length: i32, _index: i32) {
    println!("CB!");
    let _base_msg: msg::BaseMsg;
    let _decoded = protobuf::parse_from_bytes::<msg::BaseMsg>(_data);
    _base_msg = _decoded.unwrap();
    sub(&_base_msg);
}

fn load_file(_worker: &mut v8worker::V8Worker, _filename: &String) {
    let mut f = File::open(_filename).expect("file not found");
    let mut contents = String::new();
    f.read_to_string(&mut contents).expect("i/o error");
    _worker.load(_filename.to_string(), contents);
}

fn start(_worker: &mut v8worker::V8Worker) {
    // Load main.js:
    let main_js_filename = String::from("main.js");
    let mut main_js = File::open(main_js_filename).expect("file not found");
    let mut main_js_contents = String::new();
    main_js.read_to_string(&mut main_js_contents).expect("i/o error");
    _worker.load("/main.js".to_string(), main_js_contents.clone());

    // Call denoMain
    _worker.load("/deno_main.js".to_string(), "denoMain();".to_string());

    // Load main.map:
    let main_map_filename = String::from("main.map");
    let mut main_map = File::open(main_map_filename).expect("file not found");
    let mut main_map_contents = String::new();
    main_map.read_to_string(&mut main_map_contents).expect("i/o error");

    // Get current dir
    let cwd = env::current_dir().unwrap();
    let cwd_str = cwd.into_os_string().into_string().unwrap();

    // Prepare start message:
    let mut _message: msg::Msg;
    _message = msg::Msg::new();
    _message.command = msg::Msg_Command::START;
    _message.start_cwd = cwd_str;
    _message.start_main_js = main_js_contents;
    _message.start_main_map = main_map_contents;
    _message.start_argv.push("readfile.ts".to_string());
    pub_msg(_worker, &"start".to_string(), &_message);
}

fn main() {
    // Parse flags:
    let args: Vec<String> = env::args().collect();
    let _input = &args[1];

    // Initialize V8 worker:
    v8worker2::init();
    unsafe {
        v8worker2::CB = cb;
    }

    // let mut worker: v8worker::V8Worker;
    let mut worker = v8worker::new();
    start(&mut worker);
    // start(&mut worker);
}