hiphop 原理分析4 原创--胡志广

下面主要分析的是优化阶段和推导阶段的分析,前优化和后优化类似,所以就不具体再分析后优化;

1.   preOptimize分析

1.1.  preOptimize作用

1.将可以进行计算和拼接的简单的一元、二元表达式进行计算和拼接返回成为一个ScalarExpression(但变量和变量之间的是不能在preOptimize中进行合并的,这样的需要进行类型推导后才可以进行优化)

         如:

     $a=1+2*3+4 优化后$a=11

         $a=“123”+3 优化后$a =126

    $b=2;$a=$b+3 ; 优化后$a=5;

     $a=“a”.”b”.”c” 优化后 $a=“abc”

2.多个连接语句进行字符串拼接

         如:

    $a.=“aa”;

    $b=“bb”;

    $a.=$b.“dd”;

    优化后 $a=“aa”.”bb”.”dd”;数组优化同理

3.优化后的表达式,封装到上一级的表达式或者语句中,将语法树进行简化

 

1.2.  preOptimize 处理流程


hiphop 原理分析4 原创--胡志广_第1张图片
 

 

1.3.  preOptimize 实例

例:$a=1+2*3+4

语法树:

 

 
hiphop 原理分析4 原创--胡志广_第2张图片
 

(1)优化2*3 返回结果ScalarExpression(6),封装到上一级的BinaryOpExpression上


hiphop 原理分析4 原创--胡志广_第3张图片
 

 

(2)优化1+6返回结果ScalarExpression(7),封装到上一级的BinaryOpExpression上


hiphop 原理分析4 原创--胡志广_第4张图片
 

 

(3)优化1+6返回结果ScalarExpression(11),封装到上一级的AssignmentExpression上,最终把一颗大树优化为了一个赋值表达式


hiphop 原理分析4 原创--胡志广_第5张图片
 

 

 

1.4.  preOptimize代码分析

这里抽取一个一元表达式的作为例子进行分析(unary_op_expression.cpp):

/*

         解析一元表达式,并进行计算,计算出结果(reslut),然后返回

         一个scalarExpr(result),表达式;

         如果m_exp是一元或者二元表达式则返回原表达式;

*/

ExpressionPtr UnaryOpExpression::preOptimize(AnalysisResultConstPtr ar) {

  Variant value;

  Variant result;

 

  if (m_exp && ar->getPhase() >= AnalysisResult::FirstPreOptimize) {

       //T_UNSET : unset

    if (m_op == T_UNSET) {

      if (m_exp->isScalar() ||

          (m_exp->is(KindOfExpressionList) &&

           static_pointer_cast<ExpressionList>(m_exp)->getCount() == 0)) {

        recomputeEffects();

                   //返回一个null

        return CONSTANT("null");

      }

      return ExpressionPtr();

    }

  }

  //T_ISSET :isset

  if (m_op == T_ISSET && m_exp->is(KindOfExpressionList) &&

      static_pointer_cast<ExpressionList>(m_exp)->getListKind() ==

      ExpressionList::ListKindParam) {

    ExpressionListPtr el(static_pointer_cast<ExpressionList>(m_exp));

    result = true;

    int i = 0, n = el->getCount();

    for (; i < n; i++) {

                   //根据下标获取el列表下的expr

      ExpressionPtr e((*el)[i]);

           //如果e为空或e类型不是scalar 则break;

      if (!e || !e->isScalar() || !e->getScalarValue(value)) break;

      if (!isset(value)) {

        result = false;

      }

    }

         //遍历完最后一个expr时,然后返回一个result值,并且将作用域和类型保持与当前表达式一致

    if (i == n) {

      return replaceValue(makeScalarExpression(ar, result));

    }

  } else if (m_op != T_ARRAY &&

             m_exp &&

             m_exp->isScalar() &&

             m_exp->getScalarValue(value) &&

             preCompute(value, result)) {

    //非array ,并且m_exp不为空,m_exp是scalar类型, 调用preCompute返回计算后的result值

    //返回result的scalar表达式,并且修改作用域和类型与当前表达式一致

    return replaceValue(makeScalarExpression(ar, result));

  } else if (m_op == T_BOOL_CAST) {

    switch (m_exp->getKindOf()) {

      default: break;

           //表达式类型为KindOfBinaryOpExpression

      case KindOfBinaryOpExpression: {

                //获取操作符

        int op = static_pointer_cast<BinaryOpExpression>(m_exp)->getOp();

        switch (op) {

                     //OR

          case T_LOGICAL_OR:

                     //||

          case T_BOOLEAN_OR:

                     //AND

          case T_LOGICAL_AND:

                     //&&

          case T_BOOLEAN_AND:

                     //XOR

          case T_LOGICAL_XOR:

                     //instanceof

          case T_INSTANCEOF:

          case '<':

                     //<=

          case T_IS_SMALLER_OR_EQUAL:

          case '>':

                     //>=

          case T_IS_GREATER_OR_EQUAL:

                     //===

          case T_IS_IDENTICAL:

                     //!==

          case T_IS_NOT_IDENTICAL:

                     //==

          case T_IS_EQUAL:

                     //!= <>

          case T_IS_NOT_EQUAL:

                          //返回这个二元表达式

            return m_exp;

        }

        break;

      }

           //m_exp是个一元表达式

      case KindOfUnaryOpExpression: {

        int op = static_pointer_cast<UnaryOpExpression>(m_exp)->getOp();

        switch (op) {

                     //bool|boolean

          case T_BOOL_CAST:

          case '!':

                     //isset

          case T_ISSET:

                     //empty

          case T_EMPTY:

                     //print

          case T_PRINT:

                          //返回当前一元表达式

            return m_exp;

        }

        break;

      }

    }

  }

  return ExpressionPtr();

}

 

