gruesome 0.0.1

data/lib/gruesome/z/header.rb

@@ -0,0 +1,46 @@
+require 'bit-struct'
+
+module Gruesome
+	module Z
+
+		# Z-Story File Header
+		class Header < BitStruct
+			default_options :endian => :big
+
+			unsigned :version, 8, "Z-Machine Version"
+			unsigned :availablity_flags, 8, "Availability Flags"
+			unsigned :reservedw1, 16, "Reserved Word 1"
+			unsigned :high_mem_base, 16, "High Memory Base"
+			unsigned :entry, 16, "Entry Point"
+			unsigned :dictionary_addr, 16, "Address of Dictionary"
+			unsigned :object_tbl_addr, 16, "Address of Object Table"
+			unsigned :global_var_addr, 16, "Address of Global Variables Table"
+			unsigned :static_mem_base, 16, "Static Memory Base"
+			unsigned :capability_flags, 8, "Desired Capability Flags"
+			unsigned :reservedb1, 8, "Reserved Byte 1"
+			unsigned :reservedw2, 16, "Reserved Word 2"
+			unsigned :reservedw3, 16, "Reserved Word 3"
+			unsigned :reservedw4, 16, "Reserved Word 4"
+			unsigned :abbrev_tbl_addr, 16, "Address of Abbreviations Table"
+			unsigned :file_length, 16, "Length of File"
+			unsigned :checksum, 16, "Checksum of File"
+			unsigned :interpreter_number, 8, "Interpreter Number"
+			unsigned :interpreter_version, 8, "Interpreter Version"
+			unsigned :screen_height, 8, "Screen Height (in Lines)"
+			unsigned :screen_width, 8, "Screen Height (in Characters)"
+			unsigned :screen_width_units, 16, "Screen Width (in Units)"
+			unsigned :screen_height_units, 16, "Screen Height (in Units)"
+			unsigned :font_width, 8, "Font Width (in Units)"
+			unsigned :font_height, 8, "Font Height (in Units)"
+			unsigned :routines_addr, 16, "Offset to Routines (Divided by 8)"
+			unsigned :static_str_addr, 16, "Offset to Static Strings (Divided by 8)"
+			unsigned :background_color, 8, "Default Background Color"
+			unsigned :foreground_color, 8, "Default Foreground Color"
+			unsigned :terminating_chars_tbl_addr, 16, "Address of Terminating Characters Table"
+			unsigned :output_stream_3_width, 16, "Total Width of Characters Send to Output Stream 3"
+			unsigned :revision_number, 16, "Standard Revision Number"
+			unsigned :alphabet_tbl_addr, 16, "Address of Alphabet Table"
+			unsigned :header_ext_tbl_addr, 16, "Address of Header Extension Table"
+		end
+	end
+end

data/lib/gruesome/z/instruction.rb

@@ -0,0 +1,50 @@
+module Gruesome
+	module Z
+
+		# A Z-Machine instruction
+		class Instruction
+			attr_reader :opcode			# the opcode
+			attr_reader :types			# the types of the operands
+			attr_reader :operands		# the operands given to the instruction
+			attr_reader :destination	# the destination variable to place the result
+			attr_reader :branch_to		# the address to set the pc when branch is taken 
+										#  also... if 0, return true from routine
+										#          if 1, return false from routine
+			attr_reader :branch_on		# the condition is matched against this
+			attr_reader :length			# instruction size in number of bytes
+
+			def initialize(opcode, types, operands, destination, branch_destination, branch_condition, length)
+				@opcode = opcode
+				@types = types
+				@operands = operands
+				@destination = destination
+				@branch_to = branch_destination
+				@branch_on = branch_condition
+				@length = length
+			end
+
+			def to_s(version)
+				line = Opcode.name(@opcode, version)
+				idx = -1
+				line = line + @operands.inject("") do |result, element|
+					idx += 1
+					if @types[idx] == OperandType::VARIABLE
+						result + " %" + sprintf("%02x", element)
+					else
+						result + " " + element.to_s
+					end
+				end
+
+				if @destination != nil
+					line = line + " -> %" + sprintf("%02x", @destination)
+				end
+
+				if @branch_to != nil
+					line = line + " goto $" + sprintf("%04x", @branch_to) + " on " + @branch_on.to_s
+				end
+
+				line
+			end
+		end
+	end
+end

