Logical Calculator 8086 Assembly

FINALPROJECTMICRO.asm

PRINTF          MACRO   TXT                                             ; MACRO TO PRINT STRING
    LEA                 DX, TXT                                         ; LOAD THE STRING IN DX (DL)
    MOV                 AH, 09H                                         ; OUTPUT MODE FOR STRING
    INT                 21H                                             ; PRINT THE STRING
ENDM

SCANF           MACRO   NUMBER, LAB1, DONE_ENTER, NORMAL_NUM, HEX_NUM, SKIP_HEX          ; MACRO TO READ NUMBER

    MOV                 CX, 10H                                         ; PUT 16D TO CX

    LAB1:
        MOV             AH, 01H                                         ; INPUT MODE FOR 1 CH
        INT             21H                                             ; READ THE CHAR

        CMP             AL, 0DH                                         ; CHECK IF IT'S AN ENTER
        JE              DONE_ENTER         

        CMP             AL, 41H                                         ; CHECK IF HEX CHAR
        JAE             HEX_NUM                                         ; GO GET THE HEX VALUE OF THIS CHAR

        NORMAL_NUM:                                                     ; IN CASE OF NORMAL NUMBER (0-9)
        SUB         AL, 30H                                             ; CONVERT FROM ASCII TO HEX
        JMP         SKIP_HEX                                            ; SKIP TO PUT IT IN NUMBER

        HEX_NUM:                                                        ; IN CASE OF HEX CHAR (A-F)
        SUB         AL, 41H                                             ; SUB 41H TO REMOVE ASCII, example: (A:41H) - 41H = 00H
        ADD         AL, 0AH                                             ; ADD 0AH TO UPDATE ITS HEX VALUE, example: (A:41H) - 41H + 0AH = 0AH

        SKIP_HEX:
        MOV             BL, AL                                          ; PUT THE DECIMAL NUMBER IN BL
        MOV             AX, NUMBER                                      ; PUT THE NUMBER IN AX

        MUL             CX                                              ; MULTIPLY THE NUMBER WITH 10H (TO SCAN FROM LEFT TO RIGHT)

        MOV             BH, 0                                           ; ZERO THE BH (TO ADD THE WHOLE BX)

        ADD             AX, BX                                          ; ADD THE SCANNED NUMBER TO PREV NUMBER

        MOV             NUMBER, AX                                      ; PUT THE NEW NUMBER FROM AX

        JMP             LAB1                                            ; RE-SCAN NUMBER

    DONE_ENTER:
        NOP                                                             ; JUST DO NOTHING 
ENDM

.STACK 100H

.DATA        
    MSG_1               DB  "ENTER THE FRST NUMBER: 0x$"
    MSG_2               DB  "ENTER THE SCND NUMBER: 0x$"
    MSG_3               DB  "ENTER THE OPRT NUMBER", 13, 10, "[1:AND, 2:OR, 3:NOT, 4:XOR]: $"
    MSG_4               DB  "RESULT IS: 0x$"

    ID_2016             DB  10, 10, "ABDELRAHMAN ELSAIDY", 9,   "2016$"
    ID_2162             DB  13, 10, "RAMY TAMER", 9, 9,         "2162$"
    ID_2208             DB  13, 10, "HOSSAM HAYBAT", 9, 9,      "2208$"
    ID_2210             DB  13, 10, "AHMAD ABDEL-AZIZ", 9,      "2210$"

    NEWLINE_MSG         DB  13, 10, "$"

    NUM_1               DW  ?
    NUM_2               DW  ?
    OP_NUM              DW  ?

