Use pusha and popa in 8086 with TASM

Question

How do I use pusha/popa in assembly 8086 with tasm compiler? I read online that because pusha and popa are in another type of assembly (.286) I can't use it, but there is a way to tell the compiler to include those commands.

My code now:

IDEAL
MODEL small
STACK 100h
DATASEG
CODESEG
proc OpenFile
            push bp
            mov bp, sp
            pusha
            mov dx, [bp + 6]    ;Get File Name Offset
            mov si, [bp + 4]    ;Get File Handler
            mov ah, 3Dh
            xor al, al
            int 21h
            jc openerror
            mov [word ptr si], ax
            popa
            pop bp
            ret 4
openerror:  lea dx, [ErrorMsg]
            mov ah, 9h
            int 21h
            popa
            pop bp
            ret 4
endp OpenFile

The error I get:

Illegal instruction for currently selected processor(s)

Does anyone have any idea how to do that?

Answer 1

Just add .286 at the top of your code like this:

.286
IDEAL
MODEL SMALL    ;SMALL  :data = 64KB and code = 64KB
.
.
.

Answer 2

Write .286 in the first line of your file:

.286
IDEAL
MODEL small
STACK 100h
etc.

Edit: I already wrote procedures that do this type of thing, here they are:

    ;CONSTANTS: {
        ;ACTIONS: {
            READ            EQU 0
            WRITE           EQU 1
            READ&WRITE      EQU 2   ;NOT USABLE AS AN ACTION
        ;}

        ;RELATIVE TO: {
            START_OF_FILE   EQU 0
            CURRENT_POINTER EQU 1
            END_OF_FILE     EQU 2
        ;}
    ;}

    ;*********************************************************************************
    ;*********************************************************************************

    PROC FILE_OPEN
    ;INPUT: OFFSET OF FILE NAME
    ;OUTPUT: FILE HANDLE (ALL THATS LEFT IS TO "POP" IT INTO A VARIABLE/REGISTER)

    ;EXAMPLE:
        ;PUSH OFFSET FILE_NAME
        ;CALL FILE_OPEN
        ;POP [FILE_HANDLE]

    ;{  
        ;START_PROC {
            PUSH BP
            MOV  BP, SP

            _NAME  EQU [WORD PTR BP + 4] 

            PUSH AX BX DX
        ;}

        ;CODE{
            MOV DX, _NAME

            MOV AH, 3Dh
            MOV AL, READ&WRITE

            INT 21h
            JC  @@END_PROC

            MOV BX, HANDLE
            MOV [BX], AX 
        ;}

        @@END_PROC: ;{
            POP DX BX AX
            POP BP
            RET 
        ;}
    ;}
    ENDP FILE_OPEN

    ;*********************************************************************************
    ;*********************************************************************************

    PROC FILE_READ_OR_WRITE
    ;{
        ;INPUT: READ OR WRITE, FILE HANDLE, BUFFER OFFSET, NUMBER OF BYTES TO READ/WRITE
        ;OUTPUT: THE DATA IS LOADED FROM THE FILE TO THE BUFFER (IF READ), OR THE DATA IS LOADED FROM THE BUFFER TO THE FILE (WRITE)

        ;START PROC {
            PUSH BP
            MOV  BP, SP

            ACTION    EQU [WORD PTR BP + 10]    ;READ OR WRITE (CONSTANT)
            BUFFER    EQU [WORD PTR BP + 8]     ;BUFFER OFFSET
            NUM_BYTES EQU [WORD PTR BP + 6]     ;NUMBER OF BYTES DO LOAD
            HANDLE    EQU [WORD PTR BP + 4]     ;FILE HANDLE


            PUSH AX BX CX DX
        ;}

        ;SET UP PARAMS {
            MOV BX, HANDLE
            MOV CX, NUM_BYTES
            MOV DX, BUFFER

            CMP ACTION, WRITE
            JZ  @@WRITE
        ;}

        @@READ: ;{
            MOV AX, 3F00h
            INT 21h
            JMP @@END_PROC
        ;}

        @@WRITE: ;{
            MOV AX, 4000h
            INT 21h 
        ;}

        @@END_PROC: ;{
            POP DX CX BX AX BP
            RET 8
        ;}
    ;}
    ENDP FILE_READ_OR_WRITE

    ;*********************************************************************************
    ;*********************************************************************************

    PROC FILE_CLOSE
    ;INPUT: FILE HANDLE
    ;OUTPUT: THE FILE IS CLOSED
    ;{
        ;START PROC {
            PUSH BP
            MOV  BP, SP
            HANDLE EQU [BP + 4] ;FILE HANDLE

            PUSH AX BX
        ;}

        ;CODE {
            MOV AH, 3Eh
            MOV BX, HANDLE
            INT 21h
        ;}

        @@END_PROC: ;{
            POP BX AX
            POP BP
            RET 2
        ;}
    ;}
    ENDP FILE_CLOSE

    ;*********************************************************************************
    ;*********************************************************************************

    PROC FILE_UPDATE_POINTER
    ;INPUT: RELATIVE_TO(MOVING THE POINTER RELATIVE TO [START_OF_FILE, CURRENT_POINTER, END_OF_FILE]
    ;INPUT: NUM_BYTES(_1), MOVES THE POINTER NUM1:NUM SPOTS (SIGNED DWORD) WHERE POSITIVE = RIGHT AND NEGATIVE = LEFT
;INPUT: FILE HANDLE

    ;OUTPUT: UPDATES THE FILE POINTER
    ;{
        ;START PROC {
            PUSH BP
            MOV  BP, SP

            RELATIVE_TO EQU [BP + 10]   ;CONSTANT
            NUM_BYTES_1 EQU [BP + 8]    ;HIGH ORDER WORD
            NUM_BYTES   EQU [BP + 6]    ;LOW  ORDER WORD
            HANDLE      EQU [BP + 4]    ; FILE HANDLE

            PUSH AX BX CX DX
        ;}

        ;CODE {
            MOV AX, RELATIVE_TO
            MOV AH, 42h
            MOV BX, HANDLE
            MOV CX, NUM_BYTES_1
            MOV DX, NUM_BYTES
            INT 21h     
        ;}

        @@END_PROC: ;{
            POP DX CX BX AX
            POP BP
            RET 8
        ;}
    ;}
    ENDP FILE_UPDATE_POINTER