Replace one character with string in assembly language 8086

Here's my solution. I intentionally didn't optimise it much, to show the workings of the loop in a simple way. This assembles to a flat .COM format file using a command like nasm test.asm -o test.com (which uses the implicit default -f bin format of NASM). Should mostly work with another assembler too.

I made some line comments and two protocol comments for the subroutines.

        cpu 8086
        org 256
start:
        mov dx, message
        mov cx, message_length
        call display

        mov dx, linebreak
        mov cx, linebreak_length
        call display

        mov si, message
chunkloop:
        mov dx, si              ; initialise offset of most recent chunk start

byteloop:
        mov al, byte [si]       ; get this byte
        cmp al, 'E'             ; check for replacement
        je big                  ; replace big letter -->
        cmp al, 'e'
        je small                ; replace small letter -->
        cmp al, 0               ; terminator ?
        je end                  ; yes, end -->
        inc si                  ; -> next byte
        jmp byteloop            ; loop back to scan next byte

big:
        call displaychunk       ; display chunk up to this
        mov dx, replace_big
        mov cx, replace_big_length
        call display            ; display replacement
        inc si                  ; -> next byte after what we replaced
        jmp chunkloop           ; jump back and re-initialise dx so it will
                                ;  get the start offset of the next chunk

small:                          ; (same code as for big, different replacement)
        call displaychunk
        mov dx, replace_small
        mov cx, replace_small_length
        call display
        inc si
        jmp chunkloop

end:
        call displaychunk       ; display the last chunk

        mov dx, linebreak
        mov cx, linebreak_length
        call display

        mov ax, 4C00h
        int 21h


                ; INP:  ds:dx -> most recent chunk
                ;       ds:si -> byte to be replaced (or terminator)
                ; REM:  Here si points to behind the last byte that we
                ;        want to write to display the chunk. Therefore
                ;        si minus dx is the length we want to write.
                ;       The chunk length may be zero (dx equals si).
displaychunk:
        mov cx, si              ; get offset behind the chunk
        sub cx, dx              ; calculate length of chunk
        jz emptychunk           ; if empty -->

                ; INP:  ds:dx -> message data
                ;       cx = length of message to write
display:
        mov bx, 1               ; = stdout handle
        mov ah, 40h
        int 21h                 ; write to file handle
emptychunk:
        retn



message:
        db "In english: English"
message_length equ $ - message
        db 0            ; terminator for main loop

replace_big:
        db "Egg"
replace_big_length equ $ - replace_big

replace_small:
        db "egg"
replace_small_length equ $ - replace_small

linebreak:
        db 13,10
linebreak_length equ $ - linebreak

A few possible optimisations:

• Share code for the big and small cases

• Share incrementing si for all control flow pathes

• Use lodsb to both load from byte [ds:si] and increment si

• Dynamically write the to-be-replaced letter into the replacement string so it gets a small or big letter from the source message

• The _length equates could use local labels for NASM to reduce the amount of typing for the labels (avoided here for better compatibility with other assemblers)

The errors in your code are numerous and ecm's first comment summarizes most of them. I will not repeat this but present a solution that shows a loop where the main loop condition is tested at the bottom of the loop (minimizing branching), and where there are, in the loop body, additional conditions accompanied by a nested loop.
Rather than outputting the result character by character or even chunk after chunk, I display the result all at once, readily accompanied by an included carriage return / linefeed pair and the necessary $-terminator. To this effect the source string is turned into an ASCIIZ string (a string that is terminated by 0) whose three last bytes are 13 for carriage return, 10 for linefeed, and 36 for dollar sign. (*)
The program is a .COM executable file. I use FASM but very few changes are needed to use NASM instead.
In contrast to ecm's solution, I stay closer to the OP's attempt that uses $-terminated strings that are so common under DOS.

    ORG  256

    mov  dx, english
    mov  ah, 09h       ; DOS.PrintString
    int  21h

    mov  si, english   ; Address of a zero-terminated string
    mov  di, result
    jmp  BottomOfLoop
TopOfLoop:
    mov  bx, bigegg
    cmp  al, "E"
    je   .b
    mov  bx, smallegg
    cmp  al, "e"
    je   .b
    mov  bx, empty

.a: stosb
.b: mov  al, [bx]
    inc  bx
    cmp  al, "$"
    jne  .a

BottomOfLoop:
    lodsb
    cmp  al, 0         ; Reached end of the ASCIIZ string ?
    jne  TopOfLoop     ; Not yet

    mov  dx, result    ; Address of a $-terminated string
    mov  ah, 09h       ; DOS.PrintString
    int  21h

    mov  ax, 4C00h     ; DOS.Terminate
    int  21h

english   db "In english: English", 13, 10, "$", 0       ; (*)
bigegg    db "Egg$"
smallegg  db "egg"
empty     db "$"

result    rb 100

Using rb (use resb for NASM), we can avoid including the result buffer in the file, thereby keeping the final executable small. In general, small files load somewhat faster.