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);
}
}
}
