Welcome to JAGC

This is the project home of JAGC, a framework to create virtual computers. The goal of JAGC is to offer developers a possibility to create a virtual computer, but also to offer sample-applications which might be used for teaching purposes in schools or universities.

If you're just looking for our files and project-page, then please visit it :)

The original intention for this project was (and somehow still is) writing an AGC simulator. The AGC was the Apollo Guidance Computer, an onboard computer used on NASA's Apollo program which would land the first humans on the moon. Though simple in todays measurements, the AGC was a fine piece of technology at its time. It offered various programs which the Astronauts ran by simply entering the programs identification number and probably entering additional parameters in a combination of WORDS and NOUNS. If you want to know more about the AGC, then the Wikipedia-Article is a good starting point

Current implementation status

JAGC is written in Java. When I decided to make this project available, I thought it was worth sharing it. In software projects, people working alone for weeks or even months somehow seem to mess up code. They don't take care of how readable their code is.

Currently, JAGC does have only the most basic implementation. My reference 'Assembler' can't do many things yet, but it works. Also, that Assembler interpreter is exchangeable. The current implementation does have the following features:

• Two 8-Bit Registers (*A and *B)
• One 16-Bit Register (*AW)
• One 32-Bit Register (*ADW)
• One 8-Bit status register (*SR)
• One 16-Bit code register (*CR)
• A code segment of unlimited size (basically a linked List)

The integrated command parser knows the following commands (Note, only Integer-Arithmetics is supported yet):

• ADD *sourceregister [*register|value] - Add the value or the value of *register to *sourceregister. Result is in *sourceregister
• SUM *sourceregister [*register|value] - Subtract value or the value of *register from *sourceregister. Result is in *sourceregister
• MUL *sourceregister [*register|value] - Multiply *sourceregister with *register or value. Result stored in *sourceregister
• DIV *sourceregister [*register|value] - Divide *sourceregister by *register or value. Result stored in *sourceregister
• JMP [*register|value] - Unconditional jump. Set the address of the next instruction to be executed.
• JOZ [*register|value] - Jump if zero-bit in status-register is set.
• JOO [*register|value] - Jump if overflow-bit in status-register is set.

A very simple example-programm would look like this (it's taken from a JUnit-Test for JAGC):
; add 5 to *A
[00001] ADD *A 5

; add 10 to *A. Value of *A is now 15
[00002] ADD *A 10

; subtract 9 from *A. Value of *A is now 6
[00003] SUB *A 9

; divide *A by 2. Value of *A is now 3
[00004] DIV *A 2

; multiply *A with 3. Value of *A is now 9
[00005] MUL *A 3

; add value of *A to *ADW. *ADW is now 9, too
[00006] ADD *ADW *A

; multiply *A with 100. The result would be 900,
; but since *A is only 8 Bit wide the result is
; broken and the overflow bit in the status-register
; is set
[00007] MUL *A 100

; start all over again
[00008] JMP 1

Coding style

Since the project is still not very large, there are not really coding conventions. The only important thing is JUnit-Tests. For every class (except beans), a JUnit-Test has to be written. A good approach would be the one related to extreme programming: We first write the test to define the function of a class and then write the class itself. This keeps the developers eyes to the problem he has to solve.