CValue* CFloatValue::Calc(VALUE_OPERATOR op, CValue *val)
/*
pre:
ret: a new object containing the result of applying operator op to this
object and val
*/
{
//return val->CalcFloat(op, this);
switch (op)
{
case VALUE_POS_OPERATOR:
return new CFloatValue (m_float);
break;
case VALUE_NEG_OPERATOR:
return new CFloatValue (-m_float);
break;
case VALUE_NOT_OPERATOR:
return new CErrorValue (op2str(op) + "only allowed on booleans");
break;
case VALUE_AND_OPERATOR:
case VALUE_OR_OPERATOR:
return new CErrorValue(val->GetText() + op2str(op) + "only allowed on booleans");
break;
default:
return val->CalcFinal(VALUE_FLOAT_TYPE, op, this);
break;
}
}
CValue* CBoolValue::Calc(VALUE_OPERATOR op, CValue *val)
/*
pre:
ret: a new object containing the result of applying operator op to this
object and val
*/
{
switch (op)
{
case VALUE_POS_OPERATOR:
case VALUE_NEG_OPERATOR:
{
return new CErrorValue (op2str(op) + GetText());
break;
}
case VALUE_NOT_OPERATOR:
{
return new CBoolValue (!m_bool);
break;
}
default:
{
return val->CalcFinal(VALUE_BOOL_TYPE, op, this);
break;
}
}
}
static int avctp_passthrough_press(struct avctp *session, uint8_t op,
uint8_t *params, size_t params_len)
{
uint8_t operands[7];
size_t len;
DBG("op 0x%02x %s params_len %zd", op, op2str(op), params_len);
/* Button pressed */
operands[0] = op & 0x7f;
if (op == AVC_VENDOR_UNIQUE && params &&
params_len == 5) {
memcpy(&operands[2], params, params_len);
len = params_len + 2;
operands[1] = params_len;
} else {
len = 2;
operands[1] = 0;
}
return avctp_send_req(session, AVC_CTYPE_CONTROL,
AVC_SUBUNIT_PANEL, AVC_OP_PASSTHROUGH,
operands, len,
avctp_passthrough_rsp, NULL);
}
CValue* CErrorValue::Calc(VALUE_OPERATOR op, CValue *val)
/*
pre:
ret: a new object containing the result of applying operator op to this
object and val
*/
{
CValue* errorval;
switch (op)
{
case VALUE_POS_OPERATOR:
case VALUE_NEG_OPERATOR:
case VALUE_NOT_OPERATOR:
{
errorval = new CErrorValue (op2str(op) + GetText());
break;
}
default:
{
errorval = val->CalcFinal(VALUE_ERROR_TYPE, op, this);
break;
}
}
return errorval;
}
CValue* CErrorValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
/*
pre: the type of val is dtype
ret: a new object containing the result of applying operator op to val and
this object
*/
{
return new CErrorValue (val->GetText() + op2str(op) + GetText());
}
/**
* pre: the type of val is dtype
* ret: a new object containing the result of applying operator op to val and
* this object
*/
CValue* CStringValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
{
CValue *ret;
if (op == VALUE_ADD_OPERATOR) {
if (dtype == VALUE_ERROR_TYPE)
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
else
ret = new CStringValue(val->GetText() + GetText(),"");
}
else {
if (dtype == VALUE_STRING_TYPE || dtype == VALUE_EMPTY_TYPE) {
switch (op) {
case VALUE_EQL_OPERATOR:
ret = new CBoolValue(val->GetText() == GetText());
break;
case VALUE_NEQ_OPERATOR:
ret = new CBoolValue(val->GetText() != GetText());
break;
case VALUE_GRE_OPERATOR:
ret = new CBoolValue(val->GetText() > GetText());
break;
case VALUE_LES_OPERATOR:
ret = new CBoolValue(val->GetText() < GetText());
break;
case VALUE_GEQ_OPERATOR:
ret = new CBoolValue(val->GetText() >= GetText());
break;
case VALUE_LEQ_OPERATOR:
ret = new CBoolValue(val->GetText() <= GetText());
break;
default:
ret = new CErrorValue(val->GetText() + op2str(op) + "[operator not allowed on strings]");
break;
}
}
else {
ret = new CErrorValue(val->GetText() + op2str(op) + "[operator not allowed on strings]");
}
}
return ret;
}
static int avctp_passthrough_release(struct avctp *session, uint8_t op)
{
uint8_t operands[2];
DBG("%s", op2str(op));
/* Button released */
operands[0] = op | 0x80;
operands[1] = 0;
return avctp_send_req(session, AVC_CTYPE_CONTROL,
AVC_SUBUNIT_PANEL, AVC_OP_PASSTHROUGH,
operands, sizeof(operands),
NULL, NULL);
}
static void avrcp_passthrough_dump(int level, struct frame *frm)
{
uint8_t op, len;
p_indent(level, frm);
op = get_u8(frm);
printf("Operation: 0x%02x (%s %s)\n", op, op2str(op),
op & 0x80 ? "Released" : "Pressed");
p_indent(level, frm);
len = get_u8(frm);
printf("Lenght: 0x%02x\n", len);
raw_dump(level, frm);
}
static void try_get_value(int *num, VCOS_EVENT_FLAGS_T *event, uint32_t start, uint32_t bitmask,
VCOS_OPTION operation, VCOS_STATUS_T expected, int after, int *passed)
{
VCOS_STATUS_T rc;
uint32_t set = 0;
vcos_event_flags_get(event, -1, VCOS_OR_CONSUME, 0, &set);
vcos_event_flags_set(event, start, VCOS_OR);
VCOS_TRACE("%s: mask %x op %s", __FUNCTION__, bitmask, op2str(operation));
if((rc=vcos_event_flags_get(event, bitmask, operation, 0, &set)) != expected)
{
*passed = 0;
}
if(expected == VCOS_SUCCESS && set != start)
{
*passed = 0;
}
check_value(event, after, 1, passed);
}
void
TreePrinter::visit(BINOP *binop)
{
FUNCLOG;
BGN;
result += tab;
result += "BINOP(\n";
result += tab + " ";
result += op2str(binop->op);
result += "\n";
result += tab;
result += ",\n";
assert(binop->l);
binop->l->accept(this);
result += tab;
result += ",\n";
assert(binop->r);
binop->r->accept(this);
result += tab;
result += ")\n";
END;
}
static int avctp_passthrough_release(struct avctp *session, uint8_t op,
uint8_t *params, size_t params_len)
{
uint8_t operands[7];
size_t len;
DBG("%s", op2str(op));
/* Button released */
operands[0] = op | 0x80;
operands[1] = 0;
if (op == AVC_VENDOR_UNIQUE && params &&
params_len > sizeof(operands) - 2) {
memcpy(&operands[2], params, params_len);
len = params_len;
} else
len = 2;
return avctp_send_req(session, AVC_CTYPE_CONTROL,
AVC_SUBUNIT_PANEL, AVC_OP_PASSTHROUGH,
operands, len,
NULL, NULL);
}
/*
* pre: the type of val is dtype
* ret: a new object containing the result of applying operator op to val and
* this object
*/
CValue* CIntValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
{
CValue *ret;
switch (dtype) {
case VALUE_EMPTY_TYPE:
case VALUE_INT_TYPE:
{
switch (op) {
case VALUE_MOD_OPERATOR:
ret = new CIntValue (((CIntValue *) val)->GetInt() % m_int);
break;
case VALUE_ADD_OPERATOR:
ret = new CIntValue (((CIntValue *) val)->GetInt() + m_int);
break;
case VALUE_SUB_OPERATOR:
ret = new CIntValue (((CIntValue *) val)->GetInt() - m_int);
break;
case VALUE_MUL_OPERATOR:
ret = new CIntValue (((CIntValue *) val)->GetInt() * m_int);
break;
case VALUE_DIV_OPERATOR:
if (m_int == 0) {
if (val->GetNumber() == 0) {
ret = new CErrorValue("Not a Number");
}
else {
ret = new CErrorValue("Division by zero");
}
}
else
ret = new CIntValue (((CIntValue *) val)->GetInt() / m_int);
break;
case VALUE_EQL_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() == m_int);
break;
case VALUE_NEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() != m_int);
break;
case VALUE_GRE_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() > m_int);
break;
case VALUE_LES_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() < m_int);
break;
case VALUE_GEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() >= m_int);
break;
case VALUE_LEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() <= m_int);
break;
case VALUE_NEG_OPERATOR:
ret = new CIntValue (-m_int);
break;
case VALUE_POS_OPERATOR:
ret = new CIntValue (m_int);
break;
case VALUE_NOT_OPERATOR:
ret = new CBoolValue(m_int == 0);
break;
default:
printf("Found op: %d\n", op);
ret = new CErrorValue("illegal operator. please send a bug report.");
break;
}
break;
}
case VALUE_FLOAT_TYPE:
{
switch (op) {
case VALUE_MOD_OPERATOR:
ret = new CFloatValue(fmod(((CFloatValue *) val)->GetFloat(), m_int));
break;
case VALUE_ADD_OPERATOR:
ret = new CFloatValue (((CFloatValue *) val)->GetFloat() + m_int);
break;
case VALUE_SUB_OPERATOR:
ret = new CFloatValue (((CFloatValue *) val)->GetFloat() - m_int);
break;
case VALUE_MUL_OPERATOR:
ret = new CFloatValue (((CFloatValue *) val)->GetFloat() * m_int);
break;
case VALUE_DIV_OPERATOR:
if (m_int == 0)
ret = new CErrorValue("Division by zero");
else
ret = new CFloatValue (((CFloatValue *) val)->GetFloat() / m_int);
break;
case VALUE_EQL_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() == m_int);
break;
case VALUE_NEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() != m_int);
break;
case VALUE_GRE_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() > m_int);
break;
case VALUE_LES_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() < m_int);
break;
case VALUE_GEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() >= m_int);
break;
case VALUE_LEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() <= m_int);
break;
case VALUE_NOT_OPERATOR:
ret = new CBoolValue(m_int == 0);
break;
default:
ret = new CErrorValue("illegal operator. please send a bug report.");
break;
}
break;
}
case VALUE_STRING_TYPE:
{
switch (op) {
case VALUE_ADD_OPERATOR:
ret = new CStringValue(val->GetText() + GetText(),"");
break;
case VALUE_EQL_OPERATOR:
case VALUE_NEQ_OPERATOR:
case VALUE_GRE_OPERATOR:
case VALUE_LES_OPERATOR:
case VALUE_GEQ_OPERATOR:
case VALUE_LEQ_OPERATOR:
ret = new CErrorValue("[Cannot compare string with integer]" + op2str(op) + GetText());
break;
default:
ret = new CErrorValue("[operator not allowed on strings]" + op2str(op) + GetText());
break;
}
break;
}
case VALUE_BOOL_TYPE:
ret = new CErrorValue("[operator not valid on boolean and integer]" + op2str(op) + GetText());
break;
#if 0
case VALUE_EMPTY_TYPE:
{
switch (op) {
case VALUE_ADD_OPERATOR:
ret = new CIntValue (m_int);
break;
case VALUE_SUB_OPERATOR:
ret = new CIntValue (-m_int);
break;
default:
{
ret = new CErrorValue(op2str(op) + GetText());
}
}
break;
}
#endif
case VALUE_ERROR_TYPE:
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
break;
default:
ret = new CErrorValue("illegal type. contact your dealer (if any)");
break;
}
return ret;
}
CValue* CBoolValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
/*
pre: the type of val is dtype
ret: a new object containing the result of applying operator op to val and
this object
*/
{
CValue *ret;
switch (dtype) {
case VALUE_EMPTY_TYPE:
case VALUE_BOOL_TYPE:
{
switch (op) {
case VALUE_AND_OPERATOR:
{
ret = new CBoolValue (((CBoolValue *) val)->GetBool() && m_bool);
break;
}
case VALUE_OR_OPERATOR:
{
ret = new CBoolValue (((CBoolValue *) val)->GetBool() || m_bool);
break;
}
case VALUE_EQL_OPERATOR:
{
ret = new CBoolValue (((CBoolValue *) val)->GetBool() == m_bool);
break;
}
case VALUE_NEQ_OPERATOR:
{
ret = new CBoolValue (((CBoolValue *) val)->GetBool() != m_bool);
break;
}
case VALUE_NOT_OPERATOR:
{
return new CBoolValue (!m_bool);
break;
}
default:
{
ret = new CErrorValue(val->GetText() + op2str(op) +
"[operator not allowed on booleans]");
break;
}
}
break;
}
case VALUE_STRING_TYPE:
{
switch (op) {
case VALUE_ADD_OPERATOR:
{
ret = new CStringValue(val->GetText() + GetText(),"");
break;
}
default:
{
ret = new CErrorValue(val->GetText() + op2str(op) + "[Only + allowed on boolean and string]");
break;
}
}
break;
}
default:
ret = new CErrorValue("[type mismatch]" + op2str(op) + GetText());
}
return ret;
}
CValue* CFloatValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
/*
pre: the type of val is dtype
ret: a new object containing the result of applying operator op to val and
this object
*/
{
CValue *ret;
switch(dtype)
{
case VALUE_INT_TYPE:
{
switch (op)
{
case VALUE_MOD_OPERATOR:
ret = new CFloatValue(fmod(((CIntValue *) val)->GetInt(), m_float));
break;
case VALUE_ADD_OPERATOR:
ret = new CFloatValue(((CIntValue *) val)->GetInt() + m_float);
break;
case VALUE_SUB_OPERATOR:
ret = new CFloatValue(((CIntValue *) val)->GetInt() - m_float);
break;
case VALUE_MUL_OPERATOR:
ret = new CFloatValue(((CIntValue *) val)->GetInt() * m_float);
break;
case VALUE_DIV_OPERATOR:
if (m_float == 0)
ret = new CErrorValue("Division by zero");
else
ret = new CFloatValue (((CIntValue *) val)->GetInt() / m_float);
break;
case VALUE_EQL_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() == m_float);
break;
case VALUE_NEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() != m_float);
break;
case VALUE_GRE_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() > m_float);
break;
case VALUE_LES_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() < m_float);
break;
case VALUE_GEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() >= m_float);
break;
case VALUE_LEQ_OPERATOR:
ret = new CBoolValue(((CIntValue *) val)->GetInt() <= m_float);
break;
default:
ret = new CErrorValue("illegal operator. please send a bug report.");
break;
}
break;
}
case VALUE_EMPTY_TYPE:
case VALUE_FLOAT_TYPE:
{
switch (op)
{
case VALUE_MOD_OPERATOR:
ret = new CFloatValue(fmod(((CFloatValue *) val)->GetFloat(), m_float));
break;
case VALUE_ADD_OPERATOR:
ret = new CFloatValue(((CFloatValue *) val)->GetFloat() + m_float);
break;
case VALUE_SUB_OPERATOR:
ret = new CFloatValue(((CFloatValue *) val)->GetFloat() - m_float);
break;
case VALUE_MUL_OPERATOR:
ret = new CFloatValue(((CFloatValue *) val)->GetFloat() * m_float);
break;
case VALUE_DIV_OPERATOR:
if (m_float == 0)
ret = new CErrorValue("Division by zero");
else
ret = new CFloatValue (((CFloatValue *) val)->GetFloat() / m_float);
break;
case VALUE_EQL_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() == m_float);
break;
case VALUE_NEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() != m_float);
break;
case VALUE_GRE_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() > m_float);
break;
case VALUE_LES_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() < m_float);
break;
case VALUE_GEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() >= m_float);
break;
case VALUE_LEQ_OPERATOR:
ret = new CBoolValue(((CFloatValue *) val)->GetFloat() <= m_float);
break;
case VALUE_NEG_OPERATOR:
ret = new CFloatValue (-m_float);
break;
case VALUE_POS_OPERATOR:
ret = new CFloatValue (m_float);
break;
default:
ret = new CErrorValue("illegal operator. please send a bug report.");
break;
}
break;
}
case VALUE_STRING_TYPE:
{
switch(op)
{
case VALUE_ADD_OPERATOR:
ret = new CStringValue(val->GetText() + GetText(),"");
break;
case VALUE_EQL_OPERATOR:
case VALUE_NEQ_OPERATOR:
case VALUE_GRE_OPERATOR:
case VALUE_LES_OPERATOR:
case VALUE_GEQ_OPERATOR:
case VALUE_LEQ_OPERATOR:
ret = new CErrorValue("[Cannot compare string with float]" + op2str(op) + GetText());
break;
default:
ret = new CErrorValue("[operator not allowed on strings]" + op2str(op) + GetText());
break;
}
break;
}
case VALUE_BOOL_TYPE:
ret = new CErrorValue("[operator not valid on boolean and float]" + op2str(op) + GetText());
break;
case VALUE_ERROR_TYPE:
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
break;
default:
ret = new CErrorValue("illegal type. contact your dealer (if any)");
break;
}
return ret;
}
CValue* CVectorValue::CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val)
/*
pre: the type of val is dtype
ret: a new object containing the result of applying operator op to val and
this object
*/
{
CValue *ret = NULL;
switch(op)
{
case VALUE_ADD_OPERATOR:
{
switch (dtype)
{
case VALUE_EMPTY_TYPE:
case VALUE_VECTOR_TYPE:
{
ret = new CVectorValue(
val->GetVector3()[KX_X] + GetVector3()[KX_X],
val->GetVector3()[KX_Y] + GetVector3()[KX_Y],
val->GetVector3()[KX_Z] + GetVector3()[KX_Z],
CValue::HEAPVALUE);
ret->SetName(GetName());
break;
}
default:
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
}
break;
}
case VALUE_MUL_OPERATOR:
{
switch (dtype)
{
case VALUE_EMPTY_TYPE:
case VALUE_VECTOR_TYPE:
{
//MT_Vector3 supports 'scaling' by another vector, instead of using general transform, Gino?
//ret = new CVectorValue(val->GetVector3().Scaled(GetVector3()),GetName());
break;
}
case VALUE_FLOAT_TYPE:
{
ret = new CVectorValue(
val->GetVector3()[KX_X] * GetVector3()[KX_X],
val->GetVector3()[KX_Y] * GetVector3()[KX_Y],
val->GetVector3()[KX_Z] * GetVector3()[KX_Z],
CValue::HEAPVALUE);
ret->SetName(GetName());
break;
}
default:
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
}
break;
}
default:
ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
}
return ret;
}
