下面主要分析的是优化阶段和推导阶段的分析,前优化和后优化类似,所以就不具体再分析后优化;
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 处理流程
1.3. preOptimize 实例
例:$a=1+2*3+4
语法树:
(1)优化2*3 返回结果ScalarExpression(6),封装到上一级的BinaryOpExpression上
(2)优化1+6返回结果ScalarExpression(7),封装到上一级的BinaryOpExpression上
(3)优化1+6返回结果ScalarExpression(11),封装到上一级的AssignmentExpression上,最终把一颗大树优化为了一个赋值表达式
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;