2.   inferType分析

2.1.  inferType的作用

Infertype的主要作用是在pre-optimize的基础之上进行类型推衍,对表达式的类型、变量的类型进行推衍。并判断类型是否和上下文所期望的一致。形如$a = $b + $c ;这种形式,类型推衍将$b和$c的类型推衍成同一类型的然后再进行操作(post-optimize)。

Infertype的最基本操作包括BinaryOpExpression、AssignmentExpression、UnaryOpExpression。

2.2.  inferType的流程

1)根据functionscope对文件进行划分

2)获取functionscope下的statementlist,对statementlist进行遍历获取到每条statement。

3)对statement中的expression进行类型推衍,通过调用inferTypes(ar, type, coerce);方法分析出当前的expression是哪一种( AssignmentExpression 、scalarexpression等),在通过inferAndCheck()方法对表达式进行推衍和检查,最终得到表达式的类型。

4)将分析出的最小表达式的类型返回到上一级再次进行分析,直到分析出expression或者statement的类型。

 

下面有3个expression中的infertype的3个关键函数的实现分析:

inferAndCheck,checkTypesImpl,setTypes;

这3个函数的关系为:inferAndCheck=> checkTypesImpl=> setTypes

inferAndCheck 推导和检查类型(检查类型实现是checkTypesImpl,设置最终类型是setTypes);

以下是3个函数的实现具体的代码分析,在expression.cpp中:

 

2.2.1.   inferAndCheck:

/*

coerce是否强制转换

*/

TypePtr Expression::inferAndCheck(AnalysisResultPtr ar, TypePtr type,

                                  bool coerce) {

  IMPLEMENT_INFER_AND_CHECK_ASSERT(getScope());

  ASSERT(type);

  resetTypes();

  //获取实际类型

  TypePtr actualType = inferTypes(ar, type, coerce);

  //通过传入的type判断是执行如下语句还是执行checkTypesImpl

  if (type->is(Type::KindOfSome) || type->is(Type::KindOfAny)) {

    m_actualType = actualType;

    m_expectedType.reset();

    return actualType;

  }

  //返回期望值

  return checkTypesImpl(ar, type, actualType, coerce);

}

  

2.2.2.   checkTypesImpl:

TypePtr Expression::checkTypesImpl(AnalysisResultConstPtr ar,

                                   TypePtr expectedType,

                                   TypePtr actualType, bool coerce) {

  TypePtr ret;

  //返回实际类型

  actualType = propagateTypes(ar, actualType);

  ASSERT(actualType);

  //是否强转

  if (coerce) {

    ret = Type::Coerce(ar, expectedType, actualType);

         //设置实际和期望类型

    setTypes(ar, actualType, expectedType);

  } else {

    //返回期望类型,返回交集

    ret = Type::Intersection(ar, actualType, expectedType);

    setTypes(ar, actualType, ret);

  }

  ASSERT(ret);

  return ret;

}

  

