#!/bin/ksh
#**********************************************************************#
#*                                                                    *#
#* Copyright (c) 2001 by Sun Microsystems, Inc.                       *#
#* All rights reserved.                                               *#
#*                                                                    *#
#**********************************************************************#


########################################################################
#                                                                      #
# JOB MACRO           :     ONRETCODE                                  #
# Purpose             :     Specifies the action to be taken based     #
#                           on the the return code issued by an        #
#                           application program within a step.         #
#                                                                      #
########################################################################

check_bypass_func()
{
#-----------------------------------------------------------------------#
# There can be both job and step defined ONRETCODE directives.
# The job directives are checked first.  If one causes a bypass
# state, then the step directives are ignored, else the step
# directives are tested.
#
#-----------------------------------------------------------------------#
if [ -f ${STEPNAME}.onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} ]
then
   . ${STEPNAME}.onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
fi
if [ "a$ONRETCODE_BYPASS_CURRENT_STEP" = "aYES" ]
then
   BYPASS=YES; export BYPASS
   touch bypassfile.${EBMSYS}.${JON}
else
   #
   # if coming in we weren't already in bypass mode (restart/goto)
   # then ensure bypass=no.  otherwise continue with bypassing until
   # proper LABEL is encountered, which may have been changed by the
   # above, job level, oncretcode sourcing
   #
   if [ ! -f bypassfile.${EBMSYS}.${JON} ]
   then
      BYPASS=NO; export BYPASS
   fi
fi

if [ "a$STEPNAME" != a ]
then
   if [ -f onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} ]
   then
      . onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
   fi
fi

if [ "a$ONRETCODE_BYPASS_CURRENT_STEP" = "aYES" ]
then
   BYPASS=YES; export BYPASS
   touch bypassfile.${EBMSYS}.${JON}
else
   #
   # if coming in we weren't already in bypass mode (restart/goto)
   # then ensure bypass=no.  otherwise continue with bypassing until
   # proper LABEL is encountered, which may have been changed by the
   # above, job level, oncretcode sourcing
   #
   if [ ! -f bypassfile.${EBMSYS}.${JON} ]
   then
      BYPASS=NO; export BYPASS
   fi
fi

return
}

########################################################################

. verify_jobstatus
. beginjob.${EBMSYS}.${JON}
. current_proc_level.${EBMSYS}.${JON}

#
# if ifbypassnow.level.ebmsys.jon exists we must have been
# called from witin an IF/THEN/ELSE sequence, and due to 
# the IF check, we should NOT execute this particular instance
# of ONRETCODE.
#
if [ -f "currentiflevel.${EBMSYS}.${JON}" ]
then
   ls ifbypassnow.*.${EBMSYS}.${JON} 1>$DEVNULL 2>&1
   stat=$?
   if [ "$stat" = "0" ]
   then
      exit 0
   fi
fi
if [ -f beginproc.setparms.${EBMSYS}.${JON}.${PROC_LEVEL} ]
then
   . beginproc.setparms.${EBMSYS}.${JON}.${PROC_LEVEL}
fi

if [ -f setparm.${EBMSYS}.${JON}.${PROC_LEVEL} ]
then
   . setparm.${EBMSYS}.${JON}.${PROC_LEVEL}
fi

if [ -f label.${EBMSYS}.${JON}.${PROC_LEVEL} ]
then
   . label.${EBMSYS}.${JON}.${PROC_LEVEL}
fi

#-----------------------------------------------------------------------------
# Initialize variables
#-----------------------------------------------------------------------------
abort=no    ; export abort
OPERATOR='' ; export OPERATOR
comparator1=''; export comparator1
comparator2=''; export comparator2
INTEGER1='';    export INTEGER1
INTEGER2='';    export INTEGER2
LABEL='';       export LABEL
OPERATOR='';    export OPERATOR
ACTION='';      export ACTION
QUALIFIER='';   export QUALIFIER

if [ "a$STEPNAME" != "a" ]
then
   print_message_STEPNAME=$STEPNAME; export print_message_STEPNAME
