int-constant = int-bin-constant | int-oct-constant | int-dec-constant | int-hex-constant

// Floating point numbers

//  language, but might be useful? 

float-constant = DIGIT* "." DIGIT+

    "new" cwb method-expr cw ";" |

    expr cw ";"

method-params-list = "(" cw (expr (cw "," cw expr)* )? cw ")"

method-expr = method cw method-params-list

/// Generic freelist structure. Item insertion/retrieval/deletion works like a

/// HashMap through keys.

pub struct FreeList<T> {

    items: *mut Entry<T>,

    capacity: usize,

mod sets;

mod raw_vec;

// mod freelist;

pub(crate) use string_pool::{StringPool, StringRef};

    /// reallocate/deallocate until dropped (which only happens at the end of

    /// the program.)

    pub(crate) fn intern(&mut self, data: &[u8]) -> StringRef<'static> {

        let data_len = data.len();

        debug_assert!(std::str::from_utf8(data).is_ok(), "string to intern is not valid UTF-8 encoded");

        let mut last = unsafe{&mut *self.last};

use std::fmt;

use std::fmt::{Debug, Display, Formatter};

use std::ops::{Index, IndexMut};

/// the compiler.

#[derive(Debug, Clone)]

pub struct ParserTypeElement {

    pub element_span: InputSpan, // span of this element, not including the child types

    pub variant: ParserTypeVariant,

}

        }

    }

    pub fn parent(&self) -> &ExpressionParent {

        match self {

            Expression::Assignment(expr) => &expr.parent,

            Expression::Variable(expr) => &expr.parent,

        }

    }

    pub fn parent_expr_id(&self) -> Option<ExpressionId> {

        if let ExpressionParent::Expression(id, _) = self.parent() {

            Some(*id)

    write_element(target, heap, t, 0);

}

fn write_concrete_type(target: &mut String, heap: &Heap, def_id: DefinitionId, t: &ConcreteType) {

    use ConcreteTypePart as CTP;

        let lhs_heap_pos = lhs_heap_pos as usize;

        let rhs_heap_pos = rhs_heap_pos as usize;

        let mut concatenated = Vec::new();

        let lhs_len = store.heap_regions[lhs_heap_pos].values.len();

        let rhs_len = store.heap_regions[rhs_heap_pos].values.len();

    }

}

impl ProtocolDescription {

    pub fn parse(buffer: &[u8]) -> Result<Self, String> {

        let source = InputSource::new(String::new(), Vec::from(buffer));

        let mut parser = Parser::new();

        parser.feed(source).expect("failed to feed source");

        let module_root = self.lookup_module_root(module_name).unwrap();

        let root = &self.heap[module_root];

        let def = root.get_definition_ident(&self.heap, identifier).unwrap();

        ComponentState { prompt: Prompt::new(&self.types, &self.heap, def, 0, ValueGroup::new_stack(args)) }

    }

    }

}

pub trait RunContext {

    fn performed_put(&mut self, port: PortId) -> bool;

    fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

            let step_result = self.prompt.step(&pd.types, &pd.heap, &pd.modules, ctx);

