import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addBoolean(String mm, DocumentScanner loader) {
	Public pub = new Public();
	Type booleanT = new PrimitiveType("boolean");
	booleanT.addModifier(pub);
	try {
		new DeclarationLoader(booleanT,mm,view(), loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	addPrefixOperator(booleanT, "boolean", "!");
	addInfixOperator(booleanT, "boolean", equality(), "boolean");
	addInfixOperator(booleanT, "boolean", "!=", "boolean");
	addInfixOperator(booleanT, "boolean", "&", "boolean");
	addInfixOperator(booleanT, "boolean", "|", "boolean");
	addInfixOperator(booleanT, "boolean", "^", "boolean");
	addInfixOperator(booleanT, "boolean", "||", "boolean");
	addInfixOperator(booleanT, "boolean", "&&", "boolean");
	addInfixOperator(booleanT, "boolean", "&=", "boolean");
	addInfixOperator(booleanT, "boolean", "|=", "boolean");
	addInfixOperator(booleanT, "boolean", "^=", "boolean");
	addStringConcatenation(booleanT);
	view().storePrimitiveType("boolean",booleanT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addDouble(String mm, DocumentScanner loader) {
	Public pub = new Public();
	Type doubleT = new PrimitiveType("double");
	try {
		new DeclarationLoader(doubleT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}

	doubleT.addModifier(pub);
	doubleT.addModifier(new ValueType());

	addUniProm(doubleT);
	addBinNumOps(doubleT);
	addStringConcatenation(doubleT);
	addWrapperOperators(doubleT);
	view().storePrimitiveType("double",doubleT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addLong(String mm, DocumentScanner loader) {
	Public pub = new Public();

	Type longT = new PrimitiveType("long") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("float")
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(longT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	longT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("float")));
	longT.addModifier(pub);
	longT.addModifier(new ValueType());

	addUniPromIntegral(longT);

	addBinNumOpsIntegral(longT);
	addStringConcatenation(longT);
	addWrapperOperators(longT);
	view().storePrimitiveType("long",longT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addFloat(String mm, DocumentScanner loader) {
	Public pub = new Public();

	Type floatT = new PrimitiveType("float") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(floatT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	floatT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("double")));
	floatT.addModifier(pub);
	floatT.addModifier(new ValueType());

	addUniProm(floatT);

	addBinNumOps(floatT);
	addStringConcatenation(floatT);
	addWrapperOperators(floatT);
	view().storePrimitiveType("float",floatT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addVoid(String mm, DocumentScanner loader) {
	Public pub = new Public();
	Type voidT = new PrimitiveType("void") {

		public boolean assignableTo(Type other) {
			return false;
		}

	}; // toevoeging gebeurt door de constructor
	try {
		new DeclarationLoader(voidT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	voidT.addModifier(pub);

	voidT.addModifier(new ValueType());
	view().storePrimitiveType("void",voidT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected Type actualType() throws LookupException {
  Element parent = parent();
if (parent instanceof ArrayCreationExpression) {
    return ((ArrayCreationExpression)parent).getType();
  }
  else if (parent instanceof ArrayInitializer) {
    Type type = ((ArrayInitializer)parent).getType();
	ArrayType temp = (ArrayType)type;
    return temp.elementType();
  }
  else if (parent instanceof Expression) {
    return ((Expression)parent).getType();
  }
  else if (parent instanceof Variable) {
    return ((Variable)parent).getType();
  }
  else if (parent instanceof JavaVariableDeclaration) {
  	return nearestAncestor(JavaVariableDeclaration.class).typeReference().getElement();
  }
  else {
    throw new ChameleonProgrammerException("Cannot determine type of array initializer based on the parent.");
  }
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
@Override
public NormalMethod getElement() throws LookupException {
	Type parent = nearestAncestor(Type.class);
	if(parent == null) {
		throw new ChameleonProgrammerException("The super constructor delegation is not inside a type.");
	}
	List<Type> types = parent.getProperDirectSuperTypes();
DeclarationCollector<NormalMethod> collector = new DeclarationCollector<NormalMethod>(selector());
	for(Type type: types) {
		type.targetContext().lookUp(collector);
		if(!collector.willProceed()) {
			return collector.result();
		}
	}
	throw new LookupException("No super constructor was found.");
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
private Type lci(Type first, Type second, Binder root) throws LookupException {
	Type result = first;
	if(first.nbTypeParameters(TypeParameter.class) > 0) {
		result = Util.clone(first);
		result.setUniParent(first.parent());
		List<TypeArgument> firstArguments = arguments(first);
		List<TypeArgument> secondArguments = arguments(second);
		int size = firstArguments.size();
		if(secondArguments.size() != size) {
			throw new ChameleonProgrammerException("The number of type parameters from the first list: "+size+" is different from the number of type parameters in the second list: "+secondArguments.size());
		}
		List<TypeParameter> newParameters = lcta(firstArguments, secondArguments,root);
		result.replaceAllParameters(TypeParameter.class,newParameters);
	}
	return result;
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void replaceSubobjectsOld(Document javaDocument) {
  javaDocument.apply(Subobject.class, javaSubobject -> {
    try {
      Type subobjectInterface = ooFactory(javaSubobject).createRegularType(subobjectInterfaceName(javaSubobject));
      Subobject jloSubobject = (Subobject) javaSubobject.origin();
      subobjectInterface.addModifier(new Interface());
      SubtypeRelation javaSubtypeRelation = new SubtypeRelation(clone(javaSubobject.superClassReference()));
      subobjectInterface.addInheritanceRelation(javaSubtypeRelation);
      Method getter = createSubobjectGetterTemplate(jloSubobject, java(javaSubobject));
      getter.addModifier(new Abstract());
      getter.addModifier(new Public());
      Type nearestAncestor = javaSubobject.nearestAncestor(Type.class);
      nearestAncestor.add(getter);
      applyToSortedTypeMemberDeclarators(jloSubobject.nearestAncestor(Type.class), m -> {
        subobjectInterface.addParameter(TypeParameter.class, clone(m.parameter()));
      });
      javaSubobject.replaceWith(subobjectInterface);
    } catch (LookupException e) {
      throw new ChameleonProgrammerException(e);
    }
  } );
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void implementOwnInterfaces(Document javaDocument) {
	javaDocument.apply(Type.class, javaType -> {
		try {
			Java7 java = java(javaDocument);
			// Only disconnect inheritance relations that are explicit, and
			// that are no subobjects.
			if(!isGenerated(javaType)) {
				Type jloType = (Type) javaType.origin();
				javaType.explicitNonMemberInheritanceRelations().forEach(javaInheritanceRelation -> javaInheritanceRelation.disconnect());
				BasicJavaTypeReference superTypeReference = java.createTypeReference(javaType.name());
				SubtypeRelation relation = new SubtypeRelation(superTypeReference);
				relation.addModifier(new Implements());
				javaType.addInheritanceRelation(relation);
				addTypeParameters(relation,jloType);
				javaType.setName(implementationName(javaType));
				javaType.modifiers(java.SCOPE_MUTEX).forEach(m -> m.disconnect());
			}
		} catch (ModelException e) {
			throw new ChameleonProgrammerException(e);
		}
		javaType.addModifier(new Public());
	});
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addFields(Document javaDocument) {
	javaDocument.apply(MemberVariableDeclarator.class, javaMethod -> {
		if(! isGenerated(javaMethod)) {
			javaMethod.disconnect();
		}
	});
	javaDocument.apply(Type.class, t -> {
		if(! (t instanceof SubobjectType) && ! isGenerated(t)) {
			Type originalType = (Type) t.origin();
			try {
				addFields(t, originalType);
			} catch (Exception e) {
				throw new ChameleonProgrammerException(e);
			}
		} 
	});
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
@Override
public LazyClassFileDocumentLoader clone() {
	try {
		return new LazyClassFileDocumentLoader(parser(),null,null);
	} catch (InputException e) {
		// Won't be connected, so no exception
		throw new ChameleonProgrammerException(e);
	}
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
@Override
public DocumentLoaderImpl clone() {
	try {
		return new LazyReflectiveDocumentLoader(_loader, _parser, _fqn, null, null);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
public ASMClassParser(ZipFile file, ZipEntry entry, String className, String packageFQN) {
  if(className == null) {
    throw new ChameleonProgrammerException("The class name cannot be null.");
  }
  if(className.equals("")) {
    throw new ChameleonProgrammerException("The class name cannot be the empty string.");
  }
  _jarFile = file;
  _entry = entry;
  _name = className;
  _packageFQN = packageFQN;
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
@Override
public SignatureVisitor visitTypeArgument(char kind) {
  // create visitor with 'this' as its parent.
  final TypeArgumentWithTypeReference arg;
  if(kind == SignatureVisitor.INSTANCEOF) {
    arg = _language.createEqualityTypeArgument(null);
  } else if(kind == SignatureVisitor.EXTENDS) {
    arg = _language.createExtendsWildcard(null);
  } else if(kind == SignatureVisitor.SUPER) {
    arg = _language.createSuperWildcard(null);
  } else {
    throw new ChameleonProgrammerException();
  }
  ((BasicJavaTypeReference)typeReference()).addArgument(arg);
  return new TypeReferenceExtractor(language()) {
    /**
     * If there is no bound, we replace the type argument with a pure wildcard.
     * I GUESS that ? is modeled as an EXTENDS bound without a type reference.
     */
    //FIXME Or is this method no invoked for ??
    @Override
    public void visitEnd() {
      if(this.typeReference() == null) {
        SingleAssociation parentLink = arg.parentLink();
        parentLink.getOtherRelation().replace(parentLink, new JavaPureWildcard().parentLink());
      }
    }
    protected void connect(TypeReference tref) {
      arg.setTypeReference(tref);
    }
  };
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addNullType(DocumentScanner loader) {
   try {
		new DeclarationLoader(new NullType(java()),"",_view,loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addInt(String mm, DocumentScanner loader) {
	Public pub = new Public();

	Type intT = new PrimitiveType("int") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("long")
					|| other.getFullyQualifiedName().equals("float")
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(intT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	intT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("long")));
	intT.addModifier(pub);
	intT.addModifier(new ValueType());

	addUniPromIntegral(intT);

	addBinNumOpsIntegral(intT);
	addStringConcatenation(intT);
	addWrapperOperators(intT);
	view().storePrimitiveType("int",intT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addByte(String mm, DocumentScanner loader) {
	Public pub = new Public();
	Type byteT = new PrimitiveType("byte") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("short")
					|| other.getFullyQualifiedName().equals("char")
					|| other.getFullyQualifiedName().equals("int")
					|| other.getFullyQualifiedName().equals("long")
					|| other.getFullyQualifiedName().equals("float")
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(byteT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	byteT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("short")));
	byteT.addModifier(pub);

	byteT.addModifier(new ValueType());

	addUniPromIntegral(byteT);

	addBinNumOpsIntegral(byteT);
	addStringConcatenation(byteT);
	addWrapperOperators(byteT);
	view().storePrimitiveType("byte",byteT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addShort(String mm, DocumentScanner loader) {
	Public pub = new Public();
	Type shortT = new PrimitiveType("short") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("char")
					|| other.getFullyQualifiedName().equals("int")
					|| other.getFullyQualifiedName().equals("long")
					|| other.getFullyQualifiedName().equals("float")
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(shortT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	shortT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("int")));
	shortT.addModifier(pub);
	shortT.addModifier(new ValueType());


	addUniPromIntegral(shortT);

	addBinNumOpsIntegral(shortT);
	addStringConcatenation(shortT);
	addWrapperOperators(shortT);
	view().storePrimitiveType("short",shortT);
}
 

import org.aikodi.chameleon.exception.ChameleonProgrammerException; //导入依赖的package包/类
protected void addChar(String mm, DocumentScanner loader) {
	Public pub = new Public();

	Type charT = new PrimitiveType("char") {
		public boolean assignableTo(Type other) {
			return other.equals(this)
					|| other.getFullyQualifiedName().equals("int")
					|| other.getFullyQualifiedName().equals("long")
					|| other.getFullyQualifiedName().equals("float")
					|| other.getFullyQualifiedName().equals("double");
		}
	};
	try {
		new DeclarationLoader(charT,mm,view(),loader);
	} catch (InputException e) {
		throw new ChameleonProgrammerException(e);
	}
	charT.addInheritanceRelation(new SubtypeRelation(language().createTypeReference("int")));
	charT.addModifier(pub);
	charT.addModifier(new ValueType());

	addUniPromIntegral(charT);

	addBinNumOpsIntegral(charT);
	addStringConcatenation(charT);
	addWrapperOperators(charT);
	view().storePrimitiveType("char",charT);
}