static Void local drawClassRelations(HDC hDC)
{
Class cls;
for(cls=CLASSMIN; cls<classMax(); cls++) {
List supers;
for(supers=cclass(cls).supers; nonNull(supers); supers=tl(supers)) {
Class parent = getHead(hd(supers));
if (isClass(parent)) {
if (parent == cls) { /* child of itself - draw an arc */
Class source = findClassInNodes(cls);
Arc(hDC, Nodes[source].Pos.right-5, Nodes[source].Pos.bottom-5,
Nodes[source].Pos.right+15, Nodes[source].Pos.bottom+20,
Nodes[source].Pos.right-5, Nodes[source].Pos.bottom-5,
Nodes[source].Pos.right-4, Nodes[source].Pos.bottom-4);
} else { /* Join the two classes with a line */
Class source = findClassInNodes(parent);
Class target = findClassInNodes(cls);
INT sx = Nodes[source].Pos.right + 4;
INT sy = Nodes[source].Pos.top
+ (Nodes[source].Pos.bottom - Nodes[source].Pos.top)/2;
INT tx = Nodes[target].Pos.left - 4;
INT ty = Nodes[target].Pos.top
+ (Nodes[target].Pos.bottom - Nodes[target].Pos.top)/2;
MoveToEx(hDC, sx, sy,NULL);
LineTo(hDC, tx, ty);
}
}
}
}
}
IntentTag blankIntentForType(Type* t) {
if (isSyncType(t) ||
isAtomicType(t) ||
t->symbol->hasFlag(FLAG_ARRAY)) {
return INTENT_REF;
} else if (is_bool_type(t) ||
is_int_type(t) ||
is_uint_type(t) ||
is_real_type(t) ||
is_imag_type(t) ||
is_complex_type(t) ||
is_enum_type(t) ||
is_string_type(t) ||
t == dtStringC ||
t == dtStringCopy ||
isClass(t) ||
isRecord(t) ||
isUnion(t) ||
t == dtTaskID ||
t == dtFile ||
t == dtTaskList ||
t == dtNil ||
t == dtOpaque ||
t->symbol->hasFlag(FLAG_DOMAIN) ||
t->symbol->hasFlag(FLAG_DISTRIBUTION) ||
t->symbol->hasFlag(FLAG_EXTERN)) {
return constIntentForType(t);
}
INT_FATAL(t, "Unhandled type in blankIntentForType()");
return INTENT_BLANK;
}
bool Item::isCallable() const
{
if ( isClass() || isFunction() || isMethod() )
return true;
if( isObject() )
{
return asObjectSafe()->hasProperty( OVERRIDE_OP_CALL );
}
//a bit more complex: a callable array...
if( type() == FLC_ITEM_ARRAY )
{
CoreArray& arr = *asArray();
if ( arr.length() > 0 )
{
// avoid infinite recursion.
// even if arr[0] is not an array, the check is harmless, as we check by ptr value.
return arr[0].asArray() != &arr && arr[0].isCallable();
}
}
// in all the other cases, the item is not callable
return false;
}
void NonPrivateMemberVariablesInClassesCheck::registerMatchers(
MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
// We can ignore structs/classes with all member variables being public.
auto ShouldIgnoreRecord =
allOf(boolean(IgnoreClassesWithAllMemberVariablesBeingPublic),
unless(hasNonPublicMemberVariable()));
// There are three visibility types: public, protected, private.
// If we are ok with public fields, then we only want to complain about
// protected fields, else we want to complain about all non-private fields.
// We can ignore public member variables in structs/classes, in unions.
auto InterestingField = fieldDecl(
IgnorePublicMemberVariables ? isProtected() : unless(isPrivate()));
// We only want the records that not only contain the mutable data (non-static
// member variables), but also have some logic (non-static member functions).
// We may optionally ignore records where all the member variables are public.
Finder->addMatcher(cxxRecordDecl(anyOf(isStruct(), isClass()), hasMethods(),
hasNonStaticMethod(),
unless(ShouldIgnoreRecord),
forEach(InterestingField.bind("field")))
.bind("record"),
this);
}
static IntentTag constIntentForType(Type* t) {
if (isSyncType(t) ||
isRecordWrappedType(t) || // domain, array, or distribution
isRecord(t) || // may eventually want to decide based on size
is_string_type(t)) {
return INTENT_CONST_REF;
} else if (is_bool_type(t) ||
is_int_type(t) ||
is_uint_type(t) ||
is_real_type(t) ||
is_imag_type(t) ||
is_complex_type(t) ||
is_enum_type(t) ||
isClass(t) ||
isUnion(t) ||
isAtomicType(t) ||
t == dtOpaque ||
t == dtTaskID ||
t == dtFile ||
t == dtTaskList ||
t == dtNil ||
t == dtStringC ||
t == dtStringCopy ||
t->symbol->hasFlag(FLAG_EXTERN)) {
return INTENT_CONST_IN;
}
INT_FATAL(t, "Unhandled type in constIntentForType()");
return INTENT_CONST;
}
static void create_arg_bundle_class(FnSymbol* fn, CallExpr* fcall, ModuleSymbol* mod, BundleArgsFnData &baData) {
INT_ASSERT(!baData.ctype);
SET_LINENO(fn);
// Here, 'fcall' is the first of fn's callees and so it acts as a
// representative of all the other callees, if any.
// As of this writing, this should be OK because the callees are
// obtained by duplicating the original call, which resulted in
// outlining a block into 'fn' and so is unique.
// To eliminate 'fcall' in create_arg_bundle_class(), we need
// to rely on fn's formal types instead of fcall's actual types.
// create a new class to capture refs to locals
AggregateType* ctype = new AggregateType(AGGREGATE_CLASS);
TypeSymbol* new_c = new TypeSymbol(astr("_class_locals", fn->name), ctype);
new_c->addFlag(FLAG_NO_OBJECT);
new_c->addFlag(FLAG_NO_WIDE_CLASS);
// add the function args as fields in the class
int i = 0; // Fields are numbered for uniqueness.
for_actuals(arg, fcall) {
SymExpr *s = toSymExpr(arg);
Symbol *var = s->var; // arg or var
if (var->type->symbol->hasFlag(FLAG_REF) || isClass(var->type))
// Only a variable that is passed by reference out of its current scope
// is concurrently accessed -- which means that it has to be passed by
// reference.
var->addFlag(FLAG_CONCURRENTLY_ACCESSED);
VarSymbol* field = new VarSymbol(astr("_", istr(i), "_", var->name), var->type);
ctype->fields.insertAtTail(new DefExpr(field));
i++;
}
static void
genClassIDs(Vec<TypeSymbol*> & typeSymbols) {
genComment("Class Type Identification Numbers");
int count=0;
forv_Vec(TypeSymbol, ts, typeSymbols) {
if (AggregateType* ct = toAggregateType(ts->type)) {
if (!isReferenceType(ct) && isClass(ct)) {
genGlobalDefClassId(ts->cname, count);
count++;
}
}
}
}
void Tree::useNamespace(
const Identifier& namespaceName,
const Location& location) {
NameBindings& currentNamespace = getCurrentNameBindings();
auto namespaceDefinition = currentNamespace.lookupType(namespaceName);
if (namespaceDefinition == nullptr) {
Trace::error("Unknown namespace: " + namespaceName, location);
}
assert(namespaceDefinition->isClass());
auto classDef = namespaceDefinition->cast<ClassDefinition>();
currentNamespace.use(classDef->getNameBindings());
}
void Lexer::compile() {
if( isCompiled() )
throw AlreadyCompiledException();
createTable_();
foreach(Rule &r, rules_) {
assert( r.inState != S_UNCHANGED );
assert( isValidInput(r.input) );
assert( r.action.toState != S_UNCHANGED );
if( isClass(r.input) ) {
String& cl = getClass_(r.input);
foreach( char ch, cl )
getAction_(r.inState, ch) = r.action;
} else if( r.input == I_DEFAULT )
// Build a map from Symbols to ConstInfo. This is somewhat like
// buildDefUseMaps, except we don't want to put defs and uses in different
// lists (for simplicity).
//
// TODO: Can we use for_SymbolSymExprs here instead?
forv_Vec(SymExpr, se, gSymExprs) {
if (!(isVarSymbol(se->symbol()) || isArgSymbol(se->symbol()))) continue;
// TODO: BHARSH: Skip classes for now. Not sure how to deal with aliasing
if (!se->isRef() && isClass(se->typeInfo())) continue;
ConstInfo* info = NULL;
ConstInfoIter it = infoMap.find(se->symbol());
if (it == infoMap.end()) {
info = new ConstInfo(se->symbol());
infoMap[se->symbol()] = info;
} else {
info = it->second;
}
info->todo.push_back(se);
}
jclass
inStream_readClassRef(PacketInputStream *stream)
{
jobject object = inStream_readObjectRef(stream);
if (object == NULL) {
/*
* Could be error or just the null reference. In either case,
* stop now.
*/
return NULL;
}
if (!isClass(object)) {
stream->error = JDWP_ERROR(INVALID_CLASS);
return NULL;
}
return object;
}
SymbolMap CursorInfo::allReferences(const Location &loc, const SymbolMap &map, const SymbolMap *errors) const
{
SymbolMap ret;
Mode mode = NormalRefs;
switch (kind) {
case CXCursor_Constructor:
case CXCursor_Destructor:
mode = ClassRefs;
break;
case CXCursor_CXXMethod:
mode = VirtualRefs;
break;
default:
mode = isClass() ? ClassRefs : VirtualRefs;
break;
}
allImpl(map, errors, loc, *this, ret, mode, kind);
return ret;
}
// Is this type OK to pass by value (e.g. it's reasonably-sized)?
static bool
passableByVal(Type* type) {
if (is_bool_type(type) ||
is_int_type(type) ||
is_uint_type(type) ||
is_real_type(type) ||
is_imag_type(type) ||
is_complex_type(type) ||
is_enum_type(type) ||
isClass(type) ||
type == dtTaskID ||
// For now, allow ranges as a special case, not records in general.
type->symbol->hasFlag(FLAG_RANGE) ||
0)
return true;
// TODO: allow reasonably-sized records. NB this-in-taskfns-in-ctors.chpl
// TODO: allow reasonably-sized tuples - heterogeneous and homogeneous.
return false;
}
IntentTag blankIntentForType(Type* t) {
IntentTag retval = INTENT_BLANK;
if (isSyncType(t) ||
isAtomicType(t) ||
t->symbol->hasFlag(FLAG_DEFAULT_INTENT_IS_REF) ||
t->symbol->hasFlag(FLAG_ARRAY)) {
retval = INTENT_REF;
} else if (is_bool_type(t) ||
is_int_type(t) ||
is_uint_type(t) ||
is_real_type(t) ||
is_imag_type(t) ||
is_complex_type(t) ||
is_enum_type(t) ||
t == dtStringC ||
t == dtStringCopy ||
t == dtCVoidPtr ||
t == dtCFnPtr ||
isClass(t) ||
isRecord(t) ||
isUnion(t) ||
t == dtTaskID ||
t == dtFile ||
t == dtNil ||
t == dtOpaque ||
t->symbol->hasFlag(FLAG_DOMAIN) ||
t->symbol->hasFlag(FLAG_DISTRIBUTION) ||
t->symbol->hasFlag(FLAG_EXTERN)) {
retval = constIntentForType(t);
} else {
INT_FATAL(t, "Unhandled type in blankIntentForType()");
}
return retval;
}
//
// Assumes 'parent' is a PRIM_MOVE or PRIM_ASSIGN
//
// Returns false if the LHS of the move/assign indicates that the rhs cannot
// be a const-ref. For example, if we have a case like this:
//
// (move A, (set-reference B))
//
// where 'A' and 'B' are references, B cannot be a const-ref if A is not a
// const-ref.
//
// In the case of a dereference, (move A, (deref B)), this function will return
// true because we're simply reading B.
//
static bool canRHSBeConstRef(CallExpr* parent, SymExpr* use) {
INT_ASSERT(isMoveOrAssign(parent));
SymExpr* LHS = toSymExpr(parent->get(1));
CallExpr* rhs = toCallExpr(parent->get(2));
INT_ASSERT(rhs);
switch (rhs->primitive->tag) {
case PRIM_GET_MEMBER_VALUE:
case PRIM_GET_SVEC_MEMBER_VALUE:
if (LHS->isRef() == false &&
isClass(LHS->typeInfo()) == false) {
return true;
}
// fallthrough
case PRIM_GET_MEMBER:
case PRIM_GET_SVEC_MEMBER:
case PRIM_GET_REAL:
case PRIM_GET_IMAG:
case PRIM_ADDR_OF:
case PRIM_SET_REFERENCE: {
// If LHS is a reference and is not a const-ref, the reference in 'rhs'
// should not be considered a const-ref either.
//
// For the get-member primitives, I intend this to be a safe approach
// until we know what const-ref means for fields. Basically, if any field
// might be modified I do not consider the base object to be const-ref.
//
// Note that the get-*-value primitives may return a reference if the
// field is a reference.
if (LHS->isRef()) {
return inferConstRef(LHS->symbol());
}
}
default:
break;
}
return isSafeRefPrimitive(use);
}
Any Serializer::deserializeUnknownTable()
{
lua_getfield(L, -1, "class");
auto type = lua_type(L, -1);
if (type == LUA_TSTRING)
{
std::string typeName = lua_tostring(L, -1);
lua_pop(L, 1);
for (auto type : Meta::getInstance()->types)
{
if (type->name == typeName)
{
if (type->isClass())
{
auto classMeta = static_cast<IClassMeta*>(type);
return deserializeAsClass(classMeta);
}
}
}
}
return Any::empty;
}
bool LayoutConstraintInfo::isRefCounted(LayoutConstraintKind Kind) {
return isAnyRefCountedObject(Kind) || isClass(Kind);
}