let mut builder = rw::ProtocolDescriptionBuilder::new().expect("create protocol description builder");

#[derive(Debug)]

pub enum ProcedureSource {

    FuncUserDefined,

    CompUserDefined,

    // Builtin functions, available to user

    FuncGet,

    FuncPut,

    FuncFires,

    FuncCreate,

    FuncLength,

    FuncAssert,

    FuncPrint,

    // Buitlin functions, not available to user

    FuncSelectStart,

    FuncSelectRegisterCasePort,

    FuncSelectWait,

    // Builtin components, available to user

    CompRandomU32, // TODO: Remove, temporary thing

}

impl ProcedureSource {

    pub(crate) fn is_builtin(&self) -> bool {

        match self {

            ProcedureSource::FuncUserDefined | ProcedureSource::CompUserDefined => false,

            _ => true,

        }

    }

}

    pub source: ProcedureSource,

            source: ProcedureSource::FuncUserDefined,

                    self.kv(indent2).with_s_key("Source").with_debug_val(&definition.source);

pub use crate::protocol::ast::*;

        let mut parser = Parser::new()?;

    pub fn new() -> Result<Self, String> {

        return Ok(Self{

            parser: Parser::new()?,

        })

const REOWOLF_PATH_ENV: &'static str = "REOWOLF_ROOT"; // first lookup reowolf path

const REOWOLF_PATH_DIR: &'static str = "std"; // then try folder in current working directory

    pub fn new() -> Result<Self, String> {

        parser.feed_standard_library()?;

        return Ok(parser)

    /// 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;

        const FILES: [&'static str; 1] = [

            "std.global.pdl",

        ];

        // 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();

        for file in FILES {

            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) = self.feed(input_source) {

                // 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));

            }

        }

        return Ok(())

    }

        // Consume body

        let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, ProcedureKind::Function)?;

        function.source = source;

        // Consume body

        let procedure_kind = ctx.heap[definition_id].as_procedure().kind;

        let (body_id, source) = self.consume_procedure_body(module, iter, ctx, definition_id, procedure_kind)?;

        component.source = source;

    /// Consumes a procedure's body: either a user-defined procedure, which we

    /// parse as normal, or a builtin function, where we'll make sure we expect

    /// the particular builtin.

    ///

    /// We expect that the procedure's name is already stored in the

    /// preallocated AST node.

    fn consume_procedure_body(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, definition_id: DefinitionId, kind: ProcedureKind

    ) -> Result<(BlockStatementId, ProcedureSource), ParseError> {

        if iter.peek() == Some(TokenKind::Pragma) {

            let (pragma, pragma_start, pragma_end) = consume_pragma(&module.source, iter)?;

            if pragma != b"#builtin" {

                return Err(ParseError::new_error_str_at_span(

                    &module.source, InputSpan::from_positions(pragma_start, pragma_end),

                    "expected a '#builtin' pragma, or a function body"

                ));

            }

            // Retrieve module and procedure name

            assert!(module.name.is_some(), "compiler error: builtin procedure body in unnamed module");

            let (_, module_name) = module.name.as_ref().unwrap();

            let module_name = module_name.as_str();

            let definition = ctx.heap[definition_id].as_procedure();

            let procedure_name = definition.identifier.value.as_str();

            let source = match (module_name, procedure_name) {

                ("std.global", "get") => ProcedureSource::FuncGet,

                ("std.global", "put") => ProcedureSource::FuncPut,

                ("std.global", "fires") => ProcedureSource::FuncFires,

                ("std.global", "create") => ProcedureSource::FuncCreate,

                ("std.global", "length") => ProcedureSource::FuncLength,

                ("std.global", "assert") => ProcedureSource::FuncAssert,

                ("std.global", "print") => ProcedureSource::FuncPrint,

                _ => panic!(

                    "compiler error: unknown builtin procedure '{}' in module '{}'",

                    procedure_name, module_name

                ),

            };

            return Ok((BlockStatementId::new_invalid(), source));

        } else {

            let body_id = self.consume_block_statement(module, iter, ctx)?;

            let source = match kind {

                ProcedureKind::Function =>

                    ProcedureSource::FuncUserDefined,

                ProcedureKind::Primitive | ProcedureKind::Composite =>

                    ProcedureSource::CompUserDefined,

            };

            return Ok((body_id, source))

        }

    }

                                // TODO: Once we start generating bytecode this is unnecessary

                                let method = match proc_def.source {

                                    ProcedureSource::FuncUserDefined => Method::UserFunction,

                                    ProcedureSource::CompUserDefined => Method::UserComponent,

                                    ProcedureSource::FuncGet => Method::Get,

                                    ProcedureSource::FuncPut => Method::Put,

                                    ProcedureSource::FuncFires => Method::Fires,

                                    ProcedureSource::FuncCreate => Method::Create,

                                    ProcedureSource::FuncLength => Method::Length,

                                    ProcedureSource::FuncAssert => Method::Assert,

                                    ProcedureSource::FuncPrint => Method::Print,

                                    _ => todo!("other proc sources")

                    if !procedure_to_check.source.is_builtin() {

                modules, ctx, root_id, return_type, definition.source.is_builtin()

                modules, ctx, root_id, &parameter.parser_type, definition.source.is_builtin()

        let mut parser = Parser::new().unwrap();

use crate::protocol::eval::*;

use crate::protocol::*;

use super::{CompCtx, CompPDL};

}

/// Creates a new component based on its definition. Meaning that if it is a

/// user-defined component then we set up the PDL code state. Otherwise we

/// construct a custom component. This does NOT take care of port and message

/// management.

pub(crate) fn create_component(

    protocol: &ProtocolDescription,

    definition_id: ProcedureDefinitionId, type_id: TypeId,

    arguments: ValueGroup, num_ports: usize

) -> Box<dyn Component> {

    let definition = &protocol.heap[definition_id];

    debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite);

    if definition.source.is_builtin() {

        // Builtin component

        todo!("implement")

    } else {

        // User-defined component

        let prompt = Prompt::new(

            &protocol.types, &protocol.heap,

            definition_id, type_id, arguments

        );

        let component = CompPDL::new(prompt, num_ports);

        return Box::new(component);

    }

        let mut arg_iter = ValueGroupPortIter::new(&mut arguments);

struct ValueGroupPortIter<'a> {

impl<'a> ValueGroupPortIter<'a> {

impl<'a> Iterator for ValueGroupPortIter<'a> {

#module std.global

func get<T>(in<T>) -> T #builtin

func put<T>(out<T>, T value) -> #type_void #builtin

func fires<T>(#type_portlike<T>) -> bool #builtin

func create<T>(#type_integerlike length) -> T[] #builtin

func length<T>(#type_arraylike<T> array) -> u32 #builtin

func assert(bool condition) -> #type_void #builtin

func print(string message) -> #type_void #builtin