2.2.3.    setTypes:

//设置当前表达式的类型

//设置m_actualType 和m_expectedType

void Expression::setTypes(AnalysisResultConstPtr ar, TypePtr actualType,

                          TypePtr expectedType) {

  ASSERT(actualType);

  ASSERT(expectedType);

 

  m_actualType = actualType;

  //如果expectedType非any和some类型,那么将expectedType设置为期望类型,否则清空m_expectedType

  if (!expectedType->is(Type::KindOfAny) &&

      !expectedType->is(Type::KindOfSome)) {

    // store the expected type if it is not Any nor Some,

    // regardless of the actual type

    m_expectedType = expectedType;

  } else {

    m_expectedType.reset();

  }

 

  // This is a special case where Type::KindOfObject means any object.

  //m_expectedType是一个对象类型,并不是一个特殊对象时(如m_name=a,也就是class A,这是一个特殊对象)

  //并且实际类型是一个特殊对象

  if (m_expectedType && m_expectedType->is(Type::KindOfObject) &&

      !m_expectedType->isSpecificObject() &&

      m_actualType->isSpecificObject()) {

    m_expectedType.reset();

  }

  //如果m_actualType 是一个特殊对象,那么将它添加到文件作用域的依赖中

  if (m_actualType->isSpecificObject()) {

    boost::const_pointer_cast<AnalysisResult>(ar)->

      addClassDependency(getFileScope(), m_actualType->getName());

  }

}

 

2.3.  inferType原理

强转Type::Coerce

秉持的思想是向大的类型转,存在以下几种类型:

①当有一种类型为KindOfVariant 那么返回Type::Variant。

②当type1为KindOfVoid ,type2为KindOfString、 KindOfArray、 KindOfObject返回type2的类型

③当type1为某一具体类型,type2为KindOfSome、 KindOfAny返回type1的类型

④当type1为KindOfString, type2为KindOfArray返回Type:: Sequence。

⑤当type1唯一确定为KindOfInteger,如果type2唯一确定为KindOfInteger,返回type2,否则如果type2唯一确定为KindOfDouble,返回Type::Numeric。

⑥当type为objcet返回父类。

 

如下都是类型推导的具体的代码分析:

Coerce是强转类型,实际类型和期望类型之间进行转换;

Intersection 取交集类型;

IsLegalCast判断2种类型是否一致;

isStandardObject 判断是否Object类型;

isSpecificObject 是否是特定的类型,如自定义类class A这样的类型;

isNonConvertibleType 是否是Object或者Array 的类型;

isNoObjectInvolved 判断是否是非对象类型(如果是Object或者Array,则返回false)

InferredObject 推导多态的返回类型;

Inferred 推导类型;

combinedArithmeticType 数字类型推导;

php转换cpp的输出内容;

2.3.1.   Type::Coerce(强转类型)

强转的函数在type.cpp中,Type::Coerce,代码如下:

 

//强制转换 type1是期望类型 type2 是实际类型

