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);
}
}
return Option::SmartPtrPrefix + cls->getId();
}
case KindOfNumeric: return "Numeric";
case KindOfPrimitive: return "Primitive";
case KindOfPlusOperand: return "PlusOperand";
case KindOfSequence: return "Sequence";
default:
return "Variant";
}
}
void Type::outputCPPDecl(CodeGenerator &cg, AnalysisResultConstPtr ar,
BlockScopeRawPtr scope) {
cg_printf(getCPPDecl(cg, ar, scope).c_str());
if (isSpecificObject() && cg.isFileOrClassHeader() && scope) {
if (scope->getContainingClass()) {
scope->getContainingClass()->addUsedClassHeader(m_name);
} else if (scope->getContainingFile()) {
scope->getContainingFile()->addUsedClassHeader(m_name);
}
}
}
static inline void DumpScope(BlockScopeRawPtr scope, const char *prefix,
bool newline = true) {
assert(scope->is(BlockScope::FunctionScope) ||
scope->is(BlockScope::ClassScope));
const char *type = scope->is(BlockScope::FunctionScope) ?
"function" : "class";
std::cout << prefix << type << " " << scope->getName() << " @ "
<< scope->getContainingFile()->getName();
if (newline) std::cout << std::endl;
}
ClassScopePtr StaticClassName::resolveClass() {
m_present = false;
m_unknown = true;
if (m_class) return ClassScopePtr();
BlockScopeRawPtr scope = originalScope(this);
if (m_self) {
if (ClassScopePtr self = scope->getContainingClass()) {
m_className = self->getName();
m_origClassName = self->getOriginalName();
m_present = true;
m_unknown = false;
return self;
}
} else if (m_parent) {
if (ClassScopePtr self = scope->getContainingClass()) {
if (!self->getOriginalParent().empty()) {
m_className = Util::toLower(self->getOriginalParent());
m_origClassName = self->getOriginalParent();
m_present = true;
}
} else {
m_parent = false;
}
}
ClassScopePtr cls = scope->getContainingProgram()->findClass(m_className);
if (cls) {
m_unknown = false;
if (cls->isVolatile()) {
ClassScopeRawPtr c = scope->getContainingFile()->resolveClass(cls);
if (!c) {
c = scope->getContainingClass();
if (c && c->getName() != m_className) c.reset();
}
m_present = c.get() != 0;
if (cls->isRedeclaring()) {
cls = c;
if (!m_present) m_redeclared = true;
}
} else {
m_present = true;
}
}
return cls;
}
bool StaticClassName::checkPresent() {
if (m_self || m_parent || m_static) return true;
BlockScopeRawPtr scope = originalScope(this);
FileScopeRawPtr currentFile = scope->getContainingFile();
if (currentFile) {
AnalysisResultPtr ar = currentFile->getContainingProgram();
ClassScopeRawPtr cls = ar->findClass(m_className);
if (!cls) return false;
if (!cls->isVolatile()) return true;
if (currentFile->resolveClass(cls)) return true;
if (currentFile->checkClass(m_className)) return true;
}
if (ClassScopePtr self = scope->getContainingClass()) {
if (m_className == self->getName() ||
self->derivesFrom(scope->getContainingProgram(), m_className,
true, false)) {
return true;
}
}
return false;
}
