@Override public boolean equals(Object that) { if (this == that) { return true; } if (!(that instanceof ArrayType)) { return false; } ArrayType thatArrayType = (ArrayType) that; return this.baseType.equals(thatArrayType.baseType) && this.arrayInfo.equals(thatArrayType.arrayInfo); }
@Override public int hashCode() { // TODO: revisit if we end up storing large sets of types return baseType.hashCode() + arrayInfo.hashCode(); }
private Optional<Integer> maybeGetArrayCount(VariableDeclInfo vdi) { if (vdi.hasArrayInfo()) { return Optional.of(vdi.getArrayInfo().getSize()); } return Optional.empty(); }
private static Initializer makeInitializer(BasicType baseType, ArrayInfo arrayInfo, List<Number> args) { if (arrayInfo != null) { assert arrayInfo.getSize() * baseType.getNumElements() == args.size(); List<Expr> argExprs = new ArrayList<>(); for (int index = 0; index < arrayInfo.getSize(); index++) { argExprs.add(getBasicTypeLiteralExpr(baseType, args.subList(index * baseType.getNumElements(), (index + 1) * baseType.getNumElements()))); } return new ScalarInitializer(new ArrayConstructorExpr( new ArrayType(baseType.getWithoutQualifiers(), arrayInfo.clone()), argExprs)); } return new ScalarInitializer(getBasicTypeLiteralExpr(baseType, args)); }
private void processArrayInfo(Type type) { if (!(type.getWithoutQualifiers() instanceof ArrayType)) { return; } ArrayType arrayType = (ArrayType) type.getWithoutQualifiers(); while (true) { out.append("[" + (arrayType.getArrayInfo().hasSize() ? arrayType.getArrayInfo().getSize() : "") + "]"); if (!(arrayType.getBaseType().getWithoutQualifiers() instanceof ArrayType)) { break; } arrayType = (ArrayType) arrayType.getBaseType().getWithoutQualifiers(); } }
private FloatLiteralReplacer(TranslationUnit tu) { parentMap = IParentMap.createParentMap(tu); uniformIndex = 0; literalToUniformIndex = new HashMap<>(); visit(tu); if (uniformIndex > 0) { tu.addDeclaration(new VariablesDeclaration( new QualifiedType(BasicType.FLOAT, Arrays.asList(TypeQualifier.UNIFORM)), new VariableDeclInfo(Constants.FLOAT_CONST, new ArrayInfo(uniformIndex), null) )); } }
@Override public VariableDeclInfo clone() { return new VariableDeclInfo(name, arrayInfo == null ? null : arrayInfo.clone(), initializer == null ? null : initializer.clone()); }
@Override public void visitArrayConstructorExpr(ArrayConstructorExpr arrayConstructorExpr) { visit(arrayConstructorExpr.getArrayType()); out.append("[" + arrayConstructorExpr.getArrayType().getArrayInfo().getSize() + "]("); boolean first = true; for (Expr e : arrayConstructorExpr.getArgs()) { if (!first) { out.append(", "); } first = false; visit(e); } out.append(")"); }
private ArrayInfo getArrayInfo(Array_specifierContext arraySpecifierContext) { if (arraySpecifierContext.array_specifier() != null) { throw new RuntimeException("Not yet supporting multi-dimmensional arrays"); } if (arraySpecifierContext.constant_expression() == null) { // An array with unspecified length. return new ArrayInfo(); } final Expr expr = (Expr) visit(arraySpecifierContext.constant_expression()); if (expr instanceof IntConstantExpr) { return new ArrayInfo(Integer.parseInt(((IntConstantExpr) expr).getValue())); } throw new RuntimeException("Unable to construct array info for array with size " + expr.getText()); }
@Override public ParameterDecl clone() { return new ParameterDecl(name, type.clone(), arrayInfo == null ? null : arrayInfo.clone()); }
@Override public void visitParameterDecl(ParameterDecl parameterDecl) { visit(parameterDecl.getType()); if (parameterDecl.getName() != null) { out.append(" " + parameterDecl.getName()); } if (parameterDecl.getArrayInfo() != null) { out.append("[" + parameterDecl.getArrayInfo().getSize() + "]"); } }
private DeclarationStmt fuzzDeclarationStmt() { final Type baseType = fuzzType(); final int numDeclsInGroup = generator.nextPositiveInt(MAX_LOCALS_IN_DECL_GROUP); List<VariableDeclInfo> decls = new ArrayList<>(); for (int i = 0; i < numDeclsInGroup; i++) { final String name = createName("v"); ArrayInfo arrayInfo = null; if (generator.nextInt(10) < 3) { // TODO Hack for now, needs thought arrayInfo = new ArrayInfo(generator.nextPositiveInt(MAX_ARRAY_SIZE)); } fuzzingContext.addLocal(name, arrayInfo == null ? baseType : getType(baseType, arrayInfo)); decls.add(new VariableDeclInfo(name, arrayInfo, null)); // TODO: no initializer for now } return new DeclarationStmt(new VariablesDeclaration(baseType, decls)); }
@Override public ArrayType clone() { return new ArrayType(baseType.clone(), arrayInfo.clone()); }
private static Integer getSize(Type type) { assert isArrayVectorOrMatrix(type); if (type instanceof ArrayType) { return ((ArrayType) type).getArrayInfo().getSize(); } if (BasicType.allVectorTypes().contains(type)) { return ((BasicType) type).getNumElements(); } return ((BasicType) type).getNumColumns(); }
@Override public void visitVariablesDeclaration(VariablesDeclaration variablesDeclaration) { final Type baseType = variablesDeclaration.getBaseType(); visit(baseType); out.append(" "); boolean first = true; for (VariableDeclInfo vdi : variablesDeclaration.getDeclInfos()) { if (!first) { out.append(", "); } first = false; out.append(vdi.getName()); if (vdi.hasArrayInfo()) { out.append("[" + vdi.getArrayInfo().getSize() + "]"); assert !(baseType instanceof ArrayType); } else if (baseType instanceof ArrayType) { out.append("[" + ((ArrayType) baseType).getArrayInfo().getSize() + "]"); } if (vdi.hasInitializer()) { out.append(" = "); visit(vdi.getInitializer()); } } }
ArrayType arrayType = (ArrayType) targetType; List<Expr> args = new ArrayList<>(); for (int i = 0; i < arrayType.getArrayInfo().getSize(); i++) { args.add(makeExpr(arrayType.getBaseType(), isLValue, constContext, depth + 1));
arrayLength = vdi.getArrayInfo().getSize(); } else { arrayLength = 1;