TypePtr Type::Coerce(AnalysisResultConstPtr ar, TypePtr type1, TypePtr type2) {

  //type1和type2相同返回type1

  if (SameType(type1, type2)) return type1;

  //type1或type2是variant返回variant

  if (type1->m_kindOf == KindOfVariant ||

      type2->m_kindOf == KindOfVariant) return Type::Variant;

  //如果type1 包含了type2 则将type1 和type2 互换,保证type1是子集

  if (type1->m_kindOf > type2->m_kindOf) {

    TypePtr tmp = type1;

    type1 = type2;

    type2 = tmp;

  }

  //type1是void ,type2是string array object,那么返回type2

  if (type1->m_kindOf == KindOfVoid &&

      (type2->m_kindOf == KindOfString ||

       type2->m_kindOf == KindOfArray ||

       type2->m_kindOf == KindOfObject)) {

    return type2;

  }

  //type2是some any返回type1

  if (type2->m_kindOf == KindOfSome ||

      type2->m_kindOf == KindOfAny) return type1;

  //

  if (type2->m_kindOf & KindOfAuto) {

       //type1 必须是type2不包含auto类型

    if (type1->mustBe(type2->m_kindOf & ~KindOfAuto)) {

                   //type1不是string ,返回type1

      if (!(type1->m_kindOf & Type::KindOfString)) {

        return type1;

      }

      if (type2->m_kindOf == KindOfAutoSequence) {

        return Type::Sequence;

      }

           //获取type2类型,清除auto

      return GetType((KindOf)(type2->m_kindOf & ~KindOfAuto));

    }

    return Type::Variant;

  }

  // type1 type2都是integer,返回type2

  //type1 是integer,type2是double 返回Numeric

  if (type1->mustBe(KindOfInteger)) {

    if (type2->mustBe(KindOfInteger)) {

      return type2;

    } else if (type2->mustBe(KindOfDouble)) {

      return Type::Numeric;

    }

  }

  //type1 和type2必须是object

  if (type1->mustBe(Type::KindOfObject) &&

      type2->mustBe(Type::KindOfObject)) {

    //type1和type2名字为空返回本身

    if (type1->m_name.empty()) return type1;

    if (type2->m_name.empty()) return type2;

         //根据名字查找类并返回type

    ClassScopePtr cls1 = ar->findClass(type1->m_name);

         //cls1不重复,并且type2是他的父类,返回type2

    if (cls1 && !cls1->isRedeclaring() &&

        cls1->derivesFrom(ar, type2->m_name, true, false)) {

      return type2;

    }

         //cls2不重复,并且type1是他的父类,返回type1

    ClassScopePtr cls2 = ar->findClass(type2->m_name);

    if (cls2 && !cls2->isRedeclaring() &&

        cls2->derivesFrom(ar, type1->m_name, true, false)) {

      return type1;

    }

         //cls1 和cls2存在并且都不重复查找cls1或cls2的父类,并且返回

    if (cls1 && cls2 &&

        !cls1->isRedeclaring() && !cls2->isRedeclaring()) {

       //返回父类

      ClassScopePtr parent =

        ClassScope::FindCommonParent(ar, type1->m_name,

                                         type2->m_name);

      if (parent) {

                //创建父类的类型对象

        return Type::CreateObjectType(parent->getName());

      }

    }

    return Type::Object;

  }

 

  if (type1->mustBe(type2->m_kindOf)) {

    return type2;

  }

 

  CT_ASSERT(Type::KindOfString < Type::KindOfArray);

  if (type1->m_kindOf == Type::KindOfString &&

      type2->m_kindOf == Type::KindOfArray) {

    return Type::Sequence;

  }

 

  return Type::Variant;

}

  

2.3.2.    Type::Intersection(取交集)

TypePtr Type::Intersection(AnalysisResultConstPtr ar,

                           TypePtr from, TypePtr to) {

  // Special case: if we're casting to Some or Any, return the "from" type;

  // if we're casting to Variant, return Variant.

  //to 一般为期望值from一般为实际类型

  //to为some或any时,返回from

  if (to->m_kindOf == KindOfSome || to->m_kindOf == KindOfAny) {

    return from;

  } else if (to->m_kindOf == KindOfVariant) {

    return Variant;

  }

  //获取to和from的类型交际

  int resultKind = to->m_kindOf & from->m_kindOf;

  std::string resultName = "";

  //交集为object

  if (resultKind & KindOfObject) {

    // if they're the same, or we don't know one's name, then use

    // the other

    //to 和from的类型名字一致或者from 名字为空,resultName为to的名字

    if (to->m_name == from->m_name || from->m_name.empty()) {

      resultName = to->m_name;

    } else if (to->m_name.empty()) {

    //to 的名字为空,resultName为from的名字

      resultName = from->m_name;

    } else {

      // make sure there's a subclass relation

      //查找from的类

      ClassScopePtr cls = ar->findClass(from->m_name);

      if (cls) {

                 //判断to是否是from 的父类,如果是resultName设置为to的名字

        if (cls->derivesFrom(ar, to->m_name, true, false)) {

          resultName = to->m_name;

        } else {

          //不是则清空resultKind的KindOfObject类型

          resultKind &= ~KindOfObject;

        }

      }

    }

  }

 

  TypePtr res;

 

  // If there is overlap (for instance, they were the same, or we've narrowed

  // down something like Sequenece to be more specific), then return the

  // intersection of the types.

  if (resultKind) {

       //根据类型名称返回类型

    res = GetType(resultKind, resultName);

  } else if (from->mustBe(KindOfObject) && to->m_kindOf == KindOfPrimitive) {

     //from必须为对象类型,并且to的类型必须是string 或KindOfNumeric(不存在交集)

    // Special case Object -> Primitive: can we tostring it?

    //from名字不为空

    if (!from->m_name.empty()) {

                   //查找from的类,查找__tostring方法如果存在则返回ret为string

      ClassScopePtr cls = ar->findClass(from->m_name);

      if (cls && cls->findFunction(ar, "__tostring", true)) {

        res = Type::String;

      }

    }

 

    // Otherwise, return Int32

    res = Int32;

  } else if (from->m_kindOf == KindOfBoolean

             && to->mustBe(KindOfNumeric | KindOfArray | KindOfString)

             && !IsExactType(to->m_kindOf)) {

    res = Int32;

  } else {

    res = to;

  }

  //from 是boolean ,to是string 和KindOfNumeric 返回int32

  if (from->mustBe(KindOfBoolean) && to->m_kindOf == KindOfPrimitive) {

    res = Int32;

  }

 

  return res;

}

 

