bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

# randomness

rand = "0.8.4"

rand_pcg = "0.3.1"

[lib]

crate-type = [

	"rlib", # for use as a Rust dependency.

]

    DefinitionsParsed,      // produced the AST for the entire module

    TypesAddedToTable,      // added all definitions to the type table

    ValidatedAndLinked,     // AST is traversed and has linked the required AST nodes

    Typed,                  // Type inference and checking has been performed

    Rewritten,              // Special AST nodes are rewritten into regular AST nodes

    // When we continue with the compiler:

    // StackSize

}

pub struct Module {

    pub source: InputSource,

    pub tokens: TokenBuffer,

    pub root_id: RootId,

    pub name: Option<(PragmaId, StringRef<'static>)>,

    pub version: Option<(PragmaId, i64)>,

    pub phase: ModuleCompilationPhase,

}

pub struct TargetArch {

    pub void_type_id: TypeId,

    pub message_type_id: TypeId,

    pub bool_type_id: TypeId,

    pub uint8_type_id: TypeId,

    pub uint16_type_id: TypeId,

        parser.arch.pointer_type_id = insert_builtin_type(&mut parser.type_table, vec![ConcreteTypePart::Pointer, ConcreteTypePart::Void], true, 8, 8);

        // Parse standard library

        parser.feed_standard_library()?;

        return Ok(parser)

    }

    /// Feeds a new InputSource to the parser, which will tokenize it and store

    /// it internally for later parsing (when all modules are present). Returns

    /// the index of the new module.

    pub fn feed(&mut self, mut source: InputSource) -> Result<usize, ParseError> {

    }

    pub fn parse(&mut self) -> Result<(), ParseError> {

        let mut pass_ctx = PassCtx{

            heap: &mut self.heap,

            symbols: &mut self.symbol_table,

            pool: &mut self.string_pool,

            arch: &self.arch,

        };

        // Advance all modules to the phase where all symbols are scanned

        for module_idx in 0..self.modules.len() {

            writer.write_ast(&mut file, &self.heap);

        }

        Ok(())

    }

    /// Tries to find the standard library and add the files for parsing.

    fn feed_standard_library(&mut self) -> Result<(), String> {

        use std::env;

        use std::path::{Path, PathBuf};

        use std::fs;

        ];

        // Determine base directory

        let (base_path, from_env) = if let Ok(path) = env::var(REOWOLF_PATH_ENV) {

            // Path variable is set

            (path, true)

        } else {

            let mut path = String::with_capacity(REOWOLF_PATH_DIR.len() + 2);

            path.push_str("./");

            path.push_str(REOWOLF_PATH_DIR);

            (path, false)

        };

        // Make sure directory exists

        let path = Path::new(&base_path);

        if !path.exists() {

            return Err(format!("std lib root directory '{}' does not exist", base_path));

        }

        // Try to load all standard library files. We might need a more unified

        // way to do this in the future (i.e. a "std" package, containing all

        // of the modules)

        let mut file_path = PathBuf::new();

        let mut first_file = true;

            file_path.clear();

            file_path.push(path);

            file_path.push(file);

            let source = fs::read(file_path.as_path());

            if let Err(err) = source {

                return Err(format!(

                    "failed to read std lib file '{}' in root directory '{}', because: {}",

                    file, base_path, err

                ));

            }

            let source = source.unwrap();

            let input_source = InputSource::new(file.to_string(), source);

            if let Err(err) = module_index {

                // A bit of a hack, but shouldn't really happen anyway: the

                // compiler should ship with a decent standard library (at some

                // point)

                return Err(format!("{}", err));

            }

            let module_index = module_index.unwrap();

            if first_file {

                self.global_module_index = module_index;

                first_file = false;

            }

        }

        return Ok(())

    }

        let mut token_buffer = TokenBuffer::new();

        self.pass_tokenizer.tokenize(&mut source, &mut token_buffer)?;

        let module = Module{

            source,

            tokens: token_buffer,

            is_compiler_file,

            root_id: RootId::new_invalid(),

            name: None,

            version: None,

            phase: ModuleCompilationPhase::Tokenized,

        };

        let module_index = self.modules.len();

        self.modules.push(module);

        return Ok(module_index);

    }

}

        self.symbols.clear();

        self.pragmas.clear();

        self.imports.clear();

        self.definitions.clear();

        self.has_pragma_version = false;

        self.has_pragma_module = false;

    }

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

        self.reset();

        let module = &mut modules[module_idx];

        debug_assert_eq!(module.phase, ModuleCompilationPhase::Tokenized);

        debug_assert!(module.root_id.is_invalid()); // not set yet

        // Preallocate root in the heap

        let root_id = ctx.heap.alloc_protocol_description(|this| {

            Root{

                this,

                pragmas: Vec::new(),

                imports: Vec::new(),

                definitions: Vec::new(),

            }

        }

        // Add the module's symbol scope and the symbols we just parsed

        let module_scope = SymbolScope::Module(root_id);

        ctx.symbols.insert_scope(Some(SymbolScope::Global), module_scope);

        for symbol in self.symbols.drain(..) {

            ctx.symbols.insert_scope(Some(module_scope), SymbolScope::Definition(symbol.variant.as_definition().definition_id));

            if let Err((new_symbol, old_symbol)) = ctx.symbols.insert_symbol(module_scope, symbol) {

                return Err(construct_symbol_conflict_error(modules, module_idx, ctx, &new_symbol, &old_symbol))

            }

        }

            debug_assert!(self.symbols.is_empty());

            ctx.symbols.get_all_symbols_defined_in_scope(module_scope, &mut self.symbols);

            for symbol in self.symbols.drain(..) {

                ctx.symbols.insert_symbol_in_global_scope(symbol);

            }

        }

        // Modify the preallocated root

        let root = &mut ctx.heap[root_id];

        root.pragmas.extend(self.pragmas.drain(..));

        root.definitions.extend(self.definitions.drain(..));

mod store;

mod runtime;

mod component;

mod communication;

mod scheduler;

#[cfg(test)] mod tests;

pub use runtime::Runtime;

pub(crate) use scheduler::SchedulerCtx;

pub(crate) use communication::{

    PortId, PortKind, PortState,

    Message, ControlMessage, SyncMessage, DataMessage,

    SyncRoundDecision

};

            sync select {}

            index += 1;

        }

    }

    ").expect("compilation");

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

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_random_u32_temporary_thingo() {

    let pd = ProtocolDescription::parse(b"

    primitive random_taker(in<u32> generator, u32 num_values) {

        auto i = 0;

        while (i < num_values) {

            sync {

                auto a = get(generator);

            }

            i += 1;

        }

    }

    composite constructor() {

        channel tx -> rx;