删首尾换行符汇编，谁有

SSS777

删首尾换行符汇编，谁有？

逍≮遥≯神

删首尾换行符汇编

神女软件定制

自己写一个

SSS777

删首尾空 和 删首尾换行符，这两种最好合并，谁会扣汇编？

七散

  

子程序名	返回值类型	公开	备 注
删首尾空_ASM	文本型		删首尾空
参数名	类 型	参考	可空	数组	备 注
str	通用型				支持文本型  或 文本型指针

变量名	类 型	静态	数组	备 注
Heap	整数型
len	整数型

置入代码 ({ 81, 82, 83, 86, 87, 49, 192, 139, 69, 8, 139, 0, 133, 192, 116, 69, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 117, 23, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 210, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 235, 11, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0, 64, 137, 69, 248, 137, 195, 100, 139, 13, 48, 0, 0, 0, 139, 73, 24, 137, 77, 252 })
' *** 缩略程序块 ***
' push ecx
' push edx
' push ebx
' push esi
' push edi
' xor eax,eax
' mov eax, dword [ebp+0x08]
' mov eax, dword [eax]
' test eax,eax
' je label4
' lea edx, dword [eax+0x03]
' label1:
' mov edi, dword [eax]
' add eax, 0x04
' lea ecx, dword [edi-0x01010101]
' not edi
' and ecx, edi
' and ecx, 0x80808080
' jne label2
' mov edi, dword [eax]
' add eax, 0x04
' lea ecx, dword [edi-0x01010101]
' not edi
' and ecx, edi
' and ecx, 0x80808080
' je label1
' label2:
' test ecx, 0x00008080
' jne label3
' shr ecx, 0x10
' add eax, 0x02
' label3:
' shl cl, 1
' sbb eax, edx
' jmp label5
' label4:
' pop edi
' pop esi
' pop ebx
' pop edx
' pop ecx
' mov esp,ebp
' pop ebp
' ret 4
' label5:
' inc eax
' mov dword[ebp-0x08],eax
' mov ebx,eax
' mov ecx, dword [fs:0x00000030]
' mov ecx, dword [ecx+0x18]
' mov dword[ebp-0x04],ecx
RtlAllocateHeap (Heap, 0, len)
置入代码 ({ 137, 199, 133, 192, 116, 50, 139, 117, 8, 139, 54, 128, 62, 32, 116, 7, 128, 62, 161, 116, 2, 235, 3, 70, 235, 241, 49, 210, 49, 201, 128, 60, 50, 32, 116, 14, 128, 60, 50, 161, 116, 8, 128, 60, 50, 0, 116, 5, 137, 209, 66, 235, 233, 65, 243, 164, 198, 7, 0, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0 })
' *** 缩略程序块 ***
' mov edi, eax
' test eax, eax
' je label7
' mov esi, dword [ebp+0x08]
' mov esi, dword [esi]
' label1:
' cmp byte [esi], 0x20
' je label2
' cmp byte [esi], 0xA1
' je label2
' jmp label3
' label2:
' inc esi
' jmp label1
' label3:
' xor edx, edx
' xor ecx, ecx
' label4:
' cmp byte [edx+esi], 0x20
' je label5
' cmp byte [edx+esi], 0xA1
' je label5
' cmp byte [edx+esi], 0x00
' je label6
' mov ecx, edx
' label5:
' inc edx
' jmp label4
' label6:
' inc ecx
' rep movsb
' label7:
' mov byte [edi], 0x00
' pop edi
' pop esi
' pop ebx
' pop edx
' pop ecx
' mov esp, ebp
' pop ebp
' retn 0x0004
返回 (“”)

子程序名	返回值类型	公开	备 注
删全部空_ASM	文本型		删全部空
参数名	类 型	参考	可空	数组	备 注
str	通用型				支持文本型  或 文本型指针

变量名	类 型	静态	数组	备 注
Heap	整数型
len	整数型