fi

#-----------------------------------------------------------------------------

#------------------------------------------------------------------------------#
#  Valid syntax:
#------------------------------------------------------------------------------#
#                                                 FORMAT=
#------------------------------------------------------------------------------#
#1      2     3      4      5     6    7    8
#COMP1  INT1  CONT                                SIMPLE_NOQUAL
#COMP1  INT1  BYPASS                              SIMPLE_NOQUAL
#COMP1  INT1  GOTO   LABEL                        SIMPLE_NOQUAL
#COMP1  INT1  AND|OR COMP2  INT2  CONT            COMPOUND_NOQUAL
#COMP1  INT1  AND|OR COMP2  INT2  BYP             COMPOUND_NOQUAL
#COMP1  INT1  AND|OR COMP2  INT2  GOTO LABEL      COMPOUND_NOQUAL
#------------------------------------------------------------------------------#
#1      2     3      4      5     6    7    8
#MAXRC  COMP1 INT1   CONT                         SIMPLE_QUAL
#MAXRC  COMP1 INT1   BYPASS                       SIMPLE_QUAL
#MAXRC  COMP1 INT1   GOTO   LABEL                 SIMPLE_QUAL
#MAXRC  COMP1 INT1   AND|OR COMP2 INT2 CONT       COMPOUND_QUAL
#MAXRC  COMP1 INT1   AND|OR COMP2 INT2 BYP        COMPOUND_QUAL
#MAXRC  COMP1 INT1   AND|OR COMP2 INT2 GOTO LABEL COMPOUND_QUAL
#------------------------------------------------------------------------------#
#1      2     3      4      5     6    7    8
#LASTRC COMP1 INT1   CONT                         SIMPLE_QUAL
#LASTRC COMP1 INT1   BYPASS                       SIMPLE_QUAL
#LASTRC COMP1 INT1   GOTO   LABEL                 SIMPLE_QUAL
#LASTRC COMP1 INT1   AND|OR COMP2 INT2 CONT       COMPOUND_QUAL
#LASTRC COMP1 INT1   AND|OR COMP2 INT2 BYP        COMPOUND_QUAL
#LASTRC COMP1 INT1   AND|OR COMP2 INT2 GOTO LABEL COMPOUND_QUAL
#------------------------------------------------------------------------------#
#1      2     3      4      5     6    7    8
#stp    COMP1 INT1   CONT                          SIMPLE_QUAL
#stp    COMP1 INT1   BYPASS                        SIMPLE_QUAL
#stp    COMP1 INT1   GOTO   LABEL                  SIMPLE_QUAL
#stp    COMP1 INT1   AND|OR COMP2 INT2 CONT        COMPOUND_QUAL
#stp    COMP1 INT1   AND|OR COMP2 INT2 BYP         COMPOUND_QUAL
#stp    COMP1 INT1   AND|OR COMP2 INT2 GOTO LABEL  COMPOUND_QUAL
#------------------------------------------------------------------------------#
#1      2     3      4      5     6    7    8
#stp.ps COMP1 INT1   CONT                          SIMPLE_QUAL
#stp.ps COMP1 INT1   BYPASS                        SIMPLE_QUAL
#stp.ps COMP1 INT1   GOTO   LABEL                  SIMPLE_QUAL
#stp.ps COMP1 INT1   AND|OR COMP2 INT2 BYP         COMPOUND_QUAL
#stp.ps COMP1 INT1   AND|OR COMP2 INT2 GOTO LABEL  COMPOUND_QUAL
#------------------------------------------------------------------------------#

if [ $# -lt 3 ]
then
   echo " "
   print_message ONRETCODE "ERROR   invalid syntax: macro requires a minimum of 3 parameters"
   echo " "
   . set_jobstatus_abort
   ABORT=YES; export ABORT
fi

arg1=`eval echo $1`; export arg1 


case $arg1 in
   EQ|NE|GT|LT|GE|LE|eq|ne|gt|lt|ge|le)
      QUALIFIER=''; export QUALIFIER
   ;;
   MAXRC)
      QUALIFIER=MAXRC; export QUALIFIER
   ;;
   LASTRC)
      QUALIFIER=LASTRC; export QUALIFIER
   ;;
   *.*)
      QUALIFIER=$arg1; export QUALIFIER
   ;;
   *)
      QUALIFIER=$arg1; export QUALIFIER
   ;;
