组装：用另一个字符串替换子字符串

Question

嗨，我是 Assembly 的新手，我在练习时遇到了一些问题，要求我在原始字符串中查找子字符串，如果找到，则将其替换为另一个给定的字符串，但仅适用于发现的奇数事件（1， 3,5...）。即。

• 原始字符串：“abc world def world”。
• 要查找的字符串：“world”
• 字符串替换：“猫”
• 输出：“acb cat def world”

此外，这些应该适用于所有类型的输入。即使像在这种情况下，“世界”比“猫”长，我也需要完全替换“世界”（“catld”是错误的）。 谁能帮我？！我不知道如何进行。 这是我目前的代码，我仍然没有考虑奇怪的情况，我只是想让它工作：

#include <stdio.h>

void main() {

    //Input
    char stringa[1024] ="This string is a string\n";
    char str1[] ="string";  
    char str2[] ="cat"; 

    //Output
    char result[1024];

    __asm {

        XOR EAX, EAX
        CLD
        LEA ESI, str1
        LEA EDI, stringa
Ciclo:  MOV AL, [ESI]
        REPNZ SCASB
        DEC EDI
        PUSH EDI
        PUSH ESI
        MOV ECX, 7
        REPE CMPSB
        CMP ECX, 0
        POP ESI
        JZ Sost
        JMP Ciclo

Sost:   LEA ESI, str2
        POP EDI
        MOV ECX, 7
        REP MOVSB
    }

    printf("New string: %s\n",result);
}

Answer 1

下一个代码完成这项工作：它找到并用另一个字符串替换所有（不奇怪）出现的字符串，并将结果字符串留在另一个变量中，在编译器 EMU8086 中对其进行测试（我的 VS 不工作），代码后解释：

.model small
.stack 100h
.data
original db 'abc world def world xyz',0
find     db 'world',0
subst    db 'cat',0
result   db 100 dup(0)
i        dw ?             ;INDEX FOR "ORIGINAL".
j        dw ?             ;INDEX FOR "RESULT".
.code
   mov  ax, @data
   mov  ds, ax
   mov  i, offset original ;"I" POINTS TO "ORIGINAL".
   mov  j, offset result   ;"J" POINTS TO "RESULT".
;SEARCH VARIABLE "FIND" AT CURRENT POSITION ("I").
   mov  si, i
   lea  di, find
search:                        
   mov  al, [di]        ;CURRENT CHAR OF VARIABLE "FIND".
;CHECK IF END OF "FIND".
   cmp  al, 0           ;IF CURRENT CHAR OF "FIND" IS LAST ONE...
   je   match           ;... VARIABLE "FIND" WAS FOUND.
;CHECK IF END OF "ORIGINAL".
   cmp  [si], 0
   je   finale
;CONTINUE.   
   cmp  [si], al        ;CMP ORIGINAL[SI],FIND[DI].
   jne  mismatch        ;CHARS ARE DIFFERENT.
   inc  si              ;NEXT CHAR OF "ORIGINAL".
   inc  di              ;NEXT CHAR OF "FIND".
   jmp  search          ;REPEAT (COMPARE NEXT CHAR).
match:
;WHEN "FIND" IS FOUND, "SUBST" REPLACE IT IN "RESULT".
   mov  i, si           ;SKIP "FIND" IN "ORIGINAL", BUT...
   dec  i               ;...SKIPPED ON CHAR FORWARD (SO DECREASE).
   lea  di, subst       ;STRING TO REPLACE "FIND".
replace:
   mov  al, [di]        ;CURRENT CHAR OF VARIABLE "SUBST".
;CHECK IF END OF "SUBST".
   cmp  al, 0           ;IF CURRENT CHAR OF "FIND" IS LAST ONE...
   je   next
;CONTINUE.
   mov  si, j           ;CURRENT POSITION IN "RESULT".
   mov  [si], al        ;COPY CHAR INTO "RESULT[ J ]".
   inc  j               ;NEXT POSITION IN "RESULT".
   inc  di              ;NEXT POSITION IN "SUBST".
   jmp  replace
