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); }