@Override public boolean isReference() { return type.isReference(); }
@Override public boolean isReference() { return type.isReference(); }
@Override public boolean isReference() { return delegate.isReference(); }
@Override public boolean isReference() { if(instantiationHappened()) { return originalType.isReference() || instantiatedType.isReference(); } else { return originalType.isReference(); } }
static int getReferenceValue(CsmType type) { if (type.isRValueReference()) { return 2; } else if (type.isReference()) { return 1; } return 0; } }
public boolean isReference(List<CsmInstantiation> instantiations) { CsmType type = resolve(); return type != null ? type.isReference() : false; }
private boolean isCopyConstructor(CsmClass cls, CsmConstructor constructor) { Collection<CsmParameter> parameters = constructor.getParameters(); if (parameters.size() == 1) { CsmParameter p = parameters.iterator().next(); CsmType paramType = p.getType(); if (paramType.isReference()) { if (cls.equals(paramType.getClassifier())) { return true; } } } return false; } }
private boolean isCopyConstructor(CsmClass cls, CsmConstructor constructor) { Collection<CsmParameter> parameters = constructor.getParameters(); if (parameters.size() == 1) { CsmParameter p = parameters.iterator().next(); CsmType paramType = p.getType(); if (paramType.isReference()) { if (cls.equals(paramType.getClassifier())) { return true; } } } return false; } }
private boolean isCopyConstructor(CsmClass cls, CsmConstructor constructor) { Collection<CsmParameter> parameters = constructor.getParameters(); if (parameters.size() == 1) { CsmParameter p = parameters.iterator().next(); CsmType paramType = p.getType(); if (paramType.isReference()) { if (cls.equals(paramType.getClassifier())) { return true; } } } return false; } }
private static boolean isReferenceImpl(CsmType type, List<CsmInstantiation> instantiations) { if (type instanceof Decltype) { return ((Decltype) type).isReference(instantiations); } else if (type instanceof DeclTypeImpl) { return ((DeclTypeImpl) type).isReference(instantiations); } else { return type.isReference(); } }
static int getReferenceValue(CsmType type) { return getReferenceValue(type.isReference(), type.isRValueReference()); }
@Override public boolean check(CsmType value) { if (value.isReference()) { if (value.isRValueReference()) { qualificators.add(Qualificator.RVALUE_REFERENCE); } else { qualificators.add(Qualificator.REFERENCE); } } for (int i = 0; i < value.getArrayDepth(); i++) { qualificators.add(Qualificator.ARRAY); } for (int i = 0; i < value.getPointerDepth(); i++) { qualificators.add(Qualificator.POINTER); } if (value.isConst()) { qualificators.add(Qualificator.CONST); } return false; } }
@Override public CharSequence decorateText(CharSequence classifierText, CsmType decorator, boolean canonical, CharSequence variableNameToInsert) { StringBuilder sb = new StringBuilder(); if (decorator.isConst()) { sb.append("const "); // NOI18N } sb.append(getReturnType().getText()); sb.append('('); for (int i = 0; i < functionPointerDepth; i++) { sb.append('*'); if (variableNameToInsert != null) { sb.append(variableNameToInsert); } } if (decorator.isReference()) { sb.append('&'); } for( int i = 0; i < decorator.getArrayDepth(); i++ ) { sb.append("[]"); // NOI18N } sb.append(')'); InstantiationProviderImpl.appendParametersSignature(getParameters(), sb); return sb; }
public CharSequence decorateText(CharSequence classifierText, CsmType decorator, boolean canonical, CharSequence variableNameToInsert) { if (decorator.isConst() || decorator.getPointerDepth() > 0 || decorator.isReference() || decorator.getArrayDepth() > 0 || variableNameToInsert != null) { StringBuilder sb = new StringBuilder(); } else if( decorator.isReference() ) { sb.append('&');
public static void scanForFieldsAndConstructors(final CsmClass clsPath, final Set<CsmField> shouldBeInitializedFields, final Set<CsmField> mayBeIninitializedFields, final Set<CsmField> cannotBeInitializedFields, final List<CsmConstructor> constructors) { for (CsmMember member : clsPath.getMembers()) { if (CsmKindUtilities.isField(member)) { CsmField field = (CsmField) member; if (field.isStatic()) { continue; } CsmType type = field.getType(); if (type.getArrayDepth() > 0) { cannotBeInitializedFields.add(field); continue; } if (type.isConst() || type.isReference()) { shouldBeInitializedFields.add(field); continue; } mayBeIninitializedFields.add(field); } else if (CsmKindUtilities.isConstructor(member)) { constructors.add((CsmConstructor)member); } } } //
private static int checkReference(CsmType type) { int iteration = MAX_DEPTH; while (type != null && iteration != 0) { if (type.isReference()) { if (type.isRValueReference()) { return 2; } return 1; } CsmClassifier cls = type.getClassifier(); if (CsmKindUtilities.isTypedef(cls) || CsmKindUtilities.isTypeAlias(cls)) { CsmTypedef td = (CsmTypedef) cls; type = td.getType(); } else { break; } iteration--; } return 0; }
public static CsmType createType(CsmType type, int pointerDepth, int reference, int arrayDepth, boolean _const) { if(type.getPointerDepth() == pointerDepth && type.isReference() == (reference > 0) && type.isRValueReference() == (reference == 2) && type.getArrayDepth() == arrayDepth && type.isConst() == _const) { return type; } if(type instanceof NestedType) { return new NestedType((NestedType)type, pointerDepth, reference, arrayDepth, _const); } if(type instanceof TypeFunPtrImpl) { return new TypeFunPtrImpl((TypeFunPtrImpl)type, pointerDepth, reference, arrayDepth, _const); } if(type instanceof TemplateParameterTypeImpl) { return new TemplateParameterTypeImpl((TemplateParameterTypeImpl)type, pointerDepth, reference, arrayDepth, _const); } if(type instanceof TypeImpl) { return new TypeImpl((TypeImpl)type, pointerDepth, reference, arrayDepth, _const); } if (type instanceof CsmTemplateParameterType) { return new TemplateParameterTypeWrapper(type, pointerDepth, reference, arrayDepth, _const); } return new TypeWrapper(type, pointerDepth, reference, arrayDepth, _const); }
public static int getSizeOfType(CsmType type, CsmFile context) { if (!CsmBaseUtilities.isValid(type)) { return SIZEOF_UNKNOWN; } if (type.isReference()) { return getSizeOfReference(type.getContainingFile()); } else if (type.isPointer()) { return getSizeOfPointer(type.getContainingFile()); } else if (type.getArrayDepth() > 0) { // TODO: all arrays have size of classifier*2 until TypeImpl will store its array definition expression CsmClassifier cls = type.getClassifier(); return getSizeOfClassifier(cls, type.getContainingFile()); } else { CsmClassifier cls = type.getClassifier(); return getSizeOfClassifier(cls, type.getContainingFile()); } }
public static boolean isInObject(CsmObject obj, int offset) { if (!CsmKindUtilities.isOffsetable(obj)) { return false; } CsmOffsetable offs = (CsmOffsetable)obj; if ((offs.getStartOffset() <= offset) && (offset <= offs.getEndOffset())) { if (CsmKindUtilities.isNamespaceDefinition(obj)) { CsmNamespaceDefinition nsd = (CsmNamespaceDefinition) obj; // return false if we're not inside the namespace scope if (offset <= CsmObjectAttributeQuery.getDefault().getLeftBracketOffset(nsd)) { return false; } } if (offset == offs.getEndOffset()) { if (CsmKindUtilities.isType(obj)) { CsmType type = (CsmType)obj; // we do not accept type if offset is after '*', '&' or '[]' return !type.isPointer() && !type.isReference() && (type.getArrayDepth() == 0); } else if (endsWithBrace(offs)) { // if we right after closed "}" it means we are out of scope object return false; } } return true; } else { return false; } }
TypeImpl(CsmType type) { super(type.getContainingFile(), type.getStartOffset(), type.getEndOffset()); this.pointerDepth = (byte) type.getPointerDepth(); this.constQualifiers = type.isConst() ? 1 : 0; setFlags(FLAGS_REFERENCE, type.isReference()); this.arrayDepth = (byte) type.getArrayDepth(); setFlags(FLAGS_CONST, type.isConst()); if (type instanceof TypeImpl) { TypeImpl ti = (TypeImpl) type; setFlags(FLAGS_TYPE_OF_TYPEDEF, ti.isTypeOfTypedef()); setFlags(FLAGS_TYPE_WITH_CLASSIFIER, ti.isTypeWithClassifier()); this.classifierUID = ti.classifierUID; this.qname = ti.qname; this.classifierText = ti.classifierText; addAllInstantiationParams(ti.instantiationParams); } trimInstantiationParams(); }