esac

if [ "a$QUALIFIER" = "a" ]
then
   case `eval echo $3` in 
      AND|OR|and|or)
         OPERATOR=`eval echo $3`; export OPERATOR
      ;;
      *)
         OPERATOR=''; export OPERATOR
   esac
else
   case `eval echo $4` in 
      AND|OR|and|or)
         OPERATOR=`eval echo $4`; export OPERATOR
      ;;
      *)
         OPERATOR=''; export OPERATOR
   esac
fi

case $QUALIFIER in
   '')
      case $OPERATOR in
         '')
            FORMAT=UNQUALIFIED_SIMPLE; export FORMAT
         ;;
         *)
            FORMAT=UNQUALIFIED_COMPOUND; export FORMAT
         ;;
      esac
   ;;
   *)
      case $OPERATOR in
         '')
            FORMAT=QUALIFIED_SIMPLE; export FORMAT
         ;;
         *)
            FORMAT=QUALIFIED_COMPOUND; export FORMAT
         ;;
      esac
   ;;
esac

case $FORMAT in
   UNQUALIFIED_SIMPLE)
      comparator1=`eval echo $1`;  export comparator1
      INTEGER1=`eval echo $2`;     export INTEGER1
      ACTION=`eval echo $3`;       export ACTION
      LABEL=`eval echo $4`;        export LABEL

      if [ "a$comparator1" = "a" -o "a$INTEGER1" = "a" -o "a$ACTION" = "a" ]
      then
         print_message ONRETCODE "ERROR   invalid syntax" 
         . set_jobstatus_abort
         ABORT=YES; export ABORT
      fi
   ;;
   UNQUALIFIED_COMPOUND)
      comparator1=`eval echo $1`;  export comparator1
      INTEGER1=`eval echo $2`;     export INTEGER1
      OPERATOR=`eval echo $3`;     export OPERATOR
      comparator2=`eval echo $4`;  export comparator2
      INTEGER2=`eval echo $5`;     export INTEGER2
      ACTION=`eval echo $6`;       export ACTION
      LABEL=`eval echo $7`;        export LABEL
      if [ "a$comparator1" = "a" -o "a$INTEGER1" = "a" -o "a$OPERATOR" = "a" ]
      then
         print_message ONRETCODE "ERROR   invalid syntax" 
         . set_jobstatus_abort
         ABORT=YES; export ABORT
      else
         if [ "a$comparator2" = "a" -o "a$INTEGER2" = "a" -o "a$ACTION" = "a" ] 
         then
            print_message ONRETCODE "ERROR   invalid syntax" 
            . set_jobstatus_abort
            ABORT=YES; export ABORT
         fi
      fi
   ;;
   QUALIFIED_SIMPLE)
      QUALIFIER=`eval echo $1`;    export QUALIFIER
      comparator1=`eval echo $2`;  export comparator1
      INTEGER1=`eval echo $3`;     export INTEGER1
      ACTION=`eval echo $4`;       export ACTION
      LABEL=`eval echo $5`;        export LABEL
      if [ "a$comparator1" = "a" -o "a$INTEGER1" = "a" -o "a$ACTION" = "a" ]
      then
         print_message ONRETCODE "ERROR   invalid syntax" 
         . set_jobstatus_abort
         ABORT=YES; export ABORT
      fi

   ;;
   QUALIFIED_COMPOUND)
      QUALIFIER=`eval echo $1`;    export QUALIFIER
      comparator1=`eval echo $2`;  export comparator1
      INTEGER1=`eval echo $3`;     export INTEGER1
      OPERATOR=`eval echo $4`;     export OPERATOR
      comparator2=`eval echo $5`;  export comparator2
      INTEGER2=`eval echo $6`;     export INTEGER2
      ACTION=`eval echo $7`;       export ACTION
      LABEL=`eval echo $8`;        export LABEL
      if [ "a$comparator1" = "a" -o "a$INTEGER1" = "a" -o "a$OPERATOR" = "a" ]
      then
         print_message ONRETCODE "ERROR   invalid syntax" 
         . set_jobstatus_abort
         ABORT=YES; export ABORT
      else
         if [ "a$comparator2" = a -o "a$INTEGER2" = a -o "a$ACTION" = "a" ] 
         then
            print_message ONRETCODE "ERROR   invalid syntax" 
            . set_jobstatus_abort
            ABORT=YES; export ABORT
         fi
      fi
   ;;
