void HyperDijkstra::visitAdjacencyMap(AdjacencyMap& amap, TreeAction* action, bool useDistance) { typedef std::deque<HyperGraph::Vertex*> Deque; Deque q; // scans for the vertices without the parent (whcih are the roots of the trees) and applies the action to them. for (AdjacencyMap::iterator it=amap.begin(); it!=amap.end(); ++it){ AdjacencyMapEntry& entry(it->second); if (! entry.parent()) { action->perform(it->first,0,0); q.push_back(it->first); } } //std::cerr << "q.size()" << q.size() << endl; int count=0; while (! q.empty()){ HyperGraph::Vertex* parent=q.front(); q.pop_front(); ++count; AdjacencyMap::iterator parentIt=amap.find(parent); if (parentIt==amap.end()) { continue; } //cerr << "parent= " << parent << " parent id= " << parent->id() << "\t children id ="; HyperGraph::VertexSet& childs(parentIt->second.children()); for (HyperGraph::VertexSet::iterator childsIt=childs.begin(); childsIt!=childs.end(); ++childsIt){ HyperGraph::Vertex* child=*childsIt; //cerr << child->id(); AdjacencyMap::iterator adjacencyIt=amap.find(child); assert (adjacencyIt!=amap.end()); HyperGraph::Edge* edge=adjacencyIt->second.edge(); assert(adjacencyIt->first==child); assert(adjacencyIt->second.child()==child); assert(adjacencyIt->second.parent()==parent); if (! useDistance) { action->perform(child, parent, edge); } else { action->perform(child, parent, edge, adjacencyIt->second.distance()); } q.push_back(child); } //cerr << endl; } }
void ConvertPaletted::run(const Vector<SharedPtr<Option>>& arguments) { if (arguments.size() == 1) { StringBuffer sb; sb << "wrong number of arguments" << EndOfLine; throw RuntimeError(sb.str()); } SDL_Init(0); IMG_Init(IMG_INIT_PNG); Deque<String> queue; RegexFilter filter("^(?:.*" REGEX_DIRSEP ")?(?:tris|tile)[0-9]+\\.bmp$"); /// @todo Do *not* assume the path is relative. Ensure that it is absolute by a system function. for (const auto& argument : arguments) { if (argument->getType() != Option::Type::UnnamedValue) { StringBuffer sb; sb << "unrecognized argument" << EndOfLine; throw RuntimeError(sb.str()); } auto pathnameArgument = static_pointer_cast<UnnamedValue>(argument); queue.emplace_back(FileSystem::sanitize(pathnameArgument->getValue())); } while (!queue.empty()) { String path = queue[0]; queue.pop_front(); switch (FileSystem::stat(path)) { case FileSystem::PathStat::File: if (filter(path)) { convert(path); } break; case FileSystem::PathStat::Directory: FileSystem::recurDir(path, queue); break; case FileSystem::PathStat::Failure: break; // stat complains default: { StringBuffer sb; sb << "skipping '" << path << "' - not a file or directory" << EndOfLine; cerr << sb.str(); } } } IMG_Quit(); SDL_Quit(); }
int main ( ) { Deque myDeque; for (int i = 0; i < 128; i++) { myDeque.pushRight(new int[1]{i}); } while (!myDeque.empty()) { int* thing = static_cast<int*>(myDeque.popLeft()); printf("%d\n", *thing); delete thing; } printf("\n\n"); return 0; }
//--------------------Linear solution---------------------- void minimumValues(int v[], int k) { Deque<int> d = Deque<int>(); // In the queue I store positions, no elements for (int i = 0; i < N; i++) { if (i >= k) // Until we have not consider a subarray, we can not print the minimums. cout << v[d.front()] << " "; while (!d.empty() && v[d.back()] >= v[i]) { // While the queue is not empty and the element I want to insert is // greater or equal than the last one I extract the last element d.pop_back(); } d.push_back(i); // I insert the new element if (d.front() <= i - k) //This remove the minimum once is out of the subarray d.pop_front(); } cout << v[d.front()] << endl; }
void test_deque() { const size_t SIZE = 10; Deque<int, SIZE> deque; cout << "--> testing push_back..." << endl; for (size_t i = 0; i < SIZE; i++) { try { deque.push_back(i); } catch (std::overflow_error &e) { cout << "i: " << i << endl; cout << e.what() << endl; } } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing pop_back..." << endl; while (!deque.empty()) { deque.pop_back(); } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing push_front..." << endl; for (size_t i = 0; i < SIZE; i++) { try { deque.push_front(i); } catch (std::overflow_error &e) { cout << "i: " << i << endl; cout << e.what() << endl; } } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing pop_front..." << endl; while (!deque.empty()) { deque.pop_front(); } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); }
void DequeTest() { Deque<int> testq; Deque<int> testBad(256); for(int i=0;i<512;i++) { testBad.push_back(i); } for(int i=0;i<512;i++) { INVARIANT(testBad.empty() == false && testBad.front() == i, "simple test failed?!"); testBad.pop_front(); } // test empty->size1->empty for(int size1=1;size1<2000;size1++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size1;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d") % size1 % j); testq.pop_front(); } INVARIANT(testq.empty()==true,"internal"); } printf("pass empty->full->empty tests\n"); // test empty->size1, size2 add/remove, ->empty for(int size1=1;size1<150;size1++) { for(int size2=1;size2<400;size2++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size2;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d/%d") % size1 % size2 %j); testq.pop_front(); testq.push_back((j+size1)); } for(int j=size2;j<size1+size2;j++) { INVARIANT(testq.empty()==false,"internal"); int t = testq.front(); testq.pop_front(); INVARIANT(t == j, boost::format("Internal Error: %d/%d/%d/%d") % t % size1 % size2 % j); } INVARIANT(testq.empty()==true,"internal"); } } printf("pass partial fill tests\n"); }
void testIteratorOperations() { Deque<int> deque; MersenneTwisterRandom rng; int n_ops = rng.randInt(100); for (int i = 0; i < n_ops; ++i) { if (rng.randInt(10) < 3 && !deque.empty()) { deque.pop_front(); } else { deque.push_back(rng.randInt()); } } // Test iterator unary operators { for (Deque<int>::iterator it = deque.begin(); it != deque.end(); ) { Deque<int>::iterator it1 = it; Deque<int>::iterator it2 = it; SINVARIANT(it1 == it2); Deque<int>::iterator it3 = it1++; INVARIANT(it3 == it && it3 != it1 && it1 != it2, "return unchanged && return different from iterator && iterator changed"); Deque<int>::iterator it4 = ++it2; INVARIANT(it4 != it && it4 == it1 && it2 == it1, "return changed && return == updated && two updates same"); it = it4; } } // Test distance operators Deque<int>::iterator it_forward = deque.begin(); Deque<int>::iterator it_backward = deque.end(); ptrdiff_t dist_from_start = 0; // start can be .begin() or .end() ptrdiff_t dist_from_finish = deque.end() - deque.begin(); // finish can be .end() or .begin() for (; it_forward != deque.end(); ++dist_from_start, --dist_from_finish) { SINVARIANT(it_backward - it_forward == dist_from_finish - dist_from_start); SINVARIANT(it_forward + dist_from_finish == deque.end()); SINVARIANT(it_backward - dist_from_finish == deque.begin()); SINVARIANT((it_forward < it_backward) == (dist_from_start < dist_from_finish)); SINVARIANT((it_forward <= it_backward) == (dist_from_start <= dist_from_finish)); SINVARIANT((it_forward > it_backward) == (dist_from_start > dist_from_finish)); SINVARIANT((it_forward >= it_backward) == (dist_from_start >= dist_from_finish)); Deque<int>::iterator temp_a(it_forward); Deque<int>::iterator temp_b; temp_b = it_backward; SINVARIANT(temp_b - temp_a == dist_from_finish - dist_from_start); temp_a += dist_from_finish; SINVARIANT(temp_a == deque.end()); temp_b -= dist_from_finish; SINVARIANT(temp_b == deque.begin()); if (rng.randBool()) { // Exercise both variants of the increment/decrement operators ++it_forward; --it_backward; } else { it_forward++; it_backward--; } } SINVARIANT(it_backward == deque.begin()); SINVARIANT(static_cast<size_t>(dist_from_start) == deque.size()); SINVARIANT(dist_from_finish == 0); }
int main(int argc, char *argv[]) { std::set_new_handler(&mem_error); if (!ParseArguments(argc, argv)) { Usage(); exit(-1); } // Disable core dump struct rlimit r_core; r_core.rlim_cur = 0; r_core.rlim_max = 0; setrlimit(RLIMIT_CORE, &r_core); // Set demo limits if (options.demo) { struct rlimit r_cpu, r_as; memlimit = true; r_cpu.rlim_cur = 30; // max 30 secs. r_cpu.rlim_max = 30; setrlimit(RLIMIT_CPU, &r_cpu); r_as.rlim_cur = 20971520; // max 20MB r_as.rlim_max = 20971520; setrlimit(RLIMIT_DATA, &r_as); signal(SIGXCPU, &cpuLimit); } initTimer(); Timer timer_total; timer_total.start(); ///////// PARSING //////////////////////////////////////////////////////// if (options.printProgress) cout << "MONA v" << VERSION << "-" << RELEASE << " for WS1S/WS2S\n" "Copyright (C) 1997-2008 BRICS\n\n" "PARSING\n"; Timer timer_parsing; timer_parsing.start(); loadFile(inputFileName); yyparse(); MonaAST *ast = untypedAST->typeCheck(); lastPosVar = ast->lastPosVar; allPosVar = ast->allPosVar; timer_parsing.stop(); if (options.printProgress) { cout << "Time: "; timer_parsing.print(); } delete untypedAST; if (options.dump) { // Dump AST for main formula, verify formulas, and assertion cout << "Main formula:\n"; (ast->formula)->dump(); Deque<ASTForm *>::iterator vf; Deque<char *>::iterator vt; for (vf = ast->verifyformlist.begin(), vt = ast->verifytitlelist.begin(); vf != ast->verifyformlist.end(); vf++, vt++) { cout << "\n\nFormula " << *vt << ":\n"; (*vf)->dump(); } cout << "\n\nAssertions:\n"; (ast->assertion)->dump(); cout << "\n"; if (lastPosVar != -1) cout << "\nLastPos variable: " << symbolTable.lookupSymbol(lastPosVar) << "\n"; if (allPosVar != -1) cout << "\nAllPos variable: " << symbolTable.lookupSymbol(allPosVar) << "\n"; // Dump ASTs for predicates and macros PredLibEntry *pred = predicateLib.first(); while (pred != NULL) { if (pred->isMacro) cout << "\nMacro '"; else cout << "\nPredicate '"; cout << symbolTable.lookupSymbol(pred->name) << "':\n"; (pred->ast)->dump(); cout << "\n"; pred = predicateLib.next(); } // Dump restrictions if (symbolTable.defaultRestriction1) { cout << "\nDefault first-order restriction (" << symbolTable.lookupSymbol(symbolTable.defaultIdent1) << "):\n"; symbolTable.defaultRestriction1->dump(); cout << "\n"; } if (symbolTable.defaultRestriction2) { cout << "\nDefault second-order restriction (" << symbolTable.lookupSymbol(symbolTable.defaultIdent2) << "):\n"; symbolTable.defaultRestriction2->dump(); cout << "\n"; } Ident id; for (id = 0; id < (Ident) symbolTable.noIdents; id++) { Ident t; ASTForm *f = symbolTable.getRestriction(id, &t); if (f) { cout << "\nRestriction for #" << id << " (" << symbolTable.lookupSymbol(id) << "):"; if (t != -1) cout << " default\n"; else { cout << "\n"; f->dump(); cout << "\n"; } } } } if (options.mode != TREE && (options.graphvizSatisfyingEx || options.graphvizCounterEx || options.inheritedAcceptance)) cout << "Warning: options -gc, -gs, and -h are only used in tree mode\n"; if (options.mode == TREE && options.graphvizDFA) cout << "Warning: option -gw is only used in linear mode\n"; if (options.mode == TREE && (options.dump || options.whole) && !options.externalWhole) printGuide(); ///////// CODE GENERATION //////////////////////////////////////////////// if (options.printProgress) cout << "\nCODE GENERATION\n"; Timer timer_gencode; timer_gencode.start(); // Generate code codeTable = new CodeTable; VarCode formulaCode = ast->formula->makeCode(); VarCode assertionCode = ast->assertion->makeCode(); Deque<VarCode> verifyCode; /* #warning NEW: 'VERIFY' */ for (Deque<ASTForm *>::iterator i = ast->verifyformlist.begin(); i != ast->verifyformlist.end(); i++) verifyCode.push_back((*i)->makeCode()); // Implicitly assert restrictions for all global variables for (IdentList::iterator i = ast->globals.begin(); i != ast->globals.end(); i++) assertionCode = andList(assertionCode, getRestriction(*i, NULL)); // Restrict assertion if not trivial if (assertionCode.code->kind != cTrue) assertionCode = codeTable->insert (new Code_Restrict(assertionCode, assertionCode.code->pos)); // Add assertion to main formula and to all verify formulas for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) { assertionCode.code->refs++; *i = andList(*i, VarCode(copy(assertionCode.vars), assertionCode.code)); } formulaCode = andList(formulaCode, assertionCode); timer_gencode.stop(); if (options.printProgress) { codeTable->print_statistics(); /* if (options.dump && options.statistics) codeTable->print_sizes(); */ cout << "Time: "; timer_gencode.print(); } ///////// REORDER BDD OFFSETS //////////////////////////////////////////// if (options.reorder >= 1) { Timer timer_reorder; timer_reorder.start(); if (options.printProgress) cout << "\nREORDERING\n"; // reorder using heuristics offsets.reorder(); // regenerate DAG in new codetable CodeTable *oldCodeTable = codeTable, *newCodeTable = new CodeTable; IdentList emptylist; codeTable = newCodeTable; regenerate = true; // force making new nodes VarCode newcode = formulaCode.substCopy(&emptylist, &emptylist); Deque<VarCode> newverifycode; for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) newverifycode.push_back((*i).substCopy(&emptylist, &emptylist)); codeTable->clearSCTable(); regenerate = false; codeTable = oldCodeTable; formulaCode.remove(); for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) (*i).remove(); formulaCode = newcode; verifyCode.reset(); for (Deque<VarCode>::iterator i = newverifycode.begin(); i != newverifycode.end(); i++) verifyCode.push_back(*i); delete oldCodeTable; codeTable = newCodeTable; if (options.printProgress) { codeTable->print_statistics2(); cout << "Time: "; timer_reorder.print(); } } ///////// REDUCTION AND CODE DUMPING ///////////////////////////////////// if (options.optimize >= 1) { if (options.printProgress) cout << "\nREDUCTION\n"; Timer timer_reduction; timer_reduction.start(); // Reduce formulaCode.reduceAll(&verifyCode); timer_reduction.stop(); if (options.printProgress) { codeTable->print_reduction_statistics(); /* if (options.dump && options.statistics) codeTable->print_sizes(); */ cout << "Time: "; timer_reduction.print(); } } if (options.dump) { // Dump symboltable symbolTable.dump(); // Dump code cout << "\nMain formula:\n"; formulaCode.dump(); cout << "\n\n"; Deque<VarCode>::iterator i; Deque<char *>::iterator j; for (i = verifyCode.begin(), j = ast->verifytitlelist.begin(); i != verifyCode.end(); i++, j++) { cout << "Formula " << *j << ":\n"; (*i).dump(); cout << "\n\n"; } } if (options.graphvizDAG) { printf("digraph MONA_CODE_DAG {\n" " size = \"7.5,10.5\";\n" " main [shape = plaintext];\n" " main -> L%lx;\n", (unsigned long) formulaCode.code); formulaCode.code->viz(); Deque<VarCode>::iterator i; Deque<char *>::iterator j; for (i = verifyCode.begin(), j = ast->verifytitlelist.begin(); i != verifyCode.end(); i++, j++) { printf(" \"%s\" [shape = plaintext];\n" " \"%s\" -> L%lx;\n", *j, *j, (unsigned long) (*i).code); (*i).code->viz(); } formulaCode.unmark(); for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) (*i).unmark(); cout << "}\n"; } ///////// AUTOMATON CONSTRUCTION ///////////////////////////////////////// // Make variable lists Deque<char *> *verifytitlelist = ast->verifytitlelist.copy(); if (lastPosVar != -1) ast->globals.remove(lastPosVar); if (allPosVar != -1) ast->globals.remove(allPosVar); ast->globals.sort(); // sort by id (= index) int numVars = ast->globals.size(); int ix = 0; char **vnames = new char*[numVars]; unsigned *offs = new unsigned[numVars]; char *types = new char[numVars]; int **univs = new int*[numVars]; int *trees = new int[numVars]; SSSet *statespaces = new SSSet[numVars]; IdentList sign, freeVars; IdentList::iterator id; for (id = ast->globals.begin(); id != ast->globals.end(); id++, ix++) { statespaces[ix] = stateSpaces(*id); vnames[ix] = symbolTable.lookupSymbol(*id); offs[ix] = offsets.off(*id); sign.push_back(ix); freeVars.push_back(*id); switch (symbolTable.lookupType(*id)) { case VarnameTree: trees[ix] = 1; break; default: trees[ix] = 0; } IdentList *uu = symbolTable.lookupUnivs(*id); if (uu) { unsigned j; univs[ix] = new int[uu->size()+1]; for (j = 0; j < uu->size(); j++) univs[ix][j] = symbolTable.lookupUnivNumber(uu->get(j)); univs[ix][j] = -1; } else univs[ix] = 0; switch (symbolTable.lookupType(*id)) { case Varname0: types[ix] = 0; break; case Varname1: types[ix] = 1; break; default: types[ix] = 2; break; } } if (options.printProgress) cout << "\nAUTOMATON CONSTRUCTION\n"; Timer timer_automaton; timer_automaton.start(); DFA *dfa = 0; Deque<DFA *> dfalist; GTA *gta = 0; Deque<GTA *> gtalist; // Initialize bdd_init(); codeTable->init_print_progress(); if (options.mode != TREE) { // Generate DFAs dfa = formulaCode.DFATranslate(); if (lastPosVar != -1) dfa = st_dfa_lastpos(dfa, lastPosVar); if (allPosVar != -1) dfa = st_dfa_allpos(dfa, allPosVar); for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) { DFA *d = (*i).DFATranslate(); if (lastPosVar != -1) d = st_dfa_lastpos(d, lastPosVar); if (allPosVar != -1) d = st_dfa_allpos(d, allPosVar); dfalist.push_back(d); } } else { // Generate GTAs gta = formulaCode.GTATranslate(); if (allPosVar != -1) gta = st_gta_allpos(gta, allPosVar); for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) { GTA *g = (*i).GTATranslate(); if (allPosVar != -1) g = st_gta_allpos(g, allPosVar); gtalist.push_back(g); } } formulaCode.remove(); for (Deque<VarCode>::iterator i = verifyCode.begin(); i != verifyCode.end(); i++) (*i).remove(); timer_automaton.stop(); if (options.printProgress) { if (options.statistics) cout << "Total automaton construction time: "; else cout << "Time: "; timer_automaton.print(); } delete ast; delete codeTable; ///////// PRINT AUTOMATON //////////////////////////////////////////////// DFA *dfa2 = dfa; GTA *gta2 = gta; Deque<DFA *> *dfalist2 = &dfalist; Deque<GTA *> *gtalist2 = >alist; if (options.whole && !options.externalWhole) cout << "\n"; if (options.unrestrict) { // Unrestrict automata if (options.mode != TREE) { DFA *t = dfaCopy(dfa2); dfaUnrestrict(t); dfa2 = dfaMinimize(t); dfaFree(t); dfalist2 = new Deque<DFA *>; for (Deque<DFA *>::iterator i = dfalist.begin(); i != dfalist.end(); i++) { t = dfaCopy(*i); dfaUnrestrict(t); dfalist2->push_back(dfaMinimize(t)); dfaFree(t); } } else { GTA *t = gtaCopy(gta2); gtaUnrestrict(t); gta2 = gtaMinimize(t); gtaFree(t); gtalist2 = new Deque<GTA *>; for (Deque<GTA *>::iterator i = gtalist.begin(); i != gtalist.end(); i++) { t = gtaCopy(*i); gtaUnrestrict(t); gtalist2->push_back(gtaMinimize(t)); gtaFree(t); } } } if (options.whole) // Print whole automaton if (options.mode != TREE) { if (options.externalWhole) { if (!dfalist.empty()) cout << "Main formula:\n"; DFA *t = dfaCopy(dfa2); st_dfa_replace_indices(t, &sign, &freeVars, false, true); dfaExport(t, 0, numVars, vnames, types); dfaFree(t); Deque<DFA *>::iterator i; Deque<char *>::iterator j; for (i = dfalist2->begin(), j = verifytitlelist->begin(); i != dfalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; t = dfaCopy(*i); st_dfa_replace_indices(t, &sign, &freeVars, false, true); dfaExport(t, 0, numVars, vnames, types); dfaFree(t); } } else if (options.graphvizDFA) { dfaPrintGraphviz(dfa2, numVars, offs); for (Deque<DFA *>::iterator i = dfalist2->begin(); i != dfalist2->end(); i++) dfaPrintGraphviz(*i, numVars, offs); } else { if (!dfalist.empty()) cout << "Main formula:\n"; dfaPrint(dfa2, numVars, vnames, offs); Deque<DFA *>::iterator i; Deque<char *>::iterator j; for (i = dfalist2->begin(), j = verifytitlelist->begin(); i != dfalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; dfaPrint(*i, numVars, vnames, offs); } } } else { if (options.externalWhole) { if (!gtalist.empty()) cout << "Main formula:\n"; GTA *t = gtaCopy(gta2); st_gta_replace_indices(t, &sign, &freeVars, false, true); gtaExport(t, 0, numVars, vnames, types, statespaces, options.inheritedAcceptance); gtaFree(t); Deque<GTA *>::iterator i; Deque<char *>::iterator j; for (i = gtalist2->begin(), j = verifytitlelist->begin(); i != gtalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; t = gtaCopy(*i); st_gta_replace_indices(t, &sign, &freeVars, false, true); gtaExport(t, 0, numVars, vnames, types, statespaces, options.inheritedAcceptance); gtaFree(t); } } else { if (!gtalist.empty()) cout << "Main formula:\n"; gtaPrint(gta2, offs, numVars, vnames, options.inheritedAcceptance); Deque<GTA *>::iterator i; Deque<char *>::iterator j; for (i = gtalist2->begin(), j = verifytitlelist->begin(); i != gtalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; gtaPrint(*i, offs, numVars, vnames, options.inheritedAcceptance); } } } else if (options.analysis && !options.graphvizSatisfyingEx && !options.graphvizCounterEx && options.printProgress) { // Print summary only if (options.mode != TREE) { if (!dfalist.empty()) cout << "Main formula:"; dfaPrintVitals(dfa2); Deque<DFA *>::iterator i; Deque<char *>::iterator j; for (i = dfalist2->begin(), j = verifytitlelist->begin(); i != dfalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":"; dfaPrintVitals(*i); } } else { if (!gtalist.empty()) cout << "Main formula:"; gtaPrintTotalSize(gta2); Deque<GTA *>::iterator i; Deque<char *>::iterator j; for (i = gtalist2->begin(), j = verifytitlelist->begin(); i != gtalist2->end(); i++, j++) { cout << "\nFormula " << *j << ":"; gtaPrintTotalSize(*i); } } } if (dfa2 != dfa) { dfaFree(dfa2); for (Deque<DFA *>::iterator i = dfalist2->begin(); i != dfalist2->end(); i++) dfaFree(*i); delete dfalist2; } if (gta2 != gta) { gtaFree(gta2); for (Deque<GTA *>::iterator i = gtalist2->begin(); i != gtalist2->end(); i++) gtaFree(*i); delete gtalist2; } ///////// AUTOMATON ANALYSIS ///////////////////////////////////////////// if (options.analysis) { if (options.printProgress) cout << "\nANALYSIS\n"; if (options.mode != TREE) { if (!dfalist.empty()) cout << "Main formula:\n"; dfaAnalyze(dfa, numVars, vnames, offs, types, options.treemodeOutput); Deque<DFA *>::iterator i; Deque<char *>::iterator j; for (i = dfalist.begin(), j = verifytitlelist->begin(); i != dfalist.end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; dfaAnalyze(*i, numVars, vnames, offs, types, options.treemodeOutput); } } else { if (numTypes == 0 || options.treemodeOutput) { if (!gtalist.empty()) cout << "Main formula:\n"; gtaAnalyze(gta, numVars, vnames, offs, options.graphvizSatisfyingEx, options.graphvizCounterEx); Deque<GTA *>::iterator i; Deque<char *>::iterator j; for (i = gtalist.begin(), j = verifytitlelist->begin(); i != gtalist.end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; gtaAnalyze(*i, numVars, vnames, offs, options.graphvizSatisfyingEx, options.graphvizCounterEx); } } else { if (options.graphvizSatisfyingEx || options.graphvizCounterEx) cout << "Graphviz output of typed trees not implemented.\n"; if (!gtalist.empty()) cout << "Main formula:\n"; gtaTypeAnalyze(gta, numVars, vnames, types, offs, univs, trees); Deque<GTA *>::iterator i; Deque<char *>::iterator j; for (i = gtalist.begin(), j = verifytitlelist->begin(); i != gtalist.end(); i++, j++) { cout << "\nFormula " << *j << ":\n"; gtaTypeAnalyze(*i, numVars, vnames, types, offs, univs, trees); } } } } ///////// CLEAN UP /////////////////////////////////////////////////////// if (options.mode != TREE) { dfaFree(dfa); for (Deque<DFA *>::iterator i = dfalist.begin(); i != dfalist.end(); i++) dfaFree(*i); } else { gtaFree(gta); for (Deque<GTA *>::iterator i = gtalist.begin(); i != gtalist.end(); i++) gtaFree(*i); freeGuide(); } delete verifytitlelist; Deque<FileSource *>::iterator i; for (i = source.begin(); i != source.end(); i++) delete *i; for (ix = 0; ix < numVars; ix++) { delete[] univs[ix]; mem_free(statespaces[ix]); } delete[] statespaces; delete[] vnames; delete[] offs; delete[] types; delete[] univs; delete[] trees; freeTreetypes(); if (options.statistics) print_statistics(); if (options.time) { timer_total.stop(); cout << "\nTotal time: "; timer_total.print(); print_timing(); } else if (options.printProgress) { timer_total.stop(); cout << "\nTotal time: "; timer_total.print(); } #ifdef MAXALLOCATED cout << "Maximum space allocated: " << (maxallocated+524288)/1048576 << " MB\n"; #endif }
int main(int argc, char *argv[]) { Deque *deque; char line[4096]; size_t len; void *data; size_t size; if (argc == 1) { deque = Memory_Deque_create(); } else if (argc == 2 && argv[1][0] != '-') { deque = File_Deque_create(argv[1]); } else { printf("Usage:\n" " test-deque -- use the in-memory deque\n" " test-deque <path> -- use the file-based deque\n" "\n" "Commands:\n" " destroy -- destroy the deque and exit\n" " empty -- report if the deque is empty\n" " size -- print number of elements in the deque\n" " push_back -- add element at the back\n" " push_front -- add element at the front\n" " get_back -- print element at the back\n" " get_front -- print element at the front\n" " pop_back -- remove element at the back\n" " pop_front -- remove element at the front\n"); return 1; } if (deque == NULL) { fprintf(stderr, "Unable to create deque!\n"); exit(1); } while (fgets(line, sizeof(line), stdin) != NULL) { /* Determine length and strip trailing newline character */ len = strlen(line); if (len == 0) break; if (line[len - 1] == '\n') { line[len - 1] = '\0'; len -= 1; } if (strcmp(line, "destroy") == 0) { break; } else if (strcmp(line, "empty") == 0) { printf("empty=%s\n", deque->empty(deque) ? "true" : "false"); } else if (strcmp(line, "size") == 0) { printf("size=%ld\n", (long)deque->size(deque)); } else if (strncmp(line, "push_back ", 10) == 0) { if (!deque->push_back(deque, line + 10, len - 10)) printf("push_back failed!\n"); } else if (strncmp(line, "push_front ", 11) == 0) { if (!deque->push_front(deque, line + 11, len - 11)) printf("push_front failed!\n"); } else if (strcmp(line, "get_back") == 0) { if (!deque->get_back(deque, &data, &size)) printf("get_back failed!\n"); else { fwrite(data, size, 1, stdout); fputc('\n', stdout); } } else if (strcmp(line, "get_front") == 0) { if (!deque->get_front(deque, &data, &size)) printf("get_front failed!\n"); else { fwrite(data, size, 1, stdout); fputc('\n', stdout); } } else if (strcmp(line, "pop_back") == 0) { if (!deque->pop_back(deque)) printf("pop_back failed!\n"); } else if (strcmp(line, "pop_front") == 0) { if (!deque->pop_front(deque)) printf("pop_front failed!\n"); } else { printf("Unrecognized input line: %s!\n", line); } } deque->destroy(deque); return 0; }