置入代码 ({ 81, 82, 83, 86, 87, 49, 192, 139, 69, 8, 139, 0, 133, 192, 116, 69, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 117, 23, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 210, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 235, 11, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0, 64, 137, 69, 248, 137, 195, 100, 139, 13, 48, 0, 0, 0, 139, 73, 24, 137, 77, 252 })
' *** 缩略程序块 ***
' push ecx
' push edx
' push ebx
' push esi
' push edi
' xor eax,eax
' mov eax, dword [ebp+0x08]
' mov eax, dword [eax]
' test eax,eax
' je label4
' lea edx, dword [eax+0x03]
' label1:
' mov edi, dword [eax]
' add eax, 0x04
' lea ecx, dword [edi-0x01010101]
' not edi
' and ecx, edi
' and ecx, 0x80808080
' jne label2
' mov edi, dword [eax]
' add eax, 0x04
' lea ecx, dword [edi-0x01010101]
' not edi
' and ecx, edi
' and ecx, 0x80808080
' je label1
' label2:
' test ecx, 0x00008080
' jne label3
' shr ecx, 0x10
' add eax, 0x02
' label3:
' shl cl, 1
' sbb eax, edx
' jmp label5
' label4:
' pop edi
' pop esi
' pop ebx
' pop edx
' pop ecx
' mov esp,ebp
' pop ebp
' ret 4
' label5:
' inc eax
' mov dword[ebp-0x08],eax
' mov ebx,eax
' mov ecx, dword [fs:0x00000030]
' mov ecx, dword [ecx+0x18]
' mov dword[ebp-0x04],ecx
RtlAllocateHeap (Heap, 0, len)
置入代码 ({ 137, 199, 133, 192, 116, 26, 139, 117, 8, 139, 54, 128, 62, 32, 116, 13, 128, 62, 161, 116, 8, 128, 62, 0, 116, 6, 164, 235, 238, 70, 235, 235, 198, 7, 0, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0 })
' *** 缩略程序块 ***
' mov edi, eax
' test eax, eax
' je label3
' mov esi, dword [ebp+0x08]
' mov esi, dword [esi]
' label1:
' cmp byte [esi], 0x20
' je label2
' cmp byte [esi], 0xA1
' je label2
' cmp byte [esi], 0x00
' je label3
' movsb
' jmp label1
' label2:
' inc esi
' jmp label1
' label3:
' mov byte [edi], 0x00
' pop edi
' pop esi
' pop ebx
' pop edx
' pop ecx
' mov esp, ebp
' pop ebp
' retn 0x0004
返回 (“”)

