Lab 03 - Addition and Subtraction Calculator

 Addition and Subtraction Calculator


This blog post features an Assembly Language code for creating an addition and subtraction calculator. This code is not fully functional and is still a work in progress and can be improved over time.

-------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------

Down below are the defined values that are used to ensure addition or subtraction operations work:

define NUM1                        $0200   - first number storage
define NUM2                        $0201   - second number storage
define OPERATION             $0202   - operation such as +/-
define RESULT                     $0203  - result based on operation chosen
define TEXT_SCREEN        $0400  - screen memory
define SCREEN_PTR_LO    $00     - for screen pointer high byte
define SCREEN_PTR_HI     $01     - for screen pointer low byte
define KEYBOARD              $FF    - keyboard memory location
define ASCII_ENTER           #13    - ASCII enter key

START:

This following is to initialize the screen pointer

    LDA #<TEXT_SCREEN - loads $0400
    STA SCREEN_PTR_LO  - stores it into $00
    LDA #>TEXT_SCREEN - loads $0400
    STA SCREEN_PTR_HI.  - stores it into $01 

Reads first number

    JSR GET_NUMBER
    STA NUM1

Reads operation

    JSR GET_OPERATION
    STA OPERATION

Reads second number

    JSR GET_NUMBER
    STA NUM2

Performs the calculation

    LDA OPERATION
    CMP #$2B   - checks if it's #$2B, if yes, choose addition
    BEQ ADDITION
    CMP #$2D   - checks if it's #$2D, if yes, choose subtraction
    BEQ SUBTRACTION
    JMP ERROR - loads error if neither of the comparison

Addition logic

ADDITION:
    LDA NUM1 - loads number
    CLC - clears
    ADC NUM2 - adds number 1 and number 2 using ADC
    STA RESULT - loads result
    JMP DISPLAY_RESULT - loads display_result

Subtraction logic

SUBTRACTION:
    LDA NUM1 - loads number 
    SEC - sets carry 
    SBC NUM2 - subtracts using SBC
    STA RESULT - loads result
    JMP DISPLAY_RESULT - displays result

Displays result to screen

DISPLAY_RESULT:
    LDA RESULT
    STA TEXT_SCREEN
    JMP START

Displays "E" on screen if input is invalid

ERROR:
    LDA #$45  - loads "e"
    STA TEXT_SCREEN
    JMP START

Reads full number input and not just per digit entered, for example "23" instead of 2 and 3

GET_NUMBER:
    JSR GET_KEY
    CMP ASCII_ENTER  
    BEQ DONE_INPUT
    STA RESULT
    RTS

DONE_INPUT:
    LDA RESULT
    RTS

Get operation from keyboard, waits for user to enter - or +

GET_OPERATION:
    JSR GET_KEY
    RTS

This loads input from keyboard

GET_KEY:
    LDA KEYBOARD   
    CMP #$00
    BEQ GET_KEY
    RTS

------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------

Reflection:


Despite the difficulty of this lab I was able to understand how Assembly works. This code is not functional in a way that the number on the screen does not reflect what the user inputs, instead, only shows pixel colours. I am still trying to explore more and find a better solution for this to work.

Comments

Post a Comment

Popular posts from this blog

BATCH 3 | Project Stage 2, Part 3 - Cloned Functions Comparison and Reflection

Image
 Project Stage 2 - Part 3 Cloned Functions Comparison and Reflection Hello everyone! Welcome to Part 3 of this project. If you missed out on the first two parts click the following link down below as they include important details of this project: 1.  Project Stage 2, Part 1: Initial Creation of Clone-Prune Analysis Pass 2.  Project Stage 2, Part 2: Testing, Errors and Fixes Let's Dive In! The purpose of this blog post is to see a comparison between the cloned functions. Let's take a look at the evidence as to why my clone-prune analysis code works by diving into the scale_samples functions where you will find these identified cloned functions being substantially the same in clone-test-prune and being different in the clone-test-noprune files. These clone test files were provided for us and were not created by me.  Clone-Prune Test Files To start, lets take a look at the object dump files for clone-test-prune. As you notice, the functions scale_samples.default, ...
Read more

BATCH 4 | Clone-Prune Analysis Code Pass On Both Architectures

Image
Clone-Prune Analysis Code Pass On Both Architectures  Pass Works On x86_64 and aarch64 Architectures In this post, I’ll be sharing screenshots of the pass running on the x86_64 architecture. Previously, I focused only on the results from the aarch64 architecture in earlier blog entries. To start, you see a screenshot of my pass successfully built without fatal errors: The steps I took to implement pass on architecture: 1. Created a Clone-Prune Analysis Code Pass on x86_64 architecture. 2. Declared pass factory under tree-pass.h by adding this: opt_pass *make_count_pass(gcc::context *); 3. Registered the pass in passes.def by including this: NEXT_PASS (make_count_pass(g)); 4. Rebuilt the gcc by using make command: time make -j $(($(nproc)*3/2)) |& tee build.log Final Code Used: #include "config.h" #include "system.h" #include "coretypes.h" #include "backend.h" #include "tree.h" #include "basic-block.h" #include ...
Read more

BATCH 3 | Project Stage 2, Part 1 - Clone-Pruning Analysis Pass

Image
PROJECT STAGE 2 Clone-Pruning Analysis Pass Instructions Instructions were taken from Chris Tyler's Wiki and are intended to guide the completion of Project Stage 2. The requirements for this stage are outline down below: 1. Identifies one or more functions which have been cloned. These functions will have the name function.variant where the function portion is the same, and there will be a corresponding resolver named function.resolver.  2. Examines the cloned functions to determine if they are substantially the same or different. “Substantially the same” means that they are identical, with the possible exception of identifiers such as temporary and single static assignment (SSA) variable names, labels, and basic block numbers. For example, two cloned functions may have two different names for the first declared integer variable, but the corresponding variables will appear at exactly the same points in the two functions and are therefore equivalent.  3. Emit a message in the ...
Read more