So You Want to Build a Language VM - Part 16 - String Constants And More

#[test]
fn test_parse_string_operand() {
    let result = irstring(CompleteStr("'This is a test'"));
    assert_eq!(result.is_ok(), true);
}

named!(directive_combined<CompleteStr, AssemblerInstruction>,
    ws!(
        do_parse!(
            tag!(".") >>
            name: directive_declaration >>
            o1: opt!(operand) >>
            o2: opt!(operand) >>
            o3: opt!(operand) >>
            (
                AssemblerInstruction{
                    opcode: None,
                    directive: Some(name),
                    label: None,
                    operand1: o1,
                    operand2: o2,
                    operand3: o3,
                }
            )
        )
    )
);

use assembler::label_parsers::label_declaration;

named!(directive_combined<CompleteStr, AssemblerInstruction>,
    ws!(
        do_parse!(
            l: opt!(label_declaration) >>
            name: directive_declaration >>
            o1: opt!(operand) >>
            o2: opt!(operand) >>
            o3: opt!(operand) >>
            (
                AssemblerInstruction{
                    opcode: None,
                    directive: Some(name),
                    label: l,
                    operand1: o1,
                    operand2: o2,
                    operand3: o3,
                }
            )
        )
    )
);

#[test]
fn test_string_directive() {
    let result = directive_combined(CompleteStr("test: .asciiz 'Hello'"));
    assert_eq!(result.is_ok(), true);
    let (_, directive) = result.unwrap();

    // Yes, this is the what the result should be
    let correct_instruction =
        AssemblerInstruction {
            opcode: None,
            label: Some(
                Token::LabelDeclaration {
                    name: "test".to_string()
                }),
            directive: Some(
                Token::Directive {
                    name: "asciiz".to_string()
                }),
            operand1: Some(Token::IrString { name: "Hello".to_string() }),
            operand2: None,
            operand3: None };

    assert_eq!(directive, correct_instruction);
}

pub fn assemble(&mut self, raw: &str) -> Result<Vec<u8>, Vec<AssemblerError>> {
    // Runs the raw program through our `nom` parser
    match program(CompleteStr(raw)) {
        // If there were no parsing errors, we now have a `Vec<AssemblyInstructions>` to process.
        // `remainder` _should_ be "".
        // TODO: Add a check for `remainder`, make sure it is "".
        Ok((_remainder, program)) => {
            // First get the header so we can smush it into the bytecode later
            let mut assembled_program = self.write_pie_header();

            // Start processing the AssembledInstructions. This is the first pass of our two-pass assembler.
            // We pass a read-only reference down to another function.
            self.process_first_phase(&program);

            // If we accumulated any errors in the first pass, return them and don't try to do the second pass
            if !self.errors.is_empty() {
                // TODO: Can we avoid a clone here?
                return Err(self.errors.clone());
            };

            // Make sure that we have at least one data section and one code section
            if self.sections.len() != 2 {
                // TODO: Detail out which one(s) are missing
                println!("Did not find at least two sections.");
                self.errors.push(AssemblerError::InsufficientSections);
                // TODO: Can we avoid a clone here?
                return Err(self.errors.clone());
            }
            // Run the second pass, which translates opcodes and associated operands into the bytecode
            let mut body = self.process_second_phase(&program);

            // Merge the header with the populated body vector
            assembled_program.append(&mut body);
            Ok(assembled_program)
        },
        // If there were parsing errors, bad syntax, etc, this arm is run
        Err(e) => {
            println!("There was an error parsing the code: {:?}", e);
            Err(vec![AssemblerError::ParseError{ error: e.to_string() }])
        }
    }
}

/// Runs the first pass of the two-pass assembling process. It looks for labels and puts them in the symbol table
fn process_first_phase(&mut self, p: &Program) {
    // Iterate over every instruction, even though in the first phase we care about labels and directives but nothing else
    for i in &p.instructions {
        if i.is_label() {
            // TODO: Factor this out into another function? Put it in `process_label_declaration`?
            if self.current_section.is_some() {
                // If we have hit a segment header already (e.g., `.code`) then we are ok
                self.process_label_declaration(&i);
            } else {
                // If we have *not* hit a segment header yet, then we have a label outside of a segment, which is not allowed
                self.errors.push(AssemblerError::NoSegmentDeclarationFound{instruction: self.current_instruction});
            }
        }

        if i.is_directive() {
            self.process_directive(i);
        }
        // This is used to keep track of which instruction we hit an error on
        // TODO: Do we really need to track this?
        self.current_instruction += 1;
    }
    // Once we're done with this function, set the phase to second
    self.phase = AssemblerPhase::Second;
}

/// Runs the second pass of the assembler
fn process_second_phase(&mut self, p: &Program) -> Vec<u8> {
    // Restart the counting of instructions
    self.current_instruction = 0;
    // We're going to put the bytecode meant to be executed in a separate Vec so we can do some post-processing and then merge it with the header and read-only sections
    // Examples could be optimizations, additional checks, whatever
    let mut program = vec![];
    // Same as in first pass, except in the second pass we care about opcodes and directives
    for i in &p.instructions {
        if i.is_opcode() {
            // Opcodes know how to properly transform themselves into 32-bits, so we can just call `to_bytes` and append to our program
            let mut bytes = i.to_bytes(&self.symbols);
            program.append(&mut bytes);
        }
        if i.is_directive() {
            // In this phase, we can have directives but of different types than we care about in the first pass. The Directive itself can check which pass the Assembler
            // is in and decide what to do about it
            self.process_directive(i);
        }
        self.current_instruction += 1
    }
    program
}