mismatch:    
;APPEND CURRENT CHAR (AL) INTO "RESULT".
   mov  si, i           ;CURRENT POSITION IN "ORIGINAL".
   mov  di, j           ;CURRENT POSITION IN "RESULT".
   mov  al, [si]
   mov  [di], al
   inc  j               ;"I" IS ALSO INCREMENTED 4 LINES BELOW.
;NEXT CHAR IN "ORIGINAL".
next:
   lea  di, find        ;SEARCH AGAIN VARIABLE "FIND".
   inc  i               ;NEXT CHAR IN "ORIGINAL".
;CHECK IF END OF "ORIGINAL".
   mov  si, i
   cmp  [si], 0
   jne  search          ;REPEAT (SEARCH "FIND" AGAIN).
;END OF WHOLE PROCESS.
finale:
   mov  ax, 4c00h
   int  21h

结果是：

original = `abc world def world xyz`
find     = `world`
subst    = `cat`
result   = `abc cat def cat xyz`

注意代码中所有字符串（数据段中的变量）都使用0作为结束分隔符。这非常重要，因为这是处理任何大小的字符串的关键，而不是硬编码大小。

现在算法：

1. 它遍历“原始”中的每个字符。
2. 访问“original”中的每个字符时都会搜索字符串“find”。
3. 如果未找到“find”，则将“original”中的当前字符附加到“result”中。
4. 如果找到“find”，则将字符串“subst”附加到“result”中，并且“i”（指向“original”的指针）跳到搜索循环结束的位置（减 1），以便跳过我们要替换的字符串。 “j”（指向“结果”的指针）从不跳过，它总是加一。

要使其适用于奇数事件，请在标签match: 下添加另一个数值变量作为计数器，如果该变量在标签search: 之后不是奇数，则使其跳转到标签next:。

编辑：现在是 Visual Studio 2013 版本（在“C++ Win32 控制台应用程序”上测试）：

#include "stdafx.h"
#include "conio.h"

int _tmain(int argc, _TCHAR* argv[])
{  //Input
    char original[1024] = "abc world def world xyz\n";
    char find[]         = "world";
    char subst[]        = "cat";
   //Output
    char result[1024]   = { 0 };
    int i;
    int j;

    _asm { lea  esi, original
           mov  i, esi             // "I" POINTS TO "ORIGINAL".
           lea  esi, result
           mov  j, esi              // "J" POINTS TO "RESULT".
        // SEARCH VARIABLE "FIND" AT CURRENT POSITION ("I").
           mov  esi, i
           lea  edi, find
        search:                        
           mov  al, [edi]          // CURRENT CHAR OF VARIABLE "FIND".
        // CHECK IF END OF "FIND".
           cmp  al, 0              // IF CURRENT CHAR OF "FIND" IS LAST ONE...
           je   match              // ... VARIABLE "FIND" WAS FOUND.
        // CHECK IF END OF "ORIGINAL".
           cmp  [esi], 0
           je   finale
        // CONTINUE.   
           cmp  [esi], al       // CMP ORIGINAL[SI],FIND[DI].
           jne  mismatch        // CHARS ARE DIFFERENT.
           inc  esi              // NEXT CHAR OF "ORIGINAL".
           inc  edi              // NEXT CHAR OF "FIND".
           jmp  search          // REPEAT (COMPARE NEXT CHAR).
        match:
        // WHEN "FIND" IS FOUND, "SUBST" REPLACE IT IN "RESULT".
           mov  i, esi          // SKIP "FIND" IN "ORIGINAL", BUT...
           dec  i               // ...SKIPPED ON CHAR FORWARD (SO DECREASE).
           lea  edi, subst      // STRING TO REPLACE "FIND".
        replace:
           mov  al, [edi]       // CURRENT CHAR OF VARIABLE "SUBST".
        // CHECK IF END OF "SUBST".
           cmp  al, 0           // IF CURRENT CHAR OF "FIND" IS LAST ONE...
           je   next
        // CONTINUE.
           mov  esi, j          // CURRENT POSITION IN "RESULT".
           mov  [esi], al       // COPY CHAR INTO "RESULT[ J ]".
           inc  j               // NEXT POSITION IN "RESULT".
           inc  edi             // NEXT POSITION IN "SUBST".
           jmp  replace
        mismatch:    
        // APPEND CURRENT CHAR (AL) INTO "RESULT".
           mov  esi, i          // CURRENT POSITION IN "ORIGINAL".
           mov  edi, j          // CURRENT POSITION IN "RESULT".
           mov  al, [esi]
           mov  [edi], al
           inc  j               // "I" IS ALSO INCREMENTED 4 LINES BELOW.
        // NEXT CHAR IN "ORIGINAL".
        next:
           lea  edi, find       // SEARCH AGAIN VARIABLE "FIND".
           inc  i               // NEXT CHAR IN "ORIGINAL".
        // CHECK IF END OF "ORIGINAL".
           mov  esi, i
           cmp  [esi], 0
           jne  search          // REPEAT (SEARCH "FIND" AGAIN).
        // END OF WHOLE PROCESS.
        finale:       
    }
    printf("New string: %s", result );
    _getch();
    return 0;
}