2.3.3.    Type::IsLegalCast

/* This new IsLegalCast returns true in a few cases where the old version

 * (which was basically a hardcoded truth table) returned false; it seems

 * like "true" is in fact the right thing to return. The cases that appear

 * when compiling www are:

 *   Sequence -> Array

 *   PlusOperand -> Array

 *   String -> PlusOperand

 *   Boolean -> PlusOperand

 */

//对比to和from类型是否相同

bool Type::IsLegalCast(AnalysisResultConstPtr ar, TypePtr from, TypePtr to) {

  if (!from->m_kindOf) return true;

 

  // since both 'from' and 'to' represent sets of types, we do

  // this by computing the set of types that we could possibly cast 'from'

  // to, and then determining whether that overlaps with 'to'.

  //给canCastTo加上boolean类型

  int canCastTo = KindOfBoolean | from->m_kindOf;

  //判断from类型中是否有void,如果存在则canCastTo加上void

  if (from->m_kindOf & KindOfVoid) canCastTo |= KindOfVoid;

 

  // Boolean, Numeric, and String can all be cast among each other

  //判断from中是否有boolean ,数字型和字符串,如果存在给canCastTo加上数字型和字符串

  if (from->m_kindOf & (KindOfBoolean | KindOfNumeric | KindOfString)) {

    canCastTo |= KindOfNumeric | KindOfString;

  }

  //判断from是否有对象型

  if (from->m_kindOf & KindOfObject) {

    // Objects can only cast to string if they have __tostring

    //名字为空,添加上string性

    if (from->m_name.empty()) {

      canCastTo |= KindOfString; // we don't know which class it is

    } else {

      //否则是类的对象类型,通过from名字查询cls

      ClassScopePtr cls = ar->findClass(from->m_name);

      if (!cls || cls->isRedeclaring() ||

          cls->findFunction(ar, "__tostring", true)) {

        canCastTo |= KindOfString;

      }

    }

 

    // can only cast between objects if there's a subclass relation

    //to 的类型包含object并且类型名字不为空,

    //并且from类型名字不为空,并且to的m_name不等于from的m_name

    if ((to->m_kindOf & KindOfObject)  && !to->m_name.empty() &&

        !from->m_name.empty() && to->m_name != from->m_name) {

        //查找类

      ClassScopePtr cls = ar->findClass(from->m_name);

           //类存在,并且类是重复的,将canCastTo的对象类型删除

      if (cls && (cls->isRedeclaring() ||

                  !cls->derivesFrom(ar, to->m_name, true, true))) {

        canCastTo &= ~KindOfObject;

      }

 

    }

  }

  //判断to 的类型是否在canCastTo中

  bool overlap = (to->m_kindOf & canCastTo);

  return overlap;

}

 

2.3.4.    Type::isStandardObject()

//标准的Object,不是特定的class类

bool Type::isStandardObject() const {

  return m_kindOf == KindOfObject && m_name.empty();

}

 

2.3.5.   Type::isSpecificObject()

//特殊的对象,kindof类型并且名字不为空,如class A ,这样类的类型就是

bool Type::isSpecificObject() const {

  return m_kindOf == KindOfObject && !m_name.empty();

}

 

                                   

2.3.6.   Type::isNonConvertibleType()

bool Type::isNonConvertibleType() const {

  return m_kindOf == KindOfObject || m_kindOf == KindOfArray;

}

  

2.3.7.   Type::isNoObjectInvolved()

//判断不是一个对象,如果为array或object则返回false

