@Override public int getArrayDepth() { return type.getArrayDepth(); }
@Override public int getArrayDepth() { return type.getArrayDepth(); }
@Override public int getArrayDepth() { return delegate.getArrayDepth(); }
private CsmClassifier extractTypeClassifier(CsmType type, ExprKind expKind) { if (type != null) { CsmClassifier cls; if (type.getArrayDepth() == 0 || (expKind == ExprKind.ARROW)) { // Not array or deref array with arrow cls = getClassifier(type, contextFile, endOffset); } else { // Array of some depth cls = CsmCompletion.OBJECT_CLASS_ARRAY; // Use Object in this case } return cls; } return null; }
@Override public int getArrayDepth() { if (instantiationHappened()) { return originalType.getArrayDepth() + instantiatedType.getArrayDepth(); } else { return originalType.getArrayDepth(); } }
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 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; } }
@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(); for( int i = 0; i < decorator.getArrayDepth(); i++ ) { sb.append("*"); // NOI18N sb.append(variableNameToInsert); for( int i = 0; i < decorator.getArrayDepth(); i++ ) { sb.append("[]"); // NOI18N
return to.getArrayDepth() > 0 || !CsmCompletion.isPrimitiveClass(toCls); return (from.getArrayDepth() > to.getArrayDepth()) || (from.getArrayDepth() == to.getArrayDepth() && !CsmCompletion.isPrimitiveClass(fromCls)); if (from.getArrayDepth() != to.getArrayDepth() || from.getPointerDepth() != to.getPointerDepth()) { return false;
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); } } } //
nextKind = extractKind(exp, i + 1, startIdx, lastDot, false); if ((kind == ExprKind.ARROW && !derefOfTHIS.get()) && (i != startIdx) && (i < parmCnt || lastDot || findType) && (lastType != null) && (lastType.getArrayDepth() == 0)) { CsmType opType = getOverloadedOperatorReturnType(lastType, contextFile, endOffset, CsmFunction.OperatorKind.ARROW, MAX_DEPTH); if (opType != null) { kind = extractKind(exp, tokCount + 1, startIdx, true, true); if ((kind == ExprKind.ARROW && !derefOfTHIS.get()) && (lastDot || findType) && (lastType != null) && (lastType.getArrayDepth() == 0)) { CsmType opType = getOverloadedOperatorReturnType(lastType, contextFile, endOffset, CsmFunction.OperatorKind.ARROW, MAX_DEPTH); if (opType != null) {
private static CsmType getOverloadedOperatorReturnType(CsmType type, CsmFile contextFile, int offset, CsmFunction.OperatorKind operator, int level) { if (type == null || type.isPointer() || type.getArrayDepth() > 0) { return null; } CsmType opType = null; CsmClassifier cls = getClassifier(type, contextFile, offset); if (CsmKindUtilities.isClass(cls)) { CsmFunction op = CsmCompletionQuery.getOperator((CsmClass) cls, contextFile, offset, operator); if (op != null) { opType = op.getReturnType(); if ((!type.equals(opType)) && (level > 0)) { if (operator == CsmFunction.OperatorKind.ARROW) { // recursion only for -> CsmType opType2 = getOverloadedOperatorReturnType(opType, contextFile, offset, operator, level - 1); if (opType2 != null) { opType = opType2; } } } else { CsmFile typeFile = type.getContainingFile(); System.err.printf("circular pointer delegation detected:%s, line %d/n", (typeFile != null ? typeFile.getAbsolutePath() : type), type.getStartOffset());//NOI18N CndUtils.assertTrueInConsole(false, "Infinite recursion in file " + typeFile + " type " + type); //NOI18N } } } return opType; }
if (newType != null) { int pointerDepth = (newType != origType ? newType.getPointerDepth() + origType.getPointerDepth() : origType.getPointerDepth()); int arrayDepth = (newType != origType ? newType.getArrayDepth() + origType.getArrayDepth() : origType.getArrayDepth());
private void initFunctionReturnType(AST typeAST, CsmScope scope, CsmFile file) { if (typeAST != null) { AST fakeParent = new FakeAST(); fakeParent.addChild(typeAST); returnType = AstRenderer.FunctionRenderer.createReturnType(fakeParent, scope, file); } else { returnType = TypeFactory.createBuiltinType("int", (AST) null, 0, null, file); // NOI18N } int retPointerDepth = super.getPointerDepth(); int retReference = TypeFactory.getReferenceValue(super.isReference(), super.isRValueReference()); boolean retIsConst = super.isConst(); returnType = TypeFactory.createType(returnType, retPointerDepth, retReference, returnType.getArrayDepth(), retIsConst); }
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; } }
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()); } }
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(); }