Extra Credit Project

A Simple Calculator

I wrote the simple calculator so that it would accept any sequence of digits, '+', and '-' and output the result after the '=' character was scanned. I was told that this would be okay as long as the calculator works. If no numbers are between two operators, then it is read by the simple calculator as though a zero was in between the two operators. So that -5+4=-1 works because 0 - 5 + 4 = -1, and 4+-3=1 works because 4 + 0 - 3 = 1.

Source code of my project is in the file "calculator.txt"

If large numbers are input, the simple calculator may be slow because of the inefficient division subroutine I used.

I used an HTA (Hierarchical Task Analysis) as my design diagram. HTA's are used to design a system by breaking it into tasks and subtasks until the system is resolved. HTA's are read from left to right, and each subtask describes it's parent's task in more detail.
HTA of the Simple Calculator

I'll try to be brief and cover what the HTA left out:

The Get Input Number subroutine (called GIN) works by looping while the input character is a digit, if the character is not a digit then its value is left in AC untouched and the subroutine returns. On each iteration of the loop, if the character is a digit, then it is transformed to it's binary value. There is a variable labelled INN which stores the input value. Each time the input subroutine is called INN is set to zero. And every time a new digit is entered, INN is multiplied by ten and then the binary value of the new digit is added to INN. Multiplication is done by shifting INN left once, then adding that to itself shifted left 3 times. Overflow is detected by checking the E bit after shifting left and checking the sign after adding. This works for the input subroutine because it only sees digits and regards every number as unsigned.

The main program loop, which is plan 2 of the HTA above, detects overflow by checking the most significant bits of the augend, addend, and sum (subtraction is done by negating the number after the minus sign, and then adding). There are two overflow cases:

if the most significant bits of the augend and addend are both 0 and the most significant bit of the sum is 1, then there is an overflow
if the most significant bits of the augend and addend are both 1 and the most significant bit of the sum is 0, then there is an overflow

I'll make a table real fast:

	E	MSB
Carries:	0	0
Augend:	x	0
Addend:	x	0
Sum:	0	0
No Overflow

	E	MSB
Carries:	0	1
Augend:	x	0
Addend:	x	0
Sum:	0	1
OVERFLOW

	E	MSB
Carries:	0	0
Augend:	x	0
Addend:	x	1
Sum:	0	1
No Overflow

	E	MSB
Carries:	1	1
Augend:	x	0
Addend:	x	1
Sum:	1	0
No Overflow

	E	MSB
Carries:	1	0
Augend:	x	1
Addend:	x	1
Sum:	1	0
OVERFLOW

	E	MSB
Carries:	1	1
Augend:	x	1
Addend:	x	1
Sum:	1	1
No Overflow

Overflow occurs whenever the carry into the MSB XOR the carry into E equals 1, and as can be seen, also happens whenever the MSB of the augend and addend are equal and not equal to the MSB of the sum.

Division is done to convert the binary result to base 10 (shown in HTA above, plan 4.1). The division is not very good because I made it calculate the quotient by counting the number of times the divisor would go into the dividend, just like on our last exam. But it is easy and works, so....

And That's It!