esac


#------------------------------------------------------------------------------#
# Edit required entries: comparator1 INTEGER1 ACTION 
#------------------------------------------------------------------------------#

case $comparator1 in 
   EQ|NE|GT|LT|GE|LE|eq|ne|gt|lt|ge|le)
      COMPARATOR1=-`eval echo $comparator1 | tr '[A-Z]' '[a-z]'`  ; export COMPARATOR1
   ;;
   *)
      print_message ONRETCODE "ERROR   invalid syntax"
      . set_jobstatus_abort    
      ABORT=YES; export ABORT
   ;;
esac

tmp=`eval echo $INTEGER1 | tr -d '[0-9]'`
if [ "a$tmp" != "a" ]
then
   print_message ONRETCODE "invalid syntax:  value must be an integer"
   . set_jobstatus_abort    
   ABORT=YES; export ABORT
fi

case $ACTION in
   CONTINUE|continue)
      ACTION=CONTINUE ;  export ACTION
   ;;

   BYPASS|bypass)
      ACTION=BYPASS ;  export ACTION
   ;;

   GOTO|goto)
      ACTION=GOTO ;  export ACTION
      if [ "a$LABEL" = a ]
      then
         print_message ONRETCODE "ERROR   invalid syntax" 
         . set_jobstatus_abort    
         ABORT=YES; export ABORT
      fi
   ;;

   *)
      print_message ONRETCODE "invalid syntax"
      . set_jobstatus_abort    
      ABORT=YES; export ABORT
   ;;
esac

#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
# Locate and edit optional entries: verbose scope= 
#------------------------------------------------------------------------------#
for argument in $*
do
   i=`eval echo $argument`
   case $i in
      verbose)
         VERBOSE=YES  ; export VERBOSE 
      ;;
   esac
done

for argument in $*
do
   i=`eval echo $argument`
   case $i in
      scope=*|SCOPE=*)
         scope=`eval echo $argument|cut -f2 -d'='`; export scope
         SCOPE="`echo $scope | tr '[a-z]' '[A-Z]'`"  ; export SCOPE
      ;;
   esac
done

if [ "a$SCOPE" = "a" ]
then
   SCOPE=JOB; export SCOPE
fi

case $SCOPE in
   JOB)
      COND_STEP_ID=''; export COND_STEP_ID
   ;;

   STEP)
      if [ "a$STEPNAME" != "a" ]
      then
         COND_STEP_ID="$STEPNAME."; export COND_STEP_ID
      else
         print_message ONRETCODE "ERROR   invalid syntax: scope=STEP, macro is not defined inside a step"
      . set_jobstatus_abort
      ABORT=YES; export ABORT
   fi
;;

*)
   print_message ONRETCODE "Invalid syntax: scope=$SCOPE"
   . set_jobstatus_abort
   ABORT=YES; export ABORT
;;
esac

#------------------------------------------------------------------------------#
# Edit optional entries: OPERATOR comparator2 INTEGER2  
#------------------------------------------------------------------------------#

