@Override public boolean equals(Object o) { if (this == o) { return true; } if (o instanceof CsmType) { CsmType t = (CsmType) o; return clazz.equals(t.getClassifier()) && arrayDepth == t.getArrayDepth() && pointerDepth == t.getPointerDepth() && _const == t.isConst(); } return false; }
@Override public CharSequence getClassifierText() { return delegate.getClassifierText(); }
@Override public CharSequence getText() { return delegate.getText(); }
static int getReferenceValue(CsmType type) { if (type.isRValueReference()) { return 2; } else if (type.isReference()) { return 1; } return 0; } }
private final static CsmInstantiation tryGetInstantiation(CsmType type) { // This is a hack to detect class BaseType if (!type.isInstantiation() && type.getStartPosition() == null && type.getEndPosition() == null) { CsmClassifier cls = type.getClassifier(); return CsmKindUtilities.isInstantiation(cls) ? (CsmInstantiation) cls : null; } return null; }
@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; } }
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(); }
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()); } }
if (findType || !last) { boolean inner = false; int ad = lastType.getArrayDepth(); if (staticOnly && ad == 0) { // can be inner class CsmType nestedType = findNestedType(lastType, var, endOffset); if (cls != null) { if (item.getParameterCount() == 2) { // index in array follows int ptrDepth = lastType.getPointerDepth(); int arrDepth = lastType.getArrayDepth(); int ref = getReferenceValue(lastType); lastType = CsmCompletion.createType(cls, ptrDepth, ref, arrDepth, lastType.isConst()); } else if (ptrDepth > 0) { ptrDepth--; lastType = CsmCompletion.createType(cls, ptrDepth, ref, arrDepth, lastType.isConst()); } else { CsmFunction opArray = CsmCompletionQuery.getOperator(cls, contextFile, endOffset, CsmFunction.OperatorKind.ARRAY); lastType = CsmCompletion.createType(cls, lastType.getPointerDepth(), getReferenceValue(lastType), lastType.getArrayDepth() + 1, lastType.isConst()); cont = true; if (typ != null) { typ = CsmUtilities.iterateTypeChain(typ, new CsmUtilities.SearchTemplatePredicate()); CsmClassifier cls = typ.getClassifier(); if (CsmKindUtilities.isSpecialization(cls)) { Collection<CsmOffsetableDeclaration> baseTemplateCandidates = CsmInstantiationProvider.getDefault().getBaseTemplate(cls);
public static boolean isAssignable(CsmType from, CsmType to) { CsmClassifier fromCls = from.getClassifier(); CsmClassifier toCls = to.getClassifier(); return to.getArrayDepth() > 0 || !CsmCompletion.isPrimitiveClass(toCls); return (from.getArrayDepth() > to.getArrayDepth()) || (from.getArrayDepth() == to.getArrayDepth() && !CsmCompletion.isPrimitiveClass(fromCls)); if (canBePointer(from) && to.isPointer()) { return true; if (from.isPointer() && canBePointer(to)) { return true; if (from.getArrayDepth() != to.getArrayDepth() || from.getPointerDepth() != to.getPointerDepth()) { return false; return true; // equal classes String tfrom = from.getCanonicalText().toString().replaceAll("const", "").trim(); // NOI18N String tto = to.getCanonicalText().toString().replaceAll("const", "").trim(); // NOI18N
@Override public CsmClassifier getClassifier() { return delegate.getClassifier(); }
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 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; }
if (!CsmKindUtilities.isConstructor(item) && !CsmKindUtilities.isDestructor(item)) { final CsmType returnType = ((CsmFunction)item).getReturnType(); type = returnType.getText().toString()+" "; //NOI18N if (!returnType.isTemplateBased()) { if (type.indexOf("::") < 0) { //NOI18N CsmClassifier classifier = returnType.getClassifier(); if (classifier != null) { String toReplace = classifier.getName().toString();
protected CsmClassifier getCastOperatorCastEntity(CsmFunction operator) { assert CsmKindUtilities.isCastOperator(operator) : "Must be cast operator!"; // NOI18N CsmType retType = operator.getReturnType(); CsmClassifier castClassifier = retType != null ? CsmClassifierResolver.getDefault().getTypeClassifier(retType, retType.getContainingFile(), retType.getStartOffset(), true) : null; if (!checkResolvedClassifier(castClassifier) || (CsmKindUtilities.isTemplateParameter(castClassifier) && !retType.isTemplateBased())) { retType = CsmExpressionResolver.resolveType(retType.getText(), retType.getContainingFile(), retType.getStartOffset(), null); castClassifier = retType != null ? CsmClassifierResolver.getDefault().getTypeClassifier(retType, retType.getContainingFile(), retType.getStartOffset(), true) : null; } if (!checkResolvedClassifier(castClassifier)) { castClassifier = null; } return castClassifier; }
private static boolean isPointer(CsmType type) { int iteration = MAX_DEPTH; while (type != null && iteration != 0) { if (CsmKindUtilities.isFunctionPointerType(type)) { return (type.getPointerDepth() > 0); } if (type.isPointer()) { return true; } CsmClassifier cls = type.getClassifier(); if (CsmKindUtilities.isTypedef(cls) || CsmKindUtilities.isTypeAlias(cls)) { CsmTypedef td = (CsmTypedef) cls; type = td.getType(); } else { break; } iteration--; } return false; }
public int compareTo(Object o) { if (this == o) { return 0; } CsmType t = (CsmType) o; int order = clazz.getQualifiedName().toString().compareTo(t.getClassifier().getQualifiedName().toString()); if (order == 0) { order = arrayDepth - t.getArrayDepth(); } return order; }
@Override public boolean isConst() { return delegate.isConst(); }
@Override public CharSequence getCanonicalText() { return delegate.getCanonicalText(); }
@Override public int getArrayDepth() { return type.getArrayDepth(); }