private String generateMethodBody(MethodDeclaration m) {
String methodBody;
if (Modifier.isNative(m.getModifiers())) {
if (hasNativeCode(m, true)) {
methodBody = extractNativeMethodBody(m);
} else if (Options.generateNativeStubs()) {
return generateNativeStub(m);
} else {
return null;
}
} else if (Modifier.isAbstract(m.getModifiers())) {
// Generate a body which throws a NSInvalidArgumentException.
String body =
"{\n // can't call an abstract method\n " + "[self doesNotRecognizeSelector:_cmd];\n ";
if (!Types.isVoidType(m.getReturnType2())) {
body += "return 0;\n"; // Never executes, but avoids a gcc warning.
}
return body + "}";
} else {
// generate a normal method body
methodBody = generateStatement(m.getBody(), false);
}
boolean isStatic = (m.getModifiers() & Modifier.STATIC) != 0;
boolean isSynchronized = (m.getModifiers() & Modifier.SYNCHRONIZED) != 0;
if (isStatic && isSynchronized) {
methodBody = "{\n@synchronized([self class]) {\n" + methodBody + "}\n}\n";
} else if (isSynchronized) {
methodBody = "{\n@synchronized(self) {\n" + methodBody + "}\n}\n";
}
return methodBody;
}
private String extractNativeMethodBody(MethodDeclaration m) {
assert (m.getModifiers() & Modifier.NATIVE) > 0;
String nativeCode = extractNativeCode(m.getStartPosition(), m.getLength());
if (nativeCode == null) {
ErrorUtil.warning(m, "no native code found");
return "";
}
return '{' + nativeCode + '}';
}
private boolean testModifier(IVariableBinding curr) {
int modifiers = curr.getModifiers();
int staticFinal = Modifier.STATIC | Modifier.FINAL;
if ((modifiers & staticFinal) == staticFinal) {
return false;
}
if (Modifier.isStatic(modifiers) && !Modifier.isStatic(fMethodDecl.getModifiers())) {
return false;
}
return true;
}
@Override
public boolean visit(MethodDeclaration node) {
methods.add(
new OutlineMethod(
node.getName().toString(),
node.getReturnType2(),
node.isConstructor(),
node.getModifiers(),
node.parameters(),
clazz));
return super.visit(node);
}
private List<ClassObject> parseAST(CompilationUnit compilationUnit, IFile iFile) {
List<ClassObject> classObjects = new ArrayList<ClassObject>();
List<AbstractTypeDeclaration> topLevelTypeDeclarations = compilationUnit.types();
for (AbstractTypeDeclaration abstractTypeDeclaration : topLevelTypeDeclarations) {
if (abstractTypeDeclaration instanceof TypeDeclaration) {
TypeDeclaration topLevelTypeDeclaration = (TypeDeclaration) abstractTypeDeclaration;
List<TypeDeclaration> typeDeclarations = new ArrayList<TypeDeclaration>();
typeDeclarations.add(topLevelTypeDeclaration);
typeDeclarations.addAll(getRecursivelyInnerTypes(topLevelTypeDeclaration));
for (TypeDeclaration typeDeclaration : typeDeclarations) {
final ClassObject classObject = new ClassObject();
classObject.setIFile(iFile);
classObject.setName(typeDeclaration.resolveBinding().getQualifiedName());
classObject.setTypeDeclaration(typeDeclaration);
if (typeDeclaration.isInterface()) {
classObject.setInterface(true);
}
int modifiers = typeDeclaration.getModifiers();
if ((modifiers & Modifier.ABSTRACT) != 0) classObject.setAbstract(true);
if ((modifiers & Modifier.PUBLIC) != 0) classObject.setAccess(Access.PUBLIC);
else if ((modifiers & Modifier.PROTECTED) != 0) classObject.setAccess(Access.PROTECTED);
else if ((modifiers & Modifier.PRIVATE) != 0) classObject.setAccess(Access.PRIVATE);
else classObject.setAccess(Access.NONE);
if ((modifiers & Modifier.STATIC) != 0) classObject.setStatic(true);
Type superclassType = typeDeclaration.getSuperclassType();
if (superclassType != null) {
ITypeBinding binding = superclassType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
classObject.setSuperclass(typeObject);
}
List<Type> superInterfaceTypes = typeDeclaration.superInterfaceTypes();
for (Type interfaceType : superInterfaceTypes) {
ITypeBinding binding = interfaceType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
classObject.addInterface(typeObject);
}
FieldDeclaration[] fieldDeclarations = typeDeclaration.getFields();
for (FieldDeclaration fieldDeclaration : fieldDeclarations) {
Type fieldType = fieldDeclaration.getType();
ITypeBinding binding = fieldType.resolveBinding();
List<VariableDeclarationFragment> fragments = fieldDeclaration.fragments();
for (VariableDeclarationFragment fragment : fragments) {
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
typeObject.setArrayDimension(
typeObject.getArrayDimension() + fragment.getExtraDimensions());
FieldObject fieldObject =
new FieldObject(typeObject, fragment.getName().getIdentifier());
fieldObject.setClassName(classObject.getName());
fieldObject.setVariableDeclarationFragment(fragment);
int fieldModifiers = fieldDeclaration.getModifiers();
if ((fieldModifiers & Modifier.PUBLIC) != 0) fieldObject.setAccess(Access.PUBLIC);
else if ((fieldModifiers & Modifier.PROTECTED) != 0)
fieldObject.setAccess(Access.PROTECTED);
else if ((fieldModifiers & Modifier.PRIVATE) != 0)
fieldObject.setAccess(Access.PRIVATE);
else fieldObject.setAccess(Access.NONE);
if ((fieldModifiers & Modifier.STATIC) != 0) fieldObject.setStatic(true);
classObject.addField(fieldObject);
}
}
MethodDeclaration[] methodDeclarations = typeDeclaration.getMethods();
for (MethodDeclaration methodDeclaration : methodDeclarations) {
String methodName = methodDeclaration.getName().getIdentifier();
final ConstructorObject constructorObject = new ConstructorObject();
constructorObject.setMethodDeclaration(methodDeclaration);
constructorObject.setName(methodName);
constructorObject.setClassName(classObject.getName());
int methodModifiers = methodDeclaration.getModifiers();
if ((methodModifiers & Modifier.PUBLIC) != 0)
constructorObject.setAccess(Access.PUBLIC);
else if ((methodModifiers & Modifier.PROTECTED) != 0)
constructorObject.setAccess(Access.PROTECTED);
else if ((methodModifiers & Modifier.PRIVATE) != 0)
constructorObject.setAccess(Access.PRIVATE);
else constructorObject.setAccess(Access.NONE);
List<SingleVariableDeclaration> parameters = methodDeclaration.parameters();
for (SingleVariableDeclaration parameter : parameters) {
Type parameterType = parameter.getType();
ITypeBinding binding = parameterType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
typeObject.setArrayDimension(
typeObject.getArrayDimension() + parameter.getExtraDimensions());
if (parameter.isVarargs()) {
typeObject.setArrayDimension(1);
}
ParameterObject parameterObject =
new ParameterObject(typeObject, parameter.getName().getIdentifier());
parameterObject.setSingleVariableDeclaration(parameter);
constructorObject.addParameter(parameterObject);
}
Block methodBody = methodDeclaration.getBody();
if (methodBody != null) {
MethodBodyObject methodBodyObject = new MethodBodyObject(methodBody);
constructorObject.setMethodBody(methodBodyObject);
}
if (methodDeclaration.isConstructor()) {
classObject.addConstructor(constructorObject);
} else {
MethodObject methodObject = new MethodObject(constructorObject);
List<IExtendedModifier> extendedModifiers = methodDeclaration.modifiers();
for (IExtendedModifier extendedModifier : extendedModifiers) {
if (extendedModifier.isAnnotation()) {
Annotation annotation = (Annotation) extendedModifier;
if (annotation.getTypeName().getFullyQualifiedName().equals("Test")) {
methodObject.setTestAnnotation(true);
break;
}
}
}
Type returnType = methodDeclaration.getReturnType2();
ITypeBinding binding = returnType.resolveBinding();
String qualifiedName = binding.getQualifiedName();
TypeObject typeObject = TypeObject.extractTypeObject(qualifiedName);
methodObject.setReturnType(typeObject);
if ((methodModifiers & Modifier.ABSTRACT) != 0) methodObject.setAbstract(true);
if ((methodModifiers & Modifier.STATIC) != 0) methodObject.setStatic(true);
if ((methodModifiers & Modifier.SYNCHRONIZED) != 0)
methodObject.setSynchronized(true);
if ((methodModifiers & Modifier.NATIVE) != 0) methodObject.setNative(true);
classObject.addMethod(methodObject);
FieldInstructionObject fieldInstruction = methodObject.isGetter();
if (fieldInstruction != null)
systemObject.addGetter(methodObject.generateMethodInvocation(), fieldInstruction);
fieldInstruction = methodObject.isSetter();
if (fieldInstruction != null)
systemObject.addSetter(methodObject.generateMethodInvocation(), fieldInstruction);
fieldInstruction = methodObject.isCollectionAdder();
if (fieldInstruction != null)
systemObject.addCollectionAdder(
methodObject.generateMethodInvocation(), fieldInstruction);
MethodInvocationObject methodInvocation = methodObject.isDelegate();
if (methodInvocation != null)
systemObject.addDelegate(methodObject.generateMethodInvocation(), methodInvocation);
}
}
classObjects.add(classObject);
}
}
}
return classObjects;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
*/
public boolean visit(MethodDeclaration node) {
if (isPrivate(node.getModifiers())) {
return false;
}
return isContinue();
}
/**
* Method to post process returned flags from the {@link Javadoc} node of the element
*
* @param tags the tags to process
* @param element the {@link ASTNode} the tag appears on
* @return the list of valid tags to process restrictions for
*/
private List pruneTags(final List tags, ASTNode node) {
ArrayList pruned = new ArrayList(tags.size());
TagElement tag = null;
switch (node.getNodeType()) {
case ASTNode.TYPE_DECLARATION:
{
TypeDeclaration type = (TypeDeclaration) node;
int flags = type.getModifiers();
for (Iterator iterator = tags.iterator(); iterator.hasNext(); ) {
tag = (TagElement) iterator.next();
String tagname = tag.getTagName();
if (type.isInterface()
&& ("@noextend".equals(tagname)
|| //$NON-NLS-1$
"@noimplement".equals(tagname))) { // $NON-NLS-1$
pruned.add(tag);
} else {
if ("@noextend".equals(tagname)) { // $NON-NLS-1$
if (!Flags.isFinal(flags)) {
pruned.add(tag);
continue;
}
}
if ("@noinstantiate".equals(tagname)) { // $NON-NLS-1$
if (!Flags.isAbstract(flags)) {
pruned.add(tag);
continue;
}
}
}
}
break;
}
case ASTNode.METHOD_DECLARATION:
{
MethodDeclaration method = (MethodDeclaration) node;
int flags = method.getModifiers();
for (Iterator iterator = tags.iterator(); iterator.hasNext(); ) {
tag = (TagElement) iterator.next();
if ("@noreference".equals(tag.getTagName())) { // $NON-NLS-1$
pruned.add(tag);
continue;
}
if ("@nooverride".equals(tag.getTagName())) { // $NON-NLS-1$
ASTNode parent = method.getParent();
int pflags = 0;
if (parent instanceof BodyDeclaration) {
pflags = ((BodyDeclaration) parent).getModifiers();
}
if (!Flags.isFinal(flags) && !Flags.isStatic(flags) && !Flags.isFinal(pflags)) {
pruned.add(tag);
continue;
}
}
}
break;
}
case ASTNode.FIELD_DECLARATION:
{
FieldDeclaration field = (FieldDeclaration) node;
for (Iterator iterator = tags.iterator(); iterator.hasNext(); ) {
tag = (TagElement) iterator.next();
boolean isfinal = Flags.isFinal(field.getModifiers());
if (isfinal || (isfinal && Flags.isStatic(field.getModifiers()))) {
break;
}
if ("@noreference".equals(tag.getTagName())) { // $NON-NLS-1$
pruned.add(tag);
break;
}
}
break;
}
}
return pruned;
}
