;Call @Match to search in ES:EDI source for DS:ESI search string.
; EBX = end of source string. ECX = end of search string
; Search string = extended search string with each character having 4 bytes:
; Byte  1 exact character to match
;       2 if ? then ignore one character
;         if * then ignore zero or more characters
;         if non-zero character, then treat as alternate character to match
;       3 undefined
;       4 undefined

; CF clear if success. CF set if error
; EAX ?, ESI,EDI := where match stopped

; * = *.* / H*LO* = HELLO.8 / *HEL* = HELLO
; Algorithm:
; Load a char from source
; - if it's not a wildcard, do a normal comparison, and quit if fails
; - if it's '?' then move src & dest to next char and continue test
; - if it's '*', then keep loading a char from source 'til a non-wildcard,
;   then scan up to the full length of destination and quit if still no match.
;   If there is a match, continue the rest of the test and see if the test is
;   successful, if not, go get the next match, and do another test. This is
;   done until test is successful or there are no more matches and no more '*'

@Good_match
        cmp     esi,ecx
        jnb     @Match.ret      ;If the end of search string, can quit now
                                ; with CF clear (JNB = JNC)
@Match:
        lodsd                   ; load a char, SI:=next char
        cmp     ah,'*'
        je      .select_all?    ; if wild card '*' go chk if end of source

.scan_char                      ; Not '*' so match char
        scasb                   ; check for a match & point DI to next char
        je      @Good_match     ; if char of src = destination
        cmp     ah,'?'          ; if ? then okay to skip a char
        je      @Match
        mov     al,ah           ; if match failed, see if alternate char
        or      al,al
        jz      .err
        dec     edi             ; EDI => where match failed
        scasb
        je      @Good_match
.err    stc
.ret    ret                     ; quit

.skip   inc     edi             ; ? = skip one char of source string

.select_all?
        cmp     esi,ecx         ; if '*' = end of search string
        jnb     .all            ; then select remaining source string

.new_match
        ;begin with '*' already

        ;process any * or ? that may come after the first '*'
        lodsd                   ; load next char
        cmp     ah,'?'
        je      .skip           ; if '?' then skip a char
        cmp     ah,'*'
        je      .new_match      ; if '*' then ignore it

        ;scan for the non-wildcard char
.scan   cmp     edi,ebx
        jnb     .err
        scasb                   ; search whole string
        je      .test
        or      ah,ah
        jz      .scan
        dec     edi             ; EDI => where match failed
        xchg    al,ah           ; if match failed, see if alternate char
        scasb
        jne     .scan

.test
        push    edi
        push    esi             ; store current stats
        call    @Good_match     ; start new test, and also checking
                                ; if only has one non-wildcard char
        mov     eax,edi
        pop     esi
        pop     edi             ; restore stats
        lea     esi,[esi-4]     ; reload same char (last lodsd has inc SI)
                                ; does not change CF
        jc      .new_match      ;If previous test failed, try another test
        mov     edi,eax         ;If previous test was successful, then
        ret                     ; use previous test's EDI

.all    mov     edi,ebx
        ret
    

  szFind        db "DEST_STRING"
  szFindMask    db 0,1,0,0,0,0,0,0,0,0,0 ; 1 - skip searching byte
  szReplace     db "ABCD_EFGHJK"
  szReplaceMask db 0,1,1,1,1,1,1,1,1,1,0 ; 1 - skip writing byte
  hPatSize dd 11

  ; backward byte pattern search/replace algorithm by mask

  proc  _snr uses ebx esi edi, lpMem,hMemSize,lpFind,lpFindMask,lpReplace,lpReplaceMask,hPatSize
  locals
        hRetValue       dd ?
  endl
  
        mov     ebx,[lpMem]
        mov     ecx,[hMemSize]
        mov     edi,[hFindSize]

        and     [hRetValue],0

        or      ecx,ecx
        jz      .ret
        or      edi,edi
        jz      .ret

  .again:
        mov     al,byte [ebx+ecx-1]
        mov     edx,[hFindStr]
        cmp     al,byte [edx+edi-1]
        jnz     .next

        lea     edx,[edi-1]
        lea     eax,[ecx-1]
        cmp     edx,eax
        ja      .ret

  .search_loop:
        mov     al,byte [ebx+ecx-2]
        mov     esi,[hFindStr]
        dec     ecx
        cmp     al,byte [esi+edx-1]
        jz      @F
        mov     eax,[hFindStrMsk]
        cmp     byte [edx+eax-1],0
        jz      .next_test
  @@:
        dec     edx
        jnz     .search_loop

        lea     eax,[ebx+ecx-1]
        mov     edx,edi
        lea     esi,[eax+edi-1]

  .replace_loop:
        mov     eax,[hReplaceStrMsk]
        cmp     byte [eax+edx-1],0
        jnz     @F
        
        mov     eax,[hReplaceStr]
        mov     al,byte [edx+eax-1]
        inc     [hRetValue]
        mov     byte [esi],al
  
  @@:
        dec     esi
        dec     edx
        jnz     .replace_loop

        cmp     edi,ecx
        ja      .ret

  .next:
        dec     ecx
  
  .next_test:
        or      ecx,ecx
        jnz     .again

  .ret:
        mov     eax,[hRetValue]
        ret
  endp  
    

