grep_k93 - Mt Xia: Technical Consulting Group

Current Location

css
  Downloads
    Scripts
      Korn
        K93_Unix

Digg this page

Post to del.icio.us

Slashdot it!

AIX FREE DEMO UNIX
Automated AIX Deployment
Reduce your DC costs
www.siteox.com

Business Web Site Hosting
$3.99 / month includes Tools,
Shopping Cart, Site Builder
www.siteox.com

Korn shell script function to search the specified input FILEs (or standard input if no files are named) for lines containing a match to the given regular expression pattern. By default, prints the matching lines. This script is an emulation of the Unix "grep" command.

#!/usr/bin/ksh93
################################################################
function usagemsg_grep_k93 {
  print "
Program: grep_k93

Searches the specified input FILEs (or standard input if
no files are named, or the file name - is given) for
lines containing a match to the given PATTERN.  By
default, prints the matching lines.

Usage: ${1##*/} [-?] [-vV] [-n] file...

    Where:
        -n = Print line number of the matching line
        -i = Ignore case
        -v = Select non-matching lines
        -x = Verbose Mode
        -V = Very Verbose Mode

Example: grep_k93 -i "regexp" filename

Author: Dana French (dfrench@mtxia.com)
        Copyright 2006 by Dana French

\"AutoContent\" enabled
"
}
################################################################
#### 
#### Description:
#### 
#### Searches the specified input FILEs (or standard input if
#### no files are named, or the file name - is given) for
#### lines containing a match to the given PATTERN.  By
#### default, prints the matching lines.
#### 
#### Assumptions:
#### 
#### This functions assumes the first command line argument
#### after any specified options, is a regular expression
#### used to identify patterns in text.  After the regular
#### expression, one or more file names may be specified and
#### will be searched for lines that match the pattern
#### specified by the regular expression.
#### 
#### Dependencies:
#### 
#### This function is dependent upon the external function
#### "regexp_k93" to translate the regular expression into a
#### korn shell pattern.
#### 
#### Products:
#### 
#### The output from this program are the matching lines read
#### from a list of files or standard input.
#### 
#### Configured Usage:
#### 
#### This function can be used from the command line as a
#### standalone program or called from a library by other
#### shell functions.
#### 
#### Details:
#### 
################################################################
function grep_k93 {
  typeset TRUE="0"
  typeset FALSE="1"
  typeset VERBOSE="${FALSE}"
  typeset VERYVERB="${FALSE}"
  typeset SHOWLNBR="${FALSE}"
  typeset NOTMATCH="${FALSE}"
  typeset IGNORE="${FALSE}"
  typeset FNAME
  typeset EXPRLINE

  while getopts ":xVnvi" OPTION
  do
    case "${OPTION}" in
        'n') SHOWLNBR="${TRUE}";;
        'i') IGNORE="${TRUE}";;
        'v') NOTMATCH="${TRUE}";;
        'x') VERBOSE="${TRUE}";;
        'V') VERYVERB="${TRUE}";;
      [?:#]) print "Syntax: grep_k93 [FILE]..." && return 1 ;;
    esac
  done
 
  shift $(( ${OPTIND} - 1 ))

  (( IGNORE == TRUE )) && typeset -l REGEXP

  trap "usagemsg_grep_k93 ${0}" EXIT
  if [[ "_${1}" == "_" ]]
  then
      print -- "# ERROR: Regular expression not specified."
      return 2
  fi
  trap "-" EXIT

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

  set -o noglob
  IFS=$'\n'
  REARRAY=( $( regexp_k93 "${1}" ) )
  set +o noglob
  IFS=$'|'
  REGEXP="${REARRAY[*]}"
  (( VERBOSE == TRUE )) && print -u 2 -r -- "# ${REGEXP}"
  IFS=$' \t\n'

  shift 1

  (( IGNORE == TRUE )) && typeset -l EXPRLINE

  typeset STDIN="${1:+${FALSE}}"
  [[ "_${1}" == '_-' ]] && STDIN="${TRUE}"
  STDIN="${STDIN:-${TRUE}}"

#### Read in the data either from STDIN or one or more files
  if (( STDIN == TRUE ))
  then
      set -- -
  fi

  PNAME=""
  for FNAME in "${@}"
  do
      if (( STDIN == FALSE )) && [[ ! -e "${FNAME}" ]]
      then
          print -u 2 "${0##*/}: ${FNAME}: No such file or directory"
          continue
      fi

      (( ${#@} > 1 )) && PNAME="${FNAME}:"

      LCNT="0"
      LNBR=""
      cat_k93 -- "${FNAME}" |
      while IFS="" read -r -- LINE
      do
          EXPRLINE="${LINE}"
          (( ++LCNT ))
          if [[ "_${EXPRLINE}" == _${REGEXP} ]]
          then
              if (( NOTMATCH == FALSE ))
              then
                  (( SHOWLNBR == TRUE )) && LNBR="${LCNT}:"
                  print -r -- "${PNAME}${LNBR}${LINE}"
              fi
          else
              if (( NOTMATCH == TRUE ))
              then
                  print -r -- "${PNAME}${LNBR}${LINE}"
              fi
          fi
      done
  done

  return 0
}
################################################################
function usagemsg_regexp_k93 {
  print "
Program: regexp_k93

Convert and translate regular expressions into Korn Shell
patterns.  Resulting patterns can be used with Korn Shell
built-in commands such as "if", "while", and "case", to
perform Pattern matching.

Usage: ${1##*/} [-?] [-vV] 'regexp|...'

    Where:
        -v = Verbose Mode
        -V = Very Verbose Mode

Example: regexp_k93 '^start.*end$'

Author: Dana French (dfrench@mtxia.com)
        Copyright 2006 by Dana French

\"AutoContent\" enabled
"
}
################################################################
####
#### Description:
####
#### The purpose of this function is to translate regular
#### expressions into korn shell patterns. The resultant korn
#### shell pattern can be captured and then used with korn
#### shell pattern matching functions.
####
#### Limited regular expression functionality at this point
#### It understands the following regular expression
#### metacharacters:
####
####     .      ^     $       [  ]       \
####    \.      ^$    \$      \[X\]      \\
####     *      \*    .*      [a-z]*     \.*
####     +      \+    .+      [a-z]+     \.+
####    \(string\)    \
####
#### Assumptions:
####
#### The regular expression is assumed to be the first
#### command line argument after any options specified.  It
#### is usually best to enclose the regular expression in
#### single quotes on the command line to ensure the shell
#### does not process any of the metacharacters.
####
#### Dependencies:
####
#### This function is self contained and is not dependent
#### upon any external programs, functions or scripts.
####
#### Products:
####
#### This function produces a korn shell pattern equivalent
#### of the regular expression specified on the command line.
#### The korn shell pattern is written to STDOUT.
####
#### Configured Usage:
####
#### Details:
####
################################################################
function regexp_k93 {
  typeset VERSION="1.0"
  typeset TRUE="0"
  typeset FALSE="1"
  typeset VERBOSE="${FALSE}"
  typeset VERYVERB="${FALSE}"

  while getopts ":vV" OPTION
  do
    case "${OPTION}" in
        'v') VERBOSE="${TRUE}";;
        'V') VERYVERB="${TRUE}";;
      [?:#]) print "Syntax: regexp_k93 'regexp'" && return 1 ;;
    esac
  done

  shift $(( ${OPTIND} - 1 ))

#### Retrieve the remainder of the command line arguments
#### assuming they are regular expressions.  Parse multiple
#### RE's separated with OR '|' symbols or AND '&' symbols
#### and store each RE in an array to be processed
#### individually.

  IFS="|"
  REGEXP="${*}"
  IFS=$' \t\n'
  LOOPRE="${REGEXP}|"
  LOOPRE="${LOOPRE//\&/|}"
  LOOPRE="${LOOPRE//\|\|/|}"

  CNT="0"
  while [[ "_${LOOPRE}" != "_" ]]
  do
      REARRAY[CNT++]="${LOOPRE%%\|*}"
      LOOPRE="${LOOPRE#*\|}"
  done

#### If no regular expressions were specified on the command
#### line, display an error message and return from this
#### function.

  trap "usagemsg_regexp_k93 ${0}" EXIT
  if [[ "_${REGEXP}" == "_" ]]
  then
      print -- "# ERROR: Regular expression not specified."
      return 2
  fi
  trap "-" EXIT

  (( VERYVERB == TRUE )) && set -x
  (( VERBOSE  == TRUE )) && print -u 2 "# Entering Function: ${0}"
  (( VERBOSE  == TRUE )) && print -u 2 "# Version..........: ${VERSION}"

################################################################
#### Convert regular expression metacharacters to strings :

  for REGEXP in "${REARRAY[@]}"
  do

      (( VERBOSE  == TRUE )) && print -u 2 "# Specified regexp.: '${REGEXP}'"

#### convert '\' -> 'ESC' :
      REGEXP="${REGEXP//\\/%K93ESC%}"

#### convert '\$' -> '\$' :
      REGEXP="${REGEXP//%K93ESC%'$'/%K93ESC%%K93DOL%}"

#### convert 'beginning of line' -> 'BEG' :
      REGEXP="${REGEXP/#\^/%K93BEG%}"

#### convert 'end of line' -> 'END' :
      REGEXP="${REGEXP/%\$/%K93END%}"

#### convert '$' -> '$' :
      REGEXP="${REGEXP//'$'/%K93DOL%}"

#### convert '.' -> 'DOT' :
      REGEXP="${REGEXP//./%K93DOT%}"

#### convert '*' -> 'AST' :
      REGEXP="${REGEXP//\*/%K93AST%}"

#### convert '+' -> 'PLU' :
      REGEXP="${REGEXP//+/%K93PLU%}"

#### convert '<' -> 'LES' :
      REGEXP="${REGEXP//\' -> 'GRE' :
      REGEXP="${REGEXP//\>/%K93GRE%}"

#### convert '[' -> 'OSB' :
      REGEXP="${REGEXP//\[/%K93OSB%}"

#### convert ']' -> 'CSB' :
      REGEXP="${REGEXP//\]/%K93CSB%}"

#### convert '(' -> 'OPA' :
      REGEXP="${REGEXP//\(/%K93OPA%}"

#### convert ')' -> 'CPA' :
      REGEXP="${REGEXP//\)/%K93CPA%}"

#### convert '?' -> 'QUE' :
      REGEXP="${REGEXP//\?/%K93QUE%}"

#### convert '[^' -> '[!' :
      REGEXP="${REGEXP//%K93OSB%^/%K93OSB%%K93EXC%}"

#### convert 'regexp' -> '*regexp' :
      [[ "_${REGEXP}" != _%K93BEG%* ]] && REGEXP="%K93ANY%${REGEXP}"

#### convert 'regexp' -> 'regexp*' :
      [[ "_${REGEXP}" != _*%K93END% ]] && REGEXP="${REGEXP}%K93ANY%"

################################################################
#### Convert strings to korn shell patterns :

#### translate '^*' -> '*' :
      REGEXP="${REGEXP/#%K93ANY%/*}"

#### translate '*$' -> '*' :
      REGEXP="${REGEXP/%%K93ANY%/*}"

#### translate '\\*' -> '*(\\)' :
      REGEXP="${REGEXP//%K93ESC%%K93ESC%%K93AST%/*(\\)}"

#### translate '\\+' -> '+(\\)' :
      REGEXP="${REGEXP//%K93ESC%%K93ESC%%K93PLU%/+(\\)}"

#### translate '\**' -> '*(\*)' :
      REGEXP="${REGEXP//%K93ESC%%K93AST%%K93AST%/*(\*)}"

#### translate '\*+' -> '+(\*)' :
      REGEXP="${REGEXP//%K93ESC%%K93AST%%K93PLU%/+(\*)}"

#### translate '\^*' -> '*(^)' :
      REGEXP="${REGEXP//%K93ESC%%K93CAR%%K93AST%/*(^)}"

#### translate '\^+' -> '+(^)' :
      REGEXP="${REGEXP//%K93ESC%%K93CAR%%K93PLU%/+(^)}"

#### translate '\\' -> '\\' :
      REGEXP="${REGEXP//%K93ESC%%K93ESC%/\\\\}"

#### translate '\.*' -> '*(.)' :
      REGEXP="${REGEXP//%K93ESC%%K93DOT%%K93AST%/*(.)}"

#### translate '.*' -> '*(?)' :
      REGEXP="${REGEXP//%K93DOT%%K93AST%/*(?)}"

#### translate '\.+' -> '+(.)' :
      REGEXP="${REGEXP//%K93ESC%%K93DOT%%K93PLU%/+(.)}"

#### translate '.+' -> '+(?)' :
      REGEXP="${REGEXP//%K93DOT%%K93PLU%/+(?)}"

#### translate '\$*' -> '*(\$)' :
      REGEXP="${REGEXP//%K93ESC%%K93DOL%%K93AST%/*(\\$)}"

#### translate '\$+' -> '+(\$)' :
      REGEXP="${REGEXP//%K93ESC%%K93DOL%%K93PLU%/+(\\$)}"

#### translate '$*' -> '*(\$)' :
      REGEXP="${REGEXP//%K93DOL%%K93AST%/*('\$')}"

#### translate '$+' -> '+(\$)' :
      REGEXP="${REGEXP//%K93DOL%%K93PLU%/+(\\$)}"



#### translate '\[*' -> '*(\[)' :
      REGEXP="${REGEXP//%K93ESC%%K93OSB%%K93AST%/*(\\'[')}"

#### translate '\[+' -> '+(\[)' :
      REGEXP="${REGEXP//%K93ESC%%K93OSB%%K93PLU%/+(\\'[')}"

#### translate '\]*' -> '*(\])' :
      REGEXP="${REGEXP//%K93ESC%%K93CSB%%K93AST%/*(\\']')}"

#### translate '\]+' -> '+(\])' :
      REGEXP="${REGEXP//%K93ESC%%K93CSB%%K93PLU%/+(\\']')}"



#### translate '\*' -> '*(+([$' \t\n.,:'])string+([$' \t\n.,:']))'
      REGEXP="${REGEXP//%K93ESC%%K93LES%(*(?))%K93ESC%%K93GRE%%K93AST%/*([\$\' \\t\\n.,:\']\1[\$\' \\t\\n.,:\'])}"

#### translate '\' -> '+([$' \t\n.,:'])string+([$' \t\n.,:'])'
      REGEXP="${REGEXP//%K93ESC%%K93LES%(*(?))%K93ESC%%K93GRE%/[\$\' \\t\\n.,:\']\1[\$\' \\t\\n.,:\']}"

#### translate '<*' -> '*(\<)' :
      REGEXP="${REGEXP//%K93LES%%K93AST%/*(\\<)}"

#### translate '<+' -> '+(\<)' :
      REGEXP="${REGEXP//%K93LES%%K93PLU%/+(\\<)}"

#### translate '>*' -> '*(\>)' :
      REGEXP="${REGEXP//%K93GRE%%K93AST%/*(\\>)}"

#### translate '>+' -> '+(\>)' :
      REGEXP="${REGEXP//%K93GRE%%K93PLU%/+(\\>)}"



#### translate '\(string\)*' -> '*(\1)'
      REGEXP="${REGEXP//%K93ESC%%K93OPA%(*(?))%K93ESC%%K93CPA%%K93AST%/'*('\1')'}"

#### translate '\(string\)' -> '(\1)'
      REGEXP="${REGEXP//%K93ESC%%K93OPA%(*(?))%K93ESC%%K93CPA%/'('\1')'}"



#### translate '\(*' -> '*(\()' :
      REGEXP="${REGEXP//%K93ESC%%K93OPA%%K93AST%/*(\\'(')}"

#### translate '\(+' -> '+(\()' :
      REGEXP="${REGEXP//%K93ESC%%K93OPA%%K93PLU%/+(\\'(')}"

#### translate '\)*' -> '*(\))' :
      REGEXP="${REGEXP//%K93ESC%%K93CPA%%K93AST%/*(\\')')}"

#### translate '\)+' -> '+(\))' :
      REGEXP="${REGEXP//%K93ESC%%K93CPA%%K93PLU%/+(\\')')}"



#### translate '(*' -> '*(\()' :
      REGEXP="${REGEXP//%K93OPA%%K93AST%/*(\\'(')}"

#### translate '(+' -> '+(\()' :
      REGEXP="${REGEXP//%K93OPA%%K93PLU%/+(\\'(')}"

#### translate ')*' -> '*(\))' :
      REGEXP="${REGEXP//%K93CPA%%K93AST%/*(\\')')}"

#### translate ')+' -> '+(\))' :
      REGEXP="${REGEXP//%K93CPA%%K93PLU%/+(\\')')}"



#### translate '\X*' -> '*(X)' :
      REGEXP="${REGEXP//%K93ESC%(?)%K93AST%/*(\\\1)}"

#### translate '\X+' -> '+(X)' :
      REGEXP="${REGEXP//%K93ESC%(?)%K93PLU%/+(\\\1)}"

#### translate '[a-z]*' -> '*([a-z])' :
      REGEXP="${REGEXP//%K93OSB%(*(?))%K93CSB%%K93AST%/'*(['\1'])'}"

#### translate '[a-z]+' -> '+([a-z])' :
      REGEXP="${REGEXP//%K93OSB%(*(?))%K93CSB%%K93PLU%/'+(['\1'])'}"

#### translate '\*' -> '\*)' :
      REGEXP="${REGEXP//%K93ESC%%K93AST%/\\*}"

#### translate '\+' -> '\+)' :
      REGEXP="${REGEXP//%K93ESC%%K93PLU%/\\+}"

#### translate '\.' -> '.' :
      REGEXP="${REGEXP//%K93ESC%%K93DOT%/.}"

#### translate '^*' -> '\*' :
      REGEXP="${REGEXP/#%K93BEG%%K93AST%/\\*}"

#### translate '*$' -> '\*' :
      REGEXP="${REGEXP/%%K93AST%%K93END%/\\*}"

#### translate 'X*' -> '*(X)' :
      REGEXP="${REGEXP//(?)%K93AST%/*(\1)}"

#### translate 'X+' -> '+(X)' :
      REGEXP="${REGEXP//(?)%K93PLU%/+(\1)}"

#### translate '\^' -> '^' :
      REGEXP="${REGEXP//%K93ESC%%K93CAR%/\^}"

#### translate '\$' -> '\$' :
      REGEXP="${REGEXP//%K93ESC%%K93DOL%/\\$}"

#### translate '\[' -> '[' :
      REGEXP="${REGEXP//%K93ESC%%K93OSB%/'\['}"

#### translate '\]' -> ']' :
      REGEXP="${REGEXP//%K93ESC%%K93CSB%/'\]'}"

#### translate '[^' -> '[!' :
      REGEXP="${REGEXP//%K93OSB%%K93EXC%/'['!}"

#### translate 'LES' -> '<' :
      REGEXP="${REGEXP//%K93LES%/'\<'}"

#### translate 'GRE' -> '>' :
      REGEXP="${REGEXP//%K93GRE%/'\>'}"

#### translate 'OSB' -> '[' :
      REGEXP="${REGEXP//%K93OSB%/'['}"

#### translate 'CSB' -> ']' :
      REGEXP="${REGEXP//%K93CSB%/']'}"

#### translate 'OPA' -> '(' :
      REGEXP="${REGEXP//%K93OPA%/'\('}"

#### translate 'CPA' -> ')' :
      REGEXP="${REGEXP//%K93CPA%/'\)'}"

#### translate 'DOT' -> '?' :
      REGEXP="${REGEXP//%K93DOT%/?}"

#### translate 'CAR' -> '^' :
      REGEXP="${REGEXP//%K93CAR%/^}"

#### translate 'EXC' -> '!' :
      REGEXP="${REGEXP//%K93EXC%/!}"

#### translate 'AST' -> '*' :
      REGEXP="${REGEXP//%K93AST%/*}"

#### translate 'PLU' -> '+' :
      REGEXP="${REGEXP//%K93PLU%/+}"

#### translate 'QUE' -> '?' :
      REGEXP="${REGEXP//%K93QUE%/\?}"

#### translate 'ESC' -> '\' :
      REGEXP="${REGEXP//%K93ESC%/\\}"

#### translate 'DOL' -> '\$' :
      REGEXP="${REGEXP//%K93DOL%/\\$}"

#### translate 'beginning of line' -> '' :
      REGEXP="${REGEXP/#%K93BEG%/}"

#### translate 'end of line' -> '' :
      REGEXP="${REGEXP/%%K93END%/}"

      print -r -- "${REGEXP}"
      (( VERBOSE  == TRUE )) && print -u 2 "# Resultant Pattern: '${REGEXP}'"
  done

  (( VERBOSE  == TRUE )) && print -u 2 "# Exiting Function.: ${0}"
  return 0
}
################################################################

grep_k93 "${@}"

grep_k93

AIX FREE DEMO UNIX
Automated AIX Deployment
Reduce your DC costs
www.siteox.com

Business Web Site Hosting
$3.99 / month includes Tools,
Shopping Cart, Site Builder
www.siteox.com

*AIX^tm^mtXIA*	Site Guide \| Contact Us Mt Xia: *Technical Consulting Group*
	Business Continuity / Disaster Recovery / High Availability Data Center Automation / Audit Response / Audit Compliance


	Home About Mt Xia Mt Xia Officers Privacy Policies FAQs Contact Us Events Press Releases Business Continuity Business Continuity Planning BC Auditing BC Policies BC Guidelines BC Standards BC Procedures BC Automated Deployment Disaster Recovery Disaster Recovery Planning DR Plan Template DR Project Implementation DR Auditing DR Automated Deployment High Availability High Availability Planning HA Policies HA Guidelines HA Standards HA Procedures HA Automated Deployment Tech Support/Training AIX 4.3 Tech Support AIX 5.1 Tech Support AIX 5.2 Tech Support AIX 5.3 Tech Support HACMP 4.4.1 Tech Support HACMP 5.2 Tech Support HACMP 5.3 Tech Support Disaster Recovery Unix / Linux Shell Programming E-Business Downloads Scripts Editors Documentation Standards Project Template E-Business Methodology E-Business Model Random Fortune Cookie