target

**/*.rs.bk

main

examples/*/*.exe

examples/*.dll

examples/reowolf*

examples/*.txt

examples/lib*

examples/lib*.*

examples/*/amy

examples/*/bob

examples/*/main

logs/*

logs/*/*

use std::path::Path;

use backtrace::Backtrace;

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct InputSource {

    filename: String,

    pub input: Vec<u8>,

    line: usize,

    column: usize,

    offset: usize,

}

static STD_LIB_PDL: &'static [u8] = b"

primitive forward(in i, out o) {

    while(true) synchronous() put(o, get(i));

}

primitive sync(in i, out o) {

    while(true) synchronous() if(fires(i)) put(o, get(i));

}

primitive alternator(in i, out l, out r) {

    while(true) {

        synchronous() if(fires(i)) put(l, get(i));

        synchronous() if(fires(i)) put(r, get(i));

    }

}

primitive replicator(in i, out l, out r) {

    while(true) synchronous {

        if(fires(i)) {

            msg m = get(i);

            put(l, m);

            put(r, m);

        }

    }

}

primitive merger(in l, in r, out o) {

    while(true) synchronous {

        if(fires(l))      put(o, get(l));

        else if(fires(r)) put(o, get(r));

    }

}

";

impl InputSource {

    // Constructors

    pub fn new<R: io::Read, S: ToString>(filename: S, reader: &mut R) -> io::Result<InputSource> {

        let mut vec = Vec::new();

        reader.read_to_end(&mut vec)?;

        Ok(InputSource {

            filename: filename.to_string(),

            input: vec,

            line: 1,

            column: 1,

            offset: 0,

        })

    }

    // Constructor helpers

    pub fn from_file(path: &Path) -> io::Result<InputSource> {

        let filename = path.file_name();

        match filename {

            Some(filename) => {

                let mut f = File::open(path)?;

                InputSource::new(filename.to_string_lossy(), &mut f)

            }

            None => Err(io::Error::new(io::ErrorKind::NotFound, "Invalid path")),

        }

    }

    pub fn from_string(string: &str) -> io::Result<InputSource> {

        let buffer = Box::new(string);

        let mut bytes = buffer.as_bytes();

        InputSource::new(String::new(), &mut bytes)

    }

    pub fn from_buffer(buffer: &[u8]) -> io::Result<InputSource> {

        InputSource::new(String::new(), &mut Box::new(buffer))

    }

    // Internal methods

    pub fn pos(&self) -> InputPosition {

        InputPosition { line: self.line, column: self.column, offset: self.offset }

    }

    pub fn seek(&mut self, pos: InputPosition) {

        debug_assert!(pos.offset < self.input.len());

        self.line = pos.line;

        self.column = pos.column;

        self.offset = pos.offset;

    }

    pub fn error<S: ToString>(&self, message: S) -> ParseError {

        self.pos().parse_error(message)

    }

    pub fn is_eof(&self) -> bool {

        self.next() == None

    }

    pub fn next(&self) -> Option<u8> {

        if self.offset < self.input.len() {

            Some(self.input[self.offset])

        } else {