编辑#2：以前的代码用变量i 和j 分别替换为ebx 和ecx（我留下了cmets 说“I”和“J”的部分，所以你可以看到我在哪里做了替换）：

#include "stdafx.h"
#include "conio.h"

int _tmain(int argc, _TCHAR* argv[])
{  //Input
    char original[1024] = "abc world def world xyz\n";
    char find[]         = "world";
    char subst[]        = "cat";
   //Output
    char result[1024]   = { 0 };

    _asm { lea  esi, original
           mov  ebx, esi            // "I" POINTS TO "ORIGINAL".
           lea  esi, result
           mov  ecx, esi            // "J" POINTS TO "RESULT".
        // SEARCH VARIABLE "FIND" AT CURRENT POSITION ("I").
           mov  esi, ebx
           lea  edi, find
        search:                        
           mov  al, [edi]          // CURRENT CHAR OF VARIABLE "FIND".
        // CHECK IF END OF "FIND".
           cmp  al, 0              // IF CURRENT CHAR OF "FIND" IS LAST ONE...
           je   match              // ... VARIABLE "FIND" WAS FOUND.
        // CHECK IF END OF "ORIGINAL".
           cmp  [esi], 0
           je   finale
        // CONTINUE.   
           cmp  [esi], al       // CMP ORIGINAL[SI],FIND[DI].
           jne  mismatch        // CHARS ARE DIFFERENT.
           inc  esi             // NEXT CHAR OF "ORIGINAL".
           inc  edi             // NEXT CHAR OF "FIND".
           jmp  search          // REPEAT (COMPARE NEXT CHAR).
        match:
        // WHEN "FIND" IS FOUND, "SUBST" REPLACE IT IN "RESULT".
           mov  ebx, esi        // SKIP "FIND" IN "ORIGINAL", BUT...
           dec  ebx             // ...SKIPPED ON CHAR FORWARD (SO DECREASE).
           lea  edi, subst      // STRING TO REPLACE "FIND".
        replace:
           mov  al, [edi]       // CURRENT CHAR OF VARIABLE "SUBST".
        // CHECK IF END OF "SUBST".
           cmp  al, 0           // IF CURRENT CHAR OF "FIND" IS LAST ONE...
           je   next
        // CONTINUE.
           mov  esi, ecx        // CURRENT POSITION IN "RESULT".
           mov  [esi], al       // COPY CHAR INTO "RESULT[ J ]".
           inc  ecx             // NEXT POSITION IN "RESULT".
           inc  edi             // NEXT POSITION IN "SUBST".
           jmp  replace
        mismatch:    
        // APPEND CURRENT CHAR (AL) INTO "RESULT".
           mov  esi, ebx        // CURRENT POSITION IN "ORIGINAL".
           mov  edi, ecx        // CURRENT POSITION IN "RESULT".
           mov  al, [esi]
           mov  [edi], al
           inc  ecx             // "I" IS ALSO INCREMENTED 4 LINES BELOW.
        // NEXT CHAR IN "ORIGINAL".
        next:
           lea  edi, find       // SEARCH AGAIN VARIABLE "FIND".
           inc  ebx             // NEXT CHAR IN "ORIGINAL".
        // CHECK IF END OF "ORIGINAL".
           mov  esi, ebx
           cmp  [esi], 0
           jne  search          // REPEAT (SEARCH "FIND" AGAIN).
        // END OF WHOLE PROCESS.
        finale:       
    }
    printf("New string: %s", result );
    _getch();
    return 0;
}

