void load(std::string xmlFilename) { if (inputPanelIsLoaded) { return; } inputPanelIsLoaded = true; rapidxml::xml_node<>* doc = xmlutils::openXmlDocument(xmlFilename, "inputpanel"); for (rapidxml::xml_node<>* category : xmlutils::getChildNodes(doc, "category")) { std::string categoryName = xmlutils::getAttribute(category, "name"); inputpanel::addInputCategory(categoryName); for (rapidxml::xml_node<>* button : xmlutils::getChildNodes(category, "button")) { std::string text = xmlutils::getAttribute(button, "text"); std::string input = text; if (xmlutils::hasAttribute(button, "input")) { input = xmlutils::getAttribute(button, "input"); // allow stuff like \n, \\, " from XML to C++ input = stringReplace(input, "\\n", "\n"); input = stringReplace(input, "\\t", "\t"); input = stringReplace(input, "\\r", "\r"); input = stringReplace(input, "\\f", "\f"); input = stringReplace(input, "\\\\", "\\"); input = stringReplace(input, " ", " "); input = stringReplace(input, "<", "<"); input = stringReplace(input, ">", ">"); input = stringReplace(input, "&", "&"); input = stringReplace(input, """, "\""); } inputpanel::addInputButton(text, input); } } }
std::string Unit::printString(const unsigned int mode) { std::string result; std::string unicodeExp[10] = {"⁰", "¹", "²", "³", "⁴", "⁵", "⁶", "⁷", "⁸", "⁹"}; if(prefixes != 0) { std::string strPre = numberToString<int>(prefixes); if(mode == UNIT_EXP) { for(int j = 0; j < 10; j++) { stringReplace(strPre, numberToString<int>(j), unicodeExp[j]); } stringReplace(strPre, "-", "⁻"); result.append("10" + strPre); } else { result.append("10^" + strPre); } } for(size_t i = 0; i < UNIT_NUMBER_BASE_UNITS; i++) { if(units[i] == 1) { result.append(" " + baseUnitList[i]); } else if(units[i] != 0) { std::string strExp = numberToString<int>(units[i]); if(mode == UNIT_EXP) { for(int j = 0; j < 10; j++) { stringReplace(strExp, numberToString<int>(j), unicodeExp[j]); } stringReplace(strExp, "-", "⁻"); result.append(" " + baseUnitList[i] + strExp); } else { result.append(" " + baseUnitList[i] + "^" + strExp); } } } stringTrim(result); return result; }
static bool autograderYesOrNo(std::string prompt, std::string reprompt = "", std::string defaultValue = "") { if (STATIC_VARIABLE(FLAGS).graphicalUI) { prompt = stringReplace(prompt, " (Y/n)", ""); prompt = stringReplace(prompt, " (y/N)", ""); prompt = stringReplace(prompt, " (y/n)", ""); prompt = stringReplace(prompt, " (Y/N)", ""); return GOptionPane::showConfirmDialog(prompt) == GOptionPane::ConfirmResult::YES; } else { return getYesOrNo(prompt, reprompt, defaultValue); } }
void configSave() { wchar_t iniPath[MAX_PATH]; std::wstring ws; getIniFilePath(iniPath, MAX_PATH); // Completely delete the file DeleteFile(iniPath); // [DoxyIt] WritePrivateProfileString(NPP_PLUGIN_NAME, TEXT("active_commenting"), BOOLTOSTR(do_active_commenting), iniPath); WritePrivateProfileString(NPP_PLUGIN_NAME, TEXT("version"), VERSION_LINEAR_TEXT, iniPath); WritePrivateProfileString(NPP_PLUGIN_NAME, TEXT("version_stage"), VERSION_STAGE, iniPath); for(auto const &p : parsers) { const ParserSettings *ps = &(p.ps); // Wrap everything in quotes to preserve whitespace ws = TEXT("\"") + toWideString(ps->doc_start) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("doc_start"), ws.c_str(), iniPath); ws = TEXT("\"") + toWideString(ps->doc_line) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("doc_line_"), ws.c_str(), iniPath); ws = TEXT("\"") + toWideString(ps->doc_end) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("doc_end__"), ws.c_str(), iniPath); ws = TEXT("\"") + toWideString(ps->command_prefix) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("command_prefix"), ws.c_str(), iniPath); // Encode \r\n as literal "\r\n" in the ini file ws = TEXT("\"") + toWideString(stringReplace(std::string(ps->file_format), "\r\n", "\\r\\n")) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("file_format"), ws.c_str(), iniPath); // Encode \r\n as literal "\r\n" in the ini file ws = TEXT("\"") + toWideString(stringReplace(std::string(ps->function_format), "\r\n", "\\r\\n")) + TEXT("\""); WritePrivateProfileString(p.lang.c_str(), TEXT("function_format"), ws.c_str(), iniPath); // Write out interal parser attributes if(!p.external) { WritePrivateProfileString(p.lang.c_str(), TEXT("align"), BOOLTOSTR(ps->align), iniPath); } else // add it to the list of external settings { WritePrivateProfileString(TEXT("External"), p.language_name.c_str(), TEXT(""), iniPath); } } }
int main() { std::cout << "Text: "; char str[DEFAULT_LENGTH]; std::cin.getline(str, DEFAULT_LENGTH); std::cout << "What: "; char what[DEFAULT_LENGTH]; std::cin.getline(what, DEFAULT_LENGTH); std::cout << "With: "; char with[DEFAULT_LENGTH]; std::cin.getline(with, DEFAULT_LENGTH); std::cout << "Result: "; char* result = stringReplace(str, what, with); int index = 0; while (result[index] != '\0') { std::cout << result[index]; index++; } std::cout << std::endl; return 0; }
bool Gcc::shouldCompile(const std::string& source, const std::string& output) const { if (OS::timestampCompare(source, output) < 0) return true; std::ifstream f((output + ".d").c_str()); if (!f) return true; std::string line; std::getline(f, line); stringReplace(line, output + ": ", ""); do { if (line.length() > 2) { if (*line.rbegin() == '\\') line.erase(line.length()-2); StringList deps = split(line, ' '); for (const std::string& dep : deps) { if (OS::timestampCompare(dep, output) < 0) return true; } } std::getline(f, line); trim(line); } while (f); return false; }
static std::string addAutograderButton(GWindow& gui, const std::string& text, const std::string& icon) { static Set<char> usedMnemonics; std::string html = "<html><center>" + stringReplace(text, "\n", "<br>") + "</center></html>"; GButton* button = new GButton(html); STATIC_VARIABLE(AUTOGRADER_BUTTONS).add(button); // set mnemonic shortcut char mnemonic = '\0'; for (int i = 0; i < (int) text.length(); i++) { if (isalpha(text[i]) && !usedMnemonics.contains(text[i])) { mnemonic = text[i]; break; } } if (mnemonic) { usedMnemonics.add(mnemonic); button->setMnemonic(mnemonic); button->setAccelerator("ctrl " + charToString(mnemonic)); } if (!icon.empty()) { button->setIcon(icon); button->setTextPosition(SwingConstants::SWING_CENTER, SwingConstants::SWING_BOTTOM); } gui.addToRegion(button, "SOUTH"); return html; }
std::string getTimestampString(const std::string & timestampFormat) { std::stringstream str; auto now = std::chrono::system_clock::now(); auto t = std::chrono::system_clock::to_time_t(now); std::chrono::duration<double> s = now - std::chrono::system_clock::from_time_t(t); int ms = s.count() * 1000; auto tm = *std::localtime(&t); const int bufsize = 256; char buf[bufsize]; // Beware! an invalid timestamp string crashes windows apps. // so we have to filter out %i (which is not supported by vs) // earlier. std::ostringstream msStr; msStr << std::fixed << std::setfill('0') << std::setw(3) << ms; auto tmpTimestampFormat = timestampFormat; tmpTimestampFormat = stringReplace(tmpTimestampFormat, "%i", msStr.str()); if(strftime(buf,bufsize, tmpTimestampFormat.c_str(),&tm) != 0){ str << buf; } auto ret = str.str(); return ret; }
xml::Element& operator<<(xml::Element& elemServices, const Service& service) { xml::Element& elemService = elemServices.createElement("service"); std::string serviceNs = (service.ns.substr(0, 2) == "::") ? service.ns.substr(2) : service.ns; stringReplace(serviceNs, "::", ".", true); elemService.createElement("name", service.name); elemService.createElement("ns", service.ns); elemService.createElement("nsName", service.ns + service.name); elemService.createElement("serviceNs", serviceNs); elemService.createElement("serviceNsName", serviceNs + service.name); elemService.createElement("description", service.description); elemService.createElement("details", service.details); xml::Element& elemOptions = elemService.createElement("options"); for (StringMap::const_iterator itOption = service.options.begin(); itOption != service.options.end(); ++itOption) elemOptions.createElement(itOption->first, itOption->second); xml::Element& elemModules = elemService.createElement("modules"); for (StringList::const_iterator itModule = service.modules.begin(); itModule != service.modules.end(); ++itModule) elemModules.createElement("module", *itModule); elemService.createElement("operations") << service.operations; writeCppNs(elemService, service.ns); return elemServices; }
void styleCheckAddFile(const std::string& filename, const std::string& styleCheckXmlFileName) { std::string styleFile = styleCheckXmlFileName; if (styleCheckXmlFileName.empty()) { // "Foo.cpp" -> "stylecheck-foo-cpp.xml" styleFile = toLowerCase(filename); styleFile = stringReplace(styleFile, ".", "-"); styleFile = "stylecheck-" + styleFile + ".xml"; } STATIC_VARIABLE(FLAGS).styleCheckFiles.add(filename); STATIC_VARIABLE(FLAGS).styleCheckFileMap.put(filename, styleFile); }
/*! * pixSetText() * * Input: pix * textstring (can be null) * Return: 0 if OK, 1 on error * * Notes: * (1) This removes any existing textstring and puts a copy of * the input textstring there. */ l_int32 pixSetText(PIX *pix, const char *textstring) { PROCNAME("pixSetText"); if (!pix) return ERROR_INT("pix not defined", procName, 1); stringReplace(&pix->text, textstring); return 0; }
void SparDiskPanel::updateIntro() { auto typeId = _selectSparBox->getSpar(); _introSpar = typeId; if(typeId <= 0) { setSelectSparBox(nullptr); return; } auto spar = _sparDisk->getSpar(typeId); if(spar == nullptr) return; auto owner = dynamic_cast<Player*>(_sparDisk->getOwner()); if(owner == nullptr) return; auto sparPatchNum = owner->getItemBag()->getPropSizeByType(2002005); _patchNumLab->setString(a2u("ËéƬ:")+cocos2d::Value(sparPatchNum).asString()+a2u(" Éý¼¶ÏûºÄ:")+cocos2d::Value(spar->getCostPatchNum()).asString()); std::string nickName; std::string introduce; nickName = spar->getNickName(); introduce = spar->getModelByName("introduce").asString(); stringReplace(introduce, "%rate", cocos2d::Value(int(spar->getRate() * 100)).asString()+"%"); stringReplace(introduce, "%drate", cocos2d::Value(int(spar->getDrate() * 100)).asString()+"%"); _nickNameLab->setString(nickName); _introLab->setString(introduce); if(spar->getRate() >= spar->getMaxRate() || spar->getDrate() >= spar->getMaxDrate()) { _completeLab->setVisible(true); _refineBtn->setVisible(false); } else { _completeLab->setVisible(false); _refineBtn->setVisible(true); } }
/*! * pixAddText() * * Input: pix * textstring * Return: 0 if OK, 1 on error * * Notes: * (1) This adds the new textstring to any existing text. * (2) Either or both the existing text and the new text * string can be null. */ l_int32 pixAddText(PIX *pix, const char *textstring) { char *newstring; PROCNAME("pixAddText"); if (!pix) return ERROR_INT("pix not defined", procName, 1); newstring = stringJoin(pixGetText(pix), textstring); stringReplace(&pix->text, newstring); FREE(newstring); return 0; }
xml::Element& operator<<(xml::Element& elemInterfaces, const Interface& interface) { xml::Element& elemInterface = elemInterfaces.createElement("interface"); elemInterface.createElement("name", interface.name); elemInterface.createElement("ns", interface.ns); elemInterface.createElement("nsName", interface.ns + interface.name); elemInterface.createElement("fileName", interface.fileName); elemInterface.createElement("filePath", interface.filePath); xml::Element& elemOptions = elemInterface.createElement("options"); for (StringMap::const_iterator itOption = interface.options.begin(); itOption != interface.options.end(); ++itOption) { elemOptions.createElement(itOption->first, itOption->second); } // included files xml::Element& elemIncludes = elemInterface.createElement("includes"); for (std::list<Include>::const_iterator itInclude = interface.includes.begin(); itInclude != interface.includes.end(); ++itInclude) { std::string ns = itInclude->ns.substr(0, 2) == "::" ? itInclude->ns.substr(2) : itInclude->ns; stringReplace(ns, "::", ".", true); xml::Element& elemInclude = elemIncludes.createElement("include"); elemInclude.createElement("name", itInclude->interfaceName); elemInclude.createElement("ns", itInclude->ns); elemInclude.createElement("nsName", ns + itInclude->interfaceName); elemInclude.createElement("fileName", itInclude->fileName); elemInclude.createElement("filePath", itInclude->filePath); // elemInclude.createElement("targetNs", itInclude->targetNs); } elemInterface.createElement("enums") << interface.enums; elemInterface.createElement("structs") << interface.structs; elemInterface.createElement("typedefs") << interface.typedefs; elemInterface.createElement("services") << interface.services; return elemInterfaces; }
std::string escape(std::string str) { return std::move(stringReplace(str, "\"", "\\\"")); }
void ShaderWriter::writeLights(const vector<InstanceInfo>& instances) { m_Shader << "void applySceneLights() {"; for(size_t i = 0; i < instances.size(); i ++) { const InstanceInfo& light = instances[i]; if(light.type != "light" && light.type != "spotlight" && light.type != "ambient" && light.type != "directional") continue; SUVector3D colour = { 1, 1, 1 }; if(light.value != "") { //Parse colour value stringstream col(light.value); col >> colour.x; col >> colour.y; col >> colour.z; } string colourExpr = vec3string(colour); float range = (float)atof(light.getAttribute("range", "20.0").c_str()); float falloff = (float)atof(light.getAttribute("falloff", "2.0").c_str()); SUVector3D dir = yaxis * light.transform; SUPoint3D pos = {0}; pos = (pos * light.transform) / g_Scale; string posExpr = vec3string(pos); string func = light.getAttribute("func",light.type); if(light.hasAttribute("cond")) { string cond = stringReplace(light.getAttribute("cond"),"$POS",posExpr); m_Shader << "if(" << cond << ") "; } if(light.type == "ambient") { m_Shader << "ambientLight = " << colourExpr << ";"; } if(light.type == "spotlight") { float outerCone = (float)atoi(light.getAttribute("outerCone", "40").c_str()); float innerCone = outerCone - 0.5; if(light.hasAttribute("innerCone")) { outerCone = (float)atoi(light.getAttribute("innerCone").c_str()); } m_Shader << func << "(" << posExpr << "," << vec3string(dir) << "," << colourExpr<< "," << outerCone << "," << innerCone << "," << range << "," << falloff << ");"; } if(light.type == "directional") { m_Shader << func << "(" << vec3string(dir) << "," << colourExpr << ");"; } if(light.type == "light") { m_Shader << func << "(" << posExpr << "," << colourExpr << ",0.00,"<<range<<"," << falloff << ");"; } if(m_Debug) m_Shader << endl; }
void ShaderWriter::includeFile(string filename, string fromFile) { if(fileExists(currentDir() + "/"+ filename)){ filename = currentDir() + "/"+ filename; } else if (fileExists(dirName(fromFile) + "/"+ filename)){ filename = dirName(fromFile) + "/"+ filename; } else if (fileExists(shaderDir() + "/"+ filename)){ filename = shaderDir() + "/"+ filename; } else if(!fileExists(filename)) { cerr << "Could not find file: " << filename << endl; return; } ifstream file; file.open(filename); bool inComment = false; char _buff[200]; while(!file.eof()) { file.getline(_buff,sizeof(_buff)); string buff(_buff); if(!m_Debug) { if(buff[buff.size()-1] == '\r') { buff[buff.size()-1] =0; } if(inComment) { size_t i = buff.find("*/"); if(i != -1){ buff = buff.substr(i+2); inComment = false; } else { buff=""; } }else{ size_t i = buff.find("//"); if(i != -1) { buff = buff.substr(0,i); } i = buff.find("/*"); if(i != -1) { buff = buff.substr(0,i); inComment =true; } buff = stringReplace(buff,"\t",""); } } if(buff.substr(0,8) == "#include"){ includeFile(string(buff).substr(9),filename); }else{ m_Shader << buff << endl; } } }
int autograderTextMain(int argc, char** argv) { std::cout << STATIC_VARIABLE(FLAGS).assignmentName << " Autograder" << std::endl << AUTOGRADER_OUTPUT_SEPARATOR << std::endl; // set up buttons to automatically enter user input if (STATIC_VARIABLE(FLAGS).showInputPanel) { inputpanel::load(STATIC_VARIABLE(FLAGS).inputPanelFilename); } std::string autogradeYesNoMessage = STATIC_VARIABLE(FLAGS).startMessage; if (!autogradeYesNoMessage.empty()) { autogradeYesNoMessage += "\n\n"; } autogradeYesNoMessage += "Attempt auto-grading (Y/n)? "; int result = 0; bool autograde = autograderYesOrNo(autogradeYesNoMessage, "", "y"); if (autograde) { if (STATIC_VARIABLE(FLAGS).callbackStart) { STATIC_VARIABLE(FLAGS).callbackStart(); } result = mainRunAutograderTestCases(argc, argv); // a hook to allow per-assignment code to run at the start if (STATIC_VARIABLE(FLAGS).callbackEnd) { STATIC_VARIABLE(FLAGS).callbackEnd(); } } // manual testing bool manualGrade = autograderYesOrNo("Run program for manual testing (y/N)? ", "", "n"); if (manualGrade) { gwindowSetExitGraphicsEnabled(false); while (manualGrade) { studentMain(); std::cout << AUTOGRADER_OUTPUT_SEPARATOR << std::endl; manualGrade = autograderYesOrNo("Run program again (y/N)? ", "", "n"); } gwindowSetExitGraphicsEnabled(true); } std::cout << AUTOGRADER_OUTPUT_SEPARATOR << std::endl; // run any custom callbacks that the assignment's autograder added for (int i = 0; i < STATIC_VARIABLE(FLAGS).callbackButtons.size(); i++) { std::string buttonText = STATIC_VARIABLE(FLAGS).callbackButtons[i].text; buttonText = stringReplace(buttonText, "\n", " "); // GUI often uses multi-line button text strings; strip if (autograderYesOrNo(buttonText + " (Y/n)? ", "", "y")) { STATIC_VARIABLE(FLAGS).callbackButtons[i].func(); } } // run Style Checker to point out common possible style issues if (!STATIC_VARIABLE(FLAGS).styleCheckFiles.isEmpty()) { if (autograderYesOrNo("Run style checker (Y/n)? ", "", "y")) { mainRunStyleChecker(); } } // display turnin time information to decide late days used if (STATIC_VARIABLE(FLAGS).showLateDays) { showLateDays(); } std::cout << "COMPLETE: Autograder terminated successfully. Exiting." << std::endl; return result; }
int Unit::set(const std::string &value) { this->clear(); std::string unitString = value; stringTrim(unitString); if(unitString.empty()) return 0; stringReplace(unitString, "**", ""); // remove exponentiation symbols stringReplace(unitString, "^", ""); stringReplace(unitString, "*", " "); // replace multiplication symbols with space for tokenising stringReplace(unitString, "/", " /"); // pad division symbols with space for tokenising while(stringReplace(unitString, "/ ", "/") == 0); // remove all spaces after division symbols std::vector<std::string> tokens; // Tokenise string using spaces: if(stringTok(unitString, tokens, " ") != 0) { std::cerr << "Error (Unit): Failed to tokenise unit string." << std::endl; this->clear(); return 1; } if(tokens.size() < 1) { std::cerr << "Error (Unit): Failed to tokenise unit string." << std::endl; this->clear(); return 1; } // Loop through all tokens: for(size_t i = 0; i < tokens.size(); i++) { int factorDiv = 1; // Will become -1 if division sign '/' found. int exponent = 1; // Exponent of the unit; defaults to 1 if unspecified. // Check for division symbol: if(tokens[i].substr(0, 1) == "/") { tokens[i] = tokens[i].substr(1, tokens[i].size() - 1); factorDiv = -1; } // Extract exponent: size_t posExp = tokens[i].find_first_of("+-0123456789"); if(posExp != std::string::npos) { exponent = stringToNumber<int>(tokens[i].substr(posExp)); } exponent *= factorDiv; // Only proceed if unit is not unity: if(exponent != 0 and tokens[i] != "1") { // Extract base unit and prefix: bool success = false; std::map<std::string, std::vector<int> >::const_iterator iterUnit = unitMap.begin(); do { std::map<std::string, int>::const_iterator iterPrefix = prefixMap.begin(); do { std::string searchKey = iterPrefix->first + iterUnit->first; if(searchKey == tokens[i].substr(0, posExp)) { success = true; int prefix = iterPrefix->second; std::vector<int> unit(iterUnit->second); // Take care of special case 'kg': if(iterUnit->first == "g") prefix -= 3; for(size_t ii = 0; ii < UNIT_NUMBER_BASE_UNITS; ii++) { units[ii] += unit[ii] * exponent; } prefixes += prefix * exponent; } iterPrefix++; } while(success == false and iterPrefix != prefixMap.end()); iterUnit++; } while(success == false and iterUnit != unitMap.end()); if(success == false) { std::cerr << "Error (Unit): Unknown unit: \'" << value << "\'." << std::endl; std::cerr << " Creating dimensionless unit instead." << std::endl; clear(); return 1; } } } return 0; }
int autograderGraphicalMain(int argc, char** argv) { GWindow gui(500, 300, /* visible */ false); gui.setTitle(STATIC_VARIABLE(FLAGS).assignmentName + " Autograder"); gui.setCanvasSize(0, 0); gui.setExitOnClose(true); GLabel startLabel(""); if (!STATIC_VARIABLE(FLAGS).startMessage.empty()) { std::string startMessage = STATIC_VARIABLE(FLAGS).startMessage; if (!stringContains(startMessage, "<html>")) { startMessage = stringReplace(startMessage, "Note:", "<b>Note:</b>"); startMessage = stringReplace(startMessage, "NOTE:", "<b>NOTE:</b>"); startMessage = "<html><body style='width: 500px; max-width: 500px;'>" + startMessage + "</body></html>"; } startLabel.setLabel(startMessage); gui.addToRegion(&startLabel, "NORTH"); } std::string autogradeText = addAutograderButton(gui, "Automated\ntests", "check.gif"); std::string manualText = addAutograderButton(gui, "Run\nmanually", "play.gif"); std::string styleCheckText = addAutograderButton(gui, "Style\nchecker", "magnifier.gif"); for (int i = 0; i < STATIC_VARIABLE(FLAGS).callbackButtons.size(); i++) { STATIC_VARIABLE(FLAGS).callbackButtons[i].text = addAutograderButton(gui, STATIC_VARIABLE(FLAGS).callbackButtons[i].text, STATIC_VARIABLE(FLAGS).callbackButtons[i].icon); } std::string lateDayText = addAutograderButton(gui, "Late days\ninfo", "calendar.gif"); std::string aboutText = addAutograderButton(gui, "About\nGrader", "help.gif"); std::string exitText = addAutograderButton(gui, "Exit\nGrader", "stop.gif"); gui.pack(); gui.setVisible(true); int result = 0; while (true) { GEvent event = waitForEvent(ACTION_EVENT); if (event.getEventClass() == ACTION_EVENT) { GActionEvent actionEvent(event); std::string cmd = actionEvent.getActionCommand(); if (cmd == autogradeText) { if (STATIC_VARIABLE(FLAGS).callbackStart) { STATIC_VARIABLE(FLAGS).callbackStart(); } // stanfordcpplib::getPlatform()->autograderunittest_clearTests(); stanfordcpplib::getPlatform()->autograderunittest_clearTestResults(); stanfordcpplib::getPlatform()->autograderunittest_setTestingCompleted(false); stanfordcpplib::getPlatform()->autograderunittest_setVisible(true); result = mainRunAutograderTestCases(argc, argv); stanfordcpplib::getPlatform()->autograderunittest_setTestingCompleted(true); // if style checker is merged, also run it now if (stylecheck::isStyleCheckMergedWithUnitTests()) { mainRunStyleChecker(); } if (STATIC_VARIABLE(FLAGS).callbackEnd) { STATIC_VARIABLE(FLAGS).callbackEnd(); } } else if (cmd == manualText) { // set up buttons to automatically enter user input if (STATIC_VARIABLE(FLAGS).showInputPanel) { inputpanel::load(STATIC_VARIABLE(FLAGS).inputPanelFilename); } // actually run the student's program // (While program is running, if we close console, exit entire // autograder program because we might be blocked on console I/O. // But after it's done running, set behavior to just hide the // console, since the grader will probably try to close it and then // proceed with more grading and tests afterward. // A little wonky, but it avoids most of the surprise cases of // "I closed the student's console and it killed the autograder". stanfordcpplib::getPlatform()->jbeconsole_clear(); stanfordcpplib::getPlatform()->jbeconsole_setVisible(true); stanfordcpplib::getPlatform()->jbeconsole_toFront(); // setConsoleCloseOperation(ConsoleCloseOperation::CONSOLE_EXIT_ON_CLOSE); autograder::setExitEnabled(false); // block exit() call setConsoleCloseOperation(ConsoleCloseOperation::CONSOLE_HIDE_ON_CLOSE); studentMain(); // gwindowSetExitGraphicsEnabled(true); } else if (cmd == styleCheckText) { mainRunStyleChecker(); } else if (cmd == lateDayText) { showLateDays(); } else if (cmd == aboutText) { GOptionPane::showMessageDialog(STATIC_VARIABLE(FLAGS).aboutText, "About Autograder", GOptionPane::MessageType::INFORMATION); } else if (cmd == exitText) { autograder::setExitEnabled(true); // don't block exit() call // free up memory used by graphical interactors for (GButton* button : STATIC_VARIABLE(AUTOGRADER_BUTTONS)) { delete button; } STATIC_VARIABLE(AUTOGRADER_BUTTONS).clear(); gui.close(); // exits program; will not return break; } else { for (CallbackButtonInfo buttonInfo : STATIC_VARIABLE(FLAGS).callbackButtons) { if (cmd == buttonInfo.text) { buttonInfo.func(); break; } } } } } // free up memory used by graphical interactors for (GButton* button : STATIC_VARIABLE(AUTOGRADER_BUTTONS)) { delete button; } STATIC_VARIABLE(AUTOGRADER_BUTTONS).clear(); return result; }
void configLoad() { wchar_t iniPath[MAX_PATH]; wchar_t tbuffer[512]; // "relatively" large wchar_t tbuffer2[512]; wchar_t *current; ParserSettings ps; getIniFilePath(iniPath, MAX_PATH); // [DoxyIt] GetPrivateProfileString(NPP_PLUGIN_NAME, TEXT("active_commenting"), TEXT("true"), tbuffer, MAX_PATH, iniPath); do_active_commenting = (lstrcmp(tbuffer, TEXT("true")) == 0); // NPPM_SETMENUITEMCHECK does not seem to work unless the // menu item is actually clicked, so lets do it manually if(do_active_commenting) CheckMenuItem(GetMenu(nppData._nppHandle), funcItem[3]._cmdID, MF_CHECKED); // Don't need these for now //version = GetPrivateProfileInt(NPP_PLUGIN_NAME, TEXT("version"), 0, iniPath); //version_stage = GetPrivateProfileString(NPP_PLUGIN_NAME, TEXT("version_stage"), TEXT(""), tbuffer, MAX_PATH, iniPath); for(auto &p : parsers) { // NOTE: We cant use the default value because GetPrivateProfileString strips the whitespace, // also, wrapping it in quotes doesn't seem to work either. So...use "!!!" as the default text // and if we find that the value wasn't found and we have "!!!" then use the default value in the // parser, else, use what we pulled from the file. GetPrivateProfileString(p.lang.c_str(), TEXT("doc_start"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.doc_start = toString(tbuffer); GetPrivateProfileString(p.lang.c_str(), TEXT("doc_line_"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.doc_line = toString(tbuffer); GetPrivateProfileString(p.lang.c_str(), TEXT("doc_end__"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.doc_end = toString(tbuffer); GetPrivateProfileString(p.lang.c_str(), TEXT("command_prefix"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.command_prefix = toString(tbuffer); GetPrivateProfileString(p.lang.c_str(), TEXT("function_format"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.function_format = stringReplace(toString(tbuffer), "\\r\\n", "\r\n"); GetPrivateProfileString(p.lang.c_str(), TEXT("file_format"), TEXT("!!!"), tbuffer, 512, iniPath); if(lstrcmp(tbuffer, TEXT("!!!")) != 0) p.ps.file_format = stringReplace(toString(tbuffer), "\\r\\n", "\r\n"); GetPrivateProfileString(p.lang.c_str(), TEXT("align"), BOOLTOSTR(p.ps.align), tbuffer, 512, iniPath); p.ps.align = (lstrcmp(tbuffer, TEXT("true")) == 0); } GetPrivateProfileSection(TEXT("External"), tbuffer, 512, iniPath); current = tbuffer; while(current[0] != NULL) { wchar_t *equals = wcschr(current, TEXT('=')); // Temporarily remove the '=' that was found *equals = NULL; GetPrivateProfileString(current, TEXT("doc_start"), TEXT("/**"), tbuffer2, 512, iniPath); ps.doc_start = toString(tbuffer2); GetPrivateProfileString(current, TEXT("doc_line_"), TEXT(" * "), tbuffer2, 512, iniPath); ps.doc_line = toString(tbuffer2); GetPrivateProfileString(current, TEXT("doc_end__"), TEXT(" */"), tbuffer2, 512, iniPath); ps.doc_end = toString(tbuffer2); GetPrivateProfileString(current, TEXT("command_prefix"), TEXT("\\"), tbuffer2, 512, iniPath); ps.command_prefix = toString(tbuffer2); GetPrivateProfileString(current, TEXT("function_format"), TEXT("!!!"), tbuffer2, 512, iniPath); if(lstrcmp(tbuffer2, TEXT("!!!")) != 0) ps.function_format = stringReplace(toString(tbuffer2), "\\r\\n", "\r\n"); else ps.function_format = default_internal_function_format; GetPrivateProfileString(current, TEXT("file_format"), TEXT("!!!"), tbuffer2, 512, iniPath); if(lstrcmp(tbuffer2, TEXT("!!!")) != 0) ps.file_format = stringReplace(toString(tbuffer2), "\\r\\n", "\r\n"); else ps.file_format = default_file_format; addNewParser(toString(current), &ps); // add back in the equals so we can correctly calculate the length *equals = TEXT('='); current = ¤t[lstrlen(current) + 1]; } }
string CTRSeek(string cipher, string key, string newText, int offset){ string pt=AES128CTR(cipher, key, newString(NULL,0)); pt=stringReplace(pt,newText,offset); return AES128CTR(pt,key,newString(NULL,0)); }
CompletionType evaluate() { Register<Value> value; switch (method) { case ToString: case ValueOf: if (!getThis()->isObject()) { throw getErrorInstance("TypeError"); } value = static_cast<ObjectValue*>(getThis())->getValueProperty(); if (!value->isString()) { throw getErrorInstance("TypeError"); } break; case CharAt: value = charAt(); break; case CharCodeAt: value = charCodeAt(); break; case Concat: value = concat(getThis()); break; case IndexOf: value = indexOf(getThis()); break; case LastIndexOf: value = lastIndexOf(getThis()); break; case LocaleCompare: value = localeCompare(getThis()); break; case Match: value = stringMatch(); break; case Replace: value = stringReplace(); break; case Search: value = stringSearch(); break; case Slice: value = slice(getThis()); break; case Split: value = stringSplit(); break; case Substring: value = substring(getThis()); break; case Substr: value = substr(getThis()); break; case ToLowerCase: case ToLocaleLowerCase: value = toLowerCase(getThis()); break; case ToUpperCase: case ToLocaleUpperCase: value = toUpperCase(getThis()); break; } return CompletionType(CompletionType::Return, value, ""); }
std::string FormatBlock(const ParserDefinition *pd, Keywords& keywords, const std::string &format) { std::stringstream ss; std::vector<std::string> lines; std::vector<std::string> params = keywords["$PARAM"]; std::string format_copy(format); const char *eol = getEolStr(); // Replace keywords stringReplace(format_copy, "$@", pd->command_prefix); stringReplace(format_copy, "$FILENAME", keywords["$FILENAME"][0]); // $FUNCTION may not exist if(keywords.find("$FUNCTION") != keywords.end()) stringReplace(format_copy, "$FUNCTION", keywords["$FUNCTION"][0]); else stringReplace(format_copy, "$FUNCTION", ""); lines = splitLines(format_copy, "\r\n"); for(unsigned int i = 0; i < lines.size(); ++i) { if(lines[i].find("$PARAM") != std::string::npos) { // Duplicate the current line for each $PARAM std::vector<std::string> formatted_lines; for(unsigned int j = 0; j < params.size(); ++j) { // Make a copy of lines[i] before calling stringReplace std::string line = lines[i]; stringReplace(line, "$PARAM", params[j]); formatted_lines.push_back(line); } // If the align flag is set, align the lines, else remove all "$|" flags if(pd->align) alignLines(formatted_lines); else for(unsigned int j = 0; j < formatted_lines.size(); ++j) stringReplace(formatted_lines[j], "$|", ""); // Insert the lines for(unsigned int j = 0; j < formatted_lines.size(); ++j) { if(i == 0 && j == 0) ss << pd->doc_start << formatted_lines[j] << eol; else if(i == lines.size() - 1 && j == formatted_lines.size() - 1) ss << pd->doc_end << formatted_lines[j] << eol; else ss << pd->doc_line << formatted_lines[j] << eol; } } else { if(i == 0) ss << pd->doc_start << lines[i] << eol; else if(i == lines.size() -1) ss << pd->doc_end << lines[i]; else ss << pd->doc_line << lines[i] << eol; } } return ss.str(); }
/*! * gplotRead() * * Input: filename * Return: gplot, or NULL on error */ GPLOT * gplotRead(const char *filename) { char buf[L_BUF_SIZE]; char *rootname, *title, *xlabel, *ylabel, *ignores; l_int32 outformat, ret, version, ignore; FILE *fp; GPLOT *gplot; PROCNAME("gplotRead"); if (!filename) return (GPLOT *)ERROR_PTR("filename not defined", procName, NULL); if ((fp = fopenReadStream(filename)) == NULL) return (GPLOT *)ERROR_PTR("stream not opened", procName, NULL); ret = fscanf(fp, "Gplot Version %d\n", &version); if (ret != 1) { fclose(fp); return (GPLOT *)ERROR_PTR("not a gplot file", procName, NULL); } if (version != GPLOT_VERSION_NUMBER) { fclose(fp); return (GPLOT *)ERROR_PTR("invalid gplot version", procName, NULL); } ignore = fscanf(fp, "Rootname: %s\n", buf); rootname = stringNew(buf); ignore = fscanf(fp, "Output format: %d\n", &outformat); ignores = fgets(buf, L_BUF_SIZE, fp); /* Title: ... */ title = stringNew(buf + 7); title[strlen(title) - 1] = '\0'; ignores = fgets(buf, L_BUF_SIZE, fp); /* X axis label: ... */ xlabel = stringNew(buf + 14); xlabel[strlen(xlabel) - 1] = '\0'; ignores = fgets(buf, L_BUF_SIZE, fp); /* Y axis label: ... */ ylabel = stringNew(buf + 14); ylabel[strlen(ylabel) - 1] = '\0'; if (!(gplot = gplotCreate(rootname, outformat, title, xlabel, ylabel))) { fclose(fp); return (GPLOT *)ERROR_PTR("gplot not made", procName, NULL); } FREE(rootname); FREE(title); FREE(xlabel); FREE(ylabel); sarrayDestroy(&gplot->cmddata); sarrayDestroy(&gplot->datanames); sarrayDestroy(&gplot->plotdata); sarrayDestroy(&gplot->plottitles); numaDestroy(&gplot->plotstyles); ignore = fscanf(fp, "Commandfile name: %s\n", buf); stringReplace(&gplot->cmdname, buf); ignore = fscanf(fp, "\nCommandfile data:"); gplot->cmddata = sarrayReadStream(fp); ignore = fscanf(fp, "\nDatafile names:"); gplot->datanames = sarrayReadStream(fp); ignore = fscanf(fp, "\nPlot data:"); gplot->plotdata = sarrayReadStream(fp); ignore = fscanf(fp, "\nPlot titles:"); gplot->plottitles = sarrayReadStream(fp); ignore = fscanf(fp, "\nPlot styles:"); gplot->plotstyles = numaReadStream(fp); ignore = fscanf(fp, "Number of plots: %d\n", &gplot->nplots); ignore = fscanf(fp, "Output file name: %s\n", buf); stringReplace(&gplot->outname, buf); ignore = fscanf(fp, "Axis scaling: %d\n", &gplot->scaling); fclose(fp); return gplot; }
int main(int argc, char **argv) { char *str1, *str2; l_int32 i; size_t size1, size2; l_float32 x, y1, y2, pi; GPLOT *gplot1, *gplot2, *gplot3, *gplot4, *gplot5; NUMA *nax, *nay1, *nay2; static char mainName[] = "plottest"; if (argc != 1) return ERROR_INT(" Syntax: plottest", mainName, 1); /* Generate plot data */ nax = numaCreate(0); nay1 = numaCreate(0); nay2 = numaCreate(0); pi = 3.1415926535; for (i = 0; i < 180; i++) { x = (pi / 180.) * i; y1 = (l_float32)sin(2.4 * x); y2 = (l_float32)cos(2.4 * x); numaAddNumber(nax, x); numaAddNumber(nay1, y1); numaAddNumber(nay2, y2); } /* Show the plot */ gplot1 = gplotCreate("/tmp/plotroot1", GPLOT_OUTPUT, "Example plots", "theta", "f(theta)"); gplotAddPlot(gplot1, nax, nay1, GPLOT_STYLE, "sin (2.4 * theta)"); gplotAddPlot(gplot1, nax, nay2, GPLOT_STYLE, "cos (2.4 * theta)"); gplotMakeOutput(gplot1); /* Also save the plot to png */ gplot1->outformat = GPLOT_PNG; stringReplace(&gplot1->outname, "/tmp/plotroot1.png"); gplotMakeOutput(gplot1); /* Test gplot serialization */ gplotWrite("/tmp/gplot1", gplot1); if ((gplot2 = gplotRead("/tmp/gplot1")) == NULL) return ERROR_INT("gplotRead failure!", mainName, 1); gplotWrite("/tmp/gplot2", gplot2); /* Are the two written gplot files the same? */ str1 = (char *)l_binaryRead("/tmp/gplot1", &size1); str2 = (char *)l_binaryRead("/tmp/gplot2", &size2); if (size1 != size2) fprintf(stderr, "Error: size1 = %lu, size2 = %lu\n", (unsigned long)size1, (unsigned long)size2); else fprintf(stderr, "Correct: size1 = size2 = %lu\n", (unsigned long)size1); if (strcmp(str1, str2)) fprintf(stderr, "Error: str1 != str2\n"); else fprintf(stderr, "Correct: str1 == str2\n"); lept_free(str1); lept_free(str2); /* Read from file and regenerate the plot */ gplot3 = gplotRead("/tmp/gplot2"); stringReplace(&gplot3->title , "Example plots regen"); gplot3->outformat = GPLOT_X11; gplotMakeOutput(gplot3); /* Build gplot but do not make the output formatted stuff */ gplot4 = gplotCreate("/tmp/plotroot2", GPLOT_OUTPUT, "Example plots 2", "theta", "f(theta)"); gplotAddPlot(gplot4, nax, nay1, GPLOT_STYLE, "sin (2.4 * theta)"); gplotAddPlot(gplot4, nax, nay2, GPLOT_STYLE, "cos (2.4 * theta)"); /* Write, read back, and generate the plot */ gplotWrite("/tmp/gplot4", gplot4); if ((gplot5 = gplotRead("/tmp/gplot4")) == NULL) return ERROR_INT("gplotRead failure!", mainName, 1); gplotMakeOutput(gplot5); gplotDestroy(&gplot1); gplotDestroy(&gplot2); gplotDestroy(&gplot3); gplotDestroy(&gplot4); gplotDestroy(&gplot5); numaDestroy(&nax); numaDestroy(&nay1); numaDestroy(&nay2); return 0; }