As far as I understand the emu8086 is a 32bit and not a DOS assembler. However, I like to learn from scratch. From the circuits to software. For example Embedded Systems.

//swap_bytes_inline C-ansi program, TDM-GCC-32.
#include <stdio.h> //#include "stdafx.h" compiler error.
int main (void)
{
    //declare
    char temp;
    char rslt1,rslt2;

    //switch to assembly
    asm
    (
     //  ("MOV BL,0");   // compiler error
        "MOV %%BL,%%0;"  // nulling the register
        "MOV %%BH,%%0;"  // nulling the register
        "MOV %%BL,'%%A';"
        "MOV %%BH,'%%B';"
    // swap bytes
        "MOV %%temp,%%BL;"     // A in temp
        "MOV %%rslt1,%%BH;"   // B in rslt1
        "MOV %%BH,%%temp;"   // A in BH
        "MOV %%rslt2,%%BH;" // A in rslt2      
    );
        printf ("BL = %c, BH = %c\n",rslt1,rslt2);
    // terminate
    return 0;
}    

#include <stdio.h>
//TDM-GCC-32 compiler
int main()
{
        int foo = 2, bar = 3, crow = 4;
        
        asm ("add  %%bx,%%ax"   // Define Instruction and Registers
            :"=a"(foo)          // Define Destination
            :"a"(foo), "b"(bar) // Destination, Source
            );
            
        asm (                   // New asm instruction for new Register operation
            "add  %%dx,%%cx"    // must copy from CX to DX
            :"=c"(crow)         // assign new names for new integers
            :"c"(crow), "d"(bar)
            );
        printf("foo+bar = %d\ncrow+bar = %d", foo, crow );
        return 0;
}
//no result with register AL and AH, only AX, BX .
//no result with BX to CX .
//no result with ADD AX, BX, must be ADD BX,AX . 
//no result with more than one register MOV or ADD per _asm instruction .    

; Intel syntax (used by FASM)
mov bl, 0x32

; AT&T syntax (used by GAS and GCC in-line assembly)
mov $0x32, %%bl
    

mov $0, %%bl    ; base 10 number
mov $0x0, %%bl  ; base 16 number    

#include <stdio.h>

int main(void) {
    
    char something = 45;
    
    printf("%i\n", something);
    
    asm(
        "add $5, %%bl;"
        : "=b"  (something) /* output in BL goes in variable 'something'    */
        : "b"   (something) /* input variable 'something' goes in BL        */
    );
    
    printf("%i\n", something);
    
    return 0;
}    

#include <stdio.h> 
int main(void) { 
     
    char ch ='A'; 
    printf("%c\n",ch); 
     
    asm (                 
        "mov $ch,%%al;" /* Source 'ch' to destination AL         */
        : "=b"  (ch)    /* output in AL goes in variable 'ch'    */
        : "b"   (ch)    /* input variable 'ch' goes in AL        */
        );
     
    printf("%c\n",ch); 
     
    return 0; 
}    

#include <stdio.h>
                          /* TDM-GCC-32 compiler. AT%T syntax .                           */
int main(void) { 
     
    char ch1 ='A',ch2,ch3;
    printf ("C printf =\t\t%c\n",ch1); 
     
    asm ( 
        "mov $'T',%%ax;"  /* MOV $'char' or number to destination %% register             */
        : "=a" (ch1)      /* (destintaion) use a concerning EAX, and b for EBX            */
/*      : "a"                (Source) is input manually in this case, and can be left out */
        );
        
    asm (
        "mov %%ax,%%bx;"  /* MOV from AX to BX ( opposite order as Intel Syntax )         */
        "sub $46,%%bx"    /* ASCII "T" (84) - 46 = ASCII "&" (38)                         */
        : "=b" (ch2)      /* (destination) b for BX register                              */
        :  "a" (ch1), "b" (ch2)   /* (source a for AX) to (destination b for BX)          */
        );
        
    asm (
        "mov %%bx,%%cx;"
        "add $46,%%cx;"
        : "=c" (ch3)
        : "b"(ch2), "c" (ch3)
        );
     
    printf("ASM printf ch1 =\t%c\n",ch1); 
    printf("ASM printf ch2 =\t%c\n",ch2);  
    printf("ASM printf ch3 =\t%c\n",ch3);
    return 0; 
}
    

