hphp/runtime/base/tv-arith.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16 #ifndef incl_HPHP_RUNTIME_BASE_TV_ARITH_H_
  17 #define incl_HPHP_RUNTIME_BASE_TV_ARITH_H_
  18
  19 #include "hphp/runtime/base/tv-helpers.h"
  20 #include "hphp/runtime/base/type-variant.h"
  21 #include "hphp/runtime/base/typed-value.h"
  22
  23 namespace HPHP {
  24
  25 //////////////////////////////////////////////////////////////////////
  26
  27 /*
  28  * These functions return Cells by value.  In cases where they may
  29  * return reference counted types, the value is already incRef'd when
  30  * returned.
  31  */
  32
  33 /*
  34  * PHP operator +
  35  *
  36  * Returns a TypedNum, unless both arguments are KindOfArray, in which
  37  * case it returns an Cell that contains an Array.
  38  */
  39 Cell cellAdd(Cell, Cell);
  40
  41 /*
  42  * PHP operators - and *.
  43  *
  44  * These arithmetic operators on any php value only return numbers.
  45  */
  46 TypedNum cellSub(Cell, Cell);
  47 TypedNum cellMul(Cell, Cell);
  48
  49 /*
  50  * Same as their corresponding non-O functions, but will cast their sources to
  51  * doubles instead of doing integer overflow.
  52  */
  53 Cell cellAddO(Cell, Cell);
  54 TypedNum cellSubO(Cell, Cell);
  55 TypedNum cellMulO(Cell, Cell);
  56
  57 /*
  58  * PHP operators / and %.
  59  *
  60  * The operators return numbers unless the second argument converts to
  61  * zero, in which case they return boolean false.
  62  */
  63 Cell cellDiv(Cell, Cell);
  64 Cell cellMod(Cell, Cell);
  65
  66 /*
  67  * PHP Operator **.
  68  *
  69  * Always returns a TypedNum.
  70  */
  71 Cell cellPow(Cell, Cell);
  72
  73 /*
  74  * PHP operators &, |, and ^.
  75  *
  76  * These operators return a KindOfInt64, unless both arguments are
  77  * KindOfString, in which case they return a KindOfString that the caller owns
  78  * a reference to.
  79  */
  80 Cell cellBitAnd(Cell, Cell);
  81 Cell cellBitOr(Cell, Cell);
  82 Cell cellBitXor(Cell, Cell);
  83
  84 /*
  85  * PHP operators << and >>.
  86  *
  87  * These operators always return a KindOfInt64.
  88  */
  89 Cell cellShl(Cell, Cell);
  90 Cell cellShr(Cell, Cell);
  91
  92 //////////////////////////////////////////////////////////////////////
  93
  94 /*
  95  * PHP operator +=
  96  *
  97  * Mutates the first argument in place, by adding the second argument
  98  * to it in the sense of php's operator +=.
  99  *
 100  * Post: isTypedNum(c1), unless both arguments are KindOfArray, in
 101  * which case it will contain a Cell of KindOfArray.
 102  */
 103 void cellAddEq(Cell& c1, Cell);
 104
 105 /*
 106  * PHP operators -= and *=.
 107  *
 108  * Mutates the first argument in place, by combining the second
 109  * argument with it in the sense of either php operator -= or *=.
 110  *
 111  * Post: isTypedNum(c1)
 112  */
 113 void cellSubEq(Cell& c1, Cell);
 114 void cellMulEq(Cell& c1, Cell);
 115
 116 /*
 117  * Same as their corresponding non-O functions, but will cast their sources to
 118  * doubles instead of doing integer overflow.
 119  */
 120 void cellAddEqO(Cell& c1, Cell c2);
 121 void cellSubEqO(Cell& c1, Cell c2);
 122 void cellMulEqO(Cell& c1, Cell c2);
 123
 124 /*
 125  * PHP operators /= and %=.
 126  *
 127  * Mutates the first argument in place, by combining the second
 128  * argument with it in the sense of either php operator /= or %=.
 129  *
 130  * Post: isTypedNum(c1), unless the second argument converts to zero,
 131  * in which case c1 will contain boolean false.
 132  */
 133 void cellDivEq(Cell& c1, Cell);
 134 void cellModEq(Cell& c1, Cell);
 135
 136 /*
 137  * PHP operator **=.
 138  *
 139  * Mutates the first argument in place, by combining the second
 140  * argument with it in the of php operator **=.
 141  */
 142 void cellPowEq(Cell& c1, Cell);
 143
 144 /*
 145  * PHP operators &=, |=, and ^=.
 146  *
 147  * Mutates the first argument in place, by combining the second
 148  * argument with it in the sense of the appropriate operator.
 149  *
 150  * Post: c1.m_type == KindOfString || c1.m_type == KindOfInt64
 151  */
 152 void cellBitAndEq(Cell& c1, Cell);
 153 void cellBitOrEq(Cell& c1, Cell);
 154 void cellBitXorEq(Cell& c1, Cell);
 155
 156 /*
 157  * PHP operators <<= and >>=.
 158  *
 159  * Mutates the first argument in place, by combining the second argument
 160  * with it in the sense of the appropriate operator.
 161  *
 162  * Post: c1.m_type == KindOfInt64
 163  */
 164 void cellShlEq(Cell& c1, Cell);
 165 void cellShrEq(Cell& c1, Cell);
 166
 167 /*
 168  * PHP operator .=.
 169  *
 170  * Mutates the first argument in place, by concatenating the second argument
 171  * onto its end.
 172  *
 173  * Post: lhs.m_type == KindOfString
 174  */
 175 inline void cellConcatEq(Cell& lhs, Cell rhs) {
 176   concat_assign(tvAsVariant(&lhs), cellAsCVarRef(rhs).toString());
 177 }
 178
 179 //////////////////////////////////////////////////////////////////////
 180
 181 /*
 182  * PHP operator ++ and --.
 183  *
 184  * Mutates the argument in place, with the effects of php's
 185  * pre-increment or pre-decrement operators.
 186  */
 187 void cellInc(Cell&);
 188 void cellDec(Cell&);
 189
 190 void cellIncO(Cell&);
 191 void cellDecO(Cell&);
 192
 193 /*
 194  * PHP unary operator ~.
 195  *
 196  * Mutates the argument in place, with the effects of php's unary
 197  * bitwise not operator.
 198  */
 199 void cellBitNot(Cell&);
 200
 201 //////////////////////////////////////////////////////////////////////
 202
 203 }
 204
 205 #endif