Eh, maybe, maybe not... I'm thinking about working on a new project some day where i'll build a little digital assistant like thing with instant message capabilities. I won't go into all the details, but it won't require people to pay for some wireless service...

org     100h
        mov     si,mask
     mov     di,string
   call    wmatch
      add     al,'0'
    int     29h
 ret

mask:    db      "*",0
string:  db      "Hello",0

;Compare nul terminated SI mask to DI string
;Return AX non-zero if match
wmatch:
.new:     xor     cx, cx          ; clear wildcard indicator
.chkz:        sub     ax, ax          ; initialize return value
   cmp     al, [si]        ; check for end of mask
     jne     .next
       cmp     byte [di], 1    ; return TRUE if end of source
      adc     ax, cx          ; OR if end of mask is wildcard
     ret
.cmp3:       inc     di              ;  else if no match
 cmp     [di], ah
    jz      .error
.next:    mov     al, [si]
    cmp     al, "*"
   je      .wild           ; if * then set wildcard indicator to TRUE
  jcxz    .nowc           ; if not wildcard indicator then match char
 sub     bx,bx           ; Wildcard loop - initialize base counter
.cmp2: test    ax, ax          ;  if no more char in mask then end current match
   jz      .mtch
       cmp     al, "?"               ;  if ? then skip one char
  je      .sc
 cmp     al, [bx+di]
 jne     .cmp3
.sc:       inc     bx              ; Increment base counter if match
   mov     al, [bx+si]     ; 
  cmp     al, "*"               ; If next byte in mask is * then end current match
  jne     .cmp2
.mtch:     inc     di
  inc     si              ; move to next byte in source & mask
    jmp     .new
.wild:      inc     cx              ;       set wildcard indicator to TRUE
      inc     si              ;       move to next byte in mask
   jmp     .chkz           ;       check for end of mask & end of source
.nowc: cmp     al, "?"               ; if ? then
 je      .mtch           ;       match next char
     cmp     al, [di]        ; else if char matches
      je      .mtch
.error:    xor     ax, ax  ;  or return FALSE
  ret    

macro Return    rc      {mov  dword [esp+28],rc}  ; inside pushad/popad

proc  Pos strptr:DWORD,search:DWORD
  pushad
  mov    eax,[strptr]
  mov    edi,[search]
  dec    eax
  .tst: ; iterate source
  inc    eax
  mov    edx,edi  ; edx->search
  .tst2: ; iterate search
  mov    cl,byte [edx]
  cmp    cl,0
  je     .found  ; end of search str
  mov    ch,byte [eax]
  cmp    ch,0 ; if we got here - end of source
  je     .fail
  cmp    ch,cl
  je     .same
  ; case insensitivity
  jnc    .nx   ; ch < cl
  xchg   cl,ch
  .nx:   ; now ch > cl, meaning only cl may be lower case
  add    cl,20h  ; to upper case
  cmp    cl,ch
  jne    .tst  ; different
  cmp    cl,61h ; 'A'
  jc     .tst  ; out of range
  cmp    cl,7Bh ;  'Z'+1
  jnc    .tst  ; out of range
  .same:
  inc    edx   ; next in search
  inc    eax   ; next in source
  jmp    .tst2
  .fail:
  Return 0
  popad
  ret
  .found:
  sub    eax,[strptr]   ; current offset
  add    eax,edi
  sub    eax,edx        ; - search len
  inc    eax            ; offset to Pos
  Return eax 
  popad
  ret
endp