bool Type::isNoObjectInvolved() const {

  if (couldBe(KindOfObject)

   || couldBe(KindOfArray))

    return false;

  else

    return true;

}

 

 

2.3.8.   Type::InferredObject

//推导2个类的类型中返回类型

TypePtr Type::InferredObject(AnalysisResultConstPtr ar,

                             TypePtr type1,

                             TypePtr type2) {

  ASSERT(type1->m_kindOf == KindOfObject);

  ASSERT(type2->m_kindOf == KindOfObject);

 

  TypePtr resultType = Type::Object;

  // if they're the same, or we don't know one's name, then use

  // the other

  //type1和type2的类型名字相等或者type1的名字为空

  if (type1->m_name == type2->m_name || type1->m_name.empty()) {

       //赋值resultType的类型为type2

    resultType = type2;

  } else if (type2->m_name.empty()) {

    //type2类型名为空,将resultType的类型设置为type1

    resultType = type1;

  } else {

    // take the subclass

    //获取2个类型的类

    ClassScopePtr cls1 = ar->findClass(type1->m_name);

    ClassScopePtr cls2 = ar->findClass(type2->m_name);

    bool c1ok = cls1 && !cls1->isRedeclaring();

    bool c2ok = cls2 && !cls2->isRedeclaring();

 

    if (c1ok && cls1->derivesFrom(ar, type2->m_name, true, false)) {

      resultType = type1;

    } else if (c2ok && cls2->derivesFrom(ar, type1->m_name, true, false)) {

      resultType = type2;

    } else if (c1ok && c2ok && cls1->derivedByDynamic() &&

               cls2->derivesFromRedeclaring()) {

      resultType = type2;

    } else {

      resultType = type1;

    }

  }

  return resultType;

}

  

2.3.9.   Type::Inferred

/* We have inferred type1 and type2 as the actual types for the same

   expression.

   Check that the types are compatible (it cant be both a string and

   an integer, for example), and return the combined type. If they

   are not compatible, return a null pointer.

 */

 //判断2个类型是否一致

TypePtr Type::Inferred(AnalysisResultConstPtr ar,

                       TypePtr type1, TypePtr type2) {

  //判断type1或type2如果其中一个为空,返回另一个类型                     

  if (!type1) return type2;

  if (!type2) return type1;

  KindOf k1 = type1->m_kindOf;

  KindOf k2 = type2->m_kindOf;

 

  if (k1 == k2) {

       //k1 是object类型则返回推导类

    return k1 == KindOfObject ?

      Type:::InferredObject(ar, type1, type2) : type1;

  }

 

  // If one set is a subset of the other, return the subset.

  /*判断k1和k2谁是另一个类型的子集返回

         例k1 1111 k2 1011 ,那么k2是子集,k1包含k2,返回k2

    */

  if ((k1 & k2) == k1) return type1;

  if ((k1 & k2) == k2) return type2;

 

  // If one type must be numeric and the other might be, then assume numeric

  //type1 或type2中必须有一个是KindOfNumeric类型,并且另一个包含KindOfNumeric类型则返回某个type

  if (type1->mustBe(KindOfNumeric) && type2->couldBe(KindOfNumeric)) {

    return type1;

  }

  if (type2->mustBe(KindOfNumeric) && type1->couldBe(KindOfNumeric)) {

    return type2;

  }

 

  // Otherwise, take the intersection

  //如果是对象的返回对象类型

  int resultKind = type1->m_kindOf & type2->m_kindOf;

  if (resultKind == KindOfObject) {

    return Type::InferredObject(ar, type1, type2);

  }

  return resultKind ? GetType(resultKind) : TypePtr();

}

 

2.3.10.           Type::combinedArithmeticType

//数字运算的类型

/*

         t1 是Primitive,如果t2也是,如果t2>t1 返回t2否则t1;

         t1如果是double返回double否则是Numeric

         t2如果是double返回double否则是Numeric

         t1 或t2是Numeric 返回Numeric

         如果kind小于KindOfInt64 ,返回KindOfInt64

         否则都不符合返回空

*/

