@Override public int getPointerDepth() { return type.getPointerDepth(); }
@Override public int getPointerDepth() { return delegate.getPointerDepth(); }
@Override public int getPointerDepth() { return type.getPointerDepth(); }
@Override public int getPointerDepth() { if (instantiationHappened()) { return instantiatedType.getPointerDepth(); } else { return originalType.getPointerDepth(); } }
@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 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; } }
public CharSequence decorateText(CharSequence classifierText, CsmType decorator, boolean canonical, CharSequence variableNameToInsert) { if (decorator.isConst() || decorator.getPointerDepth() > 0 || decorator.isReference() || decorator.getArrayDepth() > 0 || variableNameToInsert != null) { for( int i = 1; i <= decorator.getPointerDepth(); i++ ) { sb.append('*'); if (isConst(i)) {
if (!isAssignable(t, mpt)) { if (CsmKindUtilities.isTemplateParameterType(mpt)) { if (mpt.getArrayDepth() + mpt.getPointerDepth() <= t.getArrayDepth() + t.getPointerDepth()) { matched++; } else {
from.getPointerDepth() != to.getPointerDepth()) { return false;
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; }
match += 1; if (((CsmType)declSpecFunType).getPointerDepth() == ((CsmType)paramFunType).getPointerDepth()) { match += 1;
newType = templateParamResolver.resolveTemplateParameterType(type, instantiation); if (newType != null) { int pointerDepth = (newType != origType ? newType.getPointerDepth() + origType.getPointerDepth() : origType.getPointerDepth()); int arrayDepth = (newType != origType ? newType.getArrayDepth() + origType.getArrayDepth() : origType.getArrayDepth());
varType = CsmCompletion.createType( varType.getClassifier(), oldType.getPointerDepth() + varType.getPointerDepth(), Math.max(getReferenceValue(oldType), getReferenceValue(varType)), oldType.getArrayDepth() + varType.getArrayDepth(), oldType.getPointerDepth() + varType.getPointerDepth(), Math.max(getReferenceValue(oldType), getReferenceValue(varType)), oldType.getArrayDepth() + varType.getArrayDepth(), oldType.getPointerDepth() + varType.getPointerDepth(), Math.max(getReferenceValue(oldType), getReferenceValue(varType)), oldType.getArrayDepth() + (varType.getArrayDepth() - 1),
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); }
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(); }
type = new DeclTypeImpl(typeStart, file, scope, pointerDepth, refence, arrayDepth, TypeImpl.initConstQualifiers(ast), TypeImpl.getStartOffset(ast), TypeImpl.getEndOffset(ast, inFunctionParameters)); } else if (parent != null) { type = NestedType.create(parent, file, parent.getPointerDepth(), getReferenceValue(parent), parent.getArrayDepth(), parent.isConst(), parent.getStartOffset(), parent.getEndOffset()); } else if (TypeFunPtrImpl.isFunctionPointerParamList(asts, inFunctionParameters, inTypedef)) { type = new TypeFunPtrImpl(file, returnTypePointerDepth, refence, arrayDepth, TypeImpl.initIsConst(ast), TypeImpl.getStartOffset(ast), TypeFunPtrImpl.getEndOffset(ast));
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, lastType.getPointerDepth(), getReferenceValue(lastType), lastType.getArrayDepth() + 1, lastType.isConst()); cont = true; CsmType lastNestedType = CsmUtilities.iterateTypeChain(lastType, new CsmUtilities.ConstantPredicate<CsmType>(false)); int ptrDepth = lastNestedType.getPointerDepth(); if (ptrDepth > 0 && opKind == CsmFunction.OperatorKind.POINTER) { ptrDepth--; if(lastType != null) { int ref = getReferenceValue(lastType); int ptrLevel = lastType.getPointerDepth(); if (item.getTokenCount() > 0) { switch (item.getTokenID(0)) {
returnType.getPointerDepth() - 1, TypeFactory.getReferenceValue(returnType), returnType.getArrayDepth(),