void finish() { if (m_size > 0) { // zero-pad memset (tail(), 0, needed()); static_cast <Derived*> (this)->process_block (m_block); } }
/** ** Build new units to reduce the food shortage. */ static bool AiRequestSupply() { // Don't request supply if we're sleeping. When the script starts it may // request a better unit than the one we pick here. If we only have enough // resources for one unit we don't want to build the wrong one. if (AiPlayer->SleepCycles != 0) { /* we still need supply */ return true; } // Count the already made build requests. int counter[UnitTypeMax]; AiGetBuildRequestsCount(AiPlayer, counter); struct cnode cache[16]; memset(cache, 0, sizeof(cache)); // // Check if we can build this? // int j = 0; const int n = AiHelpers.UnitLimit[0].size(); for (int i = 0; i < n; ++i) { CUnitType &type = *AiHelpers.UnitLimit[0][i]; if (counter[type.Slot]) { // Already ordered. #if defined(DEBUG) && defined(DebugRequestSupply) DebugPrint("%d: AiRequestSupply: Supply already build in %s\n" _C_ AiPlayer->Player->Index _C_ type->Name.c_str()); #endif return false; } if (!AiRequestedTypeAllowed(AiPlayer->Player, type)) { continue; } // // Check if resources available. // cache[j].needmask = AiCheckUnitTypeCosts(type); for (int c = 1; c < MaxCosts; ++c) { cache[j].unit_cost += type.Stats[AiPlayer->Player->Index].Costs[c]; } cache[j].unit_cost += type.Supply - 1; cache[j].unit_cost /= type.Supply; cache[j++].type = &type; Assert(j < 16); } if (j > 1) qsort(&cache, j, sizeof (struct cnode), cnode_cmp); if (j) { if (!cache[0].needmask) { CUnitType &type = *cache[0].type; if (AiMakeUnit(type, -1, -1)) { AiBuildQueue newqueue; newqueue.Type = &type; newqueue.Want = 1; newqueue.Made = 1; AiPlayer->UnitTypeBuilt.insert( AiPlayer->UnitTypeBuilt.begin(), newqueue); #if defined( DEBUG) && defined( DebugRequestSupply ) DebugPrint("%d: AiRequestSupply: build Supply in %s\n" _C_ AiPlayer->Player->Index _C_ type->Name.c_str()); #endif return false; } } AiPlayer->NeededMask |= cache[0].needmask; } #if defined( DEBUG) && defined( DebugRequestSupply ) std::string needed(""); for (int i = 1; i < MaxCosts; ++i) { if (cache[0].needmask & (1 << i)) { needed += ":"; switch (i) { case GoldCost: needed += "Gold<"; break; case WoodCost: needed += "Wood<"; break; case OilCost: needed += "Oil<"; break; default: needed += "unknown<"; break; } needed += '0' + i; needed += ">"; } } DebugPrint("%d: AiRequestSupply: needed build %s with %s resource\n" _C_ AiPlayer->Player->Index _C_ cache[0].type->Name.c_str() _C_ needed.c_str()); #endif return true; }
void Count() { while (needed() < 0)std::this_thread::sleep_for(std::chrono::duration<int>(static_cast<int>(1 / Fps))); Start_Time = std::chrono::steady_clock::now(); }
// Find the needed halls std::vector<int> Environment::findNeededHallsInTheRightPosition(int currentHall) { int leftEdge = theHalls[currentHall]->edges.leftEdge; int rightEdge = theHalls[currentHall]->edges.rightEdge; int backEdge = theHalls[currentHall]->edges.back; std::vector<int> needed(MAX_HALLS); // std::vector<int>::iterator itterator = needed.begin(); int itterator =0; for (itterator=0; itterator <MAX_HALLS; itterator++) { needed[itterator]=-1; } itterator = 0; needed[itterator] = currentHall; itterator++; if(leftEdge!=-1) { needed[itterator] =leftEdge; itterator++; if(theHalls[leftEdge]->edges.leftEdge!=-1) { needed[itterator] =theHalls[leftEdge]->edges.leftEdge; itterator++; } if(theHalls[leftEdge]->edges.rightEdge!=-1) { needed[itterator] =theHalls[leftEdge]->edges.rightEdge; itterator++; } } if(rightEdge!=-1) { needed[itterator] =rightEdge; itterator++; if(theHalls[rightEdge]->edges.leftEdge!=-1) { needed[itterator] =theHalls[rightEdge]->edges.leftEdge; itterator++; } if(theHalls[rightEdge]->edges.rightEdge!=-1) { needed[itterator] =theHalls[rightEdge]->edges.rightEdge; itterator++; } } if(backEdge!=-1) { needed[itterator] =backEdge; itterator++; int edgeNotYou =theHalls[backEdge]->edges.rightEdge; if(theHalls[backEdge]->edges.leftEdge!=currentHall) edgeNotYou = theHalls[backEdge]->edges.leftEdge; if(edgeNotYou!=-1) { needed[itterator] =edgeNotYou; itterator++; if(theHalls[edgeNotYou]->edges.leftEdge!=-1) { needed[itterator] =theHalls[edgeNotYou]->edges.leftEdge; itterator++; } if(theHalls[edgeNotYou]->edges.rightEdge!=-1) { needed[itterator] =theHalls[edgeNotYou]->edges.rightEdge; itterator++; } } } return needed; }
void WarningIncludeHeader(const Tokenizer &tokenizer, bool Progress, OutputFormat outputFormat, std::ostream &errout) { // A header is needed if: // * It contains some needed class declaration // * It contains some needed function declaration // * It contains some needed constant value // * It contains some needed variable // * It contains some needed enum // Extract all includes.. std::vector< std::list<IncludeInfo> > includes(tokenizer.ShortFileNames.size(), std::list< IncludeInfo >()); for (const Token *tok = tokenizer.tokens; tok; tok = tok->next) { if (strncmp(tok->str, "#include", 8) == 0) { // Get index of included file: unsigned int hfile; const char *includefile = tok->next->str; for (hfile = 0; hfile < tokenizer.ShortFileNames.size(); ++hfile) { if (SameFileName(tokenizer.ShortFileNames[hfile].c_str(), includefile)) break; } includes[tok->FileIndex].push_back(IncludeInfo(tok, hfile)); } } // System headers are checked differently.. std::vector<unsigned int> SystemHeaders(tokenizer.ShortFileNames.size(), 0); for (const Token *tok = tokenizer.tokens; tok; tok = tok->next) { if (strcmp(tok->str, "#include<>") == 0 || (SystemHeaders[tok->FileIndex] && strcmp(tok->str, "#include") == 0)) { // Get index of included file: const char *includefile = tok->next->str; for (unsigned int hfile = 0; hfile < tokenizer.ShortFileNames.size(); ++hfile) { if (SameFileName(tokenizer.ShortFileNames[hfile].c_str(), includefile)) { SystemHeaders[hfile] = 1; break; } } } } // extracted class names.. std::vector< std::set<std::string> > classes(tokenizer.ShortFileNames.size(), std::set<std::string>()); // extracted symbol names.. std::vector< std::set<std::string> > names(tokenizer.ShortFileNames.size(), std::set<std::string>()); // needed symbol/type names std::vector< std::set<std::string> > needed(tokenizer.ShortFileNames.size(), std::set<std::string>()); // symbol/type names that need at least a forward declaration std::vector< std::set<std::string> > needDeclaration(tokenizer.ShortFileNames.size(), std::set<std::string>()); // Extract symbols from the files.. { unsigned int indentlevel = 0; for (const Token *tok = tokenizer.tokens; tok; tok = tok->next) { // Don't extract symbols in the main source file if (tok->FileIndex == 0) continue; if (tok->next && tok->FileIndex != tok->next->FileIndex) indentlevel = 0; if (tok->str[0] == '{') indentlevel++; else if (indentlevel > 0 && tok->str[0] == '}') indentlevel--; if (indentlevel != 0) continue; // Class or namespace declaration.. // -------------------------------------- if (Match(tok,"class %var% {") || Match(tok,"class %var% :") || Match(tok,"struct %var% {")) classes[tok->FileIndex].insert(getstr(tok, 1)); else if (Match(tok, "namespace %var% {") || Match(tok, "extern %str% {")) { tok = gettok(tok,2); continue; } else if (Match(tok, "struct %var% ;") || Match(tok, "class %var% ;")) { // This type name is probably needed in any files that includes this file const std::string name(tok->next->str); for (unsigned int i = 0; i < tokenizer.ShortFileNames.size(); ++i) { if (i == tok->FileIndex) continue; for (std::list<IncludeInfo>::const_iterator it = includes[i].begin(); it != includes[i].end(); ++it) { if (it->hfile == tok->FileIndex) { needed[it->tok->FileIndex].insert(name); } } } continue; } // Variable declaration.. // -------------------------------------- else if (Match(tok, "%type% %var% ;") || Match(tok, "%type% %var% [") || Match(tok, "%type% %var% =")) names[tok->FileIndex].insert(getstr(tok, 1)); else if (Match(tok, "%type% * %var% ;") || Match(tok, "%type% * %var% [") || Match(tok, "%type% * %var% =")) names[tok->FileIndex].insert(getstr(tok, 2)); // enum.. // -------------------------------------- else if (strcmp(tok->str, "enum") == 0) { tok = tok->next; while (tok->next && tok->str[0]!=';') { if (IsName(tok->str)) names[tok->FileIndex].insert(tok->str); tok = tok->next; } } // function.. // -------------------------------------- else if (Match(tok,"%type% %var% (") || Match(tok,"%type% * %var% (")) { tok = tok->next; if (tok->str[0] == '*') tok = tok->next; names[tok->FileIndex].insert(tok->str); while (tok->next && tok->str[0] != ')') tok = tok->next; } // typedef.. // -------------------------------------- else if (strcmp(tok->str,"typedef")==0) { if (strcmp(getstr(tok,1),"enum")==0) continue; while (tok->str[0] != ';' && tok->next) { if (Match(tok, "%var% ;")) names[tok->FileIndex].insert(tok->str); tok = tok->next; } } // #define.. // -------------------------------------- else if (Match(tok, "#define %var%")) names[tok->FileIndex].insert(tok->next->str); } } // Get all needed symbols.. { // Which files contain implementation? std::vector<unsigned int> HasImplementation(tokenizer.ShortFileNames.size(), 0); int indentlevel = 0; for (const Token *tok1 = tokenizer.tokens; tok1; tok1 = tok1->next) { if (strncmp(tok1->str, "#include", 8) == 0) { tok1 = tok1->next; continue; } if (tok1->next && tok1->FileIndex != tok1->next->FileIndex) indentlevel = 0; // implementation begins.. else if (indentlevel == 0 && Match(tok1, ") {")) { // Go to the "{" while (tok1->str[0] != '{') tok1 = tok1->next; indentlevel = 1; HasImplementation[tok1->FileIndex] = 1; } else if (indentlevel >= 1) { if (tok1->str[0] == '{') ++indentlevel; else if (tok1->str[0] == '}') --indentlevel; } if (Match(tok1, ": %var% {") || Match(tok1, ": %type% %var% {")) { const std::string classname(getstr(tok1, (strcmp(getstr(tok1,2),"{")) ? 2 : 1)); needed[tok1->FileIndex].insert(classname); } if (indentlevel == 0 && Match(tok1, "%type% * %var%")) { if (Match(gettok(tok1,3), "[,;()[]")) { needDeclaration[tok1->FileIndex].insert(tok1->str); tok1 = gettok(tok1, 2); continue; } } if (Match(tok1, "struct") || Match(tok1, "class")) { continue; } if (IsName(tok1->str) && !Match(tok1->next, "{")) needed[tok1->FileIndex].insert(tok1->str); } // Move needDeclaration symbols to needed for all files that has // implementation.. for (unsigned int i = 0; i < HasImplementation.size(); ++i) { if (HasImplementation[i]) { needed[i].insert(needDeclaration[i].begin(), needDeclaration[i].end()); } } } // Remove keywords.. for (unsigned int i = 0; i < tokenizer.ShortFileNames.size(); ++i) { const char *keywords[] = { "defined", // preprocessor "void", "bool", "char", "short", "int", "long", "float", "double", "false", "true", "std", "if", "for", "while", NULL }; for (unsigned int k = 0; keywords[k]; ++k) { needed[i].erase(keywords[k]); needDeclaration[i].erase(keywords[k]); } } // Check if there are redundant includes.. for (unsigned int fileIndex = 0; fileIndex < tokenizer.ShortFileNames.size(); ++fileIndex) { // Is the current file a system header? If so don't check it. if (SystemHeaders[fileIndex]) continue; // Check if each include is needed.. for (std::list<IncludeInfo>::const_iterator include = includes[fileIndex].begin(); include != includes[fileIndex].end(); ++include) { // include not found if (include->hfile >= tokenizer.ShortFileNames.size()) continue; if (Progress) { std::cout << "progress: file " << tokenizer.ShortFileNames[fileIndex] << " checking include " << tokenizer.ShortFileNames[include->hfile] << std::endl; } // Get all includes std::set<unsigned int> AllIncludes; bool notfound = false; AllIncludes.insert(include->hfile); if (SystemHeaders[include->hfile]) getincludes(includes, include->hfile, AllIncludes, notfound); // match symbols: needed bool Needed(false); for (std::set<unsigned int>::const_iterator it = AllIncludes.begin(); it != AllIncludes.end(); ++it) { const std::string sym = matchSymbols(needed[fileIndex], classes[*it], names[*it]); if (!sym.empty()) { if (Progress) std::cout << "progress: needed symbol '" << sym << "'" << std::endl; Needed = true; break; } } // Check if local header is needed indirectly.. if (!Needed && !SystemHeaders[include->hfile]) { std::string needed_header; getincludes(includes, include->hfile, AllIncludes, notfound); for (std::set<unsigned int>::const_iterator it = AllIncludes.begin(); it != AllIncludes.end(); ++it) { const std::string sym = matchSymbols(needed[fileIndex], classes[*it], names[*it]); if (!sym.empty()) { needed_header = tokenizer.ShortFileNames[*it]; if (Progress) std::cout << "progress: needed symbol '" << sym << "'" << std::endl; Needed = true; break; } } if (Needed) { std::ostringstream errmsg; errmsg << "Inconclusive results: The included header '" << include->tok->next->str << "' is not needed. However it is needed indirectly because it includes '" << needed_header << "'. If it is included by intention use '--skip " << include->tok->next->str << "' to remove false positives."; ReportErr(tokenizer, outputFormat, include->tok, "HeaderNotNeeded", errmsg.str(), errout); } } if (!Needed) { if (!notfound) { bool NeedDeclaration(false); for (std::set<unsigned int>::const_iterator it = AllIncludes.begin(); it != AllIncludes.end(); ++it) { std::set<std::string> empty; const std::string sym = matchSymbols(needDeclaration[fileIndex], classes[*it], empty); if (!sym.empty()) { NeedDeclaration = true; break; } } std::ostringstream errmsg; errmsg << "The included header '" << include->tok->next->str << "' is not needed"; if (NeedDeclaration) errmsg << " (but forward declaration is needed)"; ReportErr(tokenizer, outputFormat, include->tok, "HeaderNotNeeded", errmsg.str(), errout); } else if (Progress) std::cout << "progress: bail out (header not found)" << std::endl; } } } }