public Value evaluate()

in modules/asc/src/java/macromedia/asc/semantics/ConfigurationEvaluator.java [439:655]
208 lines of code
67 McCabe index (conditional complexity)

	public Value evaluate(Context cx, BinaryExpressionNode node) {
		Value val = null;
		if( fold_expressions )
		{
			Value lhs_val = node.lhs.evaluate(cx, this);
			Value rhs_val = node.rhs.evaluate(cx, this);
			
			Node new_lhs = foldRefValue(cx, lhs_val);
			Node new_rhs = foldRefValue(cx, rhs_val);
			if( new_lhs != null )
			{
				node.lhs = new_lhs;
				lhs_val = node.lhs.evaluate(cx, this);
			}
			if( new_rhs != null )
			{
				node.rhs = new_rhs;
				rhs_val = node.rhs.evaluate(cx, this);
			}
			
			if( lhs_val != null && rhs_val != null && lhs_val.hasValue() && rhs_val.hasValue() )
			{
				ObjectValue lhs_ov = (ObjectValue)lhs_val;
				ObjectValue rhs_ov = (ObjectValue)rhs_val;
				
				TypeValue lt = lhs_ov.getType(cx).getTypeValue();
				TypeValue rt = rhs_ov.getType(cx).getTypeValue();
				
				switch(node.op)
				{
				case PLUS_TOKEN:
					if( isNumericType(cx, lt) && isNumericType(cx, rt) )
					{
	                    TypeValue[] type = new TypeValue[1];
	                    double ld = cx.getEmitter().getValueOfNumberLiteral( lhs_ov.getValue(), type, node.numberUsage).doubleValue();
	                    double rd = cx.getEmitter().getValueOfNumberLiteral( rhs_ov.getValue(), type, node.numberUsage).doubleValue();
	                    double d = 0.0/0;
	                    d = ld + rd;
	                    val = new ObjectValue(Double.toString(d), cx.numberType());
					}
					else if( lt == cx.stringType() || rt == cx.stringType() )
					{
	                    String ls = toString(cx, lhs_ov);
	                    String rs = toString(cx, rhs_ov);
	                    val = new ObjectValue(ls+rs,cx.stringType());
					}
					break;
	            case MINUS_TOKEN:
	            case MULT_TOKEN:
	            case DIV_TOKEN:
	            case MODULUS_TOKEN:
	            	if( isNumericType(cx, lt) && isNumericType(cx, rt) )
	            	{
	                    TypeValue[] type = new TypeValue[1];
	                    double ld = cx.getEmitter().getValueOfNumberLiteral( lhs_ov.getValue(), type, node.numberUsage).doubleValue();
	                    double rd = cx.getEmitter().getValueOfNumberLiteral( rhs_ov.getValue(), type, node.numberUsage).doubleValue();
	                    double d = 0.0/0;
	                    switch( node.op )
	                    {
	                    case MINUS_TOKEN:
	                        d = ld-rd;
	                        break;
	                    case MULT_TOKEN:
	                        d = ld*rd;
	                        break;
	                    case DIV_TOKEN:
	                        d = ld/rd;
	                        break;
	                    case MODULUS_TOKEN:
	                        d = ld%rd;
	                        break;
	                    }
	                    val = new ObjectValue(Double.toString(d), cx.numberType());
	                    break;
	            	}
				case LOGICALOR_TOKEN:
				{
					Boolean b = toBoolean(cx, lhs_ov);
					Boolean b2 = toBoolean(cx, rhs_ov);
					if( b != null && b2 != null )
					{
						val = getBooleanObjectValue(cx, b.booleanValue() || b2.booleanValue());
					}
					break;
				}
				case LOGICALAND_TOKEN:
				{
					Boolean b = toBoolean(cx, lhs_ov);
					Boolean b2 = toBoolean(cx, rhs_ov);
					if( b != null && b2 != null )
					{
						val = getBooleanObjectValue(cx, b.booleanValue() && b2.booleanValue());
					}
					break;
				}
				case EQUALS_TOKEN:
				case NOTEQUALS_TOKEN:
				{
					Boolean b = compare(cx, lhs_ov, rhs_ov);
					if( b != null )
						if( node.op == NOTEQUALS_TOKEN)
							val = getBooleanObjectValue(cx, !b.booleanValue());
						else
							val = getBooleanObjectValue(cx, b.booleanValue());
					break;
				}
				
				case LESSTHAN_TOKEN:
				case GREATERTHANOREQUALS_TOKEN:
				{
					String less_result = lessthan(cx, lhs_ov, rhs_ov);
					Boolean b = null;
					if( node.op == LESSTHAN_TOKEN )
					{
						if( less_result == UNDEFINED || less_result == FALSE )
							b = Boolean.FALSE;
						else
							b = Boolean.TRUE ;
					}
					else
					{
						if( less_result == UNDEFINED || less_result == TRUE )
							b = Boolean.FALSE;
						else
							b = Boolean.TRUE;
					}
					if( b != null )
						val = getBooleanObjectValue(cx, b.booleanValue());
					break;
				}
				
				case LESSTHANOREQUALS_TOKEN:
				case GREATERTHAN_TOKEN:
				{
					String less_result = lessthan(cx, rhs_ov, lhs_ov);
					Boolean b = null;
					if( node.op == LESSTHANOREQUALS_TOKEN )
					{
						if( less_result == UNDEFINED || less_result == TRUE )
							b = Boolean.FALSE;
						else
							b = Boolean.TRUE ;
					}
					else
					{
						if( less_result == UNDEFINED || less_result == FALSE )
							b = Boolean.FALSE;
						else
							b = Boolean.TRUE;
					}
					if( b != null )
						val = getBooleanObjectValue(cx, b.booleanValue());
					break;
				}
				
				case LEFTSHIFT_TOKEN:
				case RIGHTSHIFT_TOKEN:
				{
					Integer li  = toInt(cx, lhs_ov);
					Integer ri = toInt(cx, rhs_ov) ;
					if( li != null && ri != null )
					{
						ri = ri & 0x1F;
						if( node.op == LEFTSHIFT_TOKEN )
							val = new ObjectValue(String.valueOf(li << ri), cx.intType());
						else
							val = new ObjectValue(String.valueOf(li >> ri), cx.intType());
					}
					break;
				}
				case UNSIGNEDRIGHTSHIFT_TOKEN:
				{
					Long ll  = toUInt(cx, lhs_ov);
					Long rl = toUInt(cx, rhs_ov);
					if( ll != null && rl != null )
					{
						rl = rl & 0x1F;
						val = new ObjectValue(String.valueOf(ll >>> rl), cx.intType());
					}
					break;
				}
				
				case BITWISEAND_TOKEN:
				case BITWISEXOR_TOKEN:
				case BITWISEOR_TOKEN:
				{
					Integer li = toInt(cx, lhs_ov);
					Integer ri = toInt(cx, rhs_ov);
					if( li != null && ri != null )
					{
						int result = 0;
						switch(node.op)
						{
						case BITWISEAND_TOKEN:
							result = li & ri;
							break;
						case BITWISEOR_TOKEN:
							result = li | ri;
							break;
						case BITWISEXOR_TOKEN:
							result = li ^ ri;
							break;
						}
						val = new ObjectValue(String.valueOf(result), cx.intType());
					}
				}
				}

			}
		}
		else
		{
			node.lhs = evalAndFold(cx, node.lhs);
			node.rhs = evalAndFold(cx, node.rhs);
		}
		return val;
	}