Answer 2

我是这样想的： 输入：原始字符串、要查找的子字符串、要替换的子字符串、输出字符串

1. 将 EDI 设置为原始字符串指向的第一个字节
2. 将 ESI 设置为要查找的子字符串指向的第一个字节
3. 移动到 AL 的第一个子字符串字节
4. 读取原始字符串，直到与给定子字符串的第一个字符不同以查找（SCASB）。
5. 虽然不同，但将每个字符复制到输出字符串中。
6. 当/如果它们匹配，将 ECX 设置为子字符串长度。
7. 比较原始字符串和子字符串，从第一个匹配点开始。
8. 检查 ECX。
9. 如果 ECX 为零，我有一个事件，所以转到检查点。
10. 转到第 4 点。

检查点：a) 递增发生计数器 b) 检查计数器。 c) 如果奇数去更换。 d) 转到第 4 点

替换：a) 将 ECX 设置为替换字符串长度 b) 在输出字符串中复制替换字符串 c) 转到第 4 点

它看起来怎么样？

Answer 3

这段代码有效，我尝试了很多输入。有很多重复的代码行，但它有效。后天我看看能不能减。正如我对 Josè 所说，我不能在输入中给出的 4 个字符串中添加变量：stringa(original)、str1(to find)、str2(new substring)、risultato(final output)：

    __asm {
                XOR EAX, EAX
                XOR EBX, EBX
                XOR EDX, EDX
                CLD
                LEA EDI, str1
                LEA ESI, stringa

                Cicle : 
                        MOV AL, [ESI]
    //CHECK IF STRING ENDED
                        CMP AL, 0
                        JZ End
    //CHECK THE CHAR
                        SCASB
    //IF THEY DON'T MATCH GO TO COPY CHAR
                        JNZ Append
    //OTHERWISE CHECK IF FROM HERE STRINGS ARE EQUAL
                        MOV ECX, LENGTH str1
                        DEC EDI
                        REPE CMPSB
                        CMP ECX, 0
    //IF YES GO TO CHECK IF IT'S AN ODD OCCURRENCE
                        JZ Checkpoint
    //IF NOT GET BACK ESI AND EDI...
                        NEG ECX
                        ADD ECX, LENGTH str1
                        SUB EDI, ECX
                        SUB ESI, ECX
    //..AND COPY THE SINGLE CHAR
                        MOV risultato[EBX], AL
                        INC EBX
                        INC ESI
                        JMP Cicle

    //COPY CHAR WHEN STRINGS DONT'MATCH    
                Append :
                        INC ESI
                        DEC EDI
                        MOV risultato[EBX], AL
                        INC EBX
                        JMP Cicle

    //CHEK IF ODD/EVEN OCCURRENCE               
                Checkpoint :
                        INC EDX
                        TEST EDX, 00000001h
    //IF ODD GO TO REPLACE ALL SUBSTRING
                        JNZ Replacement
    //OTHERWISE GET BACK ESI/EDI AND COPY THE SAME SUBSTRING TO RESULT
                        SUB EDI, LENGTH str1
                        SUB ESI, LENGTH str1
                        PUSH EDI
                        LEA EDI, risultato[EBX]
                        MOV ECX, LENGTH str1
                        REP MOVSB
    //UPDATE RESULT INDEX COUNTER
                        ADD EBX, LENGTH str1 - 1
    //GET BACK EDI POINTER
                        POP EDI
                        DEC ESI
                        JMP Cicle

    //REPLACEMENT OF THE SUBSTRING                  
                Replacement :
    //GET BACK EDI AT FIRST CHAR AND STORE ESI/EDI FOR NEXT LOOP
                        SUB EDI, LENGTH str1
                        PUSH ESI
                        PUSH EDI
    //SET A POINTER TO THE NEW STRING AND COPY IT TO RESULT
                        LEA ESI, str2
                        LEA EDI, risultato[EBX]
                        MOV ECX, LENGTH str2
                        REP MOVSB
    //UPDATE RESULT COUNTER AND GET BACK EDI/ESI TO PREVIOUS POSITIONS TO CONTINUE
                        ADD EBX, LENGTH str2 - 1
                        POP EDI
                        POP ESI
                        DEC ESI
                        JMP Cicle

                End :
                        MOV risultato[EBX], 0
}

