How to Write an Assembly Program Code for a Calculator

Writing an assembly program for a calculator involves defining the basic operations such as addition, subtraction, multiplication, and division. This guide walks you through a simple example of an assembly program for a calculator that performs addition and subtraction using x86 assembly language (NASM syntax). This example assumes a 32-bit environment.

Example Assembly Program

The following is a complete example of an assembly program for a simple calculator using x86 assembly programming:

First, define sections for data, basic operations, and string buffers.

1. Data Section

The Data Section contains the necessary strings for prompts, and variables for storing numbers and results:

section .data
    msg1 db "Enter first number: 
", 0
    msg2 db "Enter second number: 
", 0
    msg3 db "Result: 
", 0
    num1 db 0
    num2 db 0
    result db 0
    operation db 0
    newline db 10, 0

2. BSS Section

The BSS Section reserves space for input buffers:

section .bss
    buffer resb 10

3. Text Section

The Text Section contains the main logic of the program:

section .text
    global _start
_start:
     Print message for first number
    mov edx, len msg1
    mov ecx, msg1
    call print_string
     Read first number
    call read_number
    mov [num1], al
     Print message for second number
    mov edx, len msg2
    mov ecx, msg2
    call print_string
     Read second number
    call read_number
    mov [num2], al
     Choose operation
    mov edx, len 
    mov ecx, 
    call print_string
    call read_number
    mov [operation], al
     Perform operation
    mov al, [num1]
    mov bl, [num2]
    cmp [operation], 1    ; Check if operation is addition
    je add_numbers
    cmp [operation], 2    ; Check if operation is subtraction
    je subtract_numbers
    jmp end_program
add_numbers:
    add al, bl
    jmp store_result
subtract_numbers:
    sub al, bl
store_result:
    mov [result], al
     Print result
    mov edx, len msg3
    mov ecx, msg3
    call print_string
    mov al, [result]
    call print_number
end_program:
     Exit program
    mov eax, 1         ; sys_exit
    xor ebx, ebx       ; exit code 0
    int 80h

Helper Functions

Several helper functions make the task easier:

1. Print String

This function writes a string to the console:

print_string:
    mov eax, 4         ; sys_write
    mov ebx, 1         ; file descriptor stdout
    int 80h
    ret

2. Read Number

This function reads a single character from the input.

read_number:
     Assume input is a single character representing a number
    mov eax, 3         ; sys_read
    mov ebx, 0         ; file descriptor stdin
    lea ecx, [buffer]  ; buffer to store input
    mov edx, 2        ; read 2 bytes including newline
    int 80h
    mov al, [buffer]   ; get the first byte the number
    ret

3. Print Number

This function converts a number to ASCII and prints it:

print_number:
     Print single digit in AL
    add al, 0        ; Convert to ASCII
    mov [buffer], al   ; Store in buffer
    mov eax, 4         ; sys_write
    mov ebx, 1         ; file descriptor stdout
    lea ecx, [buffer]  ; buffer to print
    mov edx, 1         ; print 1 byte
    int 80h
    ret

4. Length Calculation

This function calculates the length of a string:

len:
     Calculate length of string
    xor ecx, ecx
    .loop:
        cmp byte [eax   ecx], 0
        je .done
        inc ecx
        jmp .loop
    .done:
    ret

Assembling and Running

To assemble and run this program, follow these steps:

Save the code in a file named Assemble the program using NASM:

nasm -f elf32  -o calculator.o 

Link the object file using ld:

ld -m elf_i386 calculator.o -o calculator

Run the program:

./calculator

Note

This program is a simple example. For a more complex calculator that handles multi-digit numbers, floating-point arithmetic, or more operations, you would need to expand the code significantly.