expr.tk

openPBS的开放源代码

#         OpenPBS (Portable Batch System) v2.3 Software License
# 
# Copyright (c) 1999-2000 Veridian Information Solutions, Inc.
# All rights reserved.
# 
# ---------------------------------------------------------------------------
# For a license to use or redistribute the OpenPBS software under conditions
# other than those described below, or to purchase support for this software,
# please contact Veridian Systems, PBS Products Department ("Licensor") at:
# 
#    www.OpenPBS.org  [phone]                  [e-mail]
#                        877 902-4PBS (US toll-free)
# ---------------------------------------------------------------------------
# 
# This license covers use of the OpenPBS v2.3 software (the "Software") at
# your site or location, and, for certain users, redistribution of the
# Software to other sites and locations.  Use and redistribution of
# OpenPBS v2.3 in source and binary forms, with or without modification,
# are permitted provided that all of the following conditions are met.
# After December 31, 2001, only conditions 3-6 must be met:
# 
# 1. Commercial and/or non-commercial use of the Software is permitted
#    provided a current software registration is on file at www.OpenPBS.org.
#    If use of this software contributes to a publication, product, or
#    service, proper attribution must be given; see www.OpenPBS.org/credit.html
# 
# 2. Redistribution in any form is only permitted for non-commercial,
#    non-profit purposes.  There can be no charge for the Software or any
#    software incorporating the Software.  Further, there can be no
#    expectation of revenue generated as a consequence of redistributing
#    the Software.
# 
# 3. Any Redistribution of source code must retain the above copyright notice
#    and the acknowledgment contained in paragraph 6, this list of conditions
#    and the disclaimer contained in paragraph 7.
# 
# 4. Any Redistribution in binary form must reproduce the above copyright
#    notice and the acknowledgment contained in paragraph 6, this list of
#    conditions and the disclaimer contained in paragraph 7 in the
#    documentation and/or other materials provided with the distribution.
# 
# 5. Redistributions in any form must be accompanied by information on how to
#    obtain complete source code for the OpenPBS software and any
#    modifications and/or additions to the OpenPBS software.  The source code
#    must either be included in the distribution or be available for no more
#    than the cost of distribution plus a nominal fee, and all modifications
#    and additions to the Software must be freely redistributable by any party
#    (including Licensor) without restriction.
# 
# 6. All advertising materials mentioning features or use of the Software must
#    display the following acknowledgment:
# 
#     "This product includes software developed by NASA Ames Research Center,
#     Lawrence Livermore National Laboratory, and Veridian Information
#     Solutions, Inc.
#     Visit www.OpenPBS.org for OpenPBS software support,
#     products, and information."
# 
# 7. DISCLAIMER OF WARRANTY
# 
# THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. 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 SHALL VERIDIAN CORPORATION, ITS AFFILIATED COMPANIES, OR THE
# U.S. GOVERNMENT OR ANY OF ITS AGENCIES BE LIABLE FOR ANY DIRECT OR 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 ""
}