self.column = pos.column;

        self.offset = pos.offset;

    }

    pub fn is_eof(&self) -> bool {

        self.next() == None

    }

        }

        &source.input[start..end]

    }

    fn eval_error<S: ToString>(&self, message: S) -> EvalError {

        EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() }

    }

}

#[derive(Debug)]

    pub(crate) statements: Vec<ParseErrorStatement>

}

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

        if self.statements.is_empty() {

            return Ok(())

    }

}

    pub fn empty() -> Self {

        Self{ statements: Vec::new() }

    }

    pub fn new(source: &mut InputSource) -> Lexer {

        Lexer { source, level: 0 }

    }

    }

        let mut result: Vec<u8> = Vec::new();

        let mut next = self.source.next();

        while next.is_some() && next != Some(b'\n') && next != Some(b'\r') {

        }

        Ok(result)

    }

        let mut found = false;

        let mut next = self.source.next();

        while next.is_some() {

        if next.is_none() { return true; }

        return !is_ident_rest(next);

    }

        let len = keyword.len();

        for i in 0..len {

            let expected = Some(lowercase(keyword[i]));

    fn has_string(&self, string: &[u8]) -> bool {

        self.source.has(string)

    }

        let len = string.len();

        for i in 0..len {

            let expected = Some(string[i]);

    /// returned.

    fn consume_comma_separated<T, F>(

        &mut self, h: &mut Heap, open: u8, close: u8, expected_end_msg: &str, func: F

    {

        if Some(open) != self.source.next() {

            return Ok(None)

                self.source.consume();

                break;

            } else if !had_comma {

                    &self.source, self.source.pos(), expected_end_msg

                ));

            }

            }

        }

    }

        if !self.has_identifier() {

            return Err(self.error_at_pos("Expected identifier"));

        }

    fn has_integer(&mut self) -> bool {

        is_integer_start(self.source.next())

    }

        let position = self.source.pos();

        let mut data = Vec::new();

        let mut next = self.source.next();

            };

            if let Err(_err) = parsed {

            }

            Ok(parsed.unwrap())

        let next = self.source.next();

        is_ident_start(next)

    }

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        let value = self.consume_ident()?;

        Ok(Identifier{ position, value })

    }

        if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() {

            return Err(self.error_at_pos("Expected identifier"));

        }

        Ok(())

    }

        if self.has_reserved() {

            return Err(self.error_at_pos("Encountered reserved keyword"));

        }

        fn consume_part(

            l: &mut Lexer, h: &mut Heap, ident: &mut NamespacedIdentifier,

            backup_pos: &mut InputPosition

            // Consume identifier

            if !ident.value.is_empty() {

                ident.value.extend(b"::");

        Ok(ident)

    }

        if self.has_reserved() {

            return Err(self.error_at_pos("Encountered reserved keyword"));

        }

        debug_log!("consume_nsident2_spilled: {}", debug_line!(self.source));

            l.consume_ident()?;

            *backup_pos = l.source.pos();

            l.consume_whitespace(false)?;

    /// Consumes a type definition. When called the input position should be at

    /// the type specification. When done the input position will be at the end

    /// of the type specifications (hence may be at whitespace).

        // Small helper function to convert in/out polymorphic arguments. Not

        // pretty, but return boolean is true if the error is due to inference

        // not being allowed

        };

        // Consume the type

        let pos = self.source.pos();

        let parser_type_variant = if self.has_keyword(b"msg") {

            self.consume_keyword(b"msg")?;

            ParserTypeVariant::String

        } else if self.has_keyword(b"auto") {

            if !allow_inference {

                        &self.source, pos,

                        "Type inference is not allowed here"

                ));

                    } else {

                        "Type 'in' only allows for 1 polymorphic argument"

                    };

                })?;

            ParserTypeVariant::Input(poly_arg)

        } else if self.has_keyword(b"out") {

                    } else {

                        "Type 'out' only allows for 1 polymorphic argument, but {} were specified"

                    };

                })?;

            ParserTypeVariant::Output(poly_arg)

        } else {

        if !parser_type_variant.supports_polymorphic_args() {

            self.consume_whitespace(false)?;

            if let Some(b'<') = self.source.next() {

                    &self.source, self.source.pos(),

                    "This type does not allow polymorphic arguments"

                ));

                // In case we're dealing with another array

                self.consume_whitespace(false)?;

            } else {

                    &self.source, pos,

                    "Expected a closing ']'"

                ));

    /// Polymorphic arguments represent the specification of the parametric

    /// types of a polymorphic type: they specify the value of the polymorphic

    /// type's polymorphic variables.

        self.consume_comma_separated(

            h, b'<', b'>', "Expected the end of the polymorphic argument list",

        )

    }

    /// delimiters and the polymorphic variables are consumed. Otherwise the

    /// input position will stay where it is. If no polymorphic variables are

    /// present then an empty vector will be returned.

        let backup_pos = self.source.pos();

        match self.consume_comma_separated(

            h, b'<', b'>', "Expected the end of the polymorphic variable list",

    // Parameters

        self.consume_whitespace(true)?;

        let position = self.source.pos();

        let identifier = self.consume_identifier()?;

            h.alloc_parameter(|this| Parameter { this, position, parser_type, identifier });

        Ok(id)

    }

        match self.consume_comma_separated(

            h, b'(', b')', "Expected the end of the parameter list",

            |lexer, heap| lexer.consume_parameter(heap)

        )? {

            Some(params) => Ok(params),

            None => {

                    &self.source, self.source.pos(),

                    "Expected a parameter list"

                ))

    // Expressions

    // ====================

        self.consume_string(b"(")?;

        self.consume_whitespace(false)?;

        let result = self.consume_expression(h)?;

        self.consume_string(b")")?;

        Ok(result)

    }

        if self.level >= MAX_LEVEL {

            return Err(self.error_at_pos("Too deeply nested expression"));

        }

        self.level -= 1;

        result

    }

        let result = self.consume_conditional_expression(h)?;

        self.consume_whitespace(false)?;

        if self.has_assignment_operator() {

            || self.has_string(b"^=")

            || self.has_string(b"|=")

    }

        if self.has_string(b"=") {

            self.consume_string(b"=")?;

            Ok(AssignmentOperator::Set)

            Err(self.error_at_pos("Expected assignment operator"))

        }

    }

        let result = self.consume_concat_expression(h)?;

        self.consume_whitespace(false)?;

        if self.has_string(b"?") {

            Ok(result)

        }

    }

        let mut result = self.consume_lor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"@") {

        }

        Ok(result)

    }

        let mut result = self.consume_land_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"||") {

        }

        Ok(result)

    }

        let mut result = self.consume_bor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"&&") {

        }

        Ok(result)

    }

        let mut result = self.consume_xor_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"|") && !self.has_string(b"||") && !self.has_string(b"|=") {

        }

        Ok(result)

    }

        let mut result = self.consume_band_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"^") && !self.has_string(b"^=") {

        }

        Ok(result)

    }

        let mut result = self.consume_eq_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"&") && !self.has_string(b"&&") && !self.has_string(b"&=") {

        }

        Ok(result)

    }

        let mut result = self.consume_rel_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"==") || self.has_string(b"!=") {

        }

        Ok(result)

    }

        let mut result = self.consume_shift_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"<=")

        }

        Ok(result)

    }

        let mut result = self.consume_add_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"<<") && !self.has_string(b"<<=")

        }

        Ok(result)

    }

        let mut result = self.consume_mul_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"+") && !self.has_string(b"+=")

        }

        Ok(result)

    }

        let mut result = self.consume_prefix_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"*") && !self.has_string(b"*=")

        }

        Ok(result)

    }

        if self.has_string(b"+")

            || self.has_string(b"-")

            || self.has_string(b"~")

        }

        self.consume_postfix_expression(h)

    }

        let mut result = self.consume_primary_expression(h)?;

        self.consume_whitespace(false)?;

        while self.has_string(b"++")

        }

        Ok(result)

    }

        if self.has_string(b"(") {

            return self.consume_paren_expression(h);

        }

        }

        Ok(self.consume_variable_expression(h)?.upcast())

    }

        let position = self.source.pos();

        let mut elements = Vec::new();

        self.consume_string(b"{")?;

    fn consume_builtin_literal_expression(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        let value;

        if self.has_keyword(b"null") {

        return result;

    }

        // Consume identifier and polymorphic arguments

        debug_log!("consume_struct_literal_expression: {}", debug_line!(self.source));

        let position = self.source.pos();

            }

        )? {

            Some(fields) => fields,

                self.source, self.source.pos(),

                "A struct literal must be followed by its field values"

            ))

        self.source.seek(backup_pos);

        return result;

    }

        let position = self.source.pos();

        // Consume method identifier

    fn consume_variable_expression(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        debug_log!("consume_variable_expression: {}", debug_line!(self.source));

    /// will be wrapped in a block statement if it is not already a block

    /// statement. This is used to ensure that all `if`, `while` and `sync`

    /// statements have a block statement as body.

        if self.level >= MAX_LEVEL {

            return Err(self.error_at_pos("Too deeply nested statement"));

        }

        self.source.seek(backup_pos);

        return result;

    }

        // Parse and allocate statement

        let mut must_wrap = true;

        let mut stmt_id = if self.has_string(b"{") {

        self.source.seek(backup_pos);

        return result;

    }

        let position = self.source.pos();

        let mut statements = Vec::new();

        self.consume_string(b"{")?;

            .upcast())

        }

    }

        if self.has_keyword(b"channel") {

            let local_id = self.consume_channel_statement(h)?.upcast();

            Ok((local_id, None))

    fn consume_channel_statement(

        &mut self,

        h: &mut Heap,

        // Consume channel statement and polymorphic argument if specified.

        // Needs a tiny bit of special parsing to ensure the right amount of

        // whitespace is present.

                this, pos: position.clone(), variant: ParserTypeVariant::Inferred,

            }),

            1 => poly_args[0],

                &self.source, self.source.pos(),

                "port construction using 'channel' accepts up to 1 polymorphic argument"

            ))

            next: None,

        }))

    }

        let position = self.source.pos();

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        self.consume_whitespace(false)?;

    fn consume_labeled_statement(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        let label = self.consume_identifier()?;

        self.consume_whitespace(false)?;

            in_sync: None,

        }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"skip")?;

        self.consume_whitespace(false)?;

        self.consume_string(b";")?;

        Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"if")?;

        self.consume_whitespace(false)?;

        };

        Ok(h.alloc_if_statement(|this| IfStatement { this, position, test, true_body, false_body, end_if: None }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"while")?;

        self.consume_whitespace(false)?;

            in_sync: None,

        }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"break")?;

        self.consume_whitespace(false)?;

    fn consume_continue_statement(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        self.consume_keyword(b"continue")?;

        self.consume_whitespace(false)?;

    fn consume_synchronous_statement(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        self.consume_keyword(b"synchronous")?;

        self.consume_whitespace(false)?;

            parent_scope: None,

        }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"return")?;

        self.consume_whitespace(false)?;

        self.consume_string(b";")?;

        Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"assert")?;

        self.consume_whitespace(false)?;

            next: None,

        }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"goto")?;

        self.consume_whitespace(false)?;

        self.consume_string(b";")?;

        Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None }))

    }

        let position = self.source.pos();

        self.consume_keyword(b"new")?;

        self.consume_whitespace(false)?;

    fn consume_expression_statement(

        &mut self,

        h: &mut Heap,

        let position = self.source.pos();

        let expression = self.consume_expression(h)?;

        self.consume_whitespace(false)?;

            || self.has_type_keyword()

            || self.has_identifier()

    }

        if self.has_keyword(b"struct") {

            Ok(self.consume_struct_definition(h)?.upcast())

        } else if self.has_keyword(b"enum") {

            Ok(self.consume_function_definition(h)?.upcast())

        }

    }

        // Parse "struct" keyword, optional polyvars and its identifier

        let struct_pos = self.source.pos();

        self.consume_keyword(b"struct")?;

            h, b'{', b'}', "Expected the end of the list of struct fields",

            |lexer, heap| {

                let position = lexer.source.pos();

                lexer.consume_whitespace(true)?;

                let field = lexer.consume_identifier()?;

            }

        )? {

            Some(fields) => fields,

                self.source, struct_pos,

                "An struct definition must be followed by its fields"

            )),

            fields,

        }))

    }

        // Parse "enum" keyword, optional polyvars and its identifier

        let enum_pos = self.source.pos();

        self.consume_keyword(b"enum")?;

                        // Embedded type

                        lexer.source.consume();

                        lexer.consume_whitespace(false)?;

                        lexer.consume_whitespace(false)?;

                        lexer.consume_string(b")")?;

                        EnumVariantValue::Type(embedded_type)

            }

        )? {

            Some(variants) => variants,

                self.source, enum_pos,

                "An enum definition must be followed by its variants"

            )),

            variants,

        }))

    }

        // TODO: Cleanup

        if self.has_keyword(b"composite") {

            Ok(self.consume_composite_definition(h)?)

            Ok(self.consume_primitive_definition(h)?)

        }

    }

        // Parse keyword, optional polyvars and the identifier

        let position = self.source.pos();

        self.consume_keyword(b"composite")?;

            body

        }))

    }

        // Consume keyword, optional polyvars and identifier

        let position = self.source.pos();

        self.consume_keyword(b"primitive")?;

            body

        }))

    }

        // Consume return type, optional polyvars and identifier

        let position = self.source.pos();

        self.consume_whitespace(true)?;

        let identifier = self.consume_identifier()?;

        self.consume_whitespace(false)?;

            false

        }

    }

        let position = self.source.pos();

        let next = self.source.next();

        if next != Some(b'#') {

    fn has_import(&self) -> bool {

        self.has_keyword(b"import")

    }

        // Parse the word "import" and the name of the module

        let position = self.source.pos();

        self.consume_keyword(b"import")?;

        self.consume_string(b";")?;

        Ok(import)

    }

        let position = self.source.pos();

        let mut pragmas = Vec::new();

        let mut imports = Vec::new();

        }

    }

        // Lex the input source

        let mut lex = Lexer::new(&mut source);

        let pd = lex.consume_protocol_description(&mut self.heap)?;

                Pragma::Module(module) => {

                    if !module_name.is_empty() {

                        return Err(

                                .with_postfixed_info(&source, module_name_pos, "Previous definition was here")

                        )

                    }

                Pragma::Version(version) => {

                    if module_version.is_some() {

                        return Err(

                                .with_postfixed_info(&source, module_version_pos, "Previous definition was here")

                        )

                    }

            };

            return Err(

                    .with_postfixed_info(&prev_module.source, prev_module_pos, "Other definition was here")

            );

        }

        Ok(pd)

    }

        // Construct the symbol table to resolve any imports and/or definitions,

        // then use the symbol table to actually annotate all of the imports.

        // If the type table is constructed correctly then all imports MUST be

        Ok(())

    }