Package org.eclipse.jdt.internal.compiler.util

Examples of org.eclipse.jdt.internal.compiler.util.HashtableOfObject


    previousCategory = categoryName;
  }
  if (previousCategory != null) {
    this.categoryEnds.put(previousCategory, this.headerInfoOffset); // cache end of the category table
  }
  this.categoryTables = new HashtableOfObject(3);
}
View Full Code Here


    this.cachedChunks = null;
    if (this.categoryTables != null) {
      if (this.cachedCategoryName == null) {
        this.categoryTables = null;
      } else if (this.categoryTables.elementSize > 1) {
        HashtableOfObject newTables = new HashtableOfObject(3);
        newTables.put(this.cachedCategoryName, this.categoryTables.get(this.cachedCategoryName));
        this.categoryTables = newTables;
      }
    }
  }
}
View Full Code Here

    } finally {
      this.monitor.exitWriteEnterRead();
    }
  }

  HashtableOfObject results;
  int rule = matchRule & MATCH_RULE_INDEX_MASK;
  if (this.memoryIndex.hasChanged()) {
    results = this.diskIndex.addQueryResults(categories, key, rule, this.memoryIndex);
    results = this.memoryIndex.addQueryResults(categories, key, rule, results);
  } else {
View Full Code Here

      IProgressMonitor monitor) {
    super(settings);
    this.javaProject = javaProject;
    this.requestor = requestor;
    this.nameEnvironment = nameEnvironment;
    this.typeCache = new HashtableOfObject(5);
    this.openedBinaryTypes = 0;

    this.problemFactory = new CompletionProblemFactory(Locale.getDefault());
    this.problemReporter = new ProblemReporter(
        DefaultErrorHandlingPolicies.proceedWithAllProblems(),
View Full Code Here

    int length = this.acceptedConstructors.size();

    if(length == 0) return;
   
    HashtableOfObject onDemandFound = new HashtableOfObject();
   
    ArrayList deferredProposals = null;
    if (DEFER_QUALIFIED_PROPOSALS) {
      deferredProposals = new ArrayList();
    }
   
    try {
      next : for (int i = 0; i < length; i++) {
       
        // does not check cancellation for every types to avoid performance loss
        if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
       
        AcceptedConstructor acceptedConstructor = (AcceptedConstructor)this.acceptedConstructors.elementAt(i);
        final int typeModifiers = acceptedConstructor.typeModifiers;
        final char[] packageName = acceptedConstructor.packageName;
        final char[] simpleTypeName = acceptedConstructor.simpleTypeName;
        final int modifiers = acceptedConstructor.modifiers;
        final int parameterCount = acceptedConstructor.parameterCount;
        final char[] signature = acceptedConstructor.signature;
        final char[][] parameterTypes = acceptedConstructor.parameterTypes;
        final char[][] parameterNames = acceptedConstructor.parameterNames;
        final int extraFlags = acceptedConstructor.extraFlags;
        final int accessibility = acceptedConstructor.accessibility;
       
        boolean proposeType = hasArrayTypeAsExpectedSuperTypes() || (extraFlags & ExtraFlags.HasNonPrivateStaticMemberTypes) != 0;
       
        char[] fullyQualifiedName = CharOperation.concat(packageName, simpleTypeName, '.');
           
        Object knownTypeKind = this.knownTypes.get(fullyQualifiedName);
        if (knownTypeKind != null) {
          if (knownTypeKind == KNOWN_TYPE_WITH_KNOWN_CONSTRUCTORS) {
            // the type and its constructors are already accepted
            continue next;
          }
          // this type is already accepted
          proposeType = false;
        } else {
          this.knownTypes.put(fullyQualifiedName, KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS);
        }
       
        boolean proposeConstructor = true;
         
        if (this.options.checkVisibility) {
          if((modifiers & ClassFileConstants.AccPublic) == 0) {
            if((modifiers & ClassFileConstants.AccPrivate) != 0) {
              if (!proposeType) continue next;
              proposeConstructor = false;
            } else {
              if (this.currentPackageName == null) {
                initializePackageCache();
              }
             
              if(!CharOperation.equals(packageName, this.currentPackageName)) {
               
                if((typeModifiers & ClassFileConstants.AccAbstract) == 0 ||
                    (modifiers & ClassFileConstants.AccProtected) == 0) {
                  if (!proposeType) continue next;
                  proposeConstructor = false;
                }
              }
            }
          }
        }
       
        acceptedConstructor.fullyQualifiedName = fullyQualifiedName;
        acceptedConstructor.proposeType = proposeType;
        acceptedConstructor.proposeConstructor = proposeConstructor;
       
       
        if(!this.importCachesInitialized) {
          initializeImportCaches();
        }
       
        for (int j = 0; j < this.importCacheCount; j++) {
          char[][] importName = this.importsCache[j];
          if(CharOperation.equals(simpleTypeName, importName[0])) {
            if (proposeType) {
              proposeType(
                  packageName,
                  simpleTypeName,
                  typeModifiers,
                  accessibility,
                  simpleTypeName,
                  fullyQualifiedName,
                  !CharOperation.equals(fullyQualifiedName, importName[1]),
                  scope);
            }
           
            if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
              boolean isQualified = !CharOperation.equals(fullyQualifiedName, importName[1]);
              if (!isQualified) {
                proposeConstructor(
                    simpleTypeName,
                    parameterCount,
                    signature,
                    parameterTypes,
                    parameterNames,
                    modifiers,
                    packageName,
                    typeModifiers,
                    accessibility,
                    simpleTypeName,
                    fullyQualifiedName,
                    isQualified,
                    scope,
                    extraFlags);
              } else {
                acceptedConstructor.mustBeQualified = true;
                if (DEFER_QUALIFIED_PROPOSALS) {
                  deferredProposals.add(acceptedConstructor);
                } else {
                  proposeConstructor(acceptedConstructor, scope);
                }
              }
            }
            continue next;
          }
        }


        if (CharOperation.equals(this.currentPackageName, packageName)) {
          if (proposeType) {
            proposeType(
                packageName,
                simpleTypeName,
                typeModifiers,
                accessibility,
                simpleTypeName,
                fullyQualifiedName,
                false,
                scope);
          }
         
          if (proposeConstructor && !Flags.isEnum(typeModifiers)) {
            proposeConstructor(
                simpleTypeName,
                parameterCount,
                signature,
                parameterTypes,
                parameterNames,
                modifiers,
                packageName,
                typeModifiers,
                accessibility,
                simpleTypeName,
                fullyQualifiedName,
                false,
                scope,
                extraFlags);
          }
          continue next;
        } else {
          char[] fullyQualifiedEnclosingTypeOrPackageName = null;

          AcceptedConstructor foundConstructor = null;
          if((foundConstructor = (AcceptedConstructor)onDemandFound.get(simpleTypeName)) == null) {
            for (int j = 0; j < this.onDemandImportCacheCount; j++) {
              ImportBinding importBinding = this.onDemandImportsCache[j];

              char[][] importName = importBinding.compoundName;
              char[] importFlatName = CharOperation.concatWith(importName, '.');

              if(fullyQualifiedEnclosingTypeOrPackageName == null) {
                fullyQualifiedEnclosingTypeOrPackageName = packageName;
              }
              if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageName, importFlatName)) {
                if(importBinding.isStatic()) {
                  if((typeModifiers & ClassFileConstants.AccStatic) != 0) {
                    onDemandFound.put(
                        simpleTypeName,
                        acceptedConstructor);
                    continue next;
                  }
                } else {
                  onDemandFound.put(
                      simpleTypeName,
                      acceptedConstructor);
                  continue next;
                }
              }
View Full Code Here

    int length = this.acceptedTypes.size();

    if(length == 0) return;

    HashtableOfObject onDemandFound = new HashtableOfObject();
   
    try {
      next : for (int i = 0; i < length; i++) {
       
        // does not check cancellation for every types to avoid performance loss
        if ((i % CHECK_CANCEL_FREQUENCY) == 0) checkCancel();
       
        AcceptedType acceptedType = (AcceptedType)this.acceptedTypes.elementAt(i);
        char[] packageName = acceptedType.packageName;
        char[] simpleTypeName = acceptedType.simpleTypeName;
        char[][] enclosingTypeNames = acceptedType.enclosingTypeNames;
        int modifiers = acceptedType.modifiers;
        int accessibility = acceptedType.accessibility;
 
        char[] typeName;
        char[] flatEnclosingTypeNames;
        if(enclosingTypeNames == null || enclosingTypeNames.length == 0) {
          flatEnclosingTypeNames = null;
          typeName = simpleTypeName;
        } else {
          flatEnclosingTypeNames = CharOperation.concatWith(acceptedType.enclosingTypeNames, '.');
          typeName = CharOperation.concat(flatEnclosingTypeNames, simpleTypeName, '.');
        }
        char[] fullyQualifiedName = CharOperation.concat(packageName, typeName, '.');
 
        if (this.knownTypes.containsKey(fullyQualifiedName)) continue next;
 
        this.knownTypes.put(fullyQualifiedName, KNOWN_TYPE_WITH_UNKNOWN_CONSTRUCTORS);
 
        if (this.resolvingImports) {
          if(this.compilerOptions.complianceLevel >= ClassFileConstants.JDK1_4 && packageName.length == 0) {
            continue next; // import of default package is forbidden when compliance is 1.4 or higher
          }
 
          char[] completionName = this.insideQualifiedReference ? simpleTypeName : fullyQualifiedName;
 
          if(this.resolvingStaticImports) {
            if(enclosingTypeNames == null || enclosingTypeNames.length == 0) {
              completionName = CharOperation.concat(completionName, new char[] { '.' });
            } else if ((modifiers & ClassFileConstants.AccStatic) == 0) {
              continue next;
            } else {
              completionName = CharOperation.concat(completionName, new char[] { ';' });
            }
          } else {
            completionName = CharOperation.concat(completionName, new char[] { ';' });
          }
 
          int relevance = computeBaseRelevance();
          relevance += computeRelevanceForResolution();
          relevance += computeRelevanceForInterestingProposal(packageName, fullyQualifiedName);
          relevance += computeRelevanceForRestrictions(accessibility);
          relevance += computeRelevanceForCaseMatching(this.completionToken, simpleTypeName);
 
          this.noProposal = false;
          if(!this.requestor.isIgnored(CompletionProposal.TYPE_REF)) {
            createTypeProposal(packageName, typeName, modifiers, accessibility, completionName, relevance);
          }
        } else {
          if(!this.importCachesInitialized) {
            initializeImportCaches();
          }
 
          for (int j = 0; j < this.importCacheCount; j++) {
            char[][] importName = this.importsCache[j];
            if(CharOperation.equals(typeName, importName[0])) {
              proposeType(
                  packageName,
                  simpleTypeName,
                  modifiers,
                  accessibility,
                  typeName,
                  fullyQualifiedName,
                  !CharOperation.equals(fullyQualifiedName, importName[1]),
                  scope);
              continue next;
            }
          }
 
 
          if ((enclosingTypeNames == null || enclosingTypeNames.length == 0 ) && CharOperation.equals(this.currentPackageName, packageName)) {
            proposeType(
                packageName,
                simpleTypeName,
                modifiers,
                accessibility,
                typeName,
                fullyQualifiedName,
                false,
                scope);
            continue next;
          } else {
            char[] fullyQualifiedEnclosingTypeOrPackageName = null;
 
            AcceptedType foundType = null;
            if((foundType = (AcceptedType)onDemandFound.get(simpleTypeName)) == null) {
              for (int j = 0; j < this.onDemandImportCacheCount; j++) {
                ImportBinding importBinding = this.onDemandImportsCache[j];
 
                char[][] importName = importBinding.compoundName;
                char[] importFlatName = CharOperation.concatWith(importName, '.');
 
                if(fullyQualifiedEnclosingTypeOrPackageName == null) {
                  if(enclosingTypeNames != null && enclosingTypeNames.length != 0) {
                    fullyQualifiedEnclosingTypeOrPackageName =
                      CharOperation.concat(
                          packageName,
                          flatEnclosingTypeNames,
                          '.');
                  } else {
                    fullyQualifiedEnclosingTypeOrPackageName =
                      packageName;
                  }
                }
                if(CharOperation.equals(fullyQualifiedEnclosingTypeOrPackageName, importFlatName)) {
                  if(importBinding.isStatic()) {
                    if((modifiers & ClassFileConstants.AccStatic) != 0) {
                      acceptedType.qualifiedTypeName = typeName;
                      acceptedType.fullyQualifiedName = fullyQualifiedName;
                      onDemandFound.put(
                          simpleTypeName,
                          acceptedType);
                      continue next;
                    }
                  } else {
                    acceptedType.qualifiedTypeName = typeName;
                    acceptedType.fullyQualifiedName = fullyQualifiedName;
                    onDemandFound.put(
                        simpleTypeName,
                        acceptedType);
                    continue next;
                  }
                }
View Full Code Here

  }

  protected void reset() {

    super.reset(false);
    this.knownPkgs = new HashtableOfObject(10);
    this.knownTypes = new HashtableOfObject(10);
    if (this.noCacheNameEnvironment != null) {
      this.noCacheNameEnvironment.cleanup();
      this.noCacheNameEnvironment = null;
      JavaModelManager.getJavaModelManager().flushZipFiles(this);
    }
View Full Code Here

   * ConstantPool constructor comment.
   */
  public ConstantPool(ClassFile classFile) {
    this.UTF8Cache = new CharArrayCache(UTF8_INITIAL_SIZE);
    this.stringCache = new CharArrayCache(STRING_INITIAL_SIZE);
    this.methodsAndFieldsCache = new HashtableOfObject(METHODS_AND_FIELDS_INITIAL_SIZE);
    this.classCache = new CharArrayCache(CLASS_INITIAL_SIZE);
    this.nameAndTypeCacheForFieldsAndMethods = new HashtableOfObject(NAMEANDTYPE_INITIAL_SIZE);
    this.offsets = new int[5];
    initialize(classFile);
  }
View Full Code Here

   * @param value the new index
   * @return the given index
   */
  private int putInCacheIfAbsent(final char[] key1, final char[] key2, final char[] key3, int value) {
    int index;
    HashtableOfObject key1Value = (HashtableOfObject) this.methodsAndFieldsCache.get(key1);
    if (key1Value == null) {
      key1Value = new HashtableOfObject();
      this.methodsAndFieldsCache.put(key1, key1Value);
      CachedIndexEntry cachedIndexEntry = new CachedIndexEntry(key3, value);
      index = -value;
      key1Value.put(key2, cachedIndexEntry);
    } else {
      Object key2Value = key1Value.get(key2);
      if (key2Value == null) {
        CachedIndexEntry cachedIndexEntry = new CachedIndexEntry(key3, value);
        index = -value;
        key1Value.put(key2, cachedIndexEntry);
      } else if (key2Value instanceof CachedIndexEntry) {
        // adding a second entry
        CachedIndexEntry entry = (CachedIndexEntry) key2Value;
        if (CharOperation.equals(key3, entry.signature)) {
          index = entry.index;
        } else {
          CharArrayCache charArrayCache = new CharArrayCache();
          charArrayCache.putIfAbsent(entry.signature, entry.index);
          index = charArrayCache.putIfAbsent(key3, value);
          key1Value.put(key2, charArrayCache);
        }
      } else {
        CharArrayCache charArrayCache = (CharArrayCache) key2Value;
        index = charArrayCache.putIfAbsent(key3, value);
      }
View Full Code Here

*  Build the set of compilation source units
*/
public CompilationUnit[] getCompilationUnits() {
  int fileCount = this.filenames.length;
  CompilationUnit[] units = new CompilationUnit[fileCount];
  HashtableOfObject knownFileNames = new HashtableOfObject(fileCount);

  String defaultEncoding = (String) this.options.get(CompilerOptions.OPTION_Encoding);
  if (Util.EMPTY_STRING.equals(defaultEncoding))
    defaultEncoding = null;

  for (int i = 0; i < fileCount; i++) {
    char[] charName = this.filenames[i].toCharArray();
    if (knownFileNames.get(charName) != null)
      throw new IllegalArgumentException(this.bind("unit.more", this.filenames[i])); //$NON-NLS-1$
    knownFileNames.put(charName, charName);
    File file = new File(this.filenames[i]);
    if (!file.exists())
      throw new IllegalArgumentException(this.bind("unit.missing", this.filenames[i])); //$NON-NLS-1$
    String encoding = this.encodings[i];
    if (encoding == null)
View Full Code Here

TOP

Related Classes of org.eclipse.jdt.internal.compiler.util.HashtableOfObject

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.