Incapsulating Functions

Shell Programming and Scripting
1

Hello together,

I want to add 2 additional functions to a major function (format_work()).

The format_work() is calling two functions (check_file() & split_file()).

How should it look like, when both subfunctions are incapsulated?

format_work() {
    echo "Start of COM_WORK formatting" >> ${LOG}
    i=0
    while [ $i -lt $NB_SFI_IPN_ARRAY ]
    do
        FILE_NAME=$COM_WORK/${FILE_SFI_IPN_ARRAY[$i]}.$EXT_SFI_IPN
        # echo FILE_NAME is $FILE_NAME
        check_file $FILE_NAME
        if [ $? -eq 0 ]; then
            split_file $FILE_NAME ${FILE_SFI_IPN_ARRAY[$i]} $EXT_SFI_IPN
            rm -f $FILE_NAME 2> /dev/null
        else
            echo "No change for $FILE_NAME" >> ${LOG}
        fi
        i=$i+1
    done
    i=0
    while [ $i -lt $NB_SFI_OSMS_ARRAY ]
    do
        FILE_NAME_S=$COM_WORK/${FILE_SFI_OSMS_ARRAY[$i]}.$EXT_SFI_OSMS
        FILE_NAME_T=$COM_WORK/${FILE_SFI_OSMS_ARRAY[$i]}$TODAY.$EXT_SFI_OSMS
        # echo FILE_NAME is $FILE_NAME
        mv $FILE_NAME_S $FILE_NAME_T 2> /dev/null
        if [ $? -ne 0 ]; then
            echo "Renaming of $FILE_NAME_T not successful" >> ${LOG}
        else
            echo "Renaming of $FILE_NAME_T successful" >> ${LOG}
        fi
        i=$i+1
    done
    echo "End of COM_WORK formatting\n" >> ${LOG}
    return 0
}
#-----------------------------------------------------------------------
check_file() {
    # set -x
     
    if [ $# -ne 1 ]; then
        RC=1
        echo "Bad arguments, expected 1, received ${#}" >> ${LOG}
        return $RC
    fi
    # measure number of lines in file
    RECEIVED_NUMBER_OF_LINES=`wc -l $1 | awk '{print $1}'` 2> /dev/null
    # echo RECEIVED_NUMBER_OF_LINES $RECEIVED_NUMBER_OF_LINES
    if [ $? -ne 0 ]; then
        echo "Measuring number of lines in EOT file not successful" >> ${LOG}
        return 1
    fi
    # echo check_file $1
    if [ "$RECEIVED_NUMBER_OF_LINES" -gt $MAX_LINE ]; then
        return 0
    else
        return 1
    fi
}
#-----------------------------------------------------------------------
split_file()
{
    if [ $# -ne 3 ]; then
        RC=1
        echo "Bad arguments, expected 1, received ${#}" >> ${LOG}
        return $RC
    fi
    split -l $MAX_LINE -a 1 $1
    if [ $? -ne 0 ]; then
        echo "Split of file $1 not successful" >> ${LOG}
        return 1
    fi 
    ls x? > dirlist1
    NB_OF_SPLIT_FILES=`wc -l dirlist1 | awk '{print $1}'` 2> /dev/null
    # echo NB_OF_SPLIT_FILES $NB_OF_SPLIT_FILES
    j=0
    while [ $j -lt $NB_OF_SPLIT_FILES ]
    do
        INC=${SERNO_ARRAY[$j]}
        FILE_OLD=${XX_ARRAY[$j]}
        FILE_NEW=${2}$INC.$3
        # echo $FILE_OLD
        # echo $FILE_NEW
        mv $FILE_OLD $COM_WORK/$FILE_NEW
        j=$j+1
    done
    echo "Splitting of $1 into $NB_OF_SPLIT_FILES" >> ${LOG}
    return 0
}
2

I think function must be declared before being called (the order they are declared matter)
check_file and split_file may have to be declared before format_work

Double quote the variable that are passed as argument to a function you call (or use eval ) to avoir interpreting issue.

by the way,if you managed return code correctly in your functions,

a statements like

check_file "$WHATEVER"
if [ $? -eq 0 ]; then
    echo ok
else 
    echo ko
fi

could be written smthg like (or with a ! )

if ( check_file $WHATEVER >/dev/null ) ; then
    echo ok
else 
    echo ko
fi

Corona would give you a "useless use of test award" for that :wink:

3

Really that's not so bad a construct. It doesn't mean inevitable waste the way UUOC does.

I might boil it down into check_file $FILENAME || echo "ko" though. One line instead of five. :slight_smile: