WC_Eval_Math

Class WC_Eval_Math.

Defined (1)

The class is defined in the following location(s).

/includes/libraries/class-wc-eval-math.php  
  1. class WC_Eval_Math { 
  2.  
  3.     /** 
  4.      * Last error. 
  5.      * 
  6.      * @var string 
  7.      */ 
  8.     public static $last_error = null; 
  9.  
  10.     /** 
  11.      * Variables (and constants). 
  12.      * 
  13.      * @var array 
  14.      */ 
  15.     public static $v = array( 'e' => 2.71, 'pi' => 3.14 ); 
  16.  
  17.     /** 
  18.      * User-defined functions. 
  19.      * 
  20.      * @var array 
  21.      */ 
  22.     public static $f = array(); 
  23.  
  24.     /** 
  25.      * Constants. 
  26.      * 
  27.      * @var array 
  28.      */ 
  29.     public static $vb = array( 'e', 'pi' ); 
  30.  
  31.     /** 
  32.      * Built-in functions. 
  33.      * 
  34.      * @var array 
  35.      */ 
  36.     public static $fb = array(); 
  37.  
  38.     /** 
  39.      * Evaluate maths string. 
  40.      * 
  41.      * @param string  $expr 
  42.      * @return mixed 
  43.      */ 
  44.     public static function evaluate( $expr ) { 
  45.         self::$last_error = null; 
  46.         $expr = trim( $expr ); 
  47.         if ( substr( $expr, -1, 1 ) == ';' ) $expr = substr( $expr, 0, strlen( $expr ) -1 ); // strip semicolons at the end 
  48.         // =============== 
  49.         // is it a variable assignment? 
  50.         if ( preg_match( '/^\s*([a-z]\w*)\s*=\s*(.+)$/', $expr, $matches ) ) { 
  51.             if ( in_array( $matches[1], self::$vb ) ) { // make sure we're not assigning to a constant 
  52.                 return self::trigger( "cannot assign to constant '$matches[1]'" ); 
  53.             } 
  54.             if ( ( $tmp = self::pfx( self::nfx( $matches[2] ) ) ) === false ) return false; // get the result and make sure it's good 
  55.             self::$v[ $matches[1] ] = $tmp; // if so, stick it in the variable array 
  56.             return self::$v[ $matches[1] ]; // and return the resulting value 
  57.             // =============== 
  58.             // is it a function assignment? 
  59.         } elseif ( preg_match( '/^\s*([a-z]\w*)\s*\(\s*([a-z]\w*(?:\s*, \s*[a-z]\w*)*)\s*\)\s*=\s*(.+)$/', $expr, $matches ) ) { 
  60.             $fnn = $matches[1]; // get the function name 
  61.             if ( in_array( $matches[1], self::$fb ) ) { // make sure it isn't built in 
  62.                 return self::trigger( "cannot redefine built-in function '$matches[1]()'" ); 
  63.             } 
  64.             $args = explode( ", ", preg_replace( "/\s+/", "", $matches[2] ) ); // get the arguments 
  65.             if ( ( $stack = self::nfx( $matches[3] ) ) === false ) return false; // see if it can be converted to postfix 
  66.             $stack_size = count( $stack ); 
  67.             for ( $i = 0; $i < $stack_size; $i++ ) { // freeze the state of the non-argument variables 
  68.                 $token = $stack[ $i ]; 
  69.                 if ( preg_match( '/^[a-z]\w*$/', $token ) and ! in_array( $token, $args ) ) { 
  70.                     if ( array_key_exists( $token, self::$v ) ) { 
  71.                         $stack[ $i ] = self::$v[ $token ]; 
  72.                     } else { 
  73.                         return self::trigger( "undefined variable '$token' in function definition" ); 
  74.                     } 
  75.                 } 
  76.             } 
  77.             self::$f[ $fnn ] = array( 'args' => $args, 'func' => $stack ); 
  78.             return true; 
  79.             // =============== 
  80.         } else { 
  81.             return self::pfx( self::nfx( $expr ) ); // straight up evaluation, woo 
  82.         } 
  83.     } 
  84.  
  85.     /** 
  86.      * Convert infix to postfix notation. 
  87.      * 
  88.      * @param  string $expr 
  89.      * @return string 
  90.      */ 
  91.     private static function nfx( $expr ) { 
  92.  
  93.         $index = 0; 
  94.         $stack = new WC_Eval_Math_Stack; 
  95.         $output = array(); // postfix form of expression, to be passed to pfx() 
  96.         $expr = trim( $expr ); 
  97.  
  98.         $ops = array( '+', '-', '*', '/', '^', '_' ); 
  99.         $ops_r = array( '+' => 0, '-' => 0, '*' => 0, '/' => 0, '^' => 1 ); // right-associative operator? 
  100.         $ops_p = array( '+' => 0, '-' => 0, '*' => 1, '/' => 1, '_' => 1, '^' => 2 ); // operator precedence 
  101.  
  102.         $expecting_op = false; // we use this in syntax-checking the expression 
  103.         // and determining when a - is a negation 
  104.         if ( preg_match( "/[^\w\s+*^\/()\., -]/", $expr, $matches ) ) { // make sure the characters are all good 
  105.             return self::trigger( "illegal character '{$matches[0]}'" ); 
  106.         } 
  107.  
  108.         while ( 1 ) { // 1 Infinite Loop ;) 
  109.             $op = substr( $expr, $index, 1 ); // get the first character at the current index 
  110.             // find out if we're currently at the beginning of a number/variable/function/parenthesis/operand 
  111.             $ex = preg_match( '/^([A-Za-z]\w*\(?|\d+(?:\.\d*)?|\.\d+|\()/', substr( $expr, $index ), $match ); 
  112.             // =============== 
  113.             if ( '-' === $op and ! $expecting_op ) { // is it a negation instead of a minus? 
  114.                 $stack->push( '_' ); // put a negation on the stack 
  115.                 $index++; 
  116.             } elseif ( '_' === $op ) { // we have to explicitly deny this, because it's legal on the stack 
  117.                 return self::trigger( "illegal character '_'" ); // but not in the input expression 
  118.                 // =============== 
  119.             } elseif ( ( in_array( $op, $ops ) or $ex ) and $expecting_op ) { // are we putting an operator on the stack? 
  120.                 if ( $ex ) { // are we expecting an operator but have a number/variable/function/opening parethesis? 
  121.                     $op = '*'; 
  122.                     $index--; // it's an implicit multiplication 
  123.                 } 
  124.                 // heart of the algorithm: 
  125.                 while ( $stack->count > 0 and ( $o2 = $stack->last() ) and in_array( $o2, $ops ) and ( $ops_r[ $op ] ? $ops_p[ $op ] < $ops_p[ $o2 ] : $ops_p[ $op ] <= $ops_p[ $o2 ] ) ) { 
  126.                     $output[] = $stack->pop(); // pop stuff off the stack into the output 
  127.                 } 
  128.                 // many thanks: https://en.wikipedia.org/wiki/Reverse_Polish_notation#The_algorithm_in_detail 
  129.                 $stack->push( $op ); // finally put OUR operator onto the stack 
  130.                 $index++; 
  131.                 $expecting_op = false; 
  132.                 // =============== 
  133.             } elseif ( ')' === $op && $expecting_op ) { // ready to close a parenthesis? 
  134.                 while ( ( $o2 = $stack->pop() ) != '(' ) { // pop off the stack back to the last ( 
  135.                     if ( is_null( $o2 ) ) { 
  136.                         return self::trigger( "unexpected ')'" ); 
  137.                     } else { 
  138.                         $output[] = $o2; 
  139.                     } 
  140.                 } 
  141.                 if ( preg_match( "/^([A-Za-z]\w*)\($/", $stack->last( 2 ), $matches ) ) { // did we just close a function? 
  142.                     $fnn = $matches[1]; // get the function name 
  143.                     $arg_count = $stack->pop(); // see how many arguments there were (cleverly stored on the stack, thank you) 
  144.                     $output[] = $stack->pop(); // pop the function and push onto the output 
  145.                     if ( in_array( $fnn, self::$fb ) ) { // check the argument count 
  146.                         if ( $arg_count > 1 ) 
  147.                             return self::trigger( "too many arguments ($arg_count given, 1 expected)" ); 
  148.                     } elseif ( array_key_exists( $fnn, self::$f ) ) { 
  149.                         if ( count( self::$f[ $fnn ]['args'] ) != $arg_count ) 
  150.                             return self::trigger( "wrong number of arguments ($arg_count given, " . count( self::$f[ $fnn ]['args'] ) . " expected)" ); 
  151.                     } else { // did we somehow push a non-function on the stack? this should never happen 
  152.                         return self::trigger( "internal error" ); 
  153.                     } 
  154.                 } 
  155.                 $index++; 
  156.                 // =============== 
  157.             } elseif ( ', ' === $op and $expecting_op ) { // did we just finish a function argument? 
  158.                 while ( ( $o2 = $stack->pop() ) != '(' ) { 
  159.                     if ( is_null( $o2 ) ) { 
  160.                         return self::trigger( "unexpected ', '" ); // oops, never had a ( 
  161.                     } else { 
  162.                         $output[] = $o2; // pop the argument expression stuff and push onto the output 
  163.                     } 
  164.                 } 
  165.                 // make sure there was a function 
  166.                 if ( ! preg_match( "/^([A-Za-z]\w*)\($/", $stack->last( 2 ), $matches ) ) 
  167.                     return self::trigger( "unexpected ', '" ); 
  168.                 $stack->push( $stack->pop() + 1 ); // increment the argument count 
  169.                 $stack->push( '(' ); // put the ( back on, we'll need to pop back to it again 
  170.                 $index++; 
  171.                 $expecting_op = false; 
  172.                 // =============== 
  173.             } elseif ( '(' === $op and ! $expecting_op ) { 
  174.                 $stack->push( '(' ); // that was easy 
  175.                 $index++; 
  176.                 // =============== 
  177.             } elseif ( $ex and ! $expecting_op ) { // do we now have a function/variable/number? 
  178.                 $expecting_op = true; 
  179.                 $val = $match[1]; 
  180.                 if ( preg_match( "/^([A-Za-z]\w*)\($/", $val, $matches ) ) { // may be func, or variable w/ implicit multiplication against parentheses... 
  181.                     if ( in_array( $matches[1], self::$fb ) or array_key_exists( $matches[1], self::$f ) ) { // it's a func 
  182.                         $stack->push( $val ); 
  183.                         $stack->push( 1 ); 
  184.                         $stack->push( '(' ); 
  185.                         $expecting_op = false; 
  186.                     } else { // it's a var w/ implicit multiplication 
  187.                         $val = $matches[1]; 
  188.                         $output[] = $val; 
  189.                     } 
  190.                 } else { // it's a plain old var or num 
  191.                     $output[] = $val; 
  192.                 } 
  193.                 $index += strlen( $val ); 
  194.                 // =============== 
  195.             } elseif ( ')' === $op ) { // miscellaneous error checking 
  196.                 return self::trigger( "unexpected ')'" ); 
  197.             } elseif ( in_array( $op, $ops ) and ! $expecting_op ) { 
  198.                 return self::trigger( "unexpected operator '$op'" ); 
  199.             } else { // I don't even want to know what you did to get here 
  200.                 return self::trigger( "an unexpected error occurred" ); 
  201.             } 
  202.             if ( strlen( $expr ) == $index ) { 
  203.                 if ( in_array( $op, $ops ) ) { // did we end with an operator? bad. 
  204.                     return self::trigger( "operator '$op' lacks operand" ); 
  205.                 } else { 
  206.                     break; 
  207.                 } 
  208.             } 
  209.             while ( substr( $expr, $index, 1 ) == ' ' ) { // step the index past whitespace (pretty much turns whitespace 
  210.                 $index++;                             // into implicit multiplication if no operator is there) 
  211.             } 
  212.         } 
  213.         while ( ! is_null( $op = $stack->pop() ) ) { // pop everything off the stack and push onto output 
  214.             if ( '(' === $op ) { 
  215.                 return self::trigger( "expecting ')'" ); // if there are (s on the stack, ()s were unbalanced 
  216.             } 
  217.             $output[] = $op; 
  218.         } 
  219.         return $output; 
  220.     } 
  221.  
  222.     /** 
  223.      * Evaluate postfix notation. 
  224.      * 
  225.      * @param  mixed $tokens 
  226.      * @param  array $vars 
  227.      * 
  228.      * @return mixed 
  229.      */ 
  230.     private static function pfx( $tokens, $vars = array() ) { 
  231.         if ( false == $tokens ) { 
  232.             return false; 
  233.         } 
  234.         $stack = new WC_Eval_Math_Stack; 
  235.  
  236.         foreach ( $tokens as $token ) { // nice and easy 
  237.             // if the token is a binary operator, pop two values off the stack, do the operation, and push the result back on 
  238.             if ( in_array( $token, array( '+', '-', '*', '/', '^' ) ) ) { 
  239.                 if ( is_null( $op2 = $stack->pop() ) ) return self::trigger( "internal error" ); 
  240.                 if ( is_null( $op1 = $stack->pop() ) ) return self::trigger( "internal error" ); 
  241.                 switch ( $token ) { 
  242.                     case '+': 
  243.                         $stack->push( $op1 + $op2 ); 
  244.                         break; 
  245.                     case '-': 
  246.                         $stack->push( $op1 - $op2 ); 
  247.                         break; 
  248.                     case '*': 
  249.                         $stack->push( $op1 * $op2 ); 
  250.                         break; 
  251.                     case '/': 
  252.                         if ( 0 == $op2 ) { 
  253.                             return self::trigger( 'division by zero' ); 
  254.                         } 
  255.                         $stack->push( $op1 / $op2 ); 
  256.                         break; 
  257.                     case '^': 
  258.                         $stack->push( pow( $op1, $op2 ) ); 
  259.                         break; 
  260.                 } 
  261.                 // if the token is a unary operator, pop one value off the stack, do the operation, and push it back on 
  262.             } elseif ( '_' === $token ) { 
  263.                 $stack->push( -1 * $stack->pop() ); 
  264.                 // if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on 
  265.             } elseif ( ! preg_match( "/^([a-z]\w*)\($/", $token, $matches ) ) { 
  266.                 if ( is_numeric( $token ) ) { 
  267.                     $stack->push( $token ); 
  268.                 } elseif ( array_key_exists( $token, self::$v ) ) { 
  269.                     $stack->push( self::$v[ $token ] ); 
  270.                 } elseif ( array_key_exists( $token, $vars ) ) { 
  271.                     $stack->push( $vars[ $token ] ); 
  272.                 } else { 
  273.                     return self::trigger( "undefined variable '$token'" ); 
  274.                 } 
  275.             } 
  276.         } 
  277.         // when we're out of tokens, the stack should have a single element, the final result 
  278.         if ( 1 != $stack->count ) { 
  279.             return self::trigger( "internal error" ); 
  280.         } 
  281.         return $stack->pop(); 
  282.     } 
  283.  
  284.     /** 
  285.      * Trigger an error, but nicely, if need be. 
  286.      * 
  287.      * @param  string $msg 
  288.      * 
  289.      * @return bool 
  290.      */ 
  291.     private static function trigger( $msg ) { 
  292.         self::$last_error = $msg; 
  293.         if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) { 
  294.             echo "\nError found in:"; 
  295.             self::debugPrintCallingFunction(); 
  296.             trigger_error( $msg, E_USER_WARNING ); 
  297.         } 
  298.         return false; 
  299.     } 
  300.  
  301.     /** 
  302.      * Prints the file name, function name, and 
  303.      * line number which called your function 
  304.      * (not this function, then one that  called 
  305.      * it to begin with) 
  306.      */ 
  307.     private static function debugPrintCallingFunction() { 
  308.         $file = 'n/a'; 
  309.         $func = 'n/a'; 
  310.         $line = 'n/a'; 
  311.         $debugTrace = debug_backtrace(); 
  312.         if ( isset( $debugTrace[1] ) ) { 
  313.             $file = $debugTrace[1]['file'] ? $debugTrace[1]['file'] : 'n/a'; 
  314.             $line = $debugTrace[1]['line'] ? $debugTrace[1]['line'] : 'n/a'; 
  315.         } 
  316.         if ( isset( $debugTrace[2] ) ) $func = $debugTrace[2]['function'] ? $debugTrace[2]['function'] : 'n/a'; 
  317.         echo "\n$file, $func, $line\n"; 
  318.     } 
  319. }