if (defineValue instanceof Expression.Constant) { Expression.Constant constant = (Expression.Constant) defineValue; return typed(findDefine(name), convertToJavaType(constant.getType())); return convertExpressionToJava(defineValue, libraryClassName, promoteNativeLongToLong, forceConstants, null); return typed(expr(Expression.Constant.Type.Bool, true), primRef(define, JavaPrim.Boolean)); } else if (sname.equals("False") || sname.equals("false")) { return typed(expr(Expression.Constant.Type.Bool, false), primRef(define, JavaPrim.Boolean)); } else { Enum.EnumItem enumItem = result.enumItems.get(name); if (enumItem != null) { return typed(getEnumItemValue(enumItem, forceConstants), typeRef(Integer.TYPE)); } else { VariablesDeclaration constant = result.globalVariablesByName.get(name); if (constant != null) { return typed(varRef(findRef(name, constant, libraryClassName, true)), null); } else { return typed(new Expression.VariableRef(name), null);
protected TypeRef findTypeRef(Identifier name, Identifier libraryClassName) { TypeRef tr; tr = findStructRef(name, libraryClassName); if (tr != null) { return tr; } tr = findEnum(name, libraryClassName); if (tr != null) { return tr; } tr = findCallbackRef(name, libraryClassName); if (tr != null) { return tr; } tr = findObjCClass(name); if (tr != null) { return tr; } tr = result.manualTypeDefs.get(name); if (tr != null) { return tr; } return null; }
public Expression getJavaClassLitteralExpression(TypeRef tr) { JavaPrim prim = result.typeConverter.getPrimitive(tr); return prim != null ? classLiteral(prim.type) : typeLiteral(tr.clone()); }
private Expression createEnumExpression(NL4JConversion enumType, Expression value) { TypeRef tr = enumType.getTypeRef(false); return methodCall(expr(typeRef(org.bridj.FlagSet.class)), "fromValue", value, result.typeConverter.typeLiteral(getSingleTypeParameter(tr))); }
public Pair<Expression, TypeRef> convertExpressionToJava(Expression x, Identifier libraryClassName, boolean promoteNativeLongToLong, boolean forceConstants, Map<String, Pair<Expression, TypeRef>> mappings) throws UnsupportedConversionException { Pair<Expression, TypeRef> res = null; if (x instanceof Expression.AssignmentOp) { Pair<Expression, TypeRef> convTarget = convertExpressionToJava(((Expression.AssignmentOp) x).getTarget(), libraryClassName, promoteNativeLongToLong, forceConstants, mappings), convValue = convertExpressionToJava(((Expression.AssignmentOp) x).getValue(), libraryClassName, promoteNativeLongToLong, forceConstants, mappings); res = typed(expr(convTarget.getFirst(), Expression.AssignmentOperator.Equal, convValue.getFirst()), convTarget.getSecond()); } else if (x instanceof Expression.BinaryOp) { Expression.BinaryOp bop = (Expression.BinaryOp) x; Pair<Expression, TypeRef> conv1 = convertExpressionToJava(bop.getFirstOperand(), libraryClassName, promoteNativeLongToLong, forceConstants, mappings), conv2 = convertExpressionToJava(bop.getSecondOperand(), libraryClassName, promoteNativeLongToLong, forceConstants, mappings); JavaPrim p1 = "long".equals(t1.toString()) ? JavaPrim.Long : getPrimitive(t1), p2 = "long".equals(t2.toString()) ? JavaPrim.Long : getPrimitive(t2); if (p1 != null && p2 != null) { switch (bop.getOperator()) { tr = primRef(x, p); break; res = typed(expr(x1, ((Expression.BinaryOp) x).getOperator(), x2), tr); Pair<Expression, TypeRef> conv = convertExpressionToJava(((Expression.UnaryOp) x).getOperand(), libraryClassName, promoteNativeLongToLong, forceConstants, mappings); res = typed(expr(op, conv.getFirst()), conv.getSecond()); } else if (x instanceof Expression.Constant) { Class<?> c = null; res = typed(((Expression.Constant) x).asJava(), typeRef(c));
@SuppressWarnings("static-access") protected Declaration outputConstant(String name, Pair<Expression, TypeRef> x, Signatures signatures, Element element, String elementTypeDescription, Identifier libraryClassName, boolean addFileComment, boolean signalErrors, boolean forceInteger, boolean alreadyConverted) throws UnsupportedConversionException { try { if (result.typeConverter.isJavaKeyword(name)) { throw new UnsupportedConversionException(element, "The name '" + name + "' is invalid for a Java field."); Pair<Expression, TypeRef> converted = alreadyConverted ? x : result.typeConverter.convertExpressionToJava(x.getFirst(), libraryClassName, true, false, null); JavaPrim prim = result.typeConverter.getPrimitive(converted.getValue()); converted = pair(expr("true".equals(String.valueOf(converted.toString())) ? 1 : 0), typeRef(Integer.TYPE)); String t = converted.toString(); if (t.contains("sizeof")) { converted = alreadyConverted ? x : result.typeConverter.convertExpressionToJava(x.getFirst(), libraryClassName, false, false, null);
result.structsFullNames.contains(name) || result.enumsFullNames.contains(name) ? name : result.typeConverter.findRef(name, target, libraryClassName, true); if (ref != null) { ret.outerJavaTypeRef = typeRef(ident(CLBuffer.class, expr(typeRef(ref)))); TypeRef ref = result.typeConverter.findStructRef((Struct)target, libraryClassName); if (ref != null) { ret.outerJavaTypeRef = typeRef(ident(CLBuffer.class, expr(ref)));
public SimpleTypeRef findStructRef(Identifier name, Identifier libraryClassName) { return findStructRef(result.resolveStruct(name), libraryClassName); }
public List<Declaration> convertVariablesDeclarationToBridJ(String name, TypeRef mutatedType, int[] iChild, int bits, boolean isGlobal, Identifier holderName, Identifier callerLibraryName, String callerLibrary, Element... toImportDetailsFrom) throws UnsupportedConversionException { name = result.typeConverter.getValidJavaArgumentName(ident(name)).toString(); getGlobalPointerExpr = methodCall(getGlobalPointerExpr, "as", result.typeConverter.typeLiteral(javaType.clone()));
e.setResolvedJavaIdentifier(typeConverter.computeTaggedTypeIdentifierInJava(e)); if (!currentNamespace.isEmpty()) e.setParentNamespace(currentNamespace.peek().clone()); Identifier identifier = typeConverter.getTaggedTypeIdentifierInJava(e); if (identifier != null) { enumsFullNames.add(identifier);
@Override public void visitFunctionSignature(FunctionSignature functionSignature) { super.visitFunctionSignature(functionSignature); Function function = functionSignature.getFunction(); Identifier name = typeConverter.inferCallBackName(functionSignature, false, false, null); Identifier identifier = typeConverter.computeCallbackIdentifierInJava(functionSignature); functionSignature.setResolvedJavaIdentifier(identifier); if (function != null) { if (functionSignature.findParentOfType(Struct.class) == null) { getList(callbacksByLibrary, getLibrary(functionSignature)).add(functionSignature); } if (name != null) { callbacksByName.put(name, functionSignature); if (identifier != null) { callbacksFullNames.add(identifier); } } } }
Pair<Expression, TypeRef> val = result.typeConverter.convertExpressionToJava(defaultValue, libraryClassName, true, false, null); : primRef(v, prim) //result.typeConverter.convertTypeToJNA(mutatedType, TypeConversion.TypeConversionMode.FieldType, libraryClassName)
continue; String itemName = result.typeConverter.getValidJavaIdentifierString(ident(er.originalItem.getName())); Declaration ct = outputConstant( itemName, result.typeConverter.convertExpressionToJava(er.unconvertedValue, libraryClassName, true, false, null), signatures, er.originalItem,
public VariablesDeclaration convertVariablesDeclarationToJNA(String name, TypeRef mutatedType, int[] iChild, Identifier callerLibraryName, Element... toImportDetailsFrom) throws UnsupportedConversionException { name = result.typeConverter.getValidJavaArgumentName(ident(name)).toString(); break; } else { Pair<Expression, TypeRef> c = result.typeConverter.convertExpressionToJava(x, callerLibraryName, false, true, null); c.getFirst().setParenthesis(dims.size() != 1); if (mul == null) {
res.convertedValue = result.typeConverter.convertExpressionToJava(res.unconvertedValue, libraryClassName, true, false, mappings).getFirst(); res.constantValue = result.typeConverter.convertExpressionToJava(res.unconvertedValue, libraryClassName, true, true, mappings).getFirst(); mappings.put(item.getName(), typed(res.constantValue, typeRef(int.class))); } catch (Exception ex) { failedOnceForThisEnum = true;
functionName = ident(result.typeConverter.beautify(n, false)); functionName = result.typeConverter.getValidJavaMethodName(functionName); if (functionName == null) { return;
@Override public TypeRef findCallbackRef(TypeRef.FunctionSignature s, Identifier callerLibraryClass) { return pointerTypeRef(super.findCallbackRef(s, callerLibraryClass)); }
return super.convertExpressionToJava(x, libraryClassName, promoteNativeLongToLong, forceConstant, mappings);
public String chooseName(Element e, List<String> ownerNames, boolean isType) { String s = chooseNameSuffix(e); if (s == null) { return null; } String n; List<String> names = new ArrayList<String>(); if (ownerNames != null) { names.addAll(ownerNames); } if (ownerNames.isEmpty()) { n = s + (nextAnonymous++); } else { names.add(s); switch (nameGenerationStyle) { case Java: n = StringUtils.capitalize(ownerNames, ""); break; case PreserveCaseAndSeparateByUnderscores: n = StringUtils.implode(names, "_"); break; default: throw new UnsupportedOperationException("Unknown name generation style " + nameGenerationStyle); } } if (result.config.beautifyNames) { n = result.typeConverter.beautify(n, isType); } return n; }
private Expression createEnumExpression(NL4JConversion enumType, Expression value) { TypeRef tr = enumType.getTypeRef(false); return methodCall(expr(typeRef(org.bridj.FlagSet.class)), "fromValue", value, result.typeConverter.typeLiteral(getSingleTypeParameter(tr))); }