TypePtr Type::combinedArithmeticType(TypePtr t1, TypePtr t2) {

  KindOf kind = KindOfAny;

  //判断是否是array类型,是则返回空

  if (t1 && t1->is(Type::KindOfArray) ||

      t2 && t2->is(Type::KindOfArray)) {

    return TypePtr();

  }

  //Primitive是Numeric 和String的集合;

  //Numeric 是Double 和Integer的集合;

  //type1 是Primitive

  if (t1 && t1->isPrimitive()) {

       //t2也是Primitive

    if (t2 && t2->isPrimitive()) {

           //t2大于t1,返回t2 否则t1

           /*

                   例: t2:variant t1:int32  ,那么返回Variant

           */

      if (t2->getKindOf() > t1->getKindOf()) {

        kind = t2->getKindOf();

      } else {

        kind = t1->getKindOf();

      }

    } else if (t1->is(KindOfDouble)) {//t1是double返回double

      kind = KindOfDouble;

    } else {//否则返回Numeric

      kind = KindOfNumeric;

    }

  } else if (t2 && t2->isPrimitive()) {

    if (t2->is(KindOfDouble)) {

      kind = KindOfDouble;

    } else {

      kind = KindOfNumeric;

    }

  } else if ((t1 && t1->mustBe(KindOfNumeric)) ||

             (t2 && t2->mustBe(KindOfNumeric))) {

    kind = KindOfNumeric;

  }

 

  if (kind < KindOfInt64) {

    kind = KindOfInt64;

  }

 

  if (kind != KindOfAny) {

    return GetType(kind);

  }

 

  return TypePtr();

}

 

2.3.11.             输出cpp的类型转换的推导

2.3.11.1.       Type::getCPPDecl

/* 获取c++ 的输出类型*/

string Type::getCPPDecl(AnalysisResultConstPtr ar,

                        BlockScopeRawPtr scope,

                        CodeGenerator *cg /* = 0 */) {

  switch (m_kindOf) {

    case KindOfBoolean:     return "bool";

    case KindOfInt32:       return "int";

    case KindOfInt64:       return "int64";

    case KindOfDouble:      return "double";

    case KindOfString:      return "String";

    case KindOfArray:       return "Array";

    case KindOfObject:{

      ClassScopePtr cls(getClass(ar, scope));

      if (!cls) return "Object";

      if (cg && cg->isFileOrClassHeader() && scope) {

        if (scope->getContainingClass()) {

          scope->getContainingClass()->addUsedClassHeader(cls);

        } else if (scope->getContainingFile()) {

          scope->getContainingFile()->addUsedClassHeader(cls);

        }

      }

           //Option::SmartPtrPrefix=> p_      返回值为p_类名

      return Option::SmartPtrPrefix + cls->getId();

    }

    case KindOfNumeric:     return "Numeric";

    case KindOfPrimitive:   return "Primitive";

    case KindOfPlusOperand: return "PlusOperand";

    case KindOfSequence:    return "Sequence";

    default:

      return "Variant";

  }

}

  

2.3.11.2.       Type::getDataType()

获取数据类型的函数

DataType Type::getDataType() const {

  switch (m_kindOf) {

    case KindOfBoolean:     return HPHP::KindOfBoolean;

    case KindOfInt32:

    case KindOfInt64:       return HPHP::KindOfInt64;

    case KindOfDouble:      return HPHP::KindOfDouble;

    case KindOfString:      return HPHP::KindOfString;

    case KindOfArray:       return HPHP::KindOfArray;

    case KindOfObject:      return HPHP::KindOfObject;

    case KindOfNumeric:

    case KindOfPrimitive:

    case KindOfPlusOperand:

    case KindOfSequence:

    default:                return HPHP::KindOfUnknown;

  }

}

  

2.3.11.3.       Type::outputCPPDecl

//cpp输出声明类型

void Type::outputCPPDecl(CodeGenerator &cg, AnalysisResultConstPtr ar,

                         BlockScopeRawPtr scope) {

  cg_printf(getCPPDecl(ar, scope, &cg).c_str());

}

  

2.3.11.4.       Type::outputCPPFastObjectCast

/*

         Php对象输出cpp类对象 p_类名

*/

void Type::outputCPPFastObjectCast(CodeGenerator &cg,

    AnalysisResultConstPtr ar,

    BlockScopeRawPtr scope,

    bool isConst) {

  ASSERT(isSpecificObject());

  ClassScopePtr cls(getClass(ar, scope));

  ASSERT(cls);

  const string &cppClsName = cls->getId();

  /*

  Option::SmartPtrPrefix        const p_类名

  */

  cg_printf("(%s%s%s&)",

            isConst ? "const " : "",

            Option::SmartPtrPrefix,

            cppClsName.c_str());

}

 

 