data/lib/gruesome/z/machine.rb

@@ -0,0 +1,71 @@
+require_relative 'header'
+require_relative 'memory'
+require_relative 'decoder'
+require_relative 'processor'
+require_relative 'abbreviation_table'
+require_relative 'object_table'
+
+module Gruesome
+	module Z
+
+		# The class that initializes and maintains a Z-Machine
+		class Machine
+
+			# Will create a new virtual machine for the game file
+			def initialize(game_file)
+				file = File.open(game_file, "r")
+
+				# I. Create memory space
+
+				memory_size = file.size
+				@memory = Memory.new(file.read(memory_size))
+
+				# Set flags
+				flags = @memory.force_readb(0x01)
+				flags &= ~(0b1110000)
+				@memory.force_writeb(0x01, flags)
+
+				# Set flags 2
+				flags = @memory.force_readb(0x10)
+				flags &= ~(0b11111100)
+				@memory.force_writeb(0x10, flags)
+
+				# II. Read header (at address 0x0000) and associated tables
+				@header = Header.new(@memory.contents)
+				@object_table = ObjectTable.new(@memory)
+
+				# III. Instantiate CPU
+				@decoder = Decoder.new(@memory)
+				@processor = Processor.new(@memory)
+			end
+
+			def execute
+				while true do
+					i = @decoder.fetch
+					#var = @memory.readv(0)
+					#if var != nil
+					#	puts "var %00 = " + sprintf("%04x", var)
+					#	@memory.writev(0, var)
+					#end
+					#var = @memory.readv(1)
+					#if var != nil
+					#	puts "var %01 = " + sprintf("%04x", @memory.readv(0x01))
+					#end
+					#puts "at $" + sprintf("%04x", @memory.program_counter) + ": " + i.to_s(@header.version)
+					@memory.program_counter += i.length
+
+					if i.opcode == Opcode::QUIT
+						break
+					end
+
+					begin
+						@processor.execute(i)
+					rescue RuntimeError => fuh
+						"error at $" + sprintf("%04x", @memory.program_counter) + ": " + i.to_s(@header.version)
+					end
+				end
+			end
+		end
+	end
+end
+

data/lib/gruesome/z/memory.rb

