@Override public final int hashCode() { return toString().hashCode(); } public abstract Identifier resolveAllButLastIdentifier();
@Override public QualifiedIdentifier clone() { return (QualifiedIdentifier)super.clone(); }
public static Identifier ident(Identifier ident, Identifier... others) { if (ident == null) { if (others.length > 0) { return ident(others[0], Arrays.copyOfRange(others, 1, others.length)); } return null; } return ident.derive(Identifier.QualificationSeparator.Dot, others); }
public static Identifier templateIdent(Identifier base, Expression... args) { Identifier id = base.clone(); id.resolveLastSimpleIdentifier().setTemplateArguments(Arrays.asList(args)); return id; }
private boolean isJNAPointer(TypeRef tr) { if (!(tr instanceof SimpleTypeRef)) return false; SimpleTypeRef str = (SimpleTypeRef) tr; Identifier name = str.getName().eraseTemplateArguments(); return name.toString().equals(com.sun.jna.Pointer.class.getName()); } @SuppressWarnings("unchecked")
public Identifier getActualTaggedTypeName(TaggedTypeRef struct) { Identifier structName = null; Identifier tag = struct.getTag(); if (tag == null || tag.isPlain() && tag.toString().startsWith("_")) { TypeDef parentDef = as(struct.getParentElement(), TypeDef.class); if (parentDef != null) { structName = new Identifier.SimpleIdentifier(JNAeratorUtils.findBestPlainStorageName(parentDef)); } else if (tag != null) { String better = tag.toString().substring(1); Pair<TypeDef, Declarator> pair = result.typeDefs.get(better); if (pair != null && pair.getFirst().getValueType() != null && pair.getSecond() instanceof DirectDeclarator) { TypeRef tr = pair.getFirst().getValueType(); DirectDeclarator dd = (DirectDeclarator) pair.getSecond(); if (tr instanceof SimpleTypeRef) { if (tag.equals(((SimpleTypeRef) tr).getName())) { structName = ident(dd.resolveName()); } } else if (tr instanceof TaggedTypeRef) { if (tag.equals(((TaggedTypeRef) tr).getTag())) { structName = ident(dd.resolveName()); } } } } } if (structName == null || structName.toString().equals("")) { structName = tag; } return structName == null ? null : structName.clone(); }
librariesHub.addModifiers(ModifierType.Public, ModifierType.Abstract); Identifier hubName = result.getHubFullClassName(); librariesHub.setTag(hubName.resolveLastSimpleIdentifier()); hubOut = result.classOutputter.getClassSourceWriter(hubName.toString()); hubOut.println("package " + hubName.resolveAllButLastIdentifier() + ";"); for (Identifier pn : result.javaPackages) { if (!pn.equals("")) { hubOut.println("import " + pn + ".*;"); if (librariesHub != null) { librariesHub.addDeclaration(instanceDecl); librariesHub.addProtocol(fullLibraryClassName.clone()); } else { interf.addDeclaration(instanceDecl);
if (!"void".equals(name.toString()) && name.isPlain()) { return tr; } else { return typeRef(((TypeRef.FunctionSignature) valueType).getFunction().getName().clone()); return new TypeRef.ArrayRef(typeRef(tname.clone())); return typeRef(name.clone()); return typeRef(result.getFakePointer(libraryClassName, ((TypeRef.SimpleTypeRef) valueType).getName().clone()));
if (rawEnumName != null && rawEnumName.resolveLastSimpleIdentifier().getName() != null) { hasEnumClass = true; if (result.config.forceNames || !rawEnumName.equals(enumName)) annotateActualName(en, rawEnumName); addParentNamespaceAnnotation(en, e.getParentNamespace()); en.setTag(enumName.clone()); en.addModifiers(ModifierType.Public); out.addDeclaration(new TaggedTypeRefDeclaration(en)); en.addInterface(ident(IntValuedEnum.class, expr(typeRef(enumName.clone())))); String valueArgName = "value"; body.addDeclaration(new Function(Type.JavaMethod, enumName.clone(), null, new Arg(valueArgName, typeRef(Long.TYPE))).setBody(block( stat(expr(memberRef(thisRef(), MemberRefStyle.Dot, valueArgName), AssignmentOperator.Equal, varRef(valueArgName)))))); body.addDeclaration(new VariablesDeclaration(typeRef(Long.TYPE), new DirectDeclarator(valueArgName)).addModifiers(ModifierType.Public, ModifierType.Final)); body.addDeclaration(new Function(Type.JavaMethod, ident("iterator"), typeRef(ident(Iterator.class, expr(typeRef(enumName.clone()))))).setBody(block( new Statement.Return( methodCall( "iterator")))).addModifiers(ModifierType.Public)); body.addDeclaration(new Function(Type.JavaMethod, ident("fromValue"), typeRef(ident(IntValuedEnum.class, expr(typeRef(enumName.clone())))), new Arg(valueArgName, typeRef(Integer.TYPE))).setBody(block( new Statement.Return( methodCall(
public static void printJava(Identifier packageName, Identifier className, Element rootElement, PrintWriter out) { final Map<String, Set<Identifier>> identifiersBySimpleName = new LinkedHashMap<String, Set<Identifier>>(); final String outputPackage = packageName.toString(); final String outputClassPrefix = className + "."; importedClassesStrings.add(className.toString()); if (kv.getValue().size() == 1) { Identifier id = kv.getValue().iterator().next(); String ids = id.toString(); if (ids.indexOf(".") < 0) { continue; SimpleIdentifier si = id.resolveLastSimpleIdentifier(); if (si.isJavaStaticImportable()) continue; String name = si.getName(); resolvedIds.put(id, name); Identifier pack = id.resolveAllButLastIdentifier(); if (pack == null) { continue; String ps = pack.toString(); importedClassesStrings.add(ids);
@Override public Expression typeLiteral(TypeRef c) { if (c instanceof SimpleTypeRef && result.config.runtime == JNAeratorConfig.Runtime.BridJ) { Identifier id = ((SimpleTypeRef) c).getName(); Identifier.SimpleIdentifier sid = id.resolveLastSimpleIdentifier(); if (!sid.getTemplateArguments().isEmpty()) { Identifier erased = id.eraseTemplateArguments(); List<Expression> exprs = new ArrayList<Expression>(); exprs.add(typeLiteral(typeRef(erased.clone()))); for (Expression t : sid.getTemplateArguments()) { if (t instanceof Expression.TypeRefExpression) { exprs.add(typeLiteral(((Expression.TypeRefExpression) t).getType().clone())); } } return methodCall(expr(typeRef(DefaultParameterizedType.class)), "paramType", exprs.toArray(new Expression[exprs.size()])); } } return super.typeLiteral(c); }
private void visit(final Identifier fullClassName, Element interf, String currentLibrary) throws FileNotFoundException { final Identifier pack = fullClassName.resolveAllButLastIdentifier(); String spack = result.getLibraryPackage(currentLibrary).toString(); final PrintWriter out = new PrintWriter(getLibOut(spack, currentLibrary)); interf.accept(new Scanner() {
static boolean isNull(Identifier i) { return i == null || i.resolveLastSimpleIdentifier() == null || i.resolveLastSimpleIdentifier().getName() == null; }
@SuppressWarnings("unchecked") @Override public void visitIdentifier(Identifier e) { super.visitIdentifier(e); if (e.getParentElement() instanceof QualifiedIdentifier) { return; } Element parent = e.getParentElement(); if (!(parent instanceof TypeRef)) { return; } e = e.clone(); SimpleIdentifier si = e.resolveLastSimpleIdentifier(); si.setTemplateArguments(Collections.EMPTY_LIST); String name = si.getName(); Set<Identifier> ids = identifiersBySimpleName.get(name); if (ids == null) { identifiersBySimpleName.put(name, ids = new HashSet<Identifier>()); } ids.add(e); } });
private void fillIn(Signatures signatures, Identifier functionName, Function nativeMethod, NL4JConversion returnType, List<NL4JConversion> paramTypes, List<String> paramNames, Identifier varArgType, String varArgName, boolean isCallback, boolean useRawTypes) { for (int i = 0, n = paramTypes.size(); i < n; i++) { NL4JConversion paramType = paramTypes.get(i); String paramName = paramNames.get(i); nativeMethod.addArg(paramType.annotateTypedType(new Arg(paramName, paramType.getTypeRef(useRawTypes)), useRawTypes));//.getTypedTypeRef()))); } if (varArgType != null) { nativeMethod.addArg(new Arg(varArgName, typeRef(varArgType.clone()))).setVarArg(true); } if (returnType != null) { returnType.annotateTypedType(nativeMethod, useRawTypes); nativeMethod.setValueType(returnType.getTypeRef(useRawTypes)); } String natSig = nativeMethod.computeSignature(SignatureType.JavaStyle); Identifier javaMethodName = signatures == null ? functionName : signatures.findNextMethodName(natSig, functionName); if (!javaMethodName.equals(functionName)) { nativeMethod.setName(javaMethodName); } }
private Element resolve(Identifier ident, boolean varOrType) { if (ident == null) { return null; } // TODO handle new namespace Identifier lastIdent = ident.resolveLastSimpleIdentifier(); Element resolved = (varOrType ? variableDefinitions : typeDefinitions).get(lastIdent); if (resolved == null) { if (parent != null) { return parent.resolve(ident, varOrType); } //if (ident.getParentElement() instanceof TypeRef && ident.getParentElement().getParentElement() instanceof VariablesDeclaration) // System.out.println("hehehe"); return null; } //System.out.println("Resolved " + ident + " as " + resolved); //System.err.println("Resolved " + ident + " as " + resolved); (varOrType ? symbols.resolvedVariables : symbols.resolvedTypes).put(ident.getId(), resolved); return resolved; } }
public Struct notifyBeforeWritingClass(Identifier fullClassName, Struct interf, Signatures signatures, String currentLibrary) { for (Class<?> c : overwrittenClassesThatNeedToKeepAllTheirMethods) { if (fullClassName.equals(c.getName())) { declarationsConverter.addMissingMethods(c, signatures, interf); break; } } if (fullClassName.resolveLastSimpleIdentifier().equals("char")) { return null; } String runtimeSpecificHelp = config.runtime == JNAeratorConfig.Runtime.BridJ ? "or <a href=\"http://bridj.googlecode.com/\">BridJ</a> " : ", <a href=\"http://rococoa.dev.java.net/\">Rococoa</a>, " + "or <a href=\"http://jna.dev.java.net/\">JNA</a>"; interf.addToCommentBefore( "This file was autogenerated by <a href=\"http://jnaerator.googlecode.com/\">JNAerator</a>, ", "a tool written by <a href=\"http://ochafik.com/\">Olivier Chafik</a> that <a href=\"http://code.google.com/p/jnaerator/wiki/CreditsAndLicense\">uses a few opensource projects.</a>.", "For help, please visit <a href=\"http://nativelibs4java.googlecode.com/\">NativeLibs4Java</a> " + runtimeSpecificHelp + "."); for (ClassWritingNotifiable n : classWritingNotifiables) { interf = n.writingClass(fullClassName, interf, signatures, currentLibrary); if (interf == null) { return null; } } return interf; } public List<ClassWritingNotifiable> classWritingNotifiables = new ArrayList<ClassWritingNotifiable>();
private void addAllocIfMissing(Struct in, String allocName) { Identifier n = in.getTag(); if (n.equals("NSObject") || n.equals("NSClass")) { return; } boolean hasAlloc = false; for (Declaration d : in.getDeclarations()) { if (d instanceof Function) { Function f = (Function) d; if (f.getArgs().isEmpty() && allocName.equals(f.getName())) { hasAlloc = true; break; } } } if (!hasAlloc) { in.addDeclaration(new Function(Function.Type.ObjCMethod, ident(allocName), typeRef(in.getTag())).addModifiers(ModifierType.Static)); } }