2.3.11.5.       Type::outputCPPCast

/*

         Php对应cpp 输出相应类型

*/

void Type::outputCPPCast(CodeGenerator &cg, AnalysisResultConstPtr ar,

                         BlockScopeRawPtr scope) {

  switch (m_kindOf) {

    case KindOfBoolean:     cg_printf("toBoolean");   break;

    case KindOfInt32:       cg_printf("toInt32");     break;

    case KindOfInt64:       cg_printf("toInt64");     break;

    case KindOfDouble:      cg_printf("toDouble");    break;

    case KindOfString:      cg_printf("toString");    break;

    case KindOfArray:       cg_printf("toArray");     break;

    case KindOfNumeric:     cg_printf("Numeric");     break;

    case KindOfPrimitive:   cg_printf("Primitive");   break;

    case KindOfPlusOperand: cg_printf("PlusOperand"); break;

    case KindOfSequence:    cg_printf("Sequence");    break;

    case KindOfObject: {

      ClassScopePtr cls(getClass(ar, scope));

      if (!cls) {

        cg_printf("toObject");

      } else {

        cg_printf("%s%s", Option::SmartPtrPrefix, cls->getId().c_str());

      }

      break;

    }

    default:

      cg_printf("Variant");

      break;

  }

}

  

2.3.11.6.       Type::getCPPInitializer()

//cpp 类型初始化内容

const char *Type::getCPPInitializer() {

  switch (m_kindOf) {

  case KindOfBoolean:     return "false";

  case KindOfInt32:

  case KindOfInt64:       return "0";

  case KindOfNumeric:

  case KindOfPrimitive:

  case KindOfPlusOperand: return "0";

  case KindOfDouble:      return "0.0";

  default:                return NULL;

  }

}

 

2.3.12.             类型推导的类型

类型在type.h中,有如下的类型:

 

static const KindOf KindOfVoid       = 0x0001;

  static const KindOf KindOfBoolean    = 0x0002;

  static const KindOf KindOfInt32      = 0x0010;

  static const KindOf KindOfInt64      = 0x0020;

  static const KindOf KindOfDouble     = 0x0040;

  static const KindOf KindOfString     = 0x0080;

  static const KindOf KindOfArray      = 0x0100;

  static const KindOf KindOfObject     = 0x0200;   // with classname

  static const KindOf KindOfVariant    = 0xFFFF;

  /* This bit tells coerce that if the other type

     is already one of the specified types, it wont

     be modified.

     eg $a['foo'] = <whatever>

     If $a is already known to be string or array, it stays that way.

     If we coerce to Sequence, however, it would become Sequence, and

     hence Variant

  */

  static const KindOf KindOfAuto       = 0x0400;

  static const KindOf KindOfInteger = (KindOf)(KindOfInt64 | KindOfInt32);

  static const KindOf KindOfNumeric = (KindOf)(KindOfDouble | KindOfInteger);

  static const KindOf KindOfPrimitive = (KindOf)(KindOfNumeric | KindOfString);

  static const KindOf KindOfPlusOperand = (KindOf)(KindOfNumeric | KindOfArray);

  static const KindOf KindOfSequence = (KindOf)(KindOfString | KindOfArray);

  static const KindOf KindOfAutoSequence = (KindOf)(KindOfAuto |KindOfSequence);

  static const KindOf KindOfAutoObject = (KindOf)(KindOfAuto | KindOfObject);

  static const KindOf KindOfSome = (KindOf)0x7FFE;

  static const KindOf KindOfAny = (KindOf)0x7FFF;

  /**

   * Inferred types: types that a variable or a constant is sure to be.

   */

  static TypePtr Null;

  static TypePtr Boolean;

  static TypePtr Int32;

  static TypePtr Int64;

  static TypePtr Double;

  static TypePtr String;

  static TypePtr Array;

  static TypePtr Object;

  static TypePtr Variant;

  static TypePtr Numeric;

  static TypePtr PlusOperand;

  static TypePtr Primitive;

  static TypePtr Sequence;

  static TypePtr AutoSequence;

  static TypePtr AutoObject;

  static TypePtr Any;

  static TypePtr Some;

 

你可能感兴趣的:(C++,PHP,编译原理,hiphop,hhvm)