.版本 2<br /> <br /> .子程序 删首尾空_ASM, 文本型, 公开, 删首尾空<br /> .参数 str, 通用型, 参考, 支持文本型  或 文本型指针<br /> .局部变量 Heap, 整数型<br /> .局部变量 len, 整数型<br /> <br /> 置入代码 ({ 81, 82, 83, 86, 87, 49, 192, 139, 69, 8, 139, 0, 133, 192, 116, 69, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 117, 23, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 210, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 235, 11, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0, 64, 137, 69, 248, 137, 195, 100, 139, 13, 48, 0, 0, 0, 139, 73, 24, 137, 77, 252 })<br /> ' *** 缩略程序块 ***<br /> ' push ecx<br /> ' push edx<br /> ' push ebx<br /> ' push esi<br /> ' push edi<br /> ' xor eax,eax<br /> ' mov eax, dword [ebp+0x08]<br /> ' mov eax, dword [eax]<br /> ' test eax,eax<br /> ' je label4<br /> ' lea edx, dword [eax+0x03]<br /> ' label1:<br /> ' mov edi, dword [eax]<br /> ' add eax, 0x04<br /> ' lea ecx, dword [edi-0x01010101]<br /> ' not edi<br /> ' and ecx, edi<br /> ' and ecx, 0x80808080<br /> ' jne label2<br /> ' mov edi, dword [eax]<br /> ' add eax, 0x04<br /> ' lea ecx, dword [edi-0x01010101]<br /> ' not edi<br /> ' and ecx, edi<br /> ' and ecx, 0x80808080<br /> ' je label1<br /> ' label2:<br /> ' test ecx, 0x00008080<br /> ' jne label3<br /> ' shr ecx, 0x10<br /> ' add eax, 0x02<br /> ' label3:<br /> ' shl cl, 1<br /> ' sbb eax, edx<br /> ' jmp label5<br /> ' label4:<br /> ' pop edi<br /> ' pop esi<br /> ' pop ebx<br /> ' pop edx<br /> ' pop ecx<br /> ' mov esp,ebp<br /> ' pop ebp<br /> ' ret 4<br /> ' label5:<br /> ' inc eax<br /> ' mov dword[ebp-0x08],eax<br /> ' mov ebx,eax<br /> ' mov ecx, dword [fs:0x00000030]<br /> ' mov ecx, dword [ecx+0x18]<br /> ' mov dword[ebp-0x04],ecx<br /> RtlAllocateHeap (Heap, 0, len)<br /> 置入代码 ({ 137, 199, 133, 192, 116, 50, 139, 117, 8, 139, 54, 128, 62, 32, 116, 7, 128, 62, 161, 116, 2, 235, 3, 70, 235, 241, 49, 210, 49, 201, 128, 60, 50, 32, 116, 14, 128, 60, 50, 161, 116, 8, 128, 60, 50, 0, 116, 5, 137, 209, 66, 235, 233, 65, 243, 164, 198, 7, 0, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0 })<br /> ' *** 缩略程序块 ***<br /> ' mov edi, eax<br /> ' test eax, eax<br /> ' je label7<br /> ' mov esi, dword [ebp+0x08]<br /> ' mov esi, dword [esi]<br /> ' label1:<br /> ' cmp byte [esi], 0x20<br /> ' je label2<br /> ' cmp byte [esi], 0xA1<br /> ' je label2<br /> ' jmp label3<br /> ' label2:<br /> ' inc esi<br /> ' jmp label1<br /> ' label3:<br /> ' xor edx, edx<br /> ' xor ecx, ecx<br /> ' label4:<br /> ' cmp byte [edx+esi], 0x20<br /> ' je label5<br /> ' cmp byte [edx+esi], 0xA1<br /> ' je label5<br /> ' cmp byte [edx+esi], 0x00<br /> ' je label6<br /> ' mov ecx, edx<br /> ' label5:<br /> ' inc edx<br /> ' jmp label4<br /> ' label6:<br /> ' inc ecx<br /> ' rep movsb<br /> ' label7:<br /> ' mov byte [edi], 0x00<br /> ' pop edi<br /> ' pop esi<br /> ' pop ebx<br /> ' pop edx<br /> ' pop ecx<br /> ' mov esp, ebp<br /> ' pop ebp<br /> ' retn 0x0004<br /> 返回 (“”)<br /> <br /> .子程序 删全部空_ASM, 文本型, 公开, 删全部空<br /> .参数 str, 通用型, 参考, 支持文本型  或 文本型指针<br /> .局部变量 Heap, 整数型<br /> .局部变量 len, 整数型<br /> <br /> 置入代码 ({ 81, 82, 83, 86, 87, 49, 192, 139, 69, 8, 139, 0, 133, 192, 116, 69, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 117, 23, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 210, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 235, 11, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0, 64, 137, 69, 248, 137, 195, 100, 139, 13, 48, 0, 0, 0, 139, 73, 24, 137, 77, 252 })<br /> ' *** 缩略程序块 ***<br /> ' push ecx<br /> ' push edx<br /> ' push ebx<br /> ' push esi<br /> ' push edi<br /> ' xor eax,eax<br /> ' mov eax, dword [ebp+0x08]<br /> ' mov eax, dword [eax]<br /> ' test eax,eax<br /> ' je label4<br /> ' lea edx, dword [eax+0x03]<br /> ' label1:<br /> ' mov edi, dword [eax]<br /> ' add eax, 0x04<br /> ' lea ecx, dword [edi-0x01010101]<br /> ' not edi<br /> ' and ecx, edi<br /> ' and ecx, 0x80808080<br /> ' jne label2<br /> ' mov edi, dword [eax]<br /> ' add eax, 0x04<br /> ' lea ecx, dword [edi-0x01010101]<br /> ' not edi<br /> ' and ecx, edi<br /> ' and ecx, 0x80808080<br /> ' je label1<br /> ' label2:<br /> ' test ecx, 0x00008080<br /> ' jne label3<br /> ' shr ecx, 0x10<br /> ' add eax, 0x02<br /> ' label3:<br /> ' shl cl, 1<br /> ' sbb eax, edx<br /> ' jmp label5<br /> ' label4:<br /> ' pop edi<br /> ' pop esi<br /> ' pop ebx<br /> ' pop edx<br /> ' pop ecx<br /> ' mov esp,ebp<br /> ' pop ebp<br /> ' ret 4<br /> ' label5:<br /> ' inc eax<br /> ' mov dword[ebp-0x08],eax<br /> ' mov ebx,eax<br /> ' mov ecx, dword [fs:0x00000030]<br /> ' mov ecx, dword [ecx+0x18]<br /> ' mov dword[ebp-0x04],ecx<br /> RtlAllocateHeap (Heap, 0, len)<br /> 置入代码 ({ 137, 199, 133, 192, 116, 26, 139, 117, 8, 139, 54, 128, 62, 32, 116, 13, 128, 62, 161, 116, 8, 128, 62, 0, 116, 6, 164, 235, 238, 70, 235, 235, 198, 7, 0, 95, 94, 91, 90, 89, 137, 236, 93, 194, 4, 0 })<br /> ' *** 缩略程序块 ***<br /> ' mov edi, eax<br /> ' test eax, eax<br /> ' je label3<br /> ' mov esi, dword [ebp+0x08]<br /> ' mov esi, dword [esi]<br /> ' label1:<br /> ' cmp byte [esi], 0x20<br /> ' je label2<br /> ' cmp byte [esi], 0xA1<br /> ' je label2<br /> ' cmp byte [esi], 0x00<br /> ' je label3<br /> ' movsb<br /> ' jmp label1<br /> ' label2:<br /> ' inc esi<br /> ' jmp label1<br /> ' label3:<br /> ' mov byte [edi], 0x00<br /> ' pop edi<br /> ' pop esi<br /> ' pop ebx<br /> ' pop edx<br /> ' pop ecx<br /> ' mov esp, ebp<br /> ' pop ebp<br /> ' retn 0x0004<br /> 返回 (“”)

