Reservoir south

You are south of a large lake, far too deep and wide to be crossed. Paths lead east, south and southwest.

> go north

You would drown.

> swim in the lake

Swimming isn't allowed in the lake.

> go east

Fine, be that way.

Code for this and the next several episodes is at https://github.com/ericlippert/flathead/tree/blog9

Two instructions are followed by a zstring-encoded string.

let has_text opcode = match opcode with | OP0_178 | OP0_179 -> true | _ -> false

We already have the method we need to read it; we can just call it:

 let decode_text text_address opcode = if has_text opcode then Some (read_zstring text_address) else None

We'll need to know how long, in bytes, the zstring encoded text was, so that we know where this instruction ends and the next one begins. I've implemented a little helper method, not shown, to do that.

 let get_text_length text_address opcode = if has_text opcode then zstring_length text_address else 0

And now we can combine the efforts of the last half dozen episodes to decode a single instruction. I am going to represent the instruction using a record type:

type t ={ opcode : bytecode; address : instruction_address; length : int; operands : operand list; store : variable_location option; branch : (bool * branch_address) option; text : string option;}

Recall that in OCaml the generic types are constructed backwards, so string option and operand list are "optional string" and "list of operands" respectively.

Let's put it all together. I have the byte address of the first byte in the instruction stored in addr:

 let form = decode_form addr in let op_count = decode_op_count addr form in let opcode = decode_opcode addr form op_count in let opcode_length = get_opcode_length form in let operand_types = decode_operand_types addr form op_count opcode in let type_length = get_type_length form opcode in let operand_address = inc_byte_addr_by addr (opcode_length + type_length) in let operands = decode_operands operand_address operand_types in let operand_length = get_operand_length operand_types in let store_address = inc_byte_addr_by operand_address operand_length in let store = decode_store store_address opcode ver in let store_length = get_store_length opcode ver in let branch_code_address = inc_byte_addr_by store_address store_length in let branch = decode_branch branch_code_address opcode ver in let branch_length = get_branch_length branch_code_address opcode ver in let (Byte_address ba) = branch_code_address in let text_address = Zstring (ba + branch_length) in let text = decode_text text_address opcode in let text_length = get_text_length text_address opcode in let length = opcode_length + type_length + operand_length + store_length + branch_length + text_length in let address = Instruction address in { opcode; address; length; operands; store; branch; text }

We have finally done it; we can completely disassemble any instruction, given a pointer to the instruction.

Next time on FAIC: now that we've disassembled it, let's display it as text. This will be shorter, I promise!