UNIX for Dummies Questions & Answers

# f_PadStr                                         pad a string with fill chars
# ------------------------------------------------------------------------------
# Author.....: Wolf Machowitsch
# last update: 2001 05 30    by: Wolf Machowitsch
# ------------------------------------------------------------------------------
# Revision Log:
# - 0.99   2000 11 10   Original Creation
#                       -
#
# - 1.00   2001 01 12   Production Release
#                       did the docu, as ever
#
# - 1.01   2001 05 30   bugfix release
#                       finally did the centered padding feature
#
# ------------------------------------------------------------------------------
# Usage:
#
#     f_PadStr char* String int Length [char Fillchar [int Mode] ]
#
#     Example:
#     #!/bin/ksh
#     # example script for using f_PadStr()
#     typeset Mystring="abc"
#     # fill the variable Mystring to length 6 with leading 'x'
#     f_PadStr Mystring 6 x 1
#     print - $Mystring          # yields 'xxxabc'
#     typeset Mystring="ab"
#     # fill the variable Mystring to length 6 with trailing 'x'
#     f_PadStr Mystring 6 x 2
#     print - $Mystring          # yields 'abxxxx'
#     exit
#
# Prerequisites:
#
#     none
#
# Functional dependecies:
#
#     f_CheckInteger()
#
# ------------------------------------------------------------------------------
# Documentation:
#     f_PadStr() pads strings with a specific fill character to a given
#     given length. The string has to be passed BY REFERENCE in $1, that
#     is, not the strings value is passed but the name of variable containing
#     it. The desired length has to passed in $2 as integer value, the mode
#     describes how the string is to filled up to the specified length. Mode 1
#     (the default) means with leading fillchars, mode 2 means with trailing
#     ones. If the string is longer than the specified length an error (2)
#     is returned and the string left unmodified.
#
#     f_PadStr char* String int Length [char Fillchar [int Mode] ]
#     Parameters: char* String    the name of the variable holding the string
#                 int   length    the desired length of the result string
#                 char  fillchar  single character used to fill the string
#                 int   Mode      1: fill with leading fillchars
#                                 2: fill with trailing fillchars
#                                 3: center string in fillchars
#
#     returns:    0 success
#                 1 parameter error
#                 2 original string longer than desired length
# ------------------------------------------------------------------------------
# known bugs:
# -   while spaces *in* the string are handled ok, leading and trailing
#     whitespace are cut off at the start of the function
#
# ------------------------------------------------------------------------------
# .....................(C) 2000 Wolf Machowitsch ...............................
# ------------------------------------------------------------------------------

f_PadStr ()
{

typeset -i iRetVal=0                             # return value
typeset    chWork="$(eval print - "\${$1}")"     # work buffer
typeset    chTmp=""                              # temp buffer
typeset -i iLength=0                             # length of result string
typeset    chFill="$3"                           # fillchar
typeset -i iStrLen=0                             # length of input string
typeset -i iMode=0                               # mode (leading/trailing)
typeset -i lLeftRight=0                          # toggle for centered padding


                                                 # check parameter integrity
if [ $(f_CheckInteger "$2" 2 ; print $?) -eq 0 ] ; then
     iLength=$2                                  # result length >= 2 ?
else
     iRetVal=1
fi

if [ -n "$4" ] ; then
     if [ $(f_CheckInteger "$4" 1 3 ; print $?) -eq 0 ] ; then
          iMode=$4                               # Mode=1,2 ?
     else
          iRetVal=1
     fi
fi

if [ -n "$(print - "$chFill" | sed 's/^.//')" ] ; then
     iRetVal=1                                   # fillchar is single char ?
fi

if [ iRetVal -eq 0 ] ; then                      # get length of input string
     chTmp="$chWork"
     (( iStrLen=0 ))
     while [ -n "$chTmp" ] ; do
          chTmp=$(print - "$chTmp" | sed 's/^.//')
          (( iStrLen += 1 ))
     done

     if [ $iStrLen -gt $iLength ] ; then
          iRetVal=2
     fi
fi

if [ $iRetVal -eq 0 ] ; then                      # pad string
     while [ "$iStrLen" -lt "$iLength" ] ; do
          if     [ $iMode -eq 1 ] ; then
               chWork="$chFill$chWork"            # leading fillchar
          elif [ $iMode -eq 2 ] ; then
               chWork="$chWork$chFill"            # trailing fillchar
          elif [ $iMode -eq 3 ] ; then
               if [ $lLeftRight -eq 0 ] ; then
                    chWork="$chWork$chFill"       # padding centered
                    lLeftRight=1
               else
                    chWork="$chFill$chWork"
                    lLeftRight=0
               fi
          fi
          (( iStrLen += 1 ))
     done
     eval $1=\"$chWork\"                          # copy result back to $1
fi

return $iRetVal
}
# --- EOF f_PadStr