#         Portable Batch System (PBS) Software License
# 
# Copyright (c) 1999, MRJ Technology Solutions.
# All rights reserved.
# 
# Acknowledgment: The Portable Batch System Software was originally developed
# as a joint project between the Numerical Aerospace Simulation (NAS) Systems
# Division of NASA Ames Research Center and the National Energy Research
# Supercomputer Center (NERSC) of Lawrence Livermore National Laboratory.
# 
# Redistribution of the Portable Batch System Software and use in source
# and binary forms, with or without modification, are permitted provided
# that the following conditions are met:
# 
# - Redistributions of source code must retain the above copyright and
#   acknowledgment notices, this list of conditions and the following
#   disclaimer.
# 
# - Redistributions in binary form must reproduce the above copyright and 
#   acknowledgment notices, this list of conditions and the following
#   disclaimer in the documentation and/or other materials provided with the
#   distribution.
# 
# - All advertising materials mentioning features or use of this software must
#   display the following acknowledgment:
# 
#   This product includes software developed by NASA Ames Research Center,
#   Lawrence Livermore National Laboratory, and MRJ Technology Solutions.
# 
#         DISCLAIMER OF WARRANTY
# 
# THIS SOFTWARE IS PROVIDED BY MRJ TECHNOLOGY SOLUTIONS ("MRJ") "AS IS" WITHOUT 
# WARRANTY OF ANY KIND, AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
# FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE EXPRESSLY DISCLAIMED.
# 
# IN NO EVENT, UNLESS REQUIRED BY APPLICABLE LAW, SHALL MRJ, NASA, NOR
# THE U.S. GOVERNMENT BE LIABLE FOR ANY DIRECT DAMAGES WHATSOEVER,
# NOR ANY INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# 
# This license will be governed by the laws of the Commonwealth of Virginia,
# without reference to its choice of law rules.

proc isNumber {str number} {

        upvar $number num

        set retval [regexp {^[+-]?[0-9]+[.]?[0-9]*[kmgtpKMGTP]?[bwBW]?$} $str]

        if {$retval} {
                regsub -all {[kmgtpKMGTP]?[bwBW]?} $str "" num
        }
        return $retval
}

proc isFloat {str} {

        return [regexp {^[+-]?[0-9]+[.][0-9]*[kmgtpKMGTP]?[bwBW]?$} $str]
}

proc isSingleOp {str} {

        switch -exact -- $str {
          -                     -
          ~                     -
          *                     -
          /                     -
          %                     -
          +                     -
          ^                     -
          (                     -
          )                 { return 1 }
          <                     -
          >                     -
          !                     -
          &                     -
          =                     -
          |                 { return 2 }
          default           { return 0 }

        }
}

proc isDoubleOp {str} {

        switch -exact -- $str {
          <<                    -
          <=                    -
          >>                    -
          >=                    -
          ==                    -
          !=                    -
          &&                    -
          ||                { return 1 }
          default           { return 0 }

        }
}

# isQueryString: returns 1 if the string contains at least one alphabetic
#                character; 0, otherwise.
proc isQueryString {str} {

        set isOp \
           [regexp {^([-~!*/%+<>&^\|\(\)]|<<|>>|<=|>=|==|!=|&&|\|\|)$} $str]
        set isConstant [regexp {^[+-]?[0-9]+[.]?[0-9]*$} $str]

        if {!$isOp && !$isConstant} {
                return 1
        }
        return 0
}

proc queryExprCreate {str} {
        set val ""
        set hval ""
        set sval ""
        set expr ""
        for {set i 0} {$i < [string length $str]} {incr i} {
                set c [string index $str $i]

                if {[string compare $c " "] == 0} {
                        if {[string compare $hval ""] != 0} {
                                lappend expr $hval
                                set hval ""
                        }
                        continue
                }
                set val "$val$c"

                set singleOp [isSingleOp $val]

                if {$singleOp == 1} {
                        if {[string compare $hval ""] != 0} {
                                lappend expr $hval
                                set hval ""
                        }
                        lappend expr $val
                        set val ""
                } elseif {$singleOp == 2} {
                        if {[string compare $hval ""] != 0} {
                                lappend expr $hval
                                set hval ""
                        }
                        set sval $val
                } elseif [isDoubleOp $val] {
                        lappend expr $val
                        set hval ""
                        set val ""
                        set sval ""
                } else {
                        if {[string compare $sval ""] != 0} {
                                lappend expr $sval
                                set sval ""
                                set hval [string index $val 1]
                        } else {
                                set hval "$hval$val"
                        }
                        set val ""

                }
        }
        if {[string compare $hval ""] != 0} {
                lappend expr $hval
        }
        return $expr
}

proc fltround {val {precision 2}} {

	set lenval [string length $val]
	set inFraction 0
        set retval ""
	for {set i 0} {$i < $lenval} {incr i} {
		set c [string index $val $i]

		if {$inFraction} {
			incr j
			if {$j > $precision} {
				break
			}

		}

		if { [string compare $c "."] == 0 } {
			set inFraction 1
			set j 0
		}
		set retval "$retval$c"
	}
	return $retval	
}

proc evaluateExpr {expr} {

        if {[llength $expr] <= 1} {
                return [join $expr " "]
        }

        set newexpr $expr

        set hasFloat 0
        set i 0
        set operand [lindex $newexpr 0]
        while {[string compare $operand ""] != 0} {
             if {[string compare $operand "/"] == 0} {
                set k [expr $i + 1]
                set newexpr [linsert $newexpr $k double (]
                incr k 2
                if { [string compare [lindex $newexpr $k] "("] == 0 } {
                        stackClear
                        foreach o [lrange $newexpr $k end] {
                                if { [string compare $o "("] == 0 } {
                                        stackPush "("
                                } elseif { [string compare $o ")"] == 0 } {
                                        stackPop
                                }
                                if {[isStackEmpty]} {
                                        break
                                }
                                incr k
                        }
                }
                incr k
                set newexpr [linsert $newexpr $k )]
             } elseif {[isNumber $operand val]} {
                set newexpr [lreplace $newexpr $i $i $val]
                if [isFloat $val] {
                        set hasFloat 1
                }
             }

             incr i
             set operand [lindex $newexpr $i]
        }

        if {[catch {expr [join $newexpr ""]} val] == 0} {
                if {$hasFloat} {
                        return [fltround $val]
                }
                return [expr round(ceil($val))]

        }
        return ""
}
