X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=1e57ed649041cacdfaa58b56fa0a56dee5642dc9;hb=4414f0245005c8cfcd02b51ea394d612cc5776c4;hp=610aa390964faa9ea91dc5fdc06695a0ea318d0c;hpb=6d11ee7d6137117f441951615cd4cde4d59bf968;p=libs%2Fgl.git diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp index 610aa390..1e57ed64 100644 --- a/source/glsl/generate.cpp +++ b/source/glsl/generate.cpp @@ -238,6 +238,15 @@ void VariableResolver::enter(Block &block) block.variables.clear(); } +void VariableResolver::visit_and_replace(RefPtr &expr) +{ + r_replacement_expr = 0; + expr->visit(*this); + if(r_replacement_expr) + expr = r_replacement_expr; + r_replacement_expr = 0; +} + void VariableResolver::visit(VariableReference &var) { VariableDeclaration *declaration = 0; @@ -260,11 +269,12 @@ void VariableResolver::visit(VariableReference &var) { /* The name refers to an interface block with an instance name rather than a variable. Prepare a new syntax tree node accordingly. */ - r_iface_ref = new InterfaceBlockReference; - r_iface_ref->source = var.source; - r_iface_ref->line = var.line; - r_iface_ref->name = var.name; - r_iface_ref->declaration = i->second; + InterfaceBlockReference *iface_ref = new InterfaceBlockReference; + iface_ref->source = var.source; + iface_ref->line = var.line; + iface_ref->name = var.name; + iface_ref->declaration = i->second; + r_replacement_expr = iface_ref; } else { @@ -308,11 +318,7 @@ void VariableResolver::visit(InterfaceBlockReference &iface) void VariableResolver::visit(MemberAccess &memacc) { - r_iface_ref = 0; - memacc.left->visit(*this); - if(r_iface_ref) - memacc.left = r_iface_ref; - r_iface_ref = 0; + visit_and_replace(memacc.left); map *members = 0; if(StructDeclaration *strct = dynamic_cast(memacc.left->type)) @@ -337,8 +343,7 @@ void VariableResolver::visit(MemberAccess &memacc) void VariableResolver::visit(UnaryExpression &unary) { - TraversingVisitor::visit(unary); - r_iface_ref = 0; + visit_and_replace(unary.expression); } void VariableResolver::visit(BinaryExpression &binary) @@ -349,17 +354,15 @@ void VariableResolver::visit(BinaryExpression &binary) /* The subscript expression is not a part of the primary assignment target. */ SetFlag set(record_target, false); - binary.right->visit(*this); + visit_and_replace(binary.right); } - r_iface_ref = 0; - binary.left->visit(*this); - if(r_iface_ref) - binary.left = r_iface_ref; + visit_and_replace(binary.left); } else - TraversingVisitor::visit(binary); - - r_iface_ref = 0; + { + visit_and_replace(binary.left); + visit_and_replace(binary.right); + } } void VariableResolver::visit(Assignment &assign) @@ -367,22 +370,20 @@ void VariableResolver::visit(Assignment &assign) { SetFlag set(record_target); r_assignment_target = 0; - assign.left->visit(*this); + visit_and_replace(assign.left); r_any_resolved |= (r_assignment_target!=assign.target_declaration); assign.target_declaration = r_assignment_target; } r_self_referencing = false; - assign.right->visit(*this); + visit_and_replace(assign.right); assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='='); - - r_iface_ref = 0; } void VariableResolver::visit(FunctionCall &call) { - TraversingVisitor::visit(call); - r_iface_ref = 0; + for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + visit_and_replace(*i); } void VariableResolver::visit(VariableDeclaration &var) @@ -583,10 +584,8 @@ void ExpressionResolver::visit(UnaryExpression &unary) resolve(unary, basic, unary.expression->lvalue); } -void ExpressionResolver::visit(BinaryExpression &binary) +void ExpressionResolver::visit(BinaryExpression &binary, bool assign) { - TraversingVisitor::visit(binary); - /* Binary operators are only defined for basic types (not for image or structure types). */ BasicTypeDeclaration *basic_left = dynamic_cast(binary.left->type); @@ -618,6 +617,8 @@ void ExpressionResolver::visit(BinaryExpression &binary) Compatibility elem_compat = get_compatibility(*elem_left, *elem_right); if(elem_compat==NOT_COMPATIBLE) return; + if(assign && (compat==LEFT_CONVERTIBLE || elem_compat==LEFT_CONVERTIBLE)) + return; TypeDeclaration *type = 0; char oper2 = binary.oper->token[1]; @@ -656,11 +657,17 @@ void ExpressionResolver::visit(BinaryExpression &binary) } else if((oper=='<' || oper=='>') && oper2==oper) { - // Shifts only apply to integers. - if(basic_left->kind!=BasicTypeDeclaration::INT || basic_right->kind!=BasicTypeDeclaration::INT) + // Shifts apply to integer scalars and vectors, with some restrictions. + if(elem_left->kind!=BasicTypeDeclaration::INT || elem_right->kind!=BasicTypeDeclaration::INT) + return; + unsigned left_size = (basic_left->kind==BasicTypeDeclaration::INT ? 1 : basic_left->kind==BasicTypeDeclaration::VECTOR ? basic_left->size : 0); + unsigned right_size = (basic_right->kind==BasicTypeDeclaration::INT ? 1 : basic_right->kind==BasicTypeDeclaration::VECTOR ? basic_right->size : 0); + if(!left_size || (left_size==1 && right_size!=1) || (left_size>1 && right_size!=1 && right_size!=left_size)) return; type = basic_left; + // Don't perform conversion even if the operands are of different sizes. + compat = SAME_TYPE; } else if(oper=='+' || oper=='-' || oper=='*' || oper=='/') { @@ -707,6 +714,9 @@ void ExpressionResolver::visit(BinaryExpression &binary) else return; + if(assign && type!=basic_left) + return; + bool converted = true; if(compat==LEFT_CONVERTIBLE) convert_to(binary.left, *basic_right); @@ -720,12 +730,35 @@ void ExpressionResolver::visit(BinaryExpression &binary) if(!converted) type = 0; - resolve(binary, type, false); + resolve(binary, type, assign); +} + +void ExpressionResolver::visit(BinaryExpression &binary) +{ + TraversingVisitor::visit(binary); + visit(binary, false); } void ExpressionResolver::visit(Assignment &assign) { TraversingVisitor::visit(assign); + + if(assign.oper->token[0]!='=') + return visit(assign, true); + else if(assign.left->type!=assign.right->type) + { + BasicTypeDeclaration *basic_left = dynamic_cast(assign.left->type); + BasicTypeDeclaration *basic_right = dynamic_cast(assign.right->type); + if(!basic_left || !basic_right) + return; + + Compatibility compat = get_compatibility(*basic_left, *basic_right); + if(compat==RIGHT_CONVERTIBLE) + convert_to(assign.right, *basic_left); + else if(compat!=SAME_TYPE) + return; + } + resolve(assign, assign.left->type, true); }