[features]

default=["internet"]

internet=["libc"]

[dependencies]

libc = { version = "^0.2", optional = true } # raw sockets

mio = { version = "0.8", features = ["os-poll"] } # cross-platform IO notification queue

        )

        .arg(

            Arg::new("stdlib")

                .long("stdlib")

                .short('s')

                .help("standard library directory (overrides default)")

                .takes_value(true)

    let standard_library_dir = app.value_of("stdlib")

        .map(|v| v.to_string());

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

        .expect("create protocol description builder");

    // Start runtime

    print!("Startup of runtime ... ");

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

    if let Err(err) = &runtime {

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

    }

    println!("Success");

    let runtime = runtime.unwrap();

// note: this `Drop` impl used to be debug-only, requiring the programmer to

// call `into_vec` or `forget`. But this is rather error prone. So we'll check

// in debug mode, but always truncate in release mode (even though this is a

// noop in most cases).

    pub fn get_definition_by_ident(&self, h: &Heap, id: &[u8]) -> Option<DefinitionId> {

        this: StructDefinitionId, defined_in: RootId,

        Self{ this, defined_in, identifier, poly_vars, fields: Vec::new() }

        this: EnumDefinitionId, defined_in: RootId,

        Self{ this, defined_in, identifier, poly_vars, variants: Vec::new() }

        this: UnionDefinitionId, defined_in: RootId,

        Self{ this, defined_in, identifier, poly_vars, variants: Vec::new() }

#[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

    CompTcpClient,

}

impl ProcedureSource {

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

        match self {

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

            _ => true,

        }

    }

}

    pub source: ProcedureSource,

        this: ProcedureDefinitionId, defined_in: RootId,

            source: ProcedureSource::FuncUserDefined,

    // Builtin function, accessible by programmer

    // Builtin function, not accessible by programmer

    // Builtin component,

    ComponentRandomU32,

    ComponentTcpClient,

            ComponentRandomU32 | ComponentTcpClient => true,

    Bytestring(Vec<u8>),

                if def.source.is_builtin() {

                    self.kv(indent2).with_s_key("Body").with_s_val("Builtin");

                } else {

                }

                    Literal::Bytestring(bytes) => {

                        // Bytestrings are ASCII, so just convert back

                        let string = String::from_utf8_lossy(bytes.as_slice());

                        val.with_disp_val(&string);

                    },

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

                    Literal::Character(_) | Literal::Bytestring(_) | Literal::String(_) |

                                Literal::Bytestring(lit_value) => {

                                    let heap_pos = self.store.alloc_heap();

                                    let values = &mut self.store.heap_regions[heap_pos as usize].values;

                                    debug_assert!(values.is_empty());

                                    values.reserve(lit_value.len());

                                    for byte in lit_value {

                                        values.push(Value::UInt8(*byte));

                                    }

                                    Value::Array(heap_pos)

                                }

                                    let mut is_literal_string = value.get_heap_pos().is_some();

                                    let value = self.store.maybe_read_ref(&value);

                                    if is_literal_string {

                                    }

                                Method::ComponentRandomU32 | Method::ComponentTcpClient => {

                                    debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());

                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this);

                                },

                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this);

    /// Creates a clone of the value group, but leaves the memory inside of the

    /// ValueGroup vectors allocated.

    pub(crate) fn take(&mut self) -> ValueGroup {

        let cloned = self.clone();

        self.values.clear();

        self.regions.clear();

        return cloned;

    }

    /// Retrieves the column associated with a line. Calling this incurs a read

    /// lock, so don't spam it in happy-path compiler code.

    pub(crate) fn get_column(&self, pos: InputPosition) -> u32 {

        let line_start = self.lookup_line_start_offset(pos.line);

        return pos.offset - line_start + 1;

    }

pub(crate) mod ast_writer;

mod token_writer;

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

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

        let definition_id = root.get_definition_by_ident(&self.heap, identifier);

        let procedure_type_id = self.types.get_monomorph_type_id(&definition_id, &concrete_type.parts).unwrap();

    /// A somewhat temporary method. Can be used by components to lookup type

    /// definitions by their name (to have their implementation somewhat

    /// resistant to changes in the standard library)

    pub(crate) fn find_type<'a>(&'a self, module_name: &[u8], type_name: &[u8]) -> Option<TypeInspector<'a>> {

        // Lookup type definition in module

        let root_id = self.lookup_module_root(module_name)?;

        let module = &self.heap[root_id];

        let definition_id = module.get_definition_by_ident(&self.heap, type_name)?;

        let definition = &self.heap[definition_id];

        // Make sure type is not polymorphic and is not a procedure

        if !definition.poly_vars().is_empty() {

            return None;

        }

        if definition.is_procedure() {

            return None;

        }

        // Lookup type in type table

        let type_parts = [ConcreteTypePart::Instance(definition_id, 0)];

        let type_id = self.types.get_monomorph_type_id(&definition_id, &type_parts)

            .expect("type ID for non-polymorphic type");

        let type_monomorph = self.types.get_monomorph(type_id);

        return Some(TypeInspector{

            heap: definition,

            type_table: type_monomorph

        });

    }

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

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

        return Ok(Self{ parser })

pub struct TypeInspector<'a> {

    heap: &'a Definition,

    type_table: &'a MonoType,

}

impl<'a> TypeInspector<'a> {

    pub fn as_union(&'a self) -> UnionTypeInspector<'a> {

        let heap = self.heap.as_union();

        let type_table = self.type_table.variant.as_union();

        return UnionTypeInspector{ heap, type_table };

    }

}

pub struct UnionTypeInspector<'a> {

    heap: &'a UnionDefinition,

    type_table: &'a UnionMonomorph,

}

impl UnionTypeInspector<'_> {

    /// Retrieves union variant tag value.

    pub fn get_variant_tag_value(&self, variant_name: &[u8]) -> Option<i64> {

        let variant_index = self.heap.variants.iter()

            .position(|v| v.identifier.value.as_bytes() == variant_name)?;

        return Some(variant_index as i64);

    }

}

use crate::protocol::ast_writer::ASTWriter;

use crate::protocol::token_writer::TokenWriter;

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 is_compiler_file: bool, // TODO: @Hack for custom compiler-only types

    pub add_to_global_namespace: bool,

    pub(crate) global_module_index: usize, // contains globals, implicitly imported everywhere

    pub write_tokens_to: Option<String>,

    pub std_lib_dir: Option<String>,

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

            global_module_index: 0,

            write_tokens_to: None,

            std_lib_dir,

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

        return self.feed_internal(source, false, false);

        if let Some(filename) = &self.write_tokens_to {

            let mut writer = TokenWriter::new();

            let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();

            writer.write(&mut file, &self.modules);

        }

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

        // Pair is (name, add_to_global_namespace)

        const FILES: [(&'static str, bool); 3] = [

            ("std.global.pdl", true),

            ("std.internet.pdl", false),

            ("std.random.pdl", false),

        ];

        // 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 path = match self.std_lib_dir.take() {

                Some(path) => path,

                None => {

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

                    path.push_str("./");

                    path.push_str(REOWOLF_PATH_DIR);

                    path

                }

            };

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

        for (file, add_to_global_namespace) in FILES {

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

            let module_index = self.feed_internal(input_source, true, add_to_global_namespace);

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

    }

    fn feed_internal(&mut self, mut source: InputSource, is_compiler_file: bool, add_to_global_namespace: bool) -> Result<usize, ParseError> {

        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,

            add_to_global_namespace,

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

    }