typedecl.java

JDK1.4编译器后端

    for(Iterator iter = set.iterator(); iter.hasNext(); ) {
      MethodDecl m = (MethodDecl)iter.next();
      if(!m.isAbstract())
        return false;
    }
    return true;
  }

    // Declared in LookupVariable.jrag at line 208

  
  public TypeDecl subclassWithinBody(TypeDecl typeDecl) {
    if(instanceOf(typeDecl))
      return this;
    if(isNestedType()) {
      return enclosingType().subclassWithinBody(typeDecl);
    }
    return null;
  }

    // Declared in Modifiers.jrag at line 66


  public void checkModifiers() {
    super.checkModifiers();
    // 8.1.1
    if(isPublic() && !isTopLevelType() && !isMemberType())
      error("public pertains only to top level types and member types");

    // 8.1.1
    if((isProtected() || isPrivate()) && !(isMemberType() && enclosingType().isClassDecl()))
      error("protected and private may only be used on member types within a directly enclosing class declaration");

    // 8.1.1
    if(isStatic() && !isMemberType())
      error("static pertains only to member types");
    
    
    // 8.4.3.1
    // 8.1.1.1
    if(!isAbstract() && hasAbstract()) {
      StringBuffer s = new StringBuffer();
      s.append("" + name() + " is not declared abstract but contains abstract members: \n");
      for(Iterator iter = unimplementedMethods().iterator(); iter.hasNext(); ) {
        MethodDecl m = (MethodDecl)iter.next();
        s.append("  " + m.signature() + " in " + m.hostType().typeName() + "\n");
      }
      error(s.toString());
    }
  }

    // Declared in NameCheck.jrag at line 246


  public void nameCheck() {
    if(isTopLevelType() && lookupType(packageName(), name()) != this)
      error("duplicate member " + name() + " in compilation unit");
  
    if(!isTopLevelType() && !isAnonymous() && !isLocalClass() && extractSingleType(enclosingType().memberTypes(name())) != this)
      error("duplicate member type " + name() + " in type " + enclosingType().typeName());

    // 14.3
    if(isLocalClass()) {
      TypeDecl typeDecl = extractSingleType(lookupType(name()));
      if(typeDecl != null && typeDecl != this && typeDecl.isLocalClass() && enclosingBlock() == typeDecl.enclosingBlock())
        error("local class named " + name() + " may not be redeclared as a local class in the same block");
    }

    if(!packageName().equals("") && hasPackage(fullName()))
      error("duplicate member class and package " + name());
    
    // 8.1 & 9.1
    if(hasEnclosingTypeDecl(name())) {
      error("type may not have the same simple name as an enclosing type declaration");
    }
  }

    // Declared in QualifiedNames.jrag at line 96

  public Access createQualifiedAccess() {
    if(isLocalClass() || isAnonymous()) {
      return new TypeAccess(name());
    }
    else if(!isTopLevelType()) {
      return enclosingType().createQualifiedAccess().qualifiesAccess(new TypeAccess(name()));
    }
    else {
      return new TypeAccess(packageName(), name());
    }
  }

    // Declared in TypeAnalysis.jrag at line 235

  public FieldDeclaration findSingleVariable(String name) {
    return (FieldDeclaration)memberFields(name).iterator().next();
  }

    // Declared in TypeHierarchyCheck.jrag at line 157


  public void typeCheck() {
    // 8.4.6.4 & 9.4.1
    for(Iterator iter1 = localMethodsIterator(); iter1.hasNext(); ) {
      MethodDecl m = (MethodDecl)iter1.next();
      ASTNode target = m.hostType() == this ? (ASTNode)m : (ASTNode)this;
      
      //for(Iterator i2 = overrides(m).iterator(); i2.hasNext(); ) {
      for(Iterator i2 = ancestorMethods(m.signature()).iterator(); i2.hasNext(); ) {
        MethodDecl decl = (MethodDecl)i2.next();
        if(m.overrides(decl)) {
          // 8.4.6.1
          if(!m.isStatic() && decl.isStatic())
            target.error("an instance method may not override a static method");
 
          // regardless of overriding
          // 8.4.6.3
          if(!m.mayOverrideReturn(decl))
            target.error("the return type of method " + m.signature() + " in " + m.hostType().typeName() + " does not match the return type of method " + decl.signature() + " in " + decl.hostType().typeName() + " and may thus not be overriden");
 
          // regardless of overriding
          // 8.4.4
          for(int i = 0; i < m.getNumException(); i++) {
            Access e = m.getException(i);
            boolean found = false;
            for(int j = 0; !found && j < decl.getNumException(); j++) {
              if(e.type().instanceOf(decl.getException(j).type()))
                found = true;
            }
            if(!found && e.type().isUncheckedException())
              target.error(m.signature() + " in " + m.hostType().typeName() + " may not throw more checked exceptions than overridden method " +
               decl.signature() + " in " + decl.hostType().typeName());
          }
          // 8.4.6.3
          if(decl.isPublic() && !m.isPublic())
            target.error("overriding access modifier error");
          // 8.4.6.3
          if(decl.isProtected() && !(m.isPublic() || m.isProtected()))
            target.error("overriding access modifier error");
          // 8.4.6.3
          if((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate())
            target.error("overriding access modifier error");
 
          // regardless of overriding
          if(decl.isFinal())
            target.error("method " + m.signature() + " in " + hostType().typeName() + " can not override final method " + decl.signature() + " in " + decl.hostType().typeName());
        }
        if(m.hides(decl)) {
          // 8.4.6.2
          if(m.isStatic() && !decl.isStatic())
            target.error("a static method may not hide an instance method");
          // 8.4.6.3
          if(!m.mayOverrideReturn(decl))
            target.error("can not hide a method with a different return type");
          // 8.4.4
          for(int i = 0; i < m.getNumException(); i++) {
            Access e = m.getException(i);
            boolean found = false;
            for(int j = 0; !found && j < decl.getNumException(); j++) {
              if(e.type().instanceOf(decl.getException(j).type()))
                found = true;
            }
            if(!found)
              target.error("may not throw more checked exceptions than hidden method");
          }
          // 8.4.6.3
          if(decl.isPublic() && !m.isPublic())
            target.error("hiding access modifier error: public method " + decl.signature() + " in " + decl.hostType().typeName() + " is hidden by non public method " + m.signature() + " in " + m.hostType().typeName());
          // 8.4.6.3
          if(decl.isProtected() && !(m.isPublic() || m.isProtected()))
            target.error("hiding access modifier error: protected method " + decl.signature() + " in " + decl.hostType().typeName() + " is hidden by non (public|protected) method " + m.signature() + " in " + m.hostType().typeName());
          // 8.4.6.3
          if((!decl.isPrivate() && !decl.isProtected() && !decl.isPublic()) && m.isPrivate())
            target.error("hiding access modifier error: default method " + decl.signature() + " in " + decl.hostType().typeName() + " is hidden by private method " + m.signature() + " in " + m.hostType().typeName());
          if(decl.isFinal())
            target.error("method " + m.signature() + " in " + hostType().typeName() + " can not hide final method " + decl.signature() + " in " + decl.hostType().typeName());
        }
      }
    }
  }

    // Declared in Attributes.jrag at line 58


  public int addConstant(ConstantPool p, Constant c)     { 
    if(isString()) return p.addConstant(c.stringValue());
    throw new Error("Not supported"); 
  }

    // Declared in CodeGeneration.jrag at line 547


  public void emitPushConstant(CodeGeneration gen, int value) { }

    // Declared in CodeGeneration.jrag at line 617


  // return

  public void emitReturn(CodeGeneration gen) { error(); }

    // Declared in CodeGeneration.jrag at line 639


  public void emitLoadLocal(CodeGeneration gen, int pos) {error();}

    // Declared in CodeGeneration.jrag at line 752

  
  public void emitStoreLocal(CodeGeneration gen, int pos) {error();}

    // Declared in CodeGeneration.jrag at line 849


  // dup

  public void emitDup(CodeGeneration gen)      { gen.emit(Bytecode.DUP); }

    // Declared in CodeGeneration.jrag at line 854

  
  public void emitDup_x1(CodeGeneration gen)   { gen.emit(Bytecode.DUP_X1); }

    // Declared in CodeGeneration.jrag at line 859


  public void emitDup_x2(CodeGeneration gen)   { gen.emit(Bytecode.DUP_X2); }

    // Declared in CodeGeneration.jrag at line 864

  
  public void emitPop(CodeGeneration gen)      { gen.emit(Bytecode.POP); }

    // Declared in CodeGeneration.jrag at line 935


  // emitNew

  public void emitNew(CodeGeneration gen) {
    int index = gen.constantPool().addClass(constantPoolName());
    gen.emit(Bytecode.NEW).add2(index);
  }

    // Declared in CodeGeneration.jrag at line 941

  void emitAssignConvTo(CodeGeneration gen, TypeDecl type) {
    if(!type.isIntegralType() || !isIntegralType() || type.isLong())
      emitCastTo(gen, type);
  }

    // Declared in CodeGeneration.jrag at line 946

  
  void emitCastTo(CodeGeneration gen, TypeDecl type) { throw new Error("CastTo not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 958


  void intToThis(CodeGeneration gen) { throw new Error("intToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 967


  void floatToThis(CodeGeneration gen) { throw new Error("floatToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 976


  void doubleToThis(CodeGeneration gen) { throw new Error("doubleToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 985


  void longToThis(CodeGeneration gen) { throw new Error("longToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 994


  void byteToThis(CodeGeneration gen) { throw new Error("byteToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 1001

  
  void charToThis(CodeGeneration gen) { throw new Error("charToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 1009

  
  void shortToThis(CodeGeneration gen) { throw new Error("shortToThis not implemented for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 1042

  
  void neg(CodeGeneration gen) { error(); }

    // Declared in CodeGeneration.jrag at line 1048


  void bitNot(CodeGeneration gen) { error(); }

    // Declared in CodeGeneration.jrag at line 1052


  void logNot(CodeGeneration gen) { error();}

    // Declared in CodeGeneration.jrag at line 1055


  void add(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1061


  void sub(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1067


  void mul(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1073


  void div(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1079


  void rem(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1085


  void shl(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1089


  void shr(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1093


  void ushr(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1097


  void bitand(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1102


  void bitor(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1107


  void bitxor(CodeGeneration gen) {error();}

    // Declared in CodeGeneration.jrag at line 1114

  public void branchLT(CodeGeneration gen, int label) { throw new Error("branchLT not supported for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 1120

    
  public void branchLE(CodeGeneration gen, int label) { throw new Error("branchLE not supported for " + getClass().getName()); }

    // Declared in CodeGeneration.jrag at line 1126

  
  public void branchGE(CodeGeneration gen, int label) { throw new Error("branchGE not supported for " + getClass().getName()); }