if [ "a$OPERATOR" != "a" ]
then
   operator=$OPERATOR;export operator
   case $OPERATOR in
      AND|and)
         OPERATOR="-a" ; export OPERATOR
      ;;
      OR|or)
         OPERATOR="-o" ; export OPERATOR
      ;;
      *)
         print_message ONRETCODE "invalid syntax" 
         . set_jobstatus_abort    
         ABORT=YES; export ABORT
      ;;
   esac
   
   if [ "a$comparator2" = "a" -o "a$INTEGER2" = "a" -o "a$ACTION" = "a" ]
   then
      print_message ONRETCODE "invalid syntax" 
      . set_jobstatus_abort    
      ABORT=YES; export ABORT
   fi

   case $comparator2 in 
      EQ|NE|GT|LT|GE|LE|eq|ne|gt|lt|ge|le)
         COMPARATOR2=-`eval echo $comparator2 | tr '[A-Z]' '[a-z]'`  ; export COMPARATOR2
      ;;
      *)
         print_message ONRETCODE "invalid syntax, value must be an integer"
         ABORT=YES; export ABORT
         abort=yes ; export abort
      ;;
   esac

   tmp=`eval echo $INTEGER2 | tr -d '[0-9]'`
   if [ "a$tmp" != "a" ]
   then
      print_message ONRETCODE "invalid syntax:  value must be an integer"
      . set_jobstatus_abort    
      ABORT=YES; export ABORT
   fi
fi   
if [ "a$ABORT" = "aYES" ]
then
   exit 0
fi

#------------------------------------------------------------------------------#
# Construct the onretcode action file:
#
#   Set the default qualifier(LASTRC)
#
#   if the scope job
#      build new file
#   else
#      if an onretcode file currently exists 
#         append to it
#
#   if return code condition is true
#   then
#      case
#         BYPASS)
#
#         CONTINUE)
#            
#         GOTO)
#            if LABELNAME specified on the GOTO is not equal to current STEPNAME
#            then
#               print a message that the step is bypassed
#               execute the GOTO macro passing LABELNAME
#            else
#               the current step is the target of the GOTO
#               reset the job condition code to zero so that step will execute 
# 
#------------------------------------------------------------------------------#

# Set the default qualifier
if [ "a$QUALIFIER" = a ]
then
   QUALIFIER=LASTRC; export QUALIFIER
fi

if [ "a$VALIDATE" != "ay" ]
then
   if [ "a$SCOPE" = aJOB ]
   then
      cat <$DEVNULL > onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
      chmod 775       onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
   else
      if [ ! -f  ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} ]
      then
         cat <$DEVNULL > ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         chmod 775       ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
      fi
   fi

