@Override public Type getWithoutQualifiers() { return targetType.getWithoutQualifiers(); }
boolean typeRefersToUniform(Type type) { if (type.hasQualifier(TypeQualifier.UNIFORM)) { return true; } if (!(type.getWithoutQualifiers() instanceof ArrayType)) { return false; } return typeRefersToUniform(((ArrayType) type.getWithoutQualifiers()).getBaseType()); }
private IfStmt prepareReturnStmt(IInjectionPoint injectionPoint, IRandom generator, ShadingLanguageVersion shadingLanguageVersion, GenerationParams generationParams) { Type returnType = injectionPoint.getEnclosingFunction().getPrototype().getReturnType(); Stmt stmtToInject; if (returnType.hasCanonicalConstant()) { stmtToInject = new ReturnStmt(returnType.getCanonicalConstant()); } else if (returnType.getWithoutQualifiers() == VoidType.VOID) { stmtToInject = new ReturnStmt(); } else { stmtToInject = new BlockStmt(new ArrayList<>(), true); } return makeDeadConditional(injectionPoint, stmtToInject, generator, shadingLanguageVersion, generationParams); }
public List<VariablesDeclaration> getUniformDecls() { return getGlobalVariablesDeclarations() .stream() .filter(item -> item.getBaseType().hasQualifier(TypeQualifier.UNIFORM)) .collect(Collectors.toList()); }
final Type type = scopeOfStmt.lookupType(v); assert type != null; final Type varType = type.clone().getWithoutQualifiers(); assert !(varType.getWithoutQualifiers() instanceof ArrayType); params.add(new ParameterDecl(v, varType, null)); returnType = returnType.getWithoutQualifiers(); tu.addDeclarationBefore(new FunctionDefinition(new FunctionPrototype( newFunctionName,
@Override public StructDefinitionType clone() { return new StructDefinitionType(structNameType.map(StructNameType::clone), fieldNames, fieldTypes.stream().map(item -> item.clone()).collect(Collectors.toList())); }
@Override public Expr getCanonicalConstant() { return targetType.getCanonicalConstant(); }
@Override public boolean hasCanonicalConstant() { return targetType.hasCanonicalConstant(); }
private boolean hasOutQualifier(FunctionDefinition functionDefinition) { return functionDefinition.getPrototype().getParameters().stream() .map(item -> item.getType()) .anyMatch(item -> item.hasQualifier(TypeQualifier.OUT_PARAM) || item.hasQualifier(TypeQualifier.INOUT_PARAM)); }
@Override public InterfaceBlock clone() { return new InterfaceBlock(layoutQualifier, interfaceQualifier, structName, memberNames, memberTypes.stream().map(item -> item.clone()).collect(Collectors.toList()), instanceName); }
private Expr makeInitializationExpr(StructDefinitionType structDefinitionType, Expr originalInitializer) { List<Expr> args = new ArrayList<>(); for (int i = 0; i < structDefinitionType.getNumFields(); i++) { if (structDefinitionType.getFieldName(i).startsWith(Constants.STRUCTIFICATION_FIELD_PREFIX)) { final Type fieldType = structDefinitionType.getFieldType(i); args.add(fieldType instanceof StructNameType ? makeInitializationExpr(tu.getStructDefinition((StructNameType) fieldType), originalInitializer) : fieldType.getCanonicalConstant()); } else { args.add(originalInitializer); } } return new TypeConstructorExpr(structDefinitionType.getStructNameType().getName(), args); }
boolean typeIsReducibleToConst(Type type) { return type != null && type.hasCanonicalConstant(); }
private boolean isUsedStructType(Type type) { if (!(type.getWithoutQualifiers() instanceof StructDefinitionType)) { return false; } final StructDefinitionType sdt = (StructDefinitionType) type.getWithoutQualifiers(); return !unusedStructs.contains(sdt); }
assert !((VariablesDeclaration) decl).getBaseType().hasQualifier(TypeQualifier.UNIFORM); final String uniformName = interfaceBlock.getMemberNames().get(0); newTopLevelDeclarations.add(new VariablesDeclaration( new QualifiedType(interfaceBlock.getMemberTypes().get(0).getWithoutQualifiers(), Arrays.asList(TypeQualifier.UNIFORM)), new VariableDeclInfo(uniformName, null, null)));
@Override public void visitVariablesDeclaration(VariablesDeclaration variablesDeclaration) { if (variablesDeclaration.getBaseType().hasQualifier(TypeQualifier.UNIFORM)) { inUniformDecl = true; } super.visitVariablesDeclaration(variablesDeclaration); inUniformDecl = false; }
@Override public QualifiedType clone() { List<TypeQualifier> newQualifiers = new ArrayList<>(); for (TypeQualifier q : qualifiers) { newQualifiers.add(q); } return new QualifiedType(targetType.clone(), newQualifiers); }
@Override void identifyReductionOpportunitiesForChild(IAstNode parent, Expr child) { if (allowedToReduceExpr(parent, child) && !inLValueContext() && typeIsReducibleToConst(typer.lookupType(child)) && !isFullyReducedConstant(child)) { addOpportunity(new SimplifyExprReductionOpportunity( parent, typer.lookupType(child).getCanonicalConstant(), child, getVistitationDepth())); } }
private boolean typesMatchWithoutQualifiers(Type t1, Type t2) { return t1.getWithoutQualifiers().equals(t2.getWithoutQualifiers()); }
for (Declaration decl : tu.getTopLevelDeclarations()) { if (decl instanceof VariablesDeclaration && ((VariablesDeclaration) decl).getBaseType().hasQualifier(TypeQualifier.UNIFORM)) { final VariablesDeclaration variablesDeclaration = (VariablesDeclaration) decl; for (int i = 0; i < variablesDeclaration.getNumDecls(); i++) { assert !declInfo.hasInitializer(); final BasicType withoutQualifiers = (BasicType) variablesDeclaration.getBaseType() .getWithoutQualifiers(); declInfo.setInitializer(makeInitializer( withoutQualifiers,
@Override public void visitVariableIdentifierExpr(VariableIdentifierExpr variableIdentifierExpr) { super.visitVariableIdentifierExpr(variableIdentifierExpr); if (!currentVariablesDeclaration.isPresent()) { return; } if (!nonConst(variableIdentifierExpr)) { return; } if (currentVariablesDeclaration.get().getBaseType().hasQualifier(TypeQualifier.CONST)) { ((QualifiedType) currentVariablesDeclaration.get().getBaseType()) .removeQualifier(TypeQualifier.CONST); if (atGlobalScope) { assert !globalsToBeReInitialized.contains(currentVariablesDeclaration.get()); globalsToBeReInitialized.add(currentVariablesDeclaration.get()); } } else if (shadingLanguageVersion.globalVariableInitializersMustBeConst() && atGlobalScope) { if (!globalsToBeReInitialized.contains(currentVariablesDeclaration.get())) { globalsToBeReInitialized.add(currentVariablesDeclaration.get()); } } }