private void printTypeAnnotationsMethod(AbstractTypeDeclaration decl) { List<Annotation> runtimeAnnotations = ASTUtil.getRuntimeAnnotations(ASTUtil.getModifiers(decl)); if (runtimeAnnotations.size() > 0) { println("+ (IOSObjectArray *)__annotations {"); printAnnotationCreate(runtimeAnnotations); } }
@Override protected void generate(AnnotationTypeDeclaration node) { syncLineNumbers(node.getName()); // avoid doc-comment String typeName = NameTable.getFullName(node); printf("@implementation %s\n", typeName); if (BindingUtil.isRuntimeAnnotation(Types.getTypeBinding(node))) { List<AnnotationTypeMemberDeclaration> members = Lists.newArrayList(); for (BodyDeclaration decl : ASTUtil.getBodyDeclarations(node)) { if (decl instanceof AnnotationTypeMemberDeclaration) { members.add((AnnotationTypeMemberDeclaration) decl); } } printAnnotationProperties(members); if (!members.isEmpty()) { printAnnotationConstructor(Types.getTypeBinding(node)); } printAnnotationAccessors(members); } List<FieldDeclaration> fields = ASTUtil.getFieldDeclarations(node); List<IVariableBinding> fieldsNeedingAccessors = getStaticFieldsNeedingAccessors(fields, /* isInterface */ true); printStaticVars(fields, /* isInterface */ true); printStaticFieldAccessors(fieldsNeedingAccessors, Collections.<MethodDeclaration>emptyList()); println("- (IOSClass *)annotationType {"); printf(" return [IOSClass classWithProtocol:@protocol(%s)];\n", typeName); println("}\n"); if (!Options.stripReflection()) { printTypeAnnotationsMethod(node); printMetadata(node); } println("@end\n"); }
private void printMethodAnnotationMethods(List<MethodDeclaration> methods) { for (MethodDeclaration method : methods) { List<Annotation> runtimeAnnotations = ASTUtil.getRuntimeAnnotations(ASTUtil.getModifiers(method)); if (runtimeAnnotations.size() > 0) { printf( "+ (IOSObjectArray *)__annotations_%s {\n", methodKey(Types.getMethodBinding(method))); printAnnotationCreate(runtimeAnnotations); } printParameterAnnotationMethods(method); } }
private Statement createInnerConstructorInvocation(MethodDeclaration m) { ConstructorInvocation invocation = m.getAST().newConstructorInvocation(); Types.addBinding(invocation, Types.getBinding(m)); for (SingleVariableDeclaration param : ASTUtil.getParameters(m)) { SimpleName paramName = param.getName(); IVariableBinding paramBinding = Types.getVariableBinding(paramName); SimpleName argName = m.getAST().newSimpleName(paramName.getIdentifier()); Types.addBinding(argName, paramBinding); ASTUtil.getArguments(invocation).add(argName); } return invocation; }
private void printFieldAnnotationMethods(List<FieldDeclaration> fields) { for (FieldDeclaration field : fields) { List<Annotation> runtimeAnnotations = ASTUtil.getRuntimeAnnotations(ASTUtil.getModifiers(field)); if (runtimeAnnotations.size() > 0) { for (VariableDeclarationFragment var : ASTUtil.getFragments(field)) { printf("+ (IOSObjectArray *)__annotations_%s_ {\n", var.getName().getIdentifier()); printAnnotationCreate(runtimeAnnotations); } } } }
private void printImports(CompilationUnit node) { ImplementationImportCollector collector = new ImplementationImportCollector(); collector.collect(node, getSourceFileName()); Set<Import> imports = collector.getImports(); if (!imports.isEmpty()) { Set<String> includeStmts = Sets.newTreeSet(); for (Import imp : imports) { includeStmts.add(String.format("#include \"%s.h\"", imp.getImportFileName())); } for (String stmt : includeStmts) { println(stmt); } // Print native includes. int endOfImportText = node.types().isEmpty() ? node.getLength() : ((ASTNode) node.types().get(0)).getStartPosition(); for (Comment c : ASTUtil.getCommentList(node)) { int start = c.getStartPosition(); if (start >= endOfImportText) { break; } if (c instanceof BlockComment) { String nativeImport = extractNativeCode(start, c.getLength(), true); if (nativeImport != null) { // if it has a JSNI section println(nativeImport.trim()); } } } newline(); } }
/** Finds all block comments and associates them with their containing type. */ private void findBlockComments(CompilationUnit unit, List<AbstractTypeDeclaration> types) { List<Comment> comments = ASTUtil.getCommentList(unit); for (Comment comment : comments) { if (!comment.isBlockComment()) { continue; } int commentPos = comment.getStartPosition(); AbstractTypeDeclaration containingType = null; int containingTypePos = -1; for (AbstractTypeDeclaration type : types) { int typePos = type.getStartPosition(); if (typePos < 0) { continue; } int typeEnd = typePos + type.getLength(); if (commentPos > typePos && commentPos < typeEnd && typePos > containingTypePos) { containingType = type; containingTypePos = typePos; } } if (containingType != null) { blockComments.put(containingType, comment); } } }
private void printParameterAnnotationMethods(MethodDeclaration method) { List<SingleVariableDeclaration> params = ASTUtil.getParameters(method); // Quick test to see if there are any parameter annotations. boolean hasAnnotations = false; for (SingleVariableDeclaration param : params) { List<Annotation> runtimeAnnotations = ASTUtil.getRuntimeAnnotations(ASTUtil.getModifiers(param)); if (runtimeAnnotations.size() > 0) { hasAnnotations = true; break; } } if (hasAnnotations) { // Print array of arrays, with an element in the outer array for each parameter. printf( "+ (IOSObjectArray *)__annotations_%s_params {\n", methodKey(Types.getMethodBinding(method))); print(" return [IOSObjectArray arrayWithObjects:(id[]) { "); for (int i = 0; i < params.size(); i++) { if (i > 0) { print(", "); } SingleVariableDeclaration param = params.get(i); List<Annotation> runtimeAnnotations = ASTUtil.getRuntimeAnnotations(ASTUtil.getModifiers(param)); if (runtimeAnnotations.size() > 0) { print("[IOSObjectArray arrayWithObjects:(id[]) { "); printAnnotations(runtimeAnnotations); printf( " } count:%d type:[IOSClass classWithProtocol:" + "@protocol(JavaLangAnnotationAnnotation)]]", runtimeAnnotations.size()); } else { print( "[IOSObjectArray arrayWithLength:0 " + "type:[IOSClass classWithProtocol:@protocol(JavaLangAnnotationAnnotation)]]"); } } printf( " } count:%d type:[IOSClass classWithProtocol:" + "@protocol(JavaLangAnnotationAnnotation)]];\n}\n", params.size()); } }
private List<VariableDeclarationFragment> getProperties(FieldDeclaration[] fields) { List<VariableDeclarationFragment> properties = Lists.newArrayList(); for (FieldDeclaration field : fields) { if (!Modifier.isStatic(field.getModifiers())) { properties.addAll(ASTUtil.getFragments(field)); } } return properties; }
@Override protected void printStaticConstructorDeclaration(MethodDeclaration m) { String className = NameTable.getFullName(Types.getMethodBinding(m).getDeclaringClass()); StringBuffer sb = new StringBuffer(); sb.append("{\nif (self == [" + className + " class]) {\n"); for (Statement statement : ASTUtil.getStatements(m.getBody())) { sb.append(generateStatement(statement, false)); } sb.append("}\n}"); print("+ (void)initialize " + reindent(sb.toString()) + "\n\n"); }
@Override protected String constructorDeclaration(MethodDeclaration m) { String methodBody; IMethodBinding binding = Types.getMethodBinding(m); boolean memDebug = Options.memoryDebug(); List<Statement> statements = ASTUtil.getStatements(m.getBody()); if (binding.getDeclaringClass().isEnum()) { return enumConstructorDeclaration(m, statements, binding); } StringBuffer sb = new StringBuffer("{\n"); int constructorIdx = findConstructorInvocation(statements); int idx = 0; while (idx < constructorIdx) { sb.append(generateStatement(statements.get(idx++), false)); } String superCall = idx == constructorIdx ? generateStatement(statements.get(idx++), false) : "[super init]"; if (idx >= statements.size()) { sb.append("return "); if (memDebug) { sb.append("JreMemDebugAdd("); } sb.append(superCall).append(memDebug ? ");\n}" : ";\n}"); } else { sb.append("if (self = ").append(superCall).append(") {\n"); while (idx < statements.size()) { sb.append(generateStatement(statements.get(idx++), false)); } if (memDebug) { sb.append("JreMemDebugAdd(self);\n"); } sb.append("}\nreturn self;\n}"); } methodBody = sb.toString(); if (invokedConstructors.contains(methodKey(binding))) { return super.constructorDeclaration(m, true) + " " + reindent(methodBody) + "\n\n" + super.constructorDeclaration(m, false) + " {\n return " + generateStatement(createInnerConstructorInvocation(m), false) + ";\n}\n\n"; } else { return super.constructorDeclaration(m, false) + " " + reindent(methodBody) + "\n\n"; } }
public void generate(CompilationUnit unit) { println(J2ObjC.getFileHeader(getSourceFileName())); List<AbstractTypeDeclaration> typesToGenerate = collectTypes(unit); if (!typesToGenerate.isEmpty()) { findBlockComments(unit, typesToGenerate); findInvokedConstructors(unit); printStart(getSourceFileName()); printImports(unit); pushIgnoreDeprecatedDeclarationsPragma(); for (AbstractTypeDeclaration type : typesToGenerate) { generate(type); } popIgnoreDeprecatedDeclarationsPragma(); } else { // Print a dummy C function so compiled object file is valid. List<AbstractTypeDeclaration> types = ASTUtil.getTypes(unit); if (!types.isEmpty()) { printf("void %s_unused() {}\n", NameTable.getFullName(types.get(0))); } } save(unit); }
// We generate the runtime debug method +memDebugStaticReferences. // This method will return an array of NSNumber containing pointers (casted into unsigned long) // to the objects referenced by a class variable with a strong reference. // It will be useful for debug purpose. // // Arrays returned by -memDebugStaticReferences and -memDebugStaticReferencesNames (see below) // must be the same size. // // In case of a Java enum, valuesVarNameis the name of the array of enum values. private void printStaticReferencesMethod(List<FieldDeclaration> fields, String valuesVarName) { if (Options.memoryDebug()) { if (!Options.useReferenceCounting()) { println("+ (NSArray *)memDebugStaticReferences {"); println(" return nil;"); println("}"); return; } println("+ (NSArray *)memDebugStaticReferences {"); println(" NSMutableArray *result = [NSMutableArray array];"); for (FieldDeclaration f : fields) { if (Modifier.isStatic(f.getModifiers())) { for (VariableDeclarationFragment var : ASTUtil.getFragments(f)) { IVariableBinding binding = Types.getVariableBinding(var); // All non-primitive static variables are strong references. if (!binding.getType().isPrimitive()) { String name = NameTable.getStaticVarQualifiedName(binding); println( String.format( " [result addObject:[JreMemDebugStrongReference " + "strongReferenceWithObject:%s name:@\"%s\"]];", name, name)); } } } } if (valuesVarName != null) { println( String.format( " [result addObject:[JreMemDebugStrongReference " + "strongReferenceWithObject:%s name:@\"enumValues\"]];", valuesVarName)); } println(" return result;"); println("}\n"); } }
private void printStaticVars(List<FieldDeclaration> fields, boolean isInterface) { boolean hadStaticVar = false; for (FieldDeclaration f : fields) { if (Modifier.isStatic(f.getModifiers()) || isInterface) { for (VariableDeclarationFragment var : ASTUtil.getFragments(f)) { IVariableBinding binding = Types.getVariableBinding(var); if (!BindingUtil.isPrimitiveConstant(binding)) { String name = NameTable.getStaticVarQualifiedName(binding); String objcType = NameTable.getObjCType(binding.getType()); Expression initializer = var.getInitializer(); if (initializer != null) { printf("static %s %s = %s;\n", objcType, name, generateExpression(initializer)); } else { printf("static %s %s;\n", objcType, name); } hadStaticVar = true; } } } } if (hadStaticVar) { newline(); } }
@Override protected void generate(EnumDeclaration node) { List<EnumConstantDeclaration> constants = ASTUtil.getEnumConstants(node); List<MethodDeclaration> methods = Lists.newArrayList(); List<FieldDeclaration> fields = Lists.newArrayList(); MethodDeclaration initializeMethod = null; for (BodyDeclaration decl : ASTUtil.getBodyDeclarations(node)) { if (decl instanceof FieldDeclaration) { fields.add((FieldDeclaration) decl); } else if (decl instanceof MethodDeclaration) { MethodDeclaration md = (MethodDeclaration) decl; if (md.getName().getIdentifier().equals("initialize")) { initializeMethod = md; } else { methods.add(md); } } } syncLineNumbers(node.getName()); // avoid doc-comment String typeName = NameTable.getFullName(node); newline(); for (EnumConstantDeclaration constant : constants) { IVariableBinding var = Types.getVariableBinding(constant.getName()); printf("static %s *%s;\n", typeName, NameTable.getStaticVarQualifiedName(var)); } printf("IOSObjectArray *%s_values;\n", typeName); newline(); printf("@implementation %s\n\n", typeName); printStaticVars(fields, /* isInterface */ false); printStaticReferencesMethod(fields, typeName + "_values"); for (EnumConstantDeclaration constant : constants) { String name = NameTable.getName(constant.getName()); printf("+ (%s *)%s {\n", typeName, name); printf(" return %s_%s;\n", typeName, name); println("}"); } newline(); // Enum constants needs to implement NSCopying. Being singletons, they // can just return self, as long the retain count is incremented. String selfString = Options.useReferenceCounting() ? "[self retain]" : "self"; printf("- (id)copyWithZone:(NSZone *)zone {\n return %s;\n}\n\n", selfString); printStaticFieldAccessors(fields, methods, /* isInterface */ false); printMethodsAndOcni(node, methods, blockComments.get(node)); printf("+ (void)initialize {\n if (self == [%s class]) {\n", typeName); for (int i = 0; i < constants.size(); i++) { EnumConstantDeclaration constant = constants.get(i); List<Expression> args = ASTUtil.getArguments(constant); String name = NameTable.getName(constant.getName()); String constantTypeName = NameTable.getFullName(Types.getMethodBinding(constant).getDeclaringClass()); printf(" %s_%s = [[%s alloc] init", typeName, name, constantTypeName); if (args.isEmpty()) { print("With"); } else { print( StatementGenerator.generateArguments( Types.getMethodBinding(constant), args, fieldHiders, getBuilder().getSourcePosition())); print(" with"); } printf("NSString:@\"%s\" withInt:%d];\n", name, i); } printf(" %s_values = [[IOSObjectArray alloc] initWithObjects:(id[]){ ", typeName); for (EnumConstantDeclaration constant : constants) { printf("%s_%s, ", typeName, NameTable.getName(constant.getName())); } printf( "nil } count:%d type:[IOSClass classWithClass:[%s class]]];\n", constants.size(), typeName); if (initializeMethod != null) { for (Statement s : ASTUtil.getStatements(initializeMethod.getBody())) { printf( " %s", StatementGenerator.generate(s, fieldHiders, false, getBuilder().getSourcePosition())); } } println(" }\n}\n"); // Print generated values and valueOf methods. println("+ (IOSObjectArray *)values {"); printf(" return [IOSObjectArray arrayWithArray:%s_values];\n", typeName); println("}\n"); printf("+ (%s *)valueOfWithNSString:(NSString *)name {\n", typeName); printf(" for (int i = 0; i < [%s_values count]; i++) {\n", typeName); printf(" %s *e = %s_values->buffer_[i];\n", typeName, typeName); printf(" if ([name isEqual:[e name]]) {\n"); printf(" return e;\n"); printf(" }\n"); printf(" }\n"); if (Options.useReferenceCounting()) { printf( " @throw [[[JavaLangIllegalArgumentException alloc] initWithNSString:name]" + " autorelease];\n"); } else { printf(" @throw [[JavaLangIllegalArgumentException alloc] initWithNSString:name];\n"); } printf(" return nil;\n"); println("}\n"); if (!Options.stripReflection()) { printTypeAnnotationsMethod(node); printMetadata(node); } println("@end"); }