Trimming strings

Actor — Wed, 02 Jan 2008 02:43:07 -0700

Here, for completeness without further comment, is the code for RTrim, LTrim and Trim which are included in the unit Tools.

      Function RTrim (Var S : String) : String ;
      {
         RTrim -- remove trailing blanks
      }
      Var
         i : Byte ;

      begin { RTrim }
         for i := Length(S) downto 1 do
            if S[i] > BLANK then begin
               S     := Copy(S,1,i) ;
               RTrim := S ;
               Exit
            end ;
         {
               if we reach this point then S contains only BLANKS
            so we return a null string
         }
         S     := '' ;
         RTrim := S
      end ; { RTrim }


      Function LTrim (Var S : String) : String ;
      {
         LTrim -- remove leading blanks
      }
      Var
         i : Byte ;

      begin { LTrim }
         for i := 1 to Length(S) do
            if S[i] > BLANK then begin
               S     := Copy(S,i,MAXSTR) ;
               LTrim := S ;
               Exit
            end ;
         {
               if we reach this point then S contains only BLANKS
            so we return a null string
         }
         S     := '' ;
         LTrim := S
      end ; { LTrim }


      Function Trim  (Var S : String) : String ;
      {
         Trim -- remove leading and trailing blanks
      }
      begin { Trim }
         S     := RTrim(S) ;
         S     := LTrim(S) ;
         Trim  := S
      end ; { Trim }

Detabbing

Actor — Tue, 01 Jan 2008 09:08:25 -0700

DeTab is the inverse of EnTab. Here is the specification:

{
PROGRAM
      DeTab    -- convert tabs to blanks
USAGE
      DeTab
FUNCTION
      DeTab copies its input to its output, expanding horizontal tabs to 
      blanks along the way, so that the output is visually the same as the        
      input, but contains no tab chars.  Tab stops are assumed to be set
      every three columns (i.e., 1, 4, 7, 10, ...), so that each tab char
      is replaced by from one to three blanks.
BUGS
      1. DeTab is naive about backspace, vertical motions, and
         non-printing chars.
      2. Each line of output will be truncated at MAXSTR chars.
      3. Trailing BLANKS will be trimmed from each line of output.

}

DeTab's main routine echos EnTab's, reducing the problem to one of detabbing a single string. To detab the string we could try to simply apply EnTab's strategy in reverse, however, this is another chance to apply the "how would a human do it?" approach.

How would a human do it? If a human is sitting at a typewriter typing the incoming text, what is happening? First, he is looking at a blank sheet of paper. At least the current line is blank. If he hits any other than the TAB key the corresponding letter/character gets typed. Even if he hits the space bar a character, a BLANK, gets typed, even though what actually happens is that the carriage moves one space to the left (effectively moving the print head to the right). However, if he hits the TAB key the carriage moves to the left until it hits a tab stop, printing nothing and leaving the print head at the tab stop awaiting the next character.

This is the behavior we will try to emulate. We will copy the input string to an output string. But first we will fill the output string with BLANKS, effectively giving us a blank line. We will use an index i for the input string and j for the output string. If the char is not a TAB then we will copy the char and increment both i and j. However, if it is a TAB we increment i once but we increment j repeatedly until we get to a tab stop.

To deal with the situation of what happens when we encounter a TAB after the last tab stop we cease incrementing j once it exceeds MAXSTR. We also do an early exit from the routine should j exceed MAXSTR. In keeping with our previous philosophy we do not expect this to happen but it could. If it does the program exits cleanly, albeit with a corrupted output. We will simply live with this known bug.

Finally, we trim the end of the output string of any BLANKS. This means that any trailing BLANKS in the input string will not get copied to the output. Strictly speaking this is a bug but it is unlikely to cause problems. Again we will live with it.

The function RTrim gets rid of trailing BLANKS. We will add it to Tools. While we are at it we will also add LTrim, which gets rid of leading BLANKS, and Trim, which does both. I will post the
code next time.

Program DeTab ;
{
   DeTab -- replace blanks with tabs and blanks
}
Uses
   Tools,
   TabsUnit ;

      Procedure DeTabStr (Var S : String) ;
      {
         Detab a string
      }
      Var
         i     :  Byte ;
         j     :  Word ;
         T     :  String ;

      begin { DeTabStr }
         {
            clear target string
         }
         T := '' ;
         while Length(T) < MAXSTR do
            T := T + BLANK ;

         j := 1 ;
         for i := 1 to Length(S) do begin
            if j > MAXSTR then      { not likely but not impossible }
               Break ;                  

            Case S[i] of
               TAB :
                  repeat
                     j := j + 1
                  until (j in TabSet) OR (j > MAXSTR)
               else
                  begin
                     if j <= MAXSTR then
                        T[j]  := S[i] ;
                     j     := j + 1
                  end
            end { Case }
         end ;

         S := RTrim(T)
      end ; { DeTabStr }

Var
   S      :  String ;

begin { DeTab }
   SetTabs ;

   while NOT eof do begin
      ReadLn (S) ;
      DeTabStr (S) ;
      WriteLn (S)
   end
end.  { DeTab }

Posts Tagged With 'Trim' RSS Feed

Trimming strings

Detabbing