@Override public boolean needToTraverseDeeper(CsmScope scope) { if (CsmKindUtilities.isNamespace(scope) || CsmKindUtilities.isNamespaceDefinition(scope)) { return ((CsmNamedElement) scope).getName().length() == 0; } return isInContext(scope); }
Object getNamespaceAlias(CharSequence name) { final CharSequence s = CharSequences.create(name); CsmObject obj = namespaceAliases.get(s); CsmNamespace ns = null; if (CsmKindUtilities.isNamespaceAlias(obj)) { CsmNamespaceAlias alias = (CsmNamespaceAlias) obj; ns = alias.getReferencedNamespace(); namespaceAliases.put(s, ns); } else if (CsmKindUtilities.isNamespace(obj)) { ns = (CsmNamespace) obj; } return ns; }
private static boolean fromStd(CsmScopeElement object) { CsmScope scope = object.getScope(); return CsmKindUtilities.isNamespace(scope) && "std".equals(((CsmNamespace)scope).getQualifiedName().toString()); // NOI18N } }
private static boolean filterAuto(CsmScopeElement object) { CsmScope scope = object.getScope(); return CsmKindUtilities.isNamespace(scope) && "std".equals(((CsmNamespace)scope).getQualifiedName().toString()); // NOI18N }
@Override public boolean needToTraverseDeeper(CsmScope scope) { if (CsmKindUtilities.isNamespace(scope) || CsmKindUtilities.isNamespaceDefinition(scope)) { return ((CsmNamedElement)scope).getName().length() == 0; } return false; }
private CsmNamespace findExactNamespace(final String var, final int varPos) { CsmNamespace ns = null; compResolver.setResolveTypes(CompletionResolver.RESOLVE_GLOB_NAMESPACES | CompletionResolver.RESOLVE_LIB_NAMESPACES); if (resolve(varPos, var, true)) { CompletionResolver.Result res = compResolver.getResult(); Collection<? extends CsmObject> addResulItemsToCol = res.addResulItemsToCol(new ArrayList<CsmObject>()); for (CsmObject csmObject : addResulItemsToCol) { if (CsmKindUtilities.isNamespace(csmObject)) { return (CsmNamespace) csmObject; } else if (CsmKindUtilities.isNamespaceAlias(csmObject)) { ns = ((CsmNamespaceAlias) csmObject).getReferencedNamespace(); if (ns != null) { return ns; } } } } return ns; }
/** * Returns the namespace the given class belongs * (even if it's a nested class) */ public static CsmNamespace getClassNamespace(CsmClass cls) { CsmScope scope = cls.getScope(); while( scope != null && CsmKindUtilities.isClass(scope) ) { CsmClass outer = (CsmClass)scope; scope = outer.getScope(); } return CsmKindUtilities.isNamespace(scope) ? (CsmNamespace) scope : null; }
private static CsmDeclaration findInnerDeclaration(CsmDeclaration outDecl, int offset) { assert (isInObject(outDecl, offset)) : "must be in outDecl object!"; Iterator<? extends CsmDeclaration> it = null; if (CsmKindUtilities.isNamespace(outDecl)) { CsmNamespace ns = (CsmNamespace)outDecl; it = ns.getDeclarations().iterator(); } else if (CsmKindUtilities.isNamespaceDefinition(outDecl)) { it = ((CsmNamespaceDefinition) outDecl).getDeclarations().iterator(); } else if (CsmKindUtilities.isClass(outDecl)) { CsmClass cl = (CsmClass)outDecl; it = cl.getMembers().iterator(); } else if (CsmKindUtilities.isEnum(outDecl)) { CsmEnum en = (CsmEnum)outDecl; it = en.getEnumerators().iterator(); } return findInnerDeclaration(it, offset); }
public CsmNamespace _getClassNamespace(CsmClassifier cls) { CsmScope scope = cls.getScope(); while (scope != null) { if (CsmKindUtilities.isNamespace(scope)) { return (CsmNamespace) scope; } if (CsmKindUtilities.isScopeElement(scope)) { scope = ((CsmScopeElement) scope).getScope(); } else { break; } } return null; }
@Override public String getIncludeDirective(CsmFile currentFile, CsmObject item) { if (CsmKindUtilities.isOffsetable(item)) { CsmFile file = ((CsmOffsetable) item).getContainingFile(); if (file != null) { if (file.equals(currentFile) || file.isHeaderFile()) { return getIncludeDirectiveByFile(currentFile, item).replace('\\', '/'); // NOI18N; } else if (file.isSourceFile() && CsmKindUtilities.isGlobalVariable(item)) { Collection<CsmOffsetableDeclaration> decls = file.getProject().findDeclarations(((CsmVariable) item).getUniqueName() + " (EXTERN)"); // NOI18N if (!decls.isEmpty()) { return getIncludeDirectiveByFile(currentFile, decls.iterator().next()).replace('\\', '/'); // NOI18N; } } } else { System.err.println("can not find for item " + item); // NOI18N; } } else if (!CsmKindUtilities.isNamespace(item)) { System.err.println("not yet handled object " + item); // NOI18N; } return ""; // NOI18N }
@Override public boolean isGlobalVariable(CsmVariable var) { if (var instanceof VariableImpl) { CsmScope scope = (var).getScope(); // Cannot check on globalness class members, parameters, etc. if (CsmKindUtilities.isFile(scope) || CsmKindUtilities.isNamespace(scope)) { return NamespaceImpl.isNamespaceScope((VariableImpl) var, CsmKindUtilities.isFile(scope)); } return true; } return true; // throw UnsupportedOperationException? }
protected CharSequence getQualifiedNameWithoutSuffix() { CsmScope scope = getScope(); CharSequence name = getName(); if (CsmKindUtilities.isNamespace(scope)) { return Utils.getQualifiedName(name, (CsmNamespace) scope); } else if (CsmKindUtilities.isClass(scope)) { int last = CharSequenceUtils.lastIndexOf(name, "::"); // NOI18N if (last >= 0) { name = name.toString().substring(last + 2); // NOI18N } return CharSequenceUtils.concatenate(((CsmClass) scope).getQualifiedName(), "::", name); // NOI18N } else { return name; } }
/** * Return the name of the context of the scope element - * either namespace or (for file-level, such as C-style statics) file * (If the element is a nested class, return containing class' namespace) */ public static String getContextName(CsmScopeElement element) { CsmScope scope = element.getScope(); if( CsmKindUtilities.isClass(scope) ) { CsmClass cls = ((CsmClass) scope); CsmNamespace ns = getClassNamespace(cls); return ns.getQualifiedName().toString(); } else if( CsmKindUtilities.isNamespace(scope) ) { return ((CsmNamespace) scope).getQualifiedName().toString(); } else if( CsmKindUtilities.isFile(scope) ) { return ((CsmFile) scope).getName().toString(); } return ""; }
/** Initializes qualified name */ protected final void initQualifiedName(CsmScope scope) { CharSequence qualifiedNamePostfix = getQualifiedNamePostfix(); if (CsmKindUtilities.isNamespace(scope)) { qualifiedName = Utils.getQualifiedName(qualifiedNamePostfix.toString(), (CsmNamespace) scope); } else if (CsmKindUtilities.isClass(scope)) { int last = CharSequenceUtils.lastIndexOf(qualifiedNamePostfix, "::"); // NOI18N if (last >= 0) { // NOI18N qualifiedNamePostfix = qualifiedNamePostfix.toString().substring(last + 2); // NOI18N } qualifiedName = CharSequenceUtils.concatenate(((CsmClass) scope).getQualifiedName(), "::", qualifiedNamePostfix); // NOI18N } else { qualifiedName = qualifiedNamePostfix; } qualifiedName = QualifiedNameCache.getManager().getString(qualifiedName); // can't register here, because descendant class' constructor hasn't yet finished! // so registering is a descendant class' responsibility }
protected final void register(CsmScope scope, boolean registerUnnamedInNamespace) { RepositoryUtils.put(this); boolean registerInNamespace = registerUnnamedInNamespace; if (Utils.canRegisterDeclaration(this)) { registerInNamespace = registerInProject(); } if (registerInNamespace) { if (getContainingClass() == null) { if (CsmKindUtilities.isNamespace(scope)) { ((NamespaceImpl) scope).addDeclaration(this); } } } }
@Override public CsmNamespace getReferencedNamespace() { // TODO: process preceding aliases CsmNamespace referencedNamespace = _getReferencedNamespace(); if (referencedNamespace == null) { CsmObject result = null; Resolver aResolver = ResolverFactory.createResolver(this); try { result = aResolver.resolve(Utils.splitQualifiedName(name.toString()), Resolver.NAMESPACE); } finally { ResolverFactory.releaseResolver(aResolver); } if (result != null && result instanceof CsmNamespaceDefinition) { result = ((CsmNamespaceDefinition)result).getNamespace(); } if (CsmKindUtilities.isNamespace(result)) { referencedNamespace = (CsmNamespace)result; } _setReferencedNamespace(referencedNamespace); } return referencedNamespace; }
private CsmNamespace _getReferencedNamespace() { synchronized (this) { // can be null if namespace was removed CsmNamespace referencedNamespace = UIDCsmConverter.UIDtoNamespace(referencedNamespaceUID); if (referencedNamespaceUID == null) { FileImpl file = (FileImpl) getContainingFile(); if(file != null) { CsmReference typeReference = file.getResolvedReference(new CsmUsingReferenceImpl(this)); if (typeReference != null) { CsmObject referencedObject = typeReference.getReferencedObject(); if (CsmKindUtilities.isNamespace(referencedObject)) { referencedNamespace = (CsmNamespace) referencedObject; referencedNamespaceUID = UIDCsmConverter.namespaceToUID(referencedNamespace); //System.out.println("Hit "+referencedNamespace); } } } } return referencedNamespace; } }
/** @return either class or namespace */ public CsmObject findOwner() { CharSequence[] cnn = classOrNspNames; if( cnn != null && cnn.length > 0) { Resolver resolver = ResolverFactory.createResolver(this); try { CsmObject obj = resolver.resolve(cnn, Resolver.CLASSIFIER | Resolver.NAMESPACE); if (CsmKindUtilities.isClassifier(obj)) { CsmClassifier cls = resolver.getOriginalClassifier((CsmClassifier)obj); if (cls != null) { obj = cls; } if (CsmKindUtilities.isClass(obj)) { return obj; } } else if(CsmKindUtilities.isNamespace(obj)) { return obj; } } finally { ResolverFactory.releaseResolver(resolver); } } return null; }
@Override public CharSequence getQualifiedName() { CsmObject container = _getContainer(); if (CsmKindUtilities.isClass(container)) { return CharSequences.create(CharSequenceUtils.concatenate(((CsmClass) container).getQualifiedName(), "::", getQualifiedNamePostfix())); // NOI18N } else if (CsmKindUtilities.isNamespace(container)) { CharSequence nsName = ((CsmNamespace) container).getQualifiedName(); if (nsName != null && nsName.length() > 0) { return CharSequences.create(CharSequenceUtils.concatenate(nsName, "::", getQualifiedNamePostfix())); // NOI18N } } return getName(); }
private boolean isInContext(CsmScope scope) { if (!CsmKindUtilities.isClass(scope) && !CsmKindUtilities.isNamespace(scope)) { return false; } CsmQualifiedNamedElement el = (CsmQualifiedNamedElement)scope; CsmNamespace ns = context.getContainingNamespace(); if (ns != null && startsWith(ns.getQualifiedName(), el.getQualifiedName())) { return true; } CsmClass cls = context.getContainingClass(); if (cls != null && startsWith(cls.getQualifiedName(), el.getQualifiedName())) { return true; } return false; }