.CODE

    START:
        MOV             AX, @DATA                                       ; INIT DS REGISTER
        MOV             DS, AX

        PRINTF          MSG_1                                           ; GET THE FIRST NUMBER
        SCANF           NUM_1, L1, L2, NN1, HN1, SH1                    ; READ THE FIRST NUMBER

        CALL            NEWLINEP                                        ; PRINT NEW LINE


        ; GET THE OPERATION BEFORE SECOND NUMBER
        PRINTF          MSG_3                                           ; GET THE OPERATION
        SCANF           OP_NUM, L5, L6, NN2, HN2, SH2                   ; READ THE OPERATION NUMBER

        CALL            NEWLINEP                                        ; PRINT NEW LINE


        CMP             OP_NUM, 03H                                     ; IF OPERATION IS NOT 
        JE              NOT_OP                                          ; SKIP SCANNING SECOND NUMBER

        PRINTF          MSG_2                                           ; GET THE SECOND NUMBER
        SCANF           NUM_2, L3, L4, NN3, HN3, SH3                    ; READ THE SECOND NUMBER

        CALL            NEWLINEP                                        ; PRINT NEW LINE

        MOV             AX, NUM_1                                       ; PUT FIRST NUMBER IN AX

        CMP             OP_NUM, 01H                                     ; CHECK IF AND OPERATION
        JE              AND_OP
        CMP             OP_NUM, 02H                                     ; CHECK IF OR OPERATION
        JE              OR_OP
        CMP             OP_NUM, 04H                                     ; CHECK IF XOR OPERATION
        JE              XOR_OP


        AND_OP:                                                         ; AND SECOND NUMBER WITH FIRST NUMBER 
        AND             AX, NUM_2
        JMP             NEXT

        OR_OP:                                                          ; OR SECOND NUMBER WITH FIRST NUMBER 
        OR              AX, NUM_2
        JMP             NEXT

        NOT_OP:                                                         ; NOT THE FIRST NUMBER
        MOV             AX, NUM_1                                       ; PUT FIRST NUMBER IN AX
        NOT             AX
        JMP             NEXT

        XOR_OP:                                                         ; XOR SECOND NUMBER WITH FIRST NUMBER 
        XOR             AX, NUM_2
        JMP             NEXT

        NEXT: 
        MOV             BX, 0010H                                       ; PUT 16D IN BX
        MOV             CX, 0000H                                       ; ZERO CX

        PUT_NUMBER_IN_STACK:
        MOV             DX, 0000H                                       ; ZERO DX
        DIV             BX                                              ; DIVIDE BY 10D & PUT (NUMBER) REMINDER IN DX
        PUSH            DX                                              ; PUSH DX (NUMBER) INTO STACK
        INC             CX                                              ; INCREMENT CX TO KNOW SIZE OF NUMBER (WILL BE USED LATER IN LOOP)

        CMP             CX, 0004H                                       ; LOOP UNTIL AX IS EMPTY
        JNE             PUT_NUMBER_IN_STACK                             ; IF NOT EMPTY, REPEAT
    
        
        
        PRINTF          MSG_4                                           ; PRINT THE RESULT
        
        
        
        DISPLAY_RESULT:
        POP             DX                                              ; GET THE MOST LEFT NUMBER FROM STACK

        ADD             DL, 30H                                         ; ADD 30H TO PRINT ASCII CHAR

        CMP             DL, 39H                                         ; IF THE CHAR IS < 39H (IS A NUMBER)
        JB              SKIP_ADDING                                     ; SKIP ADDING 07H (FOR CHAR FROM [A-F]H)

        ADD             DL, 07H                                         ; ADD 07H TO CONVERT IT TO LETTER [A-F]H

        
        SKIP_ADDING:                                                    ; EVENTUALLY IT WILL GET HERE TO PRINT THE CHAR WHATEVER IT IS
        
        MOV             AH, 02H                                         ; MODE OUTPUT FOR 1 CHAR
        INT             21H                                             ; PRINT THE CHAR
        LOOP            DISPLAY_RESULT                                  ; LOOP UNTIL CX IS ZERO (PREVIOUSLY SET)


        CALL            NEWLINEP                                        ; PRINT THE FINAL MESSAGE

        ; PRINT THE NAMES & IDS FOR PROJECT CREATORS
        PRINTF          ID_2016
        PRINTF          ID_2162
        PRINTF          ID_2208
        PRINTF          ID_2210


        MOV             AX, 4C00H                                       ; RETURN TO OS
        INT             21H                                                         

        NEWLINEP    PROC                                                ; PROCEDURE TO PRINT NEW LINE
            MOV         DX, OFFSET NEWLINE_MSG
            MOV         AH, 09H                                         ; OUTPUT MODE FOR STRING
            INT         21H                                             ; PRINT THE STRING

            RET                                                         ; RETURN TO WHERE IT'S CALLED
        NEWLINEP    ENDP


    END START