string butterflyNet::showNet_(int level_, int output_) {
ostringstream r("");
if (1 == level_) {
r << "(" << outputNfo[level_][output_].inA << " "
<< getOperatorName(outputNfo[level_][output_].op) << " "
<< outputNfo[level_][output_].inB
<< ")";
} else {
r << "(" << showNet_(level_ - 1, outputNfo[level_][output_].inA) << " "
<< getOperatorName(outputNfo[level_][output_].op) << " "
<< showNet_(level_ - 1, outputNfo[level_][output_].inB)
<< ")";
}
return r.str();
}
void butterflyNet::createOutputInfo(int level_) {
int prevLevel(level_ - 1);
int pickCount(eventStreams[prevLevel].picks.size());
outputNfo.resize(level_ + 1);
outputInfo emptyNfo;
emptyNfo.op = 0;
emptyNfo.inA = 0;
emptyNfo.inB = 0;
outputNfo[level_].insert(outputNfo[level_].end(), emptyNfo);
cout << "new outputs are: ";
for (int op = 0; op <= 2; op++) {
for (int pickX = 1; pickX < pickCount; pickX++) {
for (int pickY = 1; pickY < pickCount; pickY++) {
if (pickX < pickY) {
outputInfo nfo;
nfo.op = op;
nfo.inA = eventStreams[prevLevel].picks[pickX];
nfo.inB = eventStreams[prevLevel].picks[pickY];
outputNfo[level_].insert(outputNfo[level_].end(), nfo);
cout << "(" << nfo.inA << " " << getOperatorName(nfo.op)
<< " " << nfo.inB << ") ";
}
}
}
}
cout << endl;
}
bool
VecCellRefineAdapter::findRefineOperator(
const Pointer<Variable<NDIM> >& var,
const std::string &op_name) const
{
const Pointer<VecCellVariable<double> > cast_var(var);
if (!cast_var.isNull() && (op_name == getOperatorName()))
{
return true;
}
else
{
return false;
}
}// findRefineOperator
void NewDeleteOverloadsCheck::onEndOfTranslationUnit() {
// Walk over the list of declarations we've found to see if there is a
// corresponding overload at the same declaration context or within a base
// class. If there is not, add the element to the list of declarations to
// diagnose.
SmallVector<const FunctionDecl *, 4> Diagnose;
for (const auto &RP : Overloads) {
// We don't care about the CXXRecordDecl key in the map; we use it as a way
// to shard the overloads by declaration context to reduce the algorithmic
// complexity when searching for corresponding free store functions.
for (const auto *Overload : RP.second) {
const auto *Match =
std::find_if(RP.second.begin(), RP.second.end(),
[&Overload](const FunctionDecl *FD) {
if (FD == Overload)
return false;
// If the declaration contexts don't match, we don't
// need to check any further.
if (FD->getDeclContext() != Overload->getDeclContext())
return false;
// Since the declaration contexts match, see whether
// the current element is the corresponding operator.
if (!areCorrespondingOverloads(Overload, FD))
return false;
return true;
});
if (Match == RP.second.end()) {
// Check to see if there is a corresponding overload in a base class
// context. If there isn't, or if the overload is not a class member
// function, then we should diagnose.
const auto *MD = dyn_cast<CXXMethodDecl>(Overload);
if (!MD || !hasCorrespondingOverloadInBaseClass(MD))
Diagnose.push_back(Overload);
}
}
}
for (const auto *FD : Diagnose)
diag(FD->getLocation(), "declaration of %0 has no matching declaration "
"of '%1' at the same scope")
<< FD << getOperatorName(getCorrespondingOverload(FD));
}
AValue PrefixOpExpr::gen(AstContext &astContext) {
AValue val = expr->codeGen(astContext);
if (op == '-') {
if (val.isDouble()) {
val.llvmValue = builder.CreateFNeg(val.llvmValue);
return val;
} else if (val.isLong() || val.isChar()) {
val.llvmValue = builder.CreateNeg(val.llvmValue);
return val;
}
} else if (op == '!') {
if (val.isBool()) {
val.llvmValue = builder.CreateNot(val.llvmValue);
return val;
}
}
errorMsg = "invalid argument type '" + val.clazz->name + "' to unary '"
+ getOperatorName(op) + "' expression";
throwError(this);
return val;
}
status_t BnDMAgent::onTransact(uint32_t code, const Parcel &data,
Parcel *reply, uint32_t flags) {
XLOGI("OnTransact (%u,%u)", code, flags);
reply->writeInt32(DM_READ_NO_EXCEPTION);//used for readException
switch (code) {
case TRANSACTION_setLockFlag: {
/* XLOGI("setLockFlag\n");
data.enforceInterface (descriptor);
reply->writeInt32 (setLockFlag ());
// XLOGI("locked\n");
return NO_ERROR;
*/
XLOGI("setLockFlag\n");
data.enforceInterface(descriptor);
int len = data.readInt32();
XLOGD("setLockFlag len = %d\n", len);
if (len == -1) { // array is null
reply->writeInt32(0);
} else {
char buff[len];
data.read(buff, len);
XLOGD("setLockFlag buff = %s\n", buff);
reply->writeInt32(setLockFlag(buff, len));
}
XLOGI("setLockFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_clearLockFlag: {
XLOGI("clearLockFlag\n");
data.enforceInterface(descriptor);
reply->writeInt32(clearLockFlag());
XLOGI("cleared\n");
return NO_ERROR;
}
break;
case TRANSACTION_readDMTree: {
XLOGI("readDMTree\n");
data.enforceInterface(descriptor);
int size = 0;
char * ret = readDMTree(size);
if (ret == NULL) {
reply->writeInt32(-1);
} else {
reply->writeInt32(size);
reply->write(ret, size);
free(ret);
}
XLOGI("DMTree read done\n");
return NO_ERROR;
}
break;
case TRANSACTION_writeDMTree: {
XLOGI("writeDMTree\n");
data.enforceInterface(descriptor);
int len = data.readInt32();
if (len == -1) { // array is null
reply->writeInt32(0);
} else {
char buff[len];
data.read(buff, len);
reply->writeInt32(writeDMTree(buff, len));
}
XLOGI("DMTree wrote\n");
return NO_ERROR;
}
break;
case TRANSACTION_isLockFlagSet: {
XLOGI("isLockFlagSet\n");
data.enforceInterface(descriptor);
reply->writeInt32(isLockFlagSet());
XLOGI("isLockFlagSet done\n");
return NO_ERROR;
}
break;
case TRANSACTION_readIMSI: {
XLOGI("readIMSI\n");
data.enforceInterface(descriptor);
int size = 0;
char * ret = readIMSI(size);
XLOGD("readIMSI = %s\n", ret);
if (ret == NULL) {
reply->writeInt32(-1);
} else {
reply->writeInt32(size);
reply->write(ret, size);
free(ret);
}
XLOGI("readIMSI done\n");
return NO_ERROR;
}
break;
case TRANSACTION_writeIMSI: {
XLOGI("writeIMSI\n");
data.enforceInterface(descriptor);
int len = data.readInt32();
XLOGD("writeIMSI len = %d\n", len);
if (len == -1) { // array is null
reply->writeInt32(0);
} else {
char buff[len];
data.read(buff, len);
XLOGD("writeIMSI buff = %s\n", buff);
reply->writeInt32(writeIMSI(buff, len));
}
XLOGI("writeIMSI done\n");
return NO_ERROR;
}
break;
case TRANSACTION_readCTA: {
XLOGI("readCTA\n");
data.enforceInterface(descriptor);
int size = 0;
char * ret = readCTA(size);
XLOGD("readCTA = %s\n", ret);
if (ret == NULL) {
reply->writeInt32(-1);
} else {
reply->writeInt32(size);
reply->write(ret, size);
free(ret);
}
XLOGI("readCTA done\n");
return NO_ERROR;
}
break;
case TRANSACTION_writeCTA: {
XLOGI("writeCTA\n");
data.enforceInterface(descriptor);
int len = data.readInt32();
XLOGD("writeCTA len = %d\n", len);
if (len == -1) { // array is null
reply->writeInt32(0);
} else {
char buff[len];
data.read(buff, len);
XLOGD("writeCTA buff = %s\n", buff);
reply->writeInt32(writeCTA(buff, len));
}
XLOGI("writeCTA done\n");
return NO_ERROR;
}
break;
case TRANSACTION_readOperatorName: {
XLOGI("readOperatorName\n");
data.enforceInterface(descriptor);
int size = 0;
char * ret = readOperatorName(size);
if (ret == NULL) {
reply->writeInt32(-1);
} else {
reply->writeInt32(size);
reply->write(ret, size);
free(ret);
}
XLOGI("readOperatorName done\n");
return NO_ERROR;
}
break;
case TRANSACTION_setRebootFlag: {
XLOGI("setRebootFlag\n");
data.enforceInterface(descriptor);
reply->writeInt32(setRebootFlag());
XLOGI("setRebootFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_getLockType: {
XLOGI("getLockType\n");
data.enforceInterface(descriptor);
reply->writeInt32(getLockType());
XLOGI("getLockType done\n");
return NO_ERROR;
}
break;
case TRANSACTION_getOperatorID: {
XLOGI("getOperatorID\n");
data.enforceInterface(descriptor);
reply->writeInt32(getOperatorID());
XLOGI("getOperatorID done\n");
return NO_ERROR;
}
break;
case TRANSACTION_getOperatorName: {
XLOGI("getOperatorName\n");
data.enforceInterface(descriptor);
char * ret = getOperatorName();
if (ret == NULL)
reply->writeInt32(-1);
else
reply->writeInt32(0);
XLOGI("getOperatorName done\n");
return NO_ERROR;
}
break;
case TRANSACTION_isHangMoCallLocking: {
XLOGI("isHangMoCallLocking\n");
data.enforceInterface(descriptor);
reply->writeInt32(isHangMoCallLocking());
XLOGI("isHangMoCallLocking done\n");
return NO_ERROR;
}
break;
case TRANSACTION_isHangMtCallLocking: {
XLOGI("isHangMtCallLocking\n");
data.enforceInterface(descriptor);
reply->writeInt32(isHangMtCallLocking());
XLOGI("isHangMtCallLocking\n");
return NO_ERROR;
}
break;
case TRANSACTION_clearRebootFlag: {
XLOGI("clearRebootFlag\n");
data.enforceInterface(descriptor);
reply->writeInt32(clearRebootFlag());
XLOGI("clearRebootFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_isBootRecoveryFlag: {
XLOGI("isBootRecoveryFlag\n");
data.enforceInterface(descriptor);
reply->writeInt32(isBootRecoveryFlag());
XLOGI("isBootRecoveryFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_isWipeSet: {
XLOGI("isWipeset\n");
data.enforceInterface(descriptor);
reply->writeInt32(isWipeSet());
XLOGI("isWipeset done\n");
return NO_ERROR;
}
break;
case TRANSACTION_setWipeFlag: {
XLOGI("setWipeFlag\n");
data.enforceInterface(descriptor);
//int len=data.readInt32 ();
reply->writeInt32(setWipeFlag("FactoryReset", sizeof("FactoryReset")));
XLOGI("setWipeFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_clearWipeFlag: {
XLOGI("clearWipeFlag\n");
data.enforceInterface(descriptor);
reply->writeInt32(clearWipeFlag());
XLOGI("clearWipeFlag done\n");
return NO_ERROR;
}
break;
case TRANSACTION_getUpgradeStatus: {
XLOGI("getUpgradeStatus\n");
data.enforceInterface(descriptor);
reply->writeInt32(getUpgradeStatus());
XLOGI("getUpgradeStatus done\n");
return NO_ERROR;
}
break;
case TRANSACTION_restartAndroid: {
XLOGI("restartAndroid\n");
data.enforceInterface(descriptor);
reply->writeInt32(restartAndroid());
XLOGI("restartAndroid\n");
return NO_ERROR;
}
break;
case TRANSACTION_readOtaResult: {
XLOGI("readOtaResult\n");
data.enforceInterface(descriptor);
reply->writeInt32(readOtaResult());
return NO_ERROR;
}
break;
case TRANSACTION_clearOtaResult: {
XLOGI("clearOtaResult\n");
data.enforceInterface(descriptor);
reply->writeInt32(clearOtaResult());
return NO_ERROR;
}
break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
return NO_ERROR;
}
std::unique_ptr<Value>
ArithmeticValueNode::traceValue(std::unique_ptr<Value> lval,
std::unique_ptr<Value> rval,
std::ostream& out) const
{
switch (_operator) {
case ADD:
{
if (lval->getType() == Value::String &&
rval->getType() == Value::String)
{
StringValue& slval(static_cast<StringValue&>(*lval));
StringValue& srval(static_cast<StringValue&>(*rval));
std::unique_ptr<Value> result(new StringValue(
slval.getValue() + srval.getValue()));
out << "Appended strings '" << slval << "' + '" << srval
<< "' -> '" << *result << "'.\n";
return result;
}
}
[[fallthrough]];
case SUB:
case MUL:
case DIV:
{
if (lval->getType() == Value::Integer &&
rval->getType() == Value::Integer)
{
IntegerValue& ilval(static_cast<IntegerValue&>(*lval));
IntegerValue& irval(static_cast<IntegerValue&>(*rval));
IntegerValue::ValueType res = 0;
switch (_operator) {
case ADD: res = ilval.getValue() + irval.getValue(); break;
case SUB: res = ilval.getValue() - irval.getValue(); break;
case MUL: res = ilval.getValue() * irval.getValue(); break;
case DIV: res = ilval.getValue() / irval.getValue(); break;
case MOD: assert(0);
}
std::unique_ptr<Value> result(new IntegerValue(res, false));
out << "Performed integer operation " << ilval << " "
<< getOperatorName() << " " << irval << " = " << *result
<< "\n";
return result;
}
NumberValue* nlval(dynamic_cast<NumberValue*>(lval.get()));
NumberValue* nrval(dynamic_cast<NumberValue*>(lval.get()));
if (nlval != 0 && nrval != 0) {
NumberValue::CommonValueType res = 0;
switch (_operator) {
case ADD: res = nlval->getCommonValue()
+ nrval->getCommonValue(); break;
case SUB: res = nlval->getCommonValue()
- nrval->getCommonValue(); break;
case MUL: res = nlval->getCommonValue()
* nrval->getCommonValue(); break;
case DIV: res = nlval->getCommonValue()
/ nrval->getCommonValue(); break;
case MOD: assert(0);
}
std::unique_ptr<Value> result(new FloatValue(res));
out << "Performed float operation " << nlval << " "
<< getOperatorName() << " " << nrval << " = " << *result
<< "\n";
return result;
}
}
break;
case MOD:
{
if (lval->getType() == Value::Integer &&
rval->getType() == Value::Integer)
{
IntegerValue& ilval(static_cast<IntegerValue&>(*lval));
IntegerValue& irval(static_cast<IntegerValue&>(*rval));
std::unique_ptr<Value> result(new IntegerValue(
ilval.getValue() % irval.getValue(), false));
out << "Performed integer operation " << ilval << " "
<< getOperatorName() << " " << irval << " = " << *result
<< "\n";
return result;
}
}
break;
}
out << "Failed to do operation " << getOperatorName()
<< " on values of type " << lval->getType() << " and "
<< rval->getType() << ". Resolving invalid.\n";
return std::unique_ptr<Value>(new InvalidValue);
}
AValue BinaryOpExpr::gen(AstContext &astContext) {
AValue lv = leftExpr->codeGen(astContext);
AValue rv = rightExpr->codeGen(astContext);
AValue res;
if (op == '%') {
if ((lv.isLong() || lv.isChar()) && (rv.isLong() || rv.isChar())) {
if (lv.isLong()) {
rv.castTo(longClass);
} else {
lv.castTo(rv.clazz);
}
res = AValue(builder.CreateSRem(lv.llvmValue, rv.llvmValue),lv.clazz);
}
} else if (lv.isBool() && rv.isBool()) {
switch (op) {
case EQUAL:
res = AValue(builder.CreateICmpEQ(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case NEQUAL:
res = AValue(builder.CreateICmpNE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
}
} else if ((lv.isLong() || lv.isDouble() || lv.isChar())
&& (rv.isLong() || rv.isDouble() || rv.isChar())) {
if (lv.isDouble() || rv.isDouble()) {
if (!lv.castTo(doubleClass)) {
throwError(leftExpr);
}
if (!rv.castTo(doubleClass)) {
throwError(rightExpr);
}
} else if (lv.isLong() || rv.isLong()) {
if (!lv.castTo(longClass)) {
throwError(leftExpr);
}
if (!rv.castTo(longClass)) {
throwError(rightExpr);
}
}
if (lv.isDouble()) {
switch (op) {
case '+':
res = AValue(builder.CreateFAdd(lv.llvmValue, rv.llvmValue),
doubleClass);
break;
case '-':
res = AValue(builder.CreateFSub(lv.llvmValue, rv.llvmValue),
doubleClass);
break;
case '*':
res = AValue(builder.CreateFMul(lv.llvmValue, rv.llvmValue),
doubleClass);
break;
case '/':
res = AValue(builder.CreateFDiv(lv.llvmValue, rv.llvmValue),
doubleClass);
break;
case EQUAL:
res = AValue(builder.CreateFCmpOEQ(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case NEQUAL:
res = AValue(builder.CreateFCmpONE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case '<':
res = AValue(builder.CreateFCmpOLT(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case '>':
res = AValue(builder.CreateFCmpOGT(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case LE:
res = AValue(builder.CreateFCmpOLE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case GE:
res = AValue(builder.CreateFCmpOGE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
}
} else {
switch (op) {
case '+':
res = AValue(builder.CreateAdd(lv.llvmValue, rv.llvmValue),
lv.clazz);
break;
case '-':
res = AValue(builder.CreateSub(lv.llvmValue, rv.llvmValue),
lv.clazz);
break;
case '*':
res = AValue(builder.CreateMul(lv.llvmValue, rv.llvmValue),
lv.clazz);
break;
case '/':
res = AValue(builder.CreateSDiv(lv.llvmValue, rv.llvmValue),
lv.clazz);
break;
case EQUAL:
res = AValue(builder.CreateICmpEQ(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case NEQUAL:
res = AValue(builder.CreateICmpNE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case '<':
res = AValue(builder.CreateICmpSLT(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case '>':
res = AValue(builder.CreateICmpSGT(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case LE:
res = AValue(builder.CreateICmpSLE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
case GE:
res = AValue(builder.CreateICmpSGE(lv.llvmValue, rv.llvmValue),
boolClass);
break;
}
}
} else if ((lv.isObject() || lv.isArray())
&& (rv.isObject() || rv.isArray())) {
if (op == EQUAL) {
res = AValue(builder.CreateICmpEQ(lv.llvmValue, rv.llvmValue),
boolClass);
} else if (op == NEQUAL) {
res = AValue(builder.CreateICmpNE(lv.llvmValue, rv.llvmValue),
boolClass);
}
}
if (res.llvmValue == NULL) {
errorMsg = "invalid operands to binary expression (" + lv.clazz->name
+ " " + getOperatorName(op) + " " + rv.clazz->name + ")";
throwError(this);
}
return res;
}