The processor of the GODS! You WISH you were as sexy and amazing as the awe inspiring squishyness that is posessed by those contributing to this processor project! Maybe if you asked nicely they'd allow you to watch as they conquer the universe…

• Continue working on the other instructions.(Data Transfer Group is completed except for the edit to SHLD and LHLD, Math and Logic have instruction placeholders coded and committed.)
• Build read function to feed interpreter. Grab - Sort - File - run execute function.
• Branch Group needs to be started.
• Stack group needs to be started.
• LHLD and SHLD need an incrimentation of the 2nd byte in the address at the notated location.
• Is ALL the Logic Group included in the ALU or just part?
• Add a SP (Stack Pointer) and PC (Program Counter) registers in the register class for useage with the registers.

• Jr018429
• justion
• bewanyk - Working on instructions within the register class (placeholders in place for logic and math). Cleaning and
• rthatch2

translating the interpreter (Translator is coded, read function is next.).

Register is started. The registers (A, B, C, D, E, H, and L) are indexed by letter. Bit selection within a register ranges from 1 to 8. Currently .set and .clear functions roughed out (may want to refine them to take individual bit entries and save with tick). The .rotate (left, insert right, and return orphaned bit) and .shift (right, insert to the left, and return orphaned bit) functions are completed and need test files. Beginnind work on the hex code commands for data transfer activities. keeping movement as a private function and the hex commands as public functions calling the move function or such as needed. Should be able to overload the move function for usage with 1, 2, and 3 byte commands. If it seems to work it can be implemented as a template for a LOT of the other commands, and will make the hassle of coding all the possibilities less so.

• SP and CP registers need to be added. We should probably include them in the register array and then just incorporate a designation in the regConv function.

TERP class (for the Interpreter)is going to get the commands and convert them to their appropriate hex code. Public functions will be:

• read function which will accept the assembly file name and then turn everything over to the private side for execution.

Private will include:

• A hex decoder, in a set of switch statements which sends commends to the register.
• I'm toying with the idea of just accepting the name of the assembly file and putting the actual 'read from file' function here.

I've been looking at stuff, and I'm not sure whether we should keep a translator and an interpreter, of just make the memory accessible from the register class. and go from the interpreter straight to the register where the hex command can execute. thoughts?

The memory is accessible from the register class (I've got it included at the moment. I'm just using the interpreter to change from assembly to the actual hex instruction. So you can grab from the memory within functions and do what you want with them. The memory get and put functions are public for the memory block. –BE

Right now the Register class contains 7 registers of 8-1bit latches each. they can be utilized individually or in pairs. The g8sr class is included so all bits are stored as boolean values. Entire bytes can be moved within the class by passing an entiry g8sr object.

The basic functions are held private.

The class will accept HEX commands (prefaced with an 'i') and execute the base command for the right register or information based on that input. Register designations within the class are alphabetical. there is a conversion function [int regConv(char)] which will assign translate the character to the proper register in the array.

Flags HAVE been implemented in the Register class, but they are currently in an array. I think it'll be smoother later if we actually use individual latches named for the apropriate flags. Flags are boolean values.

The MOV r1, r2 opcodes are coded and only need a .h updated for them.

The general functions for Logical Ops to rotate right and left, and rotate through carry right and left are coded. the HEX functions need to be done for them (with some adaptation to make the general function work I think.)

Everything I'm looking at for the Register class will require the passing of either a G8SR object or a character. maybe a translation function for input of actual 8bit data for things like the ADA M opcode? Can anyone thing of a better way to handle raw data passing?

The 256kB of memory for the 8085 is being represented by a 2 dimensional array of G8SR class objects. This means the array is 256×256 with each object conatining 8-1 bit flip flop latches or 1 Byte per object.

The MEM class has get, put, private address resolution and memory dump functionality at the moment.

Instructions come in one, two, and three byte instructions.

Condition flags are not affected by this group.

regConv(char): converts the character designation for a register into the appropriate numerical designation.

clear(): Clears all registers.

clear(char): Clears a single register by ANDing all bits by 0.

clear(char, char): Clears two registers (usefull for zeroing a register pair.)

set(char, G8SR):puts a 8bit value in the designated register.

set(char, G8SR, char, G8SR): useful for loading a register pair as it puts an 8bit value in designated registers.

get(char): returns a G8SR object from the indicated register.

shift(char, bool): Shifts indicated register to the right, inserting the supplied bit to the left and returning the ejected bit.

rotate(char, bool): Rotates the indicated register to the left, inserting the supplied bit to the right and returning the ejected bit.

And: a function that ands the accumulator with another register and returns the result to the accumulator.