virtual void execute( MemoryInterface *global ) {
this->global = global;
const int second = getNumberValue( );
const int first = getNumberValue( );
Object *result = new ArgumentType( binary_op(first,second) );
this->global->push( result );
}
static PyObject* enum_xor(PyObject* self, PyObject* b)
{
if (!PyNumber_Check(b)) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
long valA = SBK_ENUM(self)->ob_value;
long valB = getNumberValue(b);
return PyLong_FromLong(valA ^ valB);
}
vector<MamaInstruction> BinaryOpNode::codeB(const Environment &e, int sd) const {
ENTERED("codeB");
typedef MamaInstruction MI;
int bak_sd = sd;
if (_compiler.testFlag(Compiler::OptimizeExpressions) && hasNumberValue()) {
try {
NumberNode num(_compiler,getNumberValue());
vector<MI> r(num.codeB(e,sd));
return r /= "binaryop_B";
} catch (const string &s) {
sd = bak_sd;
DEBUGMSG(s);
}
}
vector<MI> r(_operand1->codeB(e, sd));
r += _operand2->codeB(e, sd + 1);
r.push_back(_operator);
return r /= "binaryop_B";
}
static PyObject* enum_richcompare(PyObject* self, PyObject* other, int op)
{
int result = 0;
if (!PyNumber_Check(other)) {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
long valA = SBK_ENUM(self)->ob_value;
long valB = getNumberValue(other);
switch (op) {
case Py_EQ:
result = (valA == valB);
break;
case Py_NE:
result = (valA != valB);
break;
case Py_LE:
result = (valA <= valB);
break;
case Py_GE:
result = (valA >= valB);
break;
case Py_LT:
result = (valA < valB);
break;
case Py_GT:
result = (valA > valB);
break;
default:
PyErr_BadArgument();
return NULL;
}
if (result)
Py_RETURN_TRUE;
else
Py_RETURN_FALSE;
}
static PyObject* enum_divide(PyObject* self, PyObject* v)
{
long valA = SBK_ENUM(self)->ob_value;
long valB = getNumberValue(v);
return PyLong_FromLong(valA / valB);
}
void
PluralRules::parseDescription(UnicodeString& data, RuleChain& rules, UErrorCode &status)
{
int32_t ruleIndex=0;
UnicodeString token;
tokenType type;
tokenType prevType=none;
RuleChain *ruleChain=NULL;
AndConstraint *curAndConstraint=NULL;
OrConstraint *orNode=NULL;
RuleChain *lastChain=NULL;
if (U_FAILURE(status)) {
return;
}
UnicodeString ruleData = data.toLower("");
while (ruleIndex< ruleData.length()) {
mParser->getNextToken(ruleData, &ruleIndex, token, type, status);
if (U_FAILURE(status)) {
return;
}
mParser->checkSyntax(prevType, type, status);
if (U_FAILURE(status)) {
return;
}
switch (type) {
case tAnd:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint = curAndConstraint->add();
break;
case tOr:
lastChain = &rules;
while (lastChain->next !=NULL) {
lastChain = lastChain->next;
}
orNode=lastChain->ruleHeader;
while (orNode->next != NULL) {
orNode = orNode->next;
}
orNode->next= new OrConstraint();
orNode=orNode->next;
orNode->next=NULL;
curAndConstraint = orNode->add();
break;
case tIs:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint->rangeHigh=-1;
break;
case tNot:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint->notIn=TRUE;
break;
case tIn:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint->rangeHigh=PLURAL_RANGE_HIGH;
curAndConstraint->integerOnly = TRUE;
break;
case tWithin:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint->rangeHigh=PLURAL_RANGE_HIGH;
break;
case tNumber:
U_ASSERT(curAndConstraint != NULL);
if ( (curAndConstraint->op==AndConstraint::MOD)&&
(curAndConstraint->opNum == -1 ) ) {
curAndConstraint->opNum=getNumberValue(token);
}
else {
if (curAndConstraint->rangeLow == -1) {
curAndConstraint->rangeLow=getNumberValue(token);
}
else {
curAndConstraint->rangeHigh=getNumberValue(token);
}
}
break;
case tMod:
U_ASSERT(curAndConstraint != NULL);
curAndConstraint->op=AndConstraint::MOD;
break;
case tKeyword:
if (ruleChain==NULL) {
ruleChain = &rules;
}
else {
while (ruleChain->next!=NULL){
ruleChain=ruleChain->next;
}
ruleChain=ruleChain->next=new RuleChain();
}
if (ruleChain->ruleHeader != NULL) {
delete ruleChain->ruleHeader;
}
orNode = ruleChain->ruleHeader = new OrConstraint();
curAndConstraint = orNode->add();
ruleChain->keyword = token;
break;
default:
break;
}
prevType=type;
}
}