            match step_result {

                Err(reason) => {

                    println!("Evaluation error:\n{}", reason);

                    todo!("proper error handling/bubbling up");

                },

                Ok(continuation) => match continuation {

                    EC::Stepping => continue,

                    EC::BranchInconsistent => return RR::BranchInconsistent,

                    EC::ComponentTerminated => return RR::ComponentTerminated,

                    // Not possible to end sync block if never entered one

                    EvalContinuation::SyncBlockEnd => unreachable!(),

                    EvalContinuation::NewComponent(definition_id, monomorph_idx, args) => {

                        let mut moved_ports = HashSet::new();

                        for arg in args.values.iter() {

                            match arg {

// TODO: @remove once old runtime has disappeared

impl EvalContext<'_> {

    fn new_component(&mut self, moved_ports: HashSet<PortId>, init_state: ComponentState) -> () {

        match self {

            EvalContext::None => unreachable!(),

    }

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

        let mut token_buffer = TokenBuffer::new();

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

        )?;

        let return_types = return_types.into_vec();

        match return_types.len() {

            0 => return Err(ParseError::new_error_str_at_pos(&module.source, open_curly_pos, "expected a return type")),

            1 => {},

            self.add_code_range(target, 0, last_registered_idx, last_token_idx, NO_RELATION);

        }

        Ok(())

    }

        }

    }

    pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {

        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);

        let root_id = ctx.module().root_id;

/// Consumes an integer literal, may be binary, octal, hexadecimal or decimal,

/// and may have separating '_'-characters.

pub(crate) fn consume_integer_literal(source: &InputSource, iter: &mut TokenIter, buffer: &mut String) -> Result<(u64, InputSpan), ParseError> {

    if Some(TokenKind::Integer) != iter.next() {

        return Err(ParseError::new_error_str_at_pos(source, iter.last_valid_pos(), "expected an integer literal"));

    /// Returns the token range belonging to the token returned by `next`. This

    /// assumes that we're not at the end of the range we're iterating over.

    pub(crate) fn next_positions(&self) -> (InputPosition, InputPosition) {

        debug_assert!(self.cur < self.end);

        let token = &self.tokens[self.cur];

        let root_id = definition.defined_in;

        // Check and construct return types and argument types.

        for return_type in &definition.return_types {

            Self::check_member_parser_type(

                modules, ctx, root_id, return_type, definition.builtin

pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;

/// General context structure that is used while traversing the AST.

pub(crate) struct Ctx<'p> {

    pub heap: &'p mut Heap,

    pub modules: &'p mut [Module],

        .assert_has_monomorph("Trinary");

    });

    Tester::new_single_source_expect_ok(

        "polymorphs",

        "

    // Execution state

    pub code_state: Prompt,

    pub sync_state: SpeculativeState,

    pub next_in_queue: BranchId, // used by `ExecTree`/`BranchQueue`

    pub prepared: PreparedStatement,

}

    last_finished_handled: Option<BranchId>,

}

struct ConnectorRunContext<'a> {

    branch_id: BranchId,

    consensus: &'a Consensus,

        return !self.branch_annotations.is_empty();

    }

    #[deprecated]

    pub fn get_annotation(&self, branch_id: BranchId, channel_id: PortIdLocal) -> &ChannelAnnotation {

        let branch = &self.branch_annotations[branch_id.index as usize];

use super::consensus::{GlobalSolution, LocalSolution};

use super::port::PortIdLocal;

#[derive(Debug, Copy, Clone)]

pub(crate) struct ChannelAnnotation {

    pub channel_id: ChannelId,

    }

}

unsafe impl Send for RuntimeInner {}

unsafe impl Sync for RuntimeInner {}

    /// run the synchronous behaviour in blocking fashion. The results *must* be

    /// retrieved using `try_wait` or `wait` for the interface to be considered

    /// in non-sync mode.

    pub fn perform_sync_round(&mut self, actions: Vec<ApplicationSyncAction>) -> Result<(), ApplicationStartSyncError> {

        if self.is_in_sync {

            return Err(ApplicationStartSyncError::AlreadyInSync);

    pub peer_connector: ConnectorId, // might be temporarily inconsistent while peer port is sent around in non-sync phase

}

pub struct Channel {

    pub putter_id: PortIdLocal, // can put on it, so from the connector's point of view, this is an output

    pub getter_id: PortIdLocal, // vice versa: can get on it, so an input for the connector

                    // may end up being rerouted.

                    let port_desc = scheduled.ctx.get_port_by_id(content.data_header.sending_port).unwrap();

                    debug_assert_eq!(port_desc.peer_id, content.data_header.target_port);

                    (port_desc.peer_connector, true)

                },

                Message::SyncPort(content) => {

                    let port_desc = scheduled.ctx.get_port_by_id(content.source_port).unwrap();

                    debug_assert_eq!(port_desc.peer_id, content.target_port);

                    (port_desc.peer_connector, true)

                },

        }

    }

    fn debug(&self, message: &str) {

        println!("DEBUG [thrd:{:02} conn:  ]: {}", self.scheduler_id, message);

    }