[Back to STRINGS SWAG index] [Back to Main SWAG index] [Original]

    procedure White2Space( var Str: string; const WhiteSpace: string ); assembler;
      { replace white space chars in Str by spaces
        the string WhiteSpace contains the chars to replace }
    asm     { setup }
            cld                      { string operations forwards    }
            les   di, str            { ES:DI points to Str           }
            xor   cx, cx             { clear cx                      }
            mov   cl, [di]           { length Str in cl              }
            jcxz  @exit              { if length of Str = 0, exit    }
            inc   di                 { point to 1st char of Str      }
            mov   dx, cx             { store length of Str           }
            mov   bx, di             { pointer to Str                }
            lds   si, WhiteSpace     { DS:SI points to WhiteSpace    }
            mov   ah, [si]           { load length of WhiteSpace     }

    @start: cmp   ah, 0              { more chars WhiteSpace left?   }
            jz    @exit              { no, exit                      }
            inc   si                 { point to next char WhiteSpace }
            mov   al, [si]           { next char to hunt             }
            dec   ah                 { ah counting down              }
            xor   dh, dh             { clear dh                      }
            mov   cx, dx             { restore length of Str         }
            mov   di, bx             { restore pointer to Str        }
            mov   dh, ' '            { space char                    }
    @scan:
      repne scasb                    { the hunt is on                }
            jnz   @next              { white space found?            }
            mov   [di-1], dh         { yes, replace that one         }
    #next:  jcxz  @start             { if no more chars in Str       }
            jmp   @scan              { if more chars in Str          }
    @exit:
    end  { White2Space };

    procedure Trim( var Str: string ); assembler;
      { remove trailing and leading spaces from str }
    asm     { setup }
            les   di, str            { ES:DI points to Str                }
            lds   si, str            { DS:SI points to Str                }
            xor   cx, cx             { clear cx                           }
            mov   cl, [di]           { length Str in cl                   }
            jcxz  @exit              { if length of Str = 0, exit         }
            mov   bx, di             { bx points to length byte of Str    }
            xor   dx, dx             { clear dx                           }
            mov   al, ' '            { hunt for spaces                    }

            { look for trailing spaces }
            std                      { string operations backwards        }
            add   di, cx             { start with last char in Str        }
       repe scasb                    { the hunt is on                     }
            jz    @done              { only spaces?                       }
            inc   cx                 { no, don't lose last char           }

            { look for leading spaces }
            cld                      { string operations forward          }
            inc   si                 { pointer to 1st char of Str         }
            mov   di, si             { pointer to 1st char of Str --> di  }
       repe scasb                    { the hunt is on                     }
            jz    @done              { if only spaces, we are done        }
            inc   cx                 { no, don't lose 1st non-blank char  }
            dec   di                 { no, don't lose 1st non-blank char  }
            mov   dx, cx             { new lenght of Str                  }
            xchg  di, si             { swap si and di                     }
        rep movsb                    { move remaining part of Str         }
    @done:  mov   [bx], dl           { new length of Str                  }
    @exit:
    end  { Trim };

    procedure RTrim( var Str: string ); assembler;
      { remove trailing spaces from str }
    asm     { setup }
            std                      { string operations backwards   }
            les   di, str            { ES:DI points to Str           }
            xor   cx, cx             { clear cx                      }
            mov   cl, [di]           { length Str in cl              }
            jcxz  @exit              { if length of Str = 0, exit    }
            mov   bx, di             { bx points to Str              }
            add   di, cx             { start with last char in Str   }
            mov   al, ' '            { hunt for spaces               }

            { remove trailing spaces }
       repe scasb                    { the hunt is on                }
            jz    @done              { only spaces?                  }
            inc   cx                 { no, don't lose last char      }
    @done:  mov   [bx], cl           { overwrite length byte of Str  }
    @exit:
    end  { RTrim };

    procedure LTrim( var Str: string ); assembler;
      { remove leading white space from str }
    asm     { setup }
            cld                      { string operations forward          }
            lds   si, str            { DS:SI points to Str                }
            xor   cx, cx             { clear cx                           }
            mov   cl, [si]           { length Str --> cl                  }
            jcxz  @exit              { if length Str = 0, exit            }
            mov   bx, si             { save pointer to length byte of Str }
            inc   si                 { 1st char of Str                    }
            mov   di, si             { pointer to 1st char of Str --> di  }
            mov   al, ' '            { hunt for spaces                    }
            xor   dx, dx             { clear dx                           }

            { look for leading spaces }
       repe scasb                    { the hunt is on                     }
            jz    @done              { if only spaces, we are done        }
            inc   cx                 { no, don't lose 1st non-blank char  }
            dec   di                 { no, don't lose 1st non-blank char  }
            mov   dx, cx             { new lenght of Str                  }
            xchg  di, si             { swap si and di                     }
        rep movsb                    { move remaining part of Str         }
    @done:  mov   [bx], dl           { new length of Str                  }
    @exit:
    end  { LTrim };

[Back to STRINGS SWAG index] [Back to Main SWAG index] [Original]