@@ -0,0 +1,268 @@
+require_relative 'header'
+
+# The Z-Machine Memory is a simple array of bytes
+#
+# There are three regions: Dynamic, Static, and High
+#
+# Dynamic Memory can be read and written to by a program
+# Static Memory can only be read
+# High Memory cannot be accessed by load/store instructions
+#
+# High Memory can overlap Static, but never Dynamic
+#
+# Memory is stored in big endian
+
+# Also included as memory space, yet separated from the
+# RAM itself: the stack, program counter, and a routine
+# call stack which holds the stacks of the currently
+# invocated routines
+
+# The stack is weird. Every function call starts with an empty stack
+# and any work left in the stack upon a return is lost. So there are
+# actually many stacks... one stack to hold the stacks in play, and
+# a stack for each active function.
+#
+# The stack holds the return address and the (up to) 15 local variables
+# for the routine as accessed by variables %01 to %0f.
+#
+# Variable %00 is the top of the stack, writing to it pushes, reading
+# from it pulls.
+#
+# Illegal access to variables will halt the machine. Such as illegally
+# accessing local variables that do not exist as the routine header
+# will specify an exact number.
+
+module Gruesome
+	module Z
+
+		# This class holds the memory for the virtual machine
+		class Memory
+			attr_accessor :program_counter
+			attr_reader :num_locals
+
+			def initialize(contents)
+				@call_stack = []
+				@stack = []
+				@memory = contents
+				@num_locals = 0
+
+				# Get the header information
+				@header = Header.new(@memory)
+				@program_counter = @header.entry
+
+				# With the header info, discover the bounds of each memory region
+				@dyn_base = 0x0
+				@dyn_limit = @header.static_mem_base
+
+				# Cannot Write to Static Memory
+				@static_base = @header.static_mem_base
+				@static_limit = @memory.length
+
+				# Cannot Access High Memory
+				@high_base = @header.high_mem_base
+				@high_limit = @memory.length
+
+				# Error if high memory overlaps dynamic memory
+				if @high_base < @dyn_limit
+					# XXX: ERROR
+				end
+
+				# Check machine endianess
+				@endian = [1].pack('S')[0] == 1 ? 'little' : 'big'
+			end
+
+			def packed_address_to_byte_address(address)
+				if @header.version <=3
+					address * 2
+				else
+				end
+			end
+
+			# Sets up the environment for a new routine
+			def push_routine(return_addr, num_locals, destination)
+				# pushes the stack onto the call stack
+				@call_stack.push @num_locals
+				@call_stack.push destination
+				@call_stack.push @stack
+
+				# empties the current stack
+				@stack = Array.new()
+
+				# pushes the return address onto the stack
+				@stack.push(return_addr)
+
+				# push locals
+				num_locals.times do
+					@stack.push 0
+				end
+
+				@num_locals = num_locals
+			end
+
+			# Tears down the environment for the current routine
+			def pop_routine()
+				# return the return address
+				return_addr = @stack[0]
+				@stack = @call_stack.pop
+				destination = @call_stack.pop
+				@num_locals = @call_stack.pop
+
+				{:destination => destination, :return_address => return_addr}
+			end
+
+			def readb(address)
+				if address < @high_base
+					force_readb(address)
+				else
+					# XXX: Access violation
+					raise "Access Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def readw(address)
+				if (address + 1) < @high_base
+					force_readw(address)
+				else
+					# XXX: Access violation
+					raise "Access Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def writeb(address, value)
+				if address < @static_base
+					force_writeb(address, value)
+				else
+					# XXX: Access violation
+					raise "Access Violation (W) accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def writew(address, value)
+				if (address + 1) < @static_base
+					force_writew(address, value)
+				else
+					# XXX: Access violation
+					raise "Access Violation (W) accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def force_readb(address)
+				if address < @memory.size
+					@memory.getbyte(address)
+				else
+					# XXX: Access Violation
+					raise "Major Access Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def force_readw(address)
+				if (address + 1) < @memory.size
+					if @endian == 'little'
+						(@memory.getbyte(address+1) << 8) | @memory.getbyte(address)
+					else
+						(@memory.getbyte(address) << 8) | @memory.getbyte(address+1)
+					end
+				else
+					# XXX: Access Violation
+					raise "Major Access Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def force_writeb(address, value)
+				if address < @memory.size
+					@memory.setbyte(address, (value & 255))
+				else
+					# XXX: Access Violation
+					raise "Major Access (W) Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def force_writew(address, value)
+				if (address + 1) < @memory.size
+					low_byte = value & 255
+					high_byte = (value >> 8) & 255
+
+					if @endian == 'little'
+						tmp = high_byte
+						high_byte = low_byte
+						low_byte = tmp
+					end
+
+					@memory.setbyte(address, high_byte)
+					@memory.setbyte(address+1, low_byte)
+				else
+					# XXX: Access Violation
+					raise "Major Access (W) Violation accessing $" + sprintf("%04x", address)
+					nil
+				end
+			end
+
+			def contents
+				@memory
+			end
+
+			# Read from variable number index
+			def readv(index)
+				if index == 0
+					# pop from stack
+					@stack.pop
+				elsif index >= 16
+					index -= 16
+					readw(@header.global_var_addr + (index*2))
+				elsif index <= @num_locals
+					@stack[index]
+				else
+					# XXX: Error
+				end
+			end
+
+			# Write value to variable number index
+			def writev(index, value)
+				value &= 65535
+				if index == 0
+					# push to stack
+					@stack.push value
+				elsif index >= 16
+					index -= 16
+					writew(@header.global_var_addr + (index*2), value)
+				elsif index <= @num_locals
+					@stack[index] = value
+				else
+					# XXX: Error
+				end
+			end
+
+			def force_readzstr(index, max_len = -1)
+				chrs = []
+				continue = true
+				orig_index = index
+
+				until continue == false do
+					if max_len != -1 and (index + 2 - orig_index) > max_len
+						break
+					end
+
+					byte1 = force_readb(index)
+					byte2 = force_readb(index+1)
+
+					index += 2
+
+					chrs << ((byte1 >> 2) & 0b11111)
+					chrs << (((byte1 & 0b11) << 3) | (byte2 >> 5))
+					chrs << (byte2 & 0b11111)
+
+					continue = (byte1 & 0b10000000) == 0
+				end
+
+				return [index - orig_index, chrs]
+			end
+		end
+	end
+end