IF_NEST_COUNT=1; export IF_NEST_COUNT
#------------------------------------------------------------------------------#
# Construct the if, based on QUALIFIER and FORMAT
#------------------------------------------------------------------------------#
   case $QUALIFIER in

      LASTRC)
         echo "LASTRC=\`LASTRC\` ; export LASTRC" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}

         case $FORMAT in
            
            UNQUALIFIED_SIMPLE|QUALIFIED_SIMPLE)

               echo "if [ \"\$LASTRC\" $COMPARATOR1 $INTEGER1 ]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 
            ;;
           
            UNQUALIFIED_COMPOUND|QUALIFIED_COMPOUND)

               echo "if [ \"\$LASTRC\" $COMPARATOR1 $INTEGER1 $OPERATOR \"\$LASTRC\" $COMPARATOR2 $INTEGER2 ]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 
            ;;
          
         esac
      ;;
      

      MAXRC)
         echo "MAXRC=\`MAXRC\` ; export MAXRC" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}

         case $FORMAT in
         
            UNQUALIFIED_SIMPLE|QUALIFIED_SIMPLE)
               echo "if [ \"\$MAXRC\" $COMPARATOR1 $INTEGER1 ]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 
            ;;
        
            UNQUALIFIED_COMPOUND|QUALIFIED_COMPOUND)
               echo "if [ \"\$MAXRC\" $COMPARATOR1 $INTEGER1 $OPERATOR \"\$MAXRC\" $COMPARATOR2 $INTEGER2 ]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 
            ;;
       
         esac
      ;;
     


      *)
         echo "$QUALIFIER" | grep "\." > $DEVNULL 2>&1
         if [ $? -eq 0 ]
         then
            #------------------------------------------------------------
            # Have a qualified stepname jobstepname.procedurestepname
            # e.g. : JSTP4.PSTP1
            # jobstepname identifies the EXEC statement of the calling 
            # job step. procstepname identifies the EXEC statement of 
            # the procedure step that generated the return code used for
            # the ONRETCODE test. 
            #------------------------------------------------------------
            jobstepname=`echo $QUALIFIER | cut -f1 -d'.'`
            procstepname=`echo $QUALIFIER | cut -f2 -d'.'`
            if [ -z $jobstepname ]
            then
               #error - malformed name
               echo " "
               print_message ONRETCODE "ERROR  Invalid stepname: $QUALIFIER " 
               echo " "
               . set_jobstatus_abort
               ABORT=YES; export ABORT
            fi
            if [ -z $procstepname ]
            then
               #error - malformed name
               echo " "
               print_message ONRETCODE "ERROR  Invalid stepname: $QUALIFIER " 
               echo " "
               . set_jobstatus_abort
               ABORT=YES; export ABORT
            fi
            #QUALIFIER=`echo $QUALIFIER | cut -f2 -d'.'`; export QUALIFIER
            QUALIFIER=`eval echo ${jobstepname}_${procstepname}`
            QUALIFIER="_${QUALIFIER}_"; export QUALIFIER
            echo "ENTRY=\`grep $QUALIFIER ${JON}_RETCOD 2>$DEVNULL\`;export ENTRY" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
            echo "if [ \"a\$ENTRY\" != a ]
                  then 
                     STEP_RETCODE=\`echo \$ENTRY| cut -f2 -d' '\`; export STEP_RETCODE 
                  fi">> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         else
             #------------------------------------------------------------
             # Have stepname, not qualified with a calling step stepname.
             # If proc nesting level is zero, this is a jobstepname, search the
             # ${JON}_RETCOD file using format: 
             # _jobstepname_ format. 
             # 
             # If proc level is greater than zero, this is a procedure step
             # name, search the ${JON}_PROC_RETCO_${PROC_LEVEL}D file using 
	     # _stepname_ A procedure can only retrieve return codes of
             # steps internal to the procedure.
             #------------------------------------------------------------
#8179
            if [ $PROC_LEVEL -eq 0 ]
            then
               QUALIFIER="_${QUALIFIER}_"; export QUALIFIER
               echo "ENTRY=\`grep $QUALIFIER ${JON}_RETCOD 2>$DEVNULL\`;export ENTRY" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
               echo "if [ \"a\$ENTRY\" != a ]
                     then 
                        STEP_RETCODE=\`echo \$ENTRY| cut -f2 -d' '\`; export STEP_RETCODE 
                     fi">> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
            else
               echo "ENTRY=\`grep $QUALIFIER \${JON}_PROC_RETCOD_${PROC_LEVEL} 2>$DEVNULL\`;export ENTRY" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
               echo "if [ \"a\$ENTRY\" != a ]
                     then 
                        STEP_RETCODE=\`echo \$ENTRY| cut -f2 -d' '\`; export STEP_RETCODE 
                     fi">> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
            fi
         fi

         case $FORMAT in
            UNQUALIFIED_SIMPLE|QUALIFIED_SIMPLE)
               echo "if [ \"a\$STEP_RETCODE\" != a ]  
                     then" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
               echo "if [ \$STEP_RETCODE $COMPARATOR1 $INTEGER1 ]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}

               IF_NEST_COUNT=2; export IF_NEST_COUNT
            ;;
            UNQUALIFIED_COMPOUND|QUALIFIED_COMPOUND)
               echo "if [ \"a\$STEP_RETCODE\" != a ]  
                     then" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
                     echo "if [ \$STEP_RETCODE $COMPARATOR1 $INTEGER1 $OPERATOR  \$STEP_RETCODE $COMPARATOR2 $INTEGER2]" >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}

               IF_NEST_COUNT=2; export IF_NEST_COUNT
            ;;
               esac
      ;;
      #------------------------------------------------------------------------#

   esac
#------------------------------------------------------------------------------#
# Construct the then, based on ACTION
#------------------------------------------------------------------------------#

   case $ACTION in 
#------------------------------------------------------------------------------#
      BYPASS)
         echo "then
                  ONRETCODE_BYPASS_CURRENT_STEP=YES; export ONRETCODE_BYPASS_CURRENT_STEP
         fi"  >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         
         if [ $IF_NEST_COUNT -eq 2 ]
         then
            echo "fi"  >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         fi
      ;;
#------------------------------------------------------------------------------#
      CONTINUE)
         echo "then
                  cat <$DEVNULL >> onretcode_status.${EBMSYS}.${JON}
                  echo "CONTINUE" >> onretcode_status.${EBMSYS}.${JON}
               fi"  >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 

         if [ $IF_NEST_COUNT -eq 2 ]
         then
            echo "fi"  >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         fi
      ;;
#------------------------------------------------------------------------------#
      GOTO*)
         echo "then
                  if [ \"\$STEPNAME\" = \"$LABEL\" ]
                  then
                     . set_lastrc_zero 
                     cat <$DEVNULL > restart.${EBMSYS}.${JON}
                     echo "BeginJob" >> restart.${EBMSYS}.${JON}
                     chmod 755 restart.${EBMSYS}.${JON}
                     cat <$DEVNULL > prestart.${EBMSYS}.${JON}
                     echo "BeginProc" >> prestart.${EBMSYS}.${JON}
                     chmod 755 prestart.${EBMSYS}.${JON}
                  else
                     macro_name=\`basename \$0\` ; export macro_name
                     if [ \"a\$STEPNAME\" != \"a\" ]
                     then
                        if [ \"\$macro_name\" = "EXECPGM" -o \"\$macro_name\" = "EXECPROC"  -o \"\$macro_name\" = "EBMSYSCMD" ]
                        then

                           print_message \$macro_name \"bypassed\"
                        fi
                     fi   
                     cat <$DEVNULL > onretcode_status.${EBMSYS}.${JON} 
                     echo "GOTO_${LABEL}" >> onretcode_status.${EBMSYS}.${JON}

                     touch bypassfile.${EBMSYS}.${JON}
                     if [ \"\$PROC_LEVEL\" -eq 0 ]
                     then
                        cat <$DEVNULL > restart.${EBMSYS}.${JON}
                        echo $LABEL >> restart.${EBMSYS}.${JON}
                     else
                        cat <$DEVNULL > prestart.${EBMSYS}.${JON}
                        echo $LABEL >> prestart.${EBMSYS}.${JON}
                     fi
                    #GOTO $LABEL
                     exit 0
                  fi
               fi" >>  ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL} 

         if [ $IF_NEST_COUNT -eq 2 ]
         then
            echo "fi"  >> ${COND_STEP_ID}onretcode.${EBMSYS}.${JON}.${PROC_LEVEL}
         fi
      ;;
   esac
#------------------------------------------------------------------------------#

   #
   # if we are not already in bypassfile mode
   # use the check_bypass_func function to source the onretcode
   # file just created and see if it will take immediate effect
   # this is done to create the 'bypassfile' for performance
   #

   if [ "$BATCH_MODE" = "MVS" -a ! -f bypassfile.${EBMSYS}.${JON} ]
   then
      check_bypass_func
   fi

fi  # if [ "a$VALIDATE" != "ay" ]

QUALIFIER=`echo $QUALIFIER|sed 's/_/ /g'`
#if [ "$VERBOSE" = "YES" -o "$VALIDATE" = "y" ]
echo " "
if [ "$VALIDATE" = "y" ]
then
   #echo 
   print_message ONRETCODE "----------Starting in verbose mode----------"

fi
   print_message ONRETCODE "$QUALIFIER $comparator1 $INTEGER1 $operator $comparator2 $INTEGER2 $ACTION $LABEL"

exit 0
