edition = "2021"

[package]

name = "reowolf_compiler"

version = "0.1.0"

authors = [

    "Max Henger <henger@cwi.nl>",

    "Christopher Esterhuyse <esterhuy@cwi.nl>",

    "Hans-Dieter Hiep <hdh@cwi.nl>"

]

edition = "2021"

[dependencies]

reowolf_rs = { path = "../" }

clap = "3.0"

use std::fs::File;

use std::io::Read;

use clap::{App, Arg};

use reowolf_rs as rw;

fn main() {

    let app = App::new("rwc")

        .author("Henger, M.")

        .version(env!("CARGO_PKG_VERSION"))

        .about("Reowolf compiler")

        .arg(

            Arg::new("input")

                .long("input")

                .short('i')

                .help("input files")

                .required(true)

                .takes_value(true)

                .multiple_occurrences(true)

        )

        .arg(

            Arg::new("threads")

                .long("threads")

                .short('t')

                .help("number of runtime threads")

                .default_value("1")

                .takes_value(true)

        )

        .arg(

            Arg::new("debug")

                .long("debug")

                .short('d')

                .help("enable debug logging")

        );

    // Retrieve arguments and convert

    let app = app.get_matches();

    let input_files = app.values_of("input");

    if input_files.is_none() {

        println!("ERROR: Expected at least one input file");

        return;

    }

    let num_threads = app.value_of("threads").unwrap();

    let num_threads = match num_threads.parse::<i32>() {

        Ok(num_threads) => {

            if num_threads < 0 || num_threads > 255 {

                println!("ERROR: Number of threads must be a number between 0 and 256");

                return;

            }

            num_threads as u32

        },

        Err(err) => {

            println!("ERROR: Failed to parse number of threads\nbecause: {}", err);

            return;

        }

    };

    let debug_enabled = app.is_present("debug");

    // Add input files to file buffer

    let input_files = input_files.unwrap();

    assert!(input_files.len() > 0); // because arg is required

    let mut builder = rw::ProtocolDescriptionBuilder::new();

    let mut file_buffer = Vec::with_capacity(4096);

    for input_file in input_files {

        print!("Adding file: {} ... ", input_file);

        let mut file = match File::open(input_file) {

            Ok(file) => file,

            Err(err) => {

                println!("FAILED (to open file)\nbecause:\n{}", err);

                return;

            }

        };

        file_buffer.clear();

        if let Err(err) = file.read_to_end(&mut file_buffer) {

            println!("FAILED (to read file)\nbecause:\n{}", err);

            return;

        }

        if let Err(err) = builder.add(input_file.to_string(), file_buffer.clone()) {

            println!("FAILED (to tokenize file)\nbecause:\n{}", err);

        }

        println!("Success");

    }

    // Compile the program

    print!("Compiling program ... ");

    let protocol_description = match builder.compile() {

        Ok(pd) => pd,

        Err(err) => {

            println!("FAILED\nbecause:\n{}", err);

            return;

        }

    };

    println!("Success");

    // Make sure there is a nameless module with a main component

    print!("Creating main component ... ");

    let runtime = rw::runtime2::Runtime::new(num_threads, debug_enabled, protocol_description);

    if let Err(err) = runtime.create_component(b"", b"main") {

        use rw::ComponentCreationError as CCE;

        let reason = match err {

            CCE::ModuleDoesntExist => "Input files did not contain a nameless module (that should contain the 'main' component)",

            CCE::DefinitionDoesntExist => "Input files did not contain a component called 'main'",

            CCE::DefinitionNotComponent => "Input file contained a 'main' function, but not a 'main' component",

            _ => "Unexpected error"

        };

        println!("FAILED\nbecause:\n{} (raw error: {:?})", reason, err);

        return;

    }

    println!("Success");

    println!("Now running until all components have exited");

    println!("--------------------------------------------\n\n");

}

pub use protocol::{ProtocolDescription, ProtocolDescriptionBuilder, ComponentCreationError};

pub struct ProtocolDescriptionBuilder {

    parser: Parser,

}

impl ProtocolDescriptionBuilder {

    pub fn new() -> Self {

        return Self{

            parser: Parser::new(),

        }

    }

    pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {

        let input = InputSource::new(filename, buffer);

        self.parser.feed(input)?;

        return Ok(())

    }

    pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {

        self.parser.parse()?;

        let modules: Vec<Module> = self.parser.modules.into_iter()

            .map(|module| Module{

                source: module.source,

                root_id: module.root_id,

                name: module.name.map(|(_, name)| name)

            })

            .collect();

        return Ok(ProtocolDescription {

            modules,

            heap: self.parser.heap,

            types: self.parser.type_table,

            pool: Mutex::new(self.parser.string_pool),

        });

    }

}

            let module = &modules[module_idx];

        // Modify module

    fn visit_pragma_range(&mut self, modules: &mut [Module], module_idx: usize, ctx: &mut PassCtx, range_idx: usize) -> Result<(), ParseError> {

        let module = &mut modules[module_idx];

            if let Err(other_module_root_id) = ctx.symbols.insert_module(module_name.clone(), module.root_id) {

            module.name = Some((pragma_id, module_name));

            module.version = Some((pragma_id, version as i64));

#[cfg(test)] mod tests;

pub use runtime::Runtime;

    // TODO: debug_logging should be removed at some point

    pub fn new(num_threads: u32, debug_logging: bool, protocol_description: ProtocolDescription) -> Runtime {

            let mut scheduler = Scheduler::new(runtime.inner.clone(), thread_index, debug_logging);

    pub fn create_component(&self, module_name: &[u8], routine_name: &[u8]) -> Result<(), ComponentCreationError> {

        use crate::protocol::eval::ValueGroup;

        let prompt = self.inner.protocol.new_component(

            module_name, routine_name,

            ValueGroup::new_stack(Vec::new())

        )?;

        let reserved = self.inner.start_create_pdl_component();

        let ctx = CompCtx::new(&reserved);

        let (key, _) = self.inner.finish_create_pdl_component(reserved, CompPDL::new(prompt, 0), ctx, false);

        self.inner.enqueue_work(key);

        return Ok(())

    }

    debug_logging: bool,

    pub logging_enabled: bool,

    pub fn new(runtime: &'a RuntimeInner, id: u32, logging_enabled: bool) -> Self {

            logging_enabled,

        if self.logging_enabled {

            println!("[s:{:02}, c:{:03}] {}", self.id, self.comp, text);

        }

        if self.logging_enabled {

            println!("[s:{:02}, c:{:03}] *** *** {}", self.id, self.comp, text);

        }

    pub fn new(runtime: Arc<RuntimeInner>, scheduler_id: u32, debug_logging: bool) -> Self {

        return Scheduler{ runtime, scheduler_id, debug_logging }

        let mut scheduler_ctx = SchedulerCtx::new(&*self.runtime, self.scheduler_id, self.debug_logging);

    let rt = Runtime::new(1, true, pd);

    let rt = Runtime::new(3, true, pd);

#module consumer

primitive consumer(in<u32> input) {

    sync {

        print("C: going to receive a value");

        auto v = get(input);

        print("C: I have received a value");

    }

    print("C: I am now exiting");

}

import consumer as c;

import producer::producer;

composite main() {

    channel output -> input;

    new c::consumer(input);

    new producer(output);

}

#module producer

primitive producer(out<u32> output) {

    sync {

        print("P: Going to send a value!");

        put(output, 1337);

        print("P: I just sent a value!");

    }

    print("P: I am exiting");

}

Run as:

./bin-compiler -i ./testdata/basic-modules/consumer.pdl -i ./testdata/basic-modules/producer.pdl -i ./testdata/basic-modules/main.pdl

Run as:

./bin-compiler -i ./testdata/basic-modules/testing.pdl

primitive consumer(in<u32> input) {

    sync {

        print("C: going to receive a value");

        auto v = get(input);

        print("C: I have received a value");

    }

    print("C: I am now exiting");

}

primitive producer(out<u32> output) {

    sync {

        print("P: Going to send a value!");

        put(output, 1337);

        print("P: I just sent a value!");

    }

    print("P: I am exiting");

}

composite main() {

    channel output -> input;

    new consumer(input);

    new producer(output);

}