Agfdhyk

Everyone.

I want to flip the columns of the video screen/d/display in 8086 DOS emulator process. I am studying assembly language in school.

The question is swap the right vertical half of the screen with the left half of the vertical screen.

I want to pick the first column, replace it with the last one. Then pick the 2nd column, replace it with the 24th column and so on. I am having difficulty calculating the exact screen location. Also, I need two counters to store the value of the first and last column which will be incremented and decremented respectively. Also, I need two registers to swap the column values. There should be no clrscr function.

Here is my attempted code:

<pre>`

   [org 0x0100]





mov bx,1    ;dummy number

mov di,1     ;left-most column





Call FlipColumn



FlipColumn:





mov  ax, 0xb800               

mov  es, ax             ; point es to video base              

mov  al, 80             ; load al with columns per row               

mull  byte [di]       ; multiply with y position               

add  ax, [bx]        ; add x position               

shl  ax, 1              ; turn into byte offset               

mov  di, ax             ; point di to required location               



mov [es:di],ax     ;first row & first column element

mov dx,[es:di]



FlipColumn1:



mov di, 25

mov  ax, 0xb800               

mov  es, ax             ; point es to video base              

mov  al, 80             ; load al with columns per row               

mull  byte [di]       ; multiply with y position               

add  ax, [bx]        ; add x position               

shl  ax, 1              ; turn into byte offset               

mov  di, ax             ; point di to required location               



mov [es:di], dx



jne FlipColumn

ret



mov ax,0x4c00

int 21h



</pre>`

In this code, there are addressing issues and I can't configure how to swap those two columns. Please let me know if there is a different way to swap those memory locations.

Thanks.

Okay, friends, I modified this code like this:

<pre>`

[org 0x0100]



mov di, 1

mov si, 41



FlipColumn:



mov ax, 0xb800

mov es, ax



mov word ax, [es:1*80+1]

mov word bx, [es:41*80+1]

mov word [es:1*80+1], bx

mov word [es:41*80+1], ax



inc si

inc di

cmp si, 80

jbe FlipColumn 

mov ax, 0x4c00

int 21h`

</pre>

I wanted to use this statement:

       mov ax, [es:di*80+1]

       mov bx, [es:si*80+1]

But the debugger says, it is an addressing error. Any idea how can I increment and decrement the si and di so that I can swap the right and left sides of the display.

Here is an example of how to mirror. Fundamentally the two algorithms are the same but as @Ped7g pointed out, the specification is not really definitive.

I want to pick the first column, replace it with the last one. Then pick the 2nd column, replace it with the 24th column and so on

            push    ds

            push    es

            mov     ax, 0xb800

            mov     ds, ax

            mov     es, ax

            xor     si, si

            mov     di, 158

            mov     cx, 25



       L0:  push    cx

            mov     cx, 40

            push    di

            push    si



       L1:  mov     ax, [di]

            mov     bx, [si]

            mov     [di], bx

            mov     [si], ax

            inc     si

            inc     si

            dec     di

            dec     di

            loop    L1



            pop     si

            pop     di

            add     si, 160

            add     di, 160



            pop     cx

            loop    L0



            pop     es

            pop     ds

Normally I wouldn't respond in this fashion as far too often all it equates to is doing the assignment for you, but you have put in a reasonable amount of effort so I'm going to give this example as it is a lot simpler than trying to explain why your methodology doesn't work. I've purposely left out comments as it will be incumbent upon you to use your emulator's debugger to understand the code and comment it before handing it in.

    push    ds

    push    es

    mov     ax, 0xb800

    mov     ds, ax

    mov     es, ax

    xor     si, si

    mov     di, 80

    mov     cx, 25



L0: push    cx

    mov     cx, 40



L1: mov     ax, [di]

    movsw

    mov     [si-2], ax

    loop    L1



    xchg    si, di

    add     di, 160

    pop     cx

    loop    L0



    pop     es

    pop     ds

There is probably going to be a couple of improvisations you're going to need to make to this NASM code, but I'm sure you'll figure it out.