appleqc

### 汇编语言删除字符串首尾换行符实现

以下是几种常见架构的汇编代码实现，用于删除字符串首尾的换行符（LF, 0x0A）。


### 一、x86_64 NASM 实现

```asm
; 删除字符串首尾换行符
; 参数: rdi = 字符串地址, rsi = 字符串长度
; 返回: rdx = 处理后的字符串长度

section .text
global remove_newlines

remove_newlines:
    ; 保存寄存器
    push    rcx
    push    r8
    push    r9
   
    ; 初始化指针和计数器
    mov     rcx, rdi            ; 指向字符串开始
    mov     r8, rdi             ; 指向当前处理位置
    add     r8, rsi             ; 指向字符串末尾
    dec     r8                  ; 指向最后一个字符
    mov     rdx, rsi            ; 初始化新长度为原长度
   
    ; 删除尾部换行符
.loop_tail:
    cmp     rdx, 0              ; 检查是否已处理完所有字符
    jle     .remove_head        ; 如果长度为0，直接处理头部
   
    mov     al, [r8]            ; 获取当前字符
    cmp     al, 0x0A            ; 检查是否为换行符
    jne     .remove_head        ; 如果不是，开始处理头部
   
    ; 是换行符，删除它
    dec     r8                  ; 移动指针向前
    dec     rdx                 ; 减少长度
    jmp     .loop_tail          ; 继续检查下一个字符

.remove_head:
    ; 删除头部换行符
    mov     r9, rcx             ; 保存原始字符串指针
.loop_head:
    cmp     rdx, 0              ; 检查是否已处理完所有字符
    jle     .done               ; 如果长度为0，结束处理
   
    mov     al, [rcx]           ; 获取当前字符
    cmp     al, 0x0A            ; 检查是否为换行符
    jne     .move_chars         ; 如果不是，开始移动字符
   
    ; 是换行符，删除它
    inc     rcx                 ; 移动指针向后
    dec     rdx                 ; 减少长度
    jmp     .loop_head          ; 继续检查下一个字符

.move_chars:
    ; 如果有字符被删除，需要移动剩余字符
    cmp     rcx, r9             ; 检查是否需要移动（头部有删除）
    je      .done               ; 如果不需要移动，直接结束
   
    mov     r8, r9              ; 目标位置（原字符串开始）
.loop_move:
    cmp     rdx, 0              ; 检查是否已移动完所有字符
    jle     .done               ; 如果长度为0，结束处理
   
    mov     al, [rcx]           ; 获取当前字符
    mov     [r8], al            ; 移动到新位置
    inc     rcx                 ; 源指针后移
    inc     r8                  ; 目标指针后移
    dec     rdx                 ; 减少剩余长度
    jmp     .loop_move          ; 继续移动下一个字符

.done:
    ; 恢复寄存器
    pop     r9
    pop     r8
    pop     rcx
    ret
```


