int main(int argc, char** argv){ /*main expression is one string of all args put together*/ char* mainExpression = getExpressionFromArgs(argc, argv); /*list of tokens*/ tokenNode *mainList = malloc(sizeof(tokenNode)); /*not useful yet *TODO: Something with variables*/ int totalVariables = 0; /*keep iterating i until it reaches a ; in main expression*/ for(int i = 0; mainExpression[i] != ';'; i++){ /*get necesarry tokens from expression*/ if(isalpha(mainExpression[i])){ addTokenToList(mainList, getVariableLexeme(mainExpression, &i)); } if(isdigit(mainExpression[i] )){ addTokenToList(mainList, getNumericLexeme(mainExpression, &i)); } if(isOperator(mainExpression[i])){ addTokenToList(mainList, getOperatorLexeme(mainExpression, &i)); } if(mainExpression[i] == '$'){ addTokenToList(mainList, getSpecialLexeme(mainExpression, &i)); } } /*conductor is the iterator to move across the list*/ tokenNode *conductor; /*tempNode is used for freeing memory*/ tokenNode *tempNode; /*used to determine if there are anymore *RELEVANT operators to compute with */ _Bool noMoreOperators = false; /*check if we have one number left over*/ while(mainList->size > 1){ /*i represents the current order of precedence to be checked, *in EMDAS order*/ for(int i = 0; i < 3; i++){ /*set/reset conductor back to start of list*/ conductor = mainList; /*set/reset noMoreOperators so that next loop can continue*/ noMoreOperators = false; while(!noMoreOperators){ /*default; if the list is traversed and there are no more operators, loop will end *this was inspired by traditional bubble sort*/ noMoreOperators = true; /*while not at end of list*/ while(conductor->next != NULL){ /*check if the next token is an operator*/ if(conductor->next->value.type == operator){ /*check if the operator token is the same precedence as the operator we are looking for*/ if(checkPrecedence(conductor->next->value) == i){ /*if so, we have found a RELEVANT operator and noMoreOperators is false*/ noMoreOperators = false; /*perform necesarry calculation depending on current precedence (i)*/ switch(getOperatorID(conductor->next->value)){ case 0: /*set conductor value to conductor^conductor->next->next*/ conductor->value = tokenExponentation(conductor->value, conductor->next->next->value); /*set tempNode to the 3 items down the list (next number)*/ tempNode = conductor->next->next->next; /*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/ free(conductor->next); free(conductor->next->next); /*link conductor with tempNode*/ conductor->next = tempNode; /*subtract two tokens from mainList*/ mainList->size -= 2; break; case 1: /*set conductor value to conductor*conductor->next->next*/ conductor->value = tokenMultiplication(conductor->value, conductor->next->next->value); /*set tempNode to the 3 items down the list (next number)*/ tempNode = conductor->next->next->next; /*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/ free(conductor->next); free(conductor->next->next); /*link conductor with tempNode*/ conductor->next = tempNode; /*subtract two tokens from mainList*/ mainList->size -= 2; break; case 2: /*set conductor value to conductor/conductor->next->next*/ conductor->value = tokenDivision(conductor->value, conductor->next->next->value); /*set tempNode to the 3 items down the list (next number)*/ tempNode = conductor->next->next->next; /*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/ free(conductor->next); free(conductor->next->next); /*link conductor with tempNode*/ conductor->next = tempNode; /*subtract two tokens from mainList*/ mainList->size -= 2; break; case 3: /*set conductor value to conductor+conductor->next->next*/ conductor->value = tokenAddition(conductor->value, conductor->next->next->value); /*set tempNode to the 3 items down the list (next number)*/ tempNode = conductor->next->next->next; /*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/ free(conductor->next); free(conductor->next->next); /*link conductor with tempNode*/ conductor->next = tempNode; /*subtract two tokens from mainList*/ mainList->size -= 2; break; case 4: /*set conductor value to conductor-conductor->next->next*/ conductor->value = tokenSubtraction(conductor->value, conductor->next->next->value); /*set tempNode to the 3 items down the list (next number)*/ tempNode = conductor->next->next->next; /*free the nodes between current node (conductor) and tempNode (conductor->next->next->next)*/ free(conductor->next); free(conductor->next->next); /*link conductor with tempNode*/ conductor->next = tempNode; /*subtract two tokens from mainList*/ mainList->size -= 2; break; default: /*if current token is not really a token*/ printf(ANSI_COLOR_MAGENTA"Error: Erroneous token: %s\n"ANSI_COLOR_RESET, conductor->next->value.lexeme); exit(1); } /*show your work!*/ for(int j = 0; j < mainList->size; j++){ printf("%s", getTokenFromList(mainList, j).lexeme); } printf("\n"); } } /*iterate down the list unless at end of list, unless the current operator is of the desired precedence this is to avoid skipping operators on accident*/ if(conductor->next != NULL && checkPrecedence(conductor->next->value) != i){ conductor = conductor->next; } } } } } /*print list*/ printf("Answer: %s\n",getTokenFromList(mainList, 0).lexeme); }
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; }
void eval_expr(char *str, File **f, Pile **p) { char buffer[MAX_ENTRY] = ""; Token token; int numberSaved = 0; int op_queued = 0; int p_size = 0; for(unsigned i = 0, j = 0; str[i] != '\0'; i++) { if(isAnOperator(str[i])) { p_size = pile_size(*p); while(p_size--) { char p_op = pile_pop(p); int p_opId = getOperatorID(p_op); int s_opId = getOperatorID(str[i]); if((operators[s_opId].associativity == A_LEFT && operators[s_opId].precedence <= operators[p_opId].precedence) || (operators[s_opId].associativity == A_RIGHT && operators[s_opId].precedence < operators[p_opId].precedence)) { setToken(token, OPERATOR, op, p_opId); file_enqueue(f, token); op_queued = 1; } if(!op_queued) pile_push(p, p_op); op_queued = 0; } pile_push(p, str[i]); } else if(str[i] == '(') { pile_push(p, str[i]); } else if(str[i] == ')') { char p_op; while((p_op = pile_pop(p)) != '(') { if(isAnOperator(p_op)) { setToken(token, OPERATOR, op, getOperatorID(p_op)); file_enqueue(f, token); } } } else if(isFloat(str[i])) { buffer[j] = str[i]; j++; numberSaved = 0; } else if(isblank(str[i]) || (i == strlen(str) - 1)) { if(!numberSaved && j > 0) { setToken(token, NUMBER, data, atof(buffer)); file_enqueue(f, token); memset(buffer, '\0', j); j = 0; numberSaved = 1; } } } p_size = pile_size(*p); while(p_size--) { char p_op = pile_pop(p); if(isAnOperator(p_op)) { setToken(token, OPERATOR, op, getOperatorID(p_op)); file_enqueue(f, token); } } }