#include <stdio.h>
// TDM - GCC - 32 . AT&T syntax
// Swap 2 bytes between registers using inline ASM in C.
int main ()
{
char ch1,ch2,temp;

asm     (
        "mov $'M',%%ax;"
        :"=a" (ch1)
        );

asm     (
        "mov $'A',%%bx;"
        :"=b" (ch2)
        );

asm     (
        "mov %%bx,%%cx;"
        :"=c" (temp)
        :"b" (ch2), "c" (temp)
        );

printf ("Before Swap :\t%c %c\n",ch1,ch2);        
        // A to B, then TEMP tp A
        
asm     (
        "mov %%ax,%%bx"
        :"=b" (ch2)
        :"a" (ch1), "b" (ch2)
        );
        
asm     (
        "mov %%cx,%%ax"
        :"=a" (ch1)
        :"c"(temp),"a" (ch1)
        );
        
printf ("After Swap :\t%c %c",ch1,ch2);
return 0;
}    

1. All the Low Order registers are disabled, AL, BL, CL, DL .

2. Cant copy or do instructions between AX and EAX, both use the same "constraint" . Resulting in very few registers that can be accessed or operated on .

#include <stdio.h>

/*
 * Here, we define a structure that groups 2 chars together as an
 * addressable unit.
 *
 * Due to the nature of the way x86 processors copy multi-byte values
 * to and from memory (this trait is known as endianness), the high
 * and low bytes are flipped here in this structure. The x86
 * architecture is a "little-endian" architecture, which means that
 * bytes are read from and written to memory backwards. As an example,
 * a value of 0xABCD in the AX register, such that AH contains 0xAB
 * and AL contains 0xCD, when written to memory, will be visible as
 * 0xCD, 0xAB if you were to inspect the program with a debugger.
 */
typedef struct {
    
    char low;
    char high;
    
} grouped_char;

/*
 * This function returns the high byte of a grouped char.
 *
 * It uses the SHR instruction instead of accessing AH, but both work
 * just as well.
 */
char getHigh(grouped_char chars) {
    
    char result;
    
    asm("shr $8, %%ax;"     // bitshift AH into AL
        "mov %%al, %%bl;"   // BL <-- AL
        : "=b"  (result)    // resulting char is found in BL
        : "a"   (chars)     // pass char group parameter into AX
    );
    
    return result;
    
}

/*
 * This function returns the low byte of a grouped char.
 */
char getLow(grouped_char chars) {
    
    char result;
    
    asm("mov %%al, %%bl"    // BL <-- AL, ignoring AH
        : "=b"  (result)    // resulting char is found in BL
        : "a"   (chars)     // pass char group parameter into AX
    );
    
    return result;
    
}

int main(void) {
    
    grouped_char myChars;
    myChars.high = 'A';
    myChars.low = 'B';
    
    printf("Group: %c %c\n", myChars.high, myChars.low);
    
    printf("High:  %c\n", getHigh(myChars));
    printf("Low:   %c\n", getLow(myChars));
    
    return 0;
    
}    

the AH register is inaccessible in long mode.

use64
mov ah,al    

flat assembler  version 1.71.54  (3145344 kilobytes memory)
1 passes, 2 bytes.    

Code:

/*
 * This function returns the high byte of a grouped char.
 *
 * It uses the SHR instruction instead of accessing AH, but both work
 * just as well.
 */
char getHigh(grouped_char chars) {
    
    char result;
    
    asm("shr $8, %%ax;"     // bitshift AH into AL
        "mov %%al, %%bl;"   // BL <-- AL
        : "=b"  (result)    // resulting char is found in BL
        : "a"   (chars)     // pass char group parameter into AX
    );
    
    return result;
    
}    

char getHigh(grouped_char chars) {
    
    char result;
    
    asm("mov %%ah, %%bl;"   // BL <-- AH
        : "=b"  (result)    // resulting char is found in BL
        : "a"   (chars)     // pass char group parameter into AX
    );
    
    return result;
    
}    

1. All the Low Order registers are disabled, AL, BL, CL, DL .

MOV AX,[BIGENDIAN]      ;the LSB is read to AH, MSB to AL due to the byte order in memory
XCHG AH,AL              ;LSB now in AL, MSB in AH as required for further processing...
    

BTW, I'm not sure why you've translated ABh to 15h, and CDh to 19h ??

... EMU8086 has no support for the mnemonics MOVSX, MOVZX, and CMOVC. But see when reading the IA-32 intel documentation that these are valid instructions.