### 二、ARM64 AArch64 实现

```asm
; 删除字符串首尾换行符
; 参数: x0 = 字符串地址, x1 = 字符串长度
; 返回: x0 = 处理后的字符串长度

.global remove_newlines

remove_newlines:
    stp     x29, x30, [sp, #-16]!  ; 保存帧指针和返回地址
    mov     x29, sp                ; 设置帧指针
   
    ; 保存寄存器
    stp     x19, x20, [sp, #-16]!
    stp     x21, x22, [sp, #-16]!
   
    mov     x19, x0                ; 保存字符串地址
    mov     x20, x1                ; 保存字符串长度
    mov     x21, x0                ; 当前处理位置（开始）
    add     x22, x0, x1            ; 指向字符串末尾
    sub     x22, x22, #1           ; 指向最后一个字符
   
    ; 删除尾部换行符
.loop_tail:
    cmp     x20, #0                ; 检查是否已处理完所有字符
    ble     .remove_head           ; 如果长度为0，直接处理头部
   
    ldrb    w2, [x22]              ; 获取当前字符
    cmp     w2, #0x0A              ; 检查是否为换行符
    b.ne    .remove_head           ; 如果不是，开始处理头部
   
    ; 是换行符，删除它
    sub     x22, x22, #1           ; 移动指针向前
    sub     x20, x20, #1           ; 减少长度
    b       .loop_tail             ; 继续检查下一个字符

.remove_head:
    ; 删除头部换行符
    mov     x21, x19               ; 重置为字符串开始
.loop_head:
    cmp     x20, #0                ; 检查是否已处理完所有字符
    ble     .done                  ; 如果长度为0，结束处理
   
    ldrb    w2, [x21]              ; 获取当前字符
    cmp     w2, #0x0A              ; 检查是否为换行符
    b.ne    .move_chars            ; 如果不是，开始移动字符
   
    ; 是换行符，删除它
    add     x21, x21, #1           ; 移动指针向后
    sub     x20, x20, #1           ; 减少长度
    b       .loop_head             ; 继续检查下一个字符

.move_chars:
    ; 如果有字符被删除，需要移动剩余字符
    cmp     x21, x19               ; 检查是否需要移动（头部有删除）
    b.eq    .done                  ; 如果不需要移动，直接结束
   
    mov     x22, x19               ; 目标位置（原字符串开始）
.loop_move:
    cmp     x20, #0                ; 检查是否已移动完所有字符
    ble     .done                  ; 如果长度为0，结束处理
   
    ldrb    w2, [x21]              ; 获取当前字符
    strb    w2, [x22]              ; 移动到新位置
    add     x21, x21, #1           ; 源指针后移
    add     x22, x22, #1           ; 目标指针后移
    sub     x20, x20, #1           ; 减少剩余长度
    b       .loop_move             ; 继续移动下一个字符

.done:
    ; 恢复寄存器
    ldp     x21, x22, [sp], #16
    ldp     x19, x20, [sp], #16
   
    mov     x0, x20                ; 返回处理后的字符串长度
   
    ldp     x29, x30, [sp], #16    ; 恢复帧指针和返回地址
    ret
```