我忘记了一个细节：当我找到 char 'è' 时，这段代码用 ascii 232 而不是 138 表示它（在 AL 中），为什么？我能做些什么？ 谢谢

Answer 4

终于好了。我研究了 Jose Manuel 的代码（谢谢），我已经使用 pop/push 而不是变量“i”和“j”对其进行了修改。然后在线测试失败，输入：“ccccc”、“cc”、“f”。结果应该是“fccc”但是是“fcf”。所以我修复了一些其他细节，现在没关系。

        XOR ECX, ECX
        XOR EAX, EAX
        XOR EBX, EBX
        XOR EDX, EDX
        LEA ESI, result
        PUSH ESI                //store result into stack
        LEA ESI, original       //esi points to original
        LEA EDI, find           //edi points to find

        Search :
            MOV AL, [EDI]
                CMP AL, 0           //chek if the end of find
                JE Match            //if yes, we have an occurrence
                CMP[ESI], 0         //check if end of original
                JE Mismatch         //if yes, coopy last char going to Mismatch
                CMP[ESI], al        //check if char match
                JNE Mismatch        //if yes go to Mismatch
                INC ESI             //else repeat Search to check if next char match
                INC EDI
                INC ECX             //chars counter
                JMP Search

        Match :
            INC EBX                 //occurrences counter
                TEST EBX, 00000001h
                JZ Mismatch         //if even go to Mismatch else continue...
                LEA EDI, str2       //else point to new string to replace
                MOV EDX, ESI        //copy the current original pointer
                POP ESI             //store it also into the stack

        Replacement :
            MOV AL, [EDI]           //copy new string char by char
                CMP AL, 0
                JE SetRegister      //if end of new string, get back the pointers
                MOV[ESI], AL        //else continue...
                INC ESI
                INC EDI
                JMP Replacement

        Mismatch :
            POP EDI                 //edi points to result
                SUB ESI, ECX        //set esi to the char it was pointing before Search or Match
                INC ECX             //shows how many chars we need to replace
                REP MOVSB           //ready to copy chars from original to result
                PUSH EDI
                CMP[ESI], 0         //check if original has ended
                JZ Fine
                DEC ESI
                XOR ECX, ECX        //set to zero the chars counter
                JMP Next            //go to Next char

        SetRegister :
            PUSH ESI                //after replacement set registers right positions
                MOV ESI, EDX
                DEC ESI
                XOR ECX, ECX

        Next :
            LEA EDI, find           //ready to find next char
                INC ESI
                CMP[ESI], 0
                JNE Search

        Fine :
            POP EDI
                MOV[EDI], 0         //close the result string

谢谢大家。