int main(int argc,char* argv[]) { if(argc < 3) { printf("Modo de usar:\n ./grep expressao arquivo\n"); return 0; } char* exp = (char*)malloc(tamanhoaux*sizeof(char)); strcpy(exp,argv[1]); char* contentFile = (char*)malloc(tamTextArquivo*sizeof(char)); contentFile = importFile(argv[2]); Stack* stack = createStack(tamanhoaux); if(!VerificacaoPilha(stack,exp)) printf("Expressão Invalida\n"); char* newExp; newExp = convertExpression(exp); printf("Expressão lida: %s\n", newExp); State* state = exprestoNdeter(newExp); printRightLines(contentFile,argv[2],state); return 0; }
// // Method: runOnFunction() // // Description: // Entry point for this LLVM pass. // // Return value: // true - The function was modified. // false - The function was not modified. // bool BreakConstantGEPs::runOnFunction (Function & F) { bool modified = false; // Worklist of values to check for constant GEP expressions std::vector<Instruction *> Worklist; // // Initialize the worklist by finding all instructions that have one or more // operands containing a constant GEP expression. // for (Function::iterator BB = F.begin(); BB != F.end(); ++BB) { for (BasicBlock::iterator i = BB->begin(); i != BB->end(); ++i) { // // Scan through the operands of this instruction. If it is a constant // expression GEP, insert an instruction GEP before the instruction. // Instruction * I = i; for (unsigned index = 0; index < I->getNumOperands(); ++index) { if (hasConstantGEP (I->getOperand(index))) { Worklist.push_back (I); } } } } // // Determine whether we will modify anything. // if (Worklist.size()) modified = true; // // While the worklist is not empty, take an item from it, convert the // operands into instructions if necessary, and determine if the newly // added instructions need to be processed as well. // while (Worklist.size()) { Instruction * I = Worklist.back(); Worklist.pop_back(); // // Scan through the operands of this instruction and convert each into an // instruction. Note that this works a little differently for phi // instructions because the new instruction must be added to the // appropriate predecessor block. // if (PHINode * PHI = dyn_cast<PHINode>(I)) { for (unsigned index = 0; index < PHI->getNumIncomingValues(); ++index) { // // For PHI Nodes, if an operand is a constant expression with a GEP, we // want to insert the new instructions in the predecessor basic block. // // Note: It seems that it's possible for a phi to have the same // incoming basic block listed multiple times; this seems okay as long // the same value is listed for the incoming block. // Instruction * InsertPt = PHI->getIncomingBlock(index)->getTerminator(); if (ConstantExpr * CE = hasConstantGEP (PHI->getIncomingValue(index))) { Instruction * NewInst = convertExpression (CE, InsertPt); for (unsigned i2 = index; i2 < PHI->getNumIncomingValues(); ++i2) { if ((PHI->getIncomingBlock (i2)) == PHI->getIncomingBlock (index)) PHI->setIncomingValue (i2, NewInst); } Worklist.push_back (NewInst); } } } else { for (unsigned index = 0; index < I->getNumOperands(); ++index) { // // For other instructions, we want to insert instructions replacing // constant expressions immediently before the instruction using the // constant expression. // if (ConstantExpr * CE = hasConstantGEP (I->getOperand(index))) { Instruction * NewInst = convertExpression (CE, I); I->replaceUsesOfWith (CE, NewInst); Worklist.push_back (NewInst); } } } } return modified; }
std::string printCalcResult (const ExpressionPtr & exp, const std::string & connector, const PrimitiveValue & value) { shared_ptr<InfixFunctionBox> infixBox (new InfixFunctionBox(connector)); infixBox->addArgument(convertExpression(exp)); infixBox->addArgument(convertPrimitiveValue(value)); return printBox (infixBox); }
std::string print (const ExpressionPtr & expression) { BoxPtr box = convertExpression (expression); return printBox (box); }