### 三、x86 NASM 32位实现

```asm
; 删除字符串首尾换行符
; 参数: eax = 字符串地址, ebx = 字符串长度
; 返回: ebx = 处理后的字符串长度

section .text
global remove_newlines

remove_newlines:
    ; 保存寄存器
    push    ecx
    push    edx
    push    esi
    push    edi
   
    ; 初始化指针和计数器
    mov     esi, eax            ; 指向字符串开始
    mov     edi, eax            ; 指向当前处理位置
    add     edi, ebx            ; 指向字符串末尾
    dec     edi                 ; 指向最后一个字符
    mov     edx, ebx            ; 初始化新长度为原长度
   
    ; 删除尾部换行符
.loop_tail:
    cmp     edx, 0              ; 检查是否已处理完所有字符
    jle     .remove_head        ; 如果长度为0，直接处理头部
   
    mov     al, [edi]           ; 获取当前字符
    cmp     al, 0x0A            ; 检查是否为换行符
    jne     .remove_head        ; 如果不是，开始处理头部
   
    ; 是换行符，删除它
    dec     edi                 ; 移动指针向前
    dec     edx                 ; 减少长度
    jmp     .loop_tail          ; 继续检查下一个字符

.remove_head:
    ; 删除头部换行符
    mov     ecx, esi            ; 保存原始字符串指针
.loop_head:
    cmp     edx, 0              ; 检查是否已处理完所有字符
    jle     .done               ; 如果长度为0，结束处理
   
    mov     al, [esi]           ; 获取当前字符
    cmp     al, 0x0A            ; 检查是否为换行符
    jne     .move_chars         ; 如果不是，开始移动字符
   
    ; 是换行符，删除它
    inc     esi                 ; 移动指针向后
    dec     edx                 ; 减少长度
    jmp     .loop_head          ; 继续检查下一个字符

.move_chars:
    ; 如果有字符被删除，需要移动剩余字符
    cmp     esi, ecx            ; 检查是否需要移动（头部有删除）
    je      .done               ; 如果不需要移动，直接结束
   
    mov     edi, ecx            ; 目标位置（原字符串开始）
.loop_move:
    cmp     edx, 0              ; 检查是否已移动完所有字符
    jle     .done               ; 如果长度为0，结束处理
   
    mov     al, [esi]           ; 获取当前字符
    mov     [edi], al           ; 移动到新位置
    inc     esi                 ; 源指针后移
    inc     edi                 ; 目标指针后移
    dec     edx                 ; 减少剩余长度
    jmp     .loop_move          ; 继续移动下一个字符

.done:
    ; 恢复寄存器
    pop     edi
    pop     esi
    pop     edx
    pop     ecx
   
    mov     ebx, edx            ; 返回处理后的字符串长度
    ret
```


### 使用说明

这些代码实现了相同的功能：删除字符串首尾的换行符（LF, 0x0A）。函数接受字符串地址和长度作为输入，返回处理后的字符串长度。如果有头部换行符被删除，函数会将剩余字符前移以覆盖被删除的字符。

调用示例（C语言伪代码）：

```c
char str[] = "\n\nHello World!\n\n";
int len = strlen(str);
// 调用汇编函数：remove_newlines(str, len)
len = remove_newlines(str, len);
str[len] = '\0';  // 添加字符串结束符
printf("处理后的字符串: '%s'\n", str);  // 输出: "Hello World!"
```

根据你的架构选择对应的汇编代码，这些实现都采用了高效的算法，时间复杂度为O(n)。

SSS777

appleqc 发表于 2025-6-15 10:03
### 汇编语言删除字符串首尾换行符实现

以下是几种常见架构的汇编代码实现，用于删除字符串首尾的换行符（ ...

能给置入代码吗？我转不了