/* ** Pomocná funkce doOperation. ** Zpracuje operátor, který je pøedán parametrem c po naètení znaku ze ** vstupního pole znakù. ** ** Dle priority pøedaného operátoru a pøípadnì priority operátoru na ** vrcholu zásobníku rozhodneme o dal¹ím postupu. Délka pøevedeného ** výrazu a takté¾ ukazatel na první volné místo, do kterého se má zapisovat, ** pøedstavuje parametr postLen, výstupním polem znakù je opìt postExpr. */ void doOperation ( tStack* s, char c, char* postExpr, unsigned* postLen ) { char topChar; if (!stackEmpty(s)) { // nacteni znaku z vrcholu zasobniku pokud neni zasobnik prazdny stackTop(s, &topChar); } // Operátor vkladam na vrchol zasobniku v pripade, ze: // - zásobník je prázdný // - na vrcholu zásobníku je levá závorka // - na vrcholu zásobníku je operátor s ni¾¹í prioritou if ( (stackEmpty(s)) || (topChar == '(') || (topChar == '+' && c != '-' && c != '+') || (topChar == '-' && c != '-' && c != '+') ) { // nacteni operatoru do zasobniku stackPush(s, c); } else { postExpr[*postLen] = topChar; *postLen+=1; stackPop(s); doOperation(s, c, postExpr, postLen); } }
void FileWriter::write(Blob* data, ExceptionCode& ec) { ASSERT(writer()); ASSERT(data); ASSERT(m_truncateLength == -1); if (m_readyState == WRITING) { setError(FileError::INVALID_STATE_ERR, ec); return; } if (!data) { setError(FileError::TYPE_MISMATCH_ERR, ec); return; } if (m_recursionDepth > kMaxRecursionDepth) { setError(FileError::SECURITY_ERR, ec); return; } m_blobBeingWritten = data; m_readyState = WRITING; m_bytesWritten = 0; m_bytesToWrite = data->size(); ASSERT(m_queuedOperation == OperationNone); if (m_operationInProgress != OperationNone) { // We must be waiting for an abort to complete, since m_readyState wasn't WRITING. ASSERT(m_operationInProgress == OperationAbort); m_queuedOperation = OperationWrite; } else doOperation(OperationWrite); fireEvent(eventNames().writestartEvent); }
void FileWriter::truncate(long long position, ExceptionCode& ec) { ASSERT(writer()); ASSERT(m_truncateLength == -1); if (m_readyState == WRITING || position < 0) { setError(FileError::INVALID_STATE_ERR, ec); return; } if (m_recursionDepth > kMaxRecursionDepth) { setError(FileError::SECURITY_ERR, ec); return; } m_readyState = WRITING; m_bytesWritten = 0; m_bytesToWrite = 0; m_truncateLength = position; ASSERT(m_queuedOperation == OperationNone); if (m_operationInProgress != OperationNone) { // We must be waiting for an abort to complete, since m_readyState wasn't WRITING. ASSERT(m_operationInProgress == OperationAbort); m_queuedOperation = OperationTruncate; } else doOperation(OperationTruncate); fireEvent(eventNames().writestartEvent); }
void doActivities() { setNum1(4545); setNum2(5); setOperation(8); getResult(); doOperation(10, 51, MYCALC_ADD); setNum1(4545); setNum2(5); setOperation(MYCALC_DIV); getResult(); doOperation(740, -4551, MYCALC_MUL); }
void MainWindow::on_actionResizeMap_triggered(){ if(!map.isLoaded())return; DialogResizeMap dlg(map.getWidth(),map.getHeight()); if(dlg.exec()!=QDialog::Accepted)return; MoResizeMap mo(dlg.mapWidth,dlg.mapHeight,dlg.hAlign,dlg.vAlign); mo.toolTip=tr("Resize Map"); doOperation(&mo); }
void FileWriter::completeAbort() { ASSERT(m_operationInProgress == OperationAbort); m_operationInProgress = OperationNone; Operation operation = m_queuedOperation; m_queuedOperation = OperationNone; doOperation(operation); }
void FileWriter::stop() { // Make sure we've actually got something to stop, and haven't already called abort(). if (!writer() || m_readyState != WRITING) return; doOperation(OperationAbort); m_readyState = DONE; }
void MainWindow::editItemScripts(u8 itemId){ DialogScripts dlg(map.itemAt(itemId).scripts,this); dlg.setWindowTitle(QString(tr("Scripts for item#%1")).arg(itemId)); if(dlg.exec()==QDialog::Accepted){ MoEditItemScript mo(dlg.scripts,itemId); mo.toolTip=QString(tr("Edit Scripts for item#%1")).arg(itemId); doOperation(&mo); } }
void FileWriter::completeAbort() { ASSERT(m_operationInProgress == OperationAbort); m_operationInProgress = OperationNone; Operation operation = m_queuedOperation; m_queuedOperation = OperationNone; doOperation(operation); unsetPendingActivity(this); }
void forEach(ArrayUtil source, OperationFunc* doOperation, void* hint){ void *sourceItem = source.base; void *end = source.base + (source.length * source.typeSize); for( ; sourceItem != end; ){ doOperation(hint, sourceItem); sourceItem += source.typeSize; } }
void FileWriter::abort(ExceptionCode& ec) { ASSERT(writer()); if (m_readyState != WRITING) return; ++m_numAborts; doOperation(OperationAbort); signalCompletion(FileError::ABORT_ERR); }
void onQNetworkReplyFinished() { // either error or all data has been read DEBUG("httpFinished()"); QVariant redirectionTarget = qreply->attribute(QNetworkRequest::RedirectionTargetAttribute); if (!redirectionTarget.isNull()) { QUrl newUrl = url.resolved(redirectionTarget.toUrl()); DEBUG("Handled redirect to: " << newUrl.toString()); qreply->deleteLater(); qreply = nullptr; doOperation(newUrl); return; } else if (qreply->error()) { WARN("HTTP ERROR: " << qreply->errorString()); result << InvocationErrors::INVOCATION_FAILED; QVariant statusCode = qreply->attribute( QNetworkRequest::HttpStatusCodeAttribute ); if (statusCode.isValid()) { httpStatus = HTTPInvocationDefinition::resolveHttpStatus(statusCode.toInt()); } else { httpStatus = HTTPInvocationDefinition::UNDEFINED; result << Result::reasonFromDesc("Http response code is not valid"); } invocationStatus = Invocation::ERROR; // get possible return data (detailed error info) // responseErrorData = qreply->readAll(); result << InvocationErrors::CONNECTION_FAILED << Result::Meta("qnetworkreply_error_string", qreply->errorString()); QNetworkReply::NetworkError err = qreply->error(); result << NetworkErrorReasons::from(err, qreply->errorString()); //result << Result::reasonFromCode("QNETWORKREPLY_ERROR", qreply->errorString()); emit q->finishedError(q); } else { // we have all data // (TODO: is it so that readRead() is invoked before?) if (outputFile.isOpen()) outputFile.close(); invocationStatus = Invocation::FINISHED; emit q->finishedOK(q); } qreply->deleteLater(); qreply = nullptr; }
// // operation // void GeneratorBase::handleOperation(IR__::InterfaceDef_ptr intf) { IR__::ContainedSeq_var contained_seq = intf->contents(CORBA__::dk_Operation, false); CORBA::ULong len = contained_seq->length(); for(CORBA::ULong i = 0; i < len; i++) { IR__::OperationDef_var a_operation = IR__::OperationDef::_narrow(((*contained_seq)[i])); doOperation(a_operation); } }
void MainWindow::on_buttonItemDelete_clicked() { if(!map.isLoaded())return; QModelIndex selection=ui->itemTable->currentIndex(); if(!selection.isValid())return; u8 selItem=selection.row(); if(selItem>=map.getItemCount())return; MoDeleteItem mo(selItem); mo.toolTip=QString(tr("Remove Item#%1")).arg(selItem); doOperation(&mo); }
void MainWindow::on_actionMapProperties_triggered() { if(!map.isLoaded()){ return; } DialogProperties dlg(map.metaData); if(QDialog::Accepted==dlg.exec()){ MoEditMetaData mo(dlg.metaData); mo.toolTip=tr("Change Properties"); doOperation(&mo); } }
void MainWindow::on_buttonItemDown_clicked() { if(!map.isLoaded())return; QModelIndex selection=ui->itemTable->currentIndex(); if(!selection.isValid())return; u8 selItem=selection.row(); if(selItem==map.getItemCount()-1)return; if(selItem>=map.getItemCount())return; MoSwapItem mo(selItem); mo.toolTip=QString(tr("Move down Item#%1")).arg(selItem); doOperation(&mo); ui->itemTable->setCurrentIndex(itemTableModal.getIndex(selItem+1,selection.column())); }
void MainWindow::on_buttonItemNew_clicked() { if(!map.isLoaded())return; KfMap::RipeItem item; QSize size=ui->mapViewScrollArea->size(); int tx=(ui->mapViewScrollArea->horizontalScrollBar()->value()+size.width()/2); item.basic.x=(tx>=0?tx:0); int ty=(ui->mapViewScrollArea->verticalScrollBar()->value()+size.height()/2); item.basic.y=(ty>=0?ty:0); if(item.basic.x>map.getWidth()*24)item.basic.x=map.getWidth()*24; if(item.basic.y>map.getHeight()*24)item.basic.y=map.getHeight()*24; MoNewItem mo(map.getItemCount(),item); mo.toolTip=tr("Add Item"); doOperation(&mo); ui->itemTable->setCurrentIndex(itemTableModal.getIndex( map.getItemCount()-1,0)); }
double Parser::evaluatePostFix(const std::string &input, bool& failed) { std::queue<std::string> postFix = createPostFix(input,failed); std::stack<double> numbers; std::string debug; std::string mainQuery = input; double result = 0; double firstNumber = 0; double secondNumber = 0; bool overflow = false; while(!postFix.empty() && !overflow && !failed) { debug = postFix.front(); if(isdigit(postFix.front()[0]) || postFix.front()[0] == '#') { numbers.push(convertStringToNumber(postFix.front(), failed)); postFix.pop(); } else //is an operator { if(numbers.size() >= 2) { secondNumber = numbers.top(); numbers.pop(); firstNumber = numbers.top(); numbers.pop(); result = doOperation(firstNumber, secondNumber, postFix.front().c_str()[0], overflow); //all operators are 1 charater failed = overflow; postFix.pop(); numbers.push(result); } else { failed = true; errorCode_ = ERR_SYNTAX; } } } if(!numbers.empty()) { return numbers.top(); } else { failed = true; errorCode_ = ERR_SYNTAX; return 0; } }
/* ** Konverzní funkce infix2postfix. ** Ète infixový výraz ze vstupního øetìzce infExpr a generuje ** odpovídající postfixový výraz do výstupního øetìzce (postup pøevodu ** hledejte v pøedná¹kách nebo ve studijní opoøe). Pamì» pro výstupní øetìzec ** (o velikosti MAX_LEN) je tøeba alokovat. Volající funkce, tedy ** pøíjemce konvertovaného øetìzce, zajistí korektní uvolnìní zde alokované ** pamìti. ** ** Tvar výrazu: ** 1. Výraz obsahuje operátory + - * / ve významu sèítání, odèítání, ** násobení a dìlení. Sèítání má stejnou prioritu jako odèítání, ** násobení má stejnou prioritu jako dìlení. Priorita násobení je ** vìt¹í ne¾ priorita sèítání. V¹echny operátory jsou binární ** (neuva¾ujte unární mínus). ** ** 2. Hodnoty ve výrazu jsou reprezentovány jednoznakovými identifikátory ** a èíslicemi - 0..9, a..z, A..Z (velikost písmen se rozli¹uje). ** ** 3. Ve výrazu mù¾e být pou¾it pøedem neurèený poèet dvojic kulatých ** závorek. Uva¾ujte, ¾e vstupní výraz je zapsán správnì (neo¹etøujte ** chybné zadání výrazu). ** ** 4. Ka¾dý korektnì zapsaný výraz (infixový i postfixový) musí být uzavøen ** ukonèovacím znakem '='. ** ** 5. Pøi stejné prioritì operátorù se výraz vyhodnocuje zleva doprava. ** ** Poznámky k implementaci ** ----------------------- ** Jako zásobník pou¾ijte zásobník znakù tStack implementovaný v pøíkladu c202. ** Pro práci se zásobníkem pak pou¾ívejte výhradnì operace z jeho rozhraní. ** ** Pøi implementaci vyu¾ijte pomocné funkce untilLeftPar a doOperation. ** ** Øetìzcem (infixového a postfixového výrazu) je zde my¹leno pole znakù typu ** char, jen¾ je korektnì ukonèeno nulovým znakem dle zvyklostí jazyka C. ** ** Na vstupu oèekávejte pouze korektnì zapsané a ukonèené výrazy. Jejich délka ** nepøesáhne MAX_LEN-1 (MAX_LEN i s nulovým znakem) a tedy i výsledný výraz ** by se mìl vejít do alokovaného pole. Po alokaci dynamické pamìti si v¾dycky ** ovìøte, ¾e se alokace skuteènì zdraøila. V pøípadì chyby alokace vra»te namísto ** øetìzce konstantu NULL. */ char* infix2postfix (const char* infExpr) { char *postExpr = malloc(MAX_LEN * sizeof(char)); unsigned postLen = 0; tStack stack; stackInit(&stack); char tmp; for(unsigned i = 0; (tmp = infExpr[i]) != '='; i++) { switch(tmp) { case '+': case '-': case '*': case '/': // Zpracuj operator doOperation(&stack, tmp, postExpr, &postLen); break; case '(': // Pridaj lavu zatvorku do zasobniku. stackPush(&stack, '('); break; case ')': // Zpracuj pravu zatvorku. untilLeftPar(&stack, postExpr, &postLen); break; default: // Zpracuj hodnotu. // isalnum() if((tmp >= '0' && tmp <='9') || (tmp >= 'a' && tmp <= 'z') || (tmp >= 'A' && tmp <= 'Z')) postExpr[postLen++] = tmp; break; } } while(!stackEmpty(&stack)) { stackTop(&stack, &tmp); postExpr[postLen++] = tmp; stackPop(&stack); } postExpr[postLen++] = '='; postExpr[postLen] = '\0'; return postExpr; }
void MainWindow::on_actionImportMap_triggered() { if(!map.isLoaded())return; QString fileName=QFileDialog::getOpenFileName(this, tr("Import map from..."), "", tr("Binary file(*.bin)")); if(fileName==QString::null)return; QFile file(fileName); if(!file.open(QIODevice::ReadOnly)){ QMessageBox msgBox; msgBox.setText(tr("Failed to open the file.")); msgBox.setIcon(QMessageBox::Icon::Critical); msgBox.exec(); return; } const uchar* src=file.map(0,file.size()); if(std::memcmp(src,exportMapMagic,4)!=0){ QMessageBox msgBox; msgBox.setText(tr("The file is not a map.")); msgBox.setIcon(QMessageBox::Icon::Critical); msgBox.exec(); return; } int importRoomId; memcpy(&importRoomId,src+4,4); if(importRoomId!=curRoomId){ QMessageBox msgBox; msgBox.setText(tr("The index of the map being imported is not equal to current map's, " "and they probably use different block sets.\n" "Do you still want to import this map?")); msgBox.setIcon(QMessageBox::Icon::Warning); msgBox.setStandardButtons(QMessageBox::Yes|QMessageBox::No); msgBox.setDefaultButton(QMessageBox::No); if(msgBox.exec()!=QMessageBox::Yes)return; } KfMap importMap; importMap.readFile(src+8); MoPasteMap pasteMap(importMap); pasteMap.toolTip=tr("Import Map"); doOperation(&pasteMap); }
bool RDOSimulatorBase::rdoNext() { if (m_mode == RTM_Pause || m_mode == RTM_BreakPoint) { boost::this_thread::sleep(boost::posix_time::milliseconds(1)); return true; } // Если нажата клавиша или активная область, то задержки надо проскачить bool keyboard = isKeyDown(); if (!keyboard) { // Задержка общей скорости моделирования // Это mode == RTM_Jump || mode == RTM_Sync if (m_mode != RTM_MaxSpeed && m_next_delay_count) { ++m_next_delay_current; if (m_next_delay_current < m_next_delay_count) return true; m_next_delay_current = 0; } // Задержка синхронной скорости моделирования (длительность операций) // Тут не надо проверять mode == RTM_Sync, т.к. это уже заложено в msec_wait, // который сбрасывается в setMode и не изменяется далее. if (m_msec_wait > 1) { boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time(); std::size_t msec_curr = getMSec(systime_current); std::size_t msec_delta; // Милисекунды считаются с учетом часов, но при смене суток часы сбрасываются на ноль, // и текущее время в милисекундах становится меньше предыдущего. Учитываем этот момент // через ветку ELSE. Теперь система сможет учесть переход на один день вперед между // двумя соседники моментами времени, но не сможет учесть на два и более дня. Это // является маразматической ситуаций (ждать слудующего события два дня), но запросто // может потребоваться в системе мониторинга реального времени, которая работает в // автоматическом режиме, обрабатывая информацию с контроллеров. РДО это делать не умеет. // Как решение - отказ от синхронной работы в таких системах, и учет только скорости, или // переход на работу с календарем дней, месяцев и лет. SYSTEMTIME содержит такую информацию. if (msec_curr >= m_msec_prev) { msec_delta = msec_curr - m_msec_prev; } else { msec_delta = UINT_MAX - m_msec_prev + msec_curr; } if (msec_delta <= m_msec_wait) return true; m_msec_wait -= msec_delta; } } // Окончание моделирования - сработало событие конца if (endCondition()) { onEndCondition(); return false; } if (m_currentTime != m_nextTime) { m_currentTime = m_nextTime; onNewTimeNow(); } // Выполнение операции if (doOperation()) { if (breakPoints()) { setMode(RTM_BreakPoint); } return true; } else { // Переход к следующей операции if (!m_timePoints.empty()) { BOPlannedMap::iterator begin = m_timePoints.begin(); double newTime = begin->first; const BOPlannedList& list = begin->second; if (list.empty()) { m_timePoints.erase(begin); } if (m_currentTime > newTime) { newTime = m_currentTime; } if (m_mode == RTM_Sync) { m_msec_wait += (newTime - m_nextTime) * 3600.0 * 1000.0 / m_showRate; if (m_msec_wait > 0) { if (newTime != m_startTime) { if (m_speed > DBL_MIN) { m_msec_wait = m_msec_wait / m_speed; } else { m_msec_wait = m_msec_wait / DBL_MIN; } boost::posix_time::ptime systime_current = boost::posix_time::microsec_clock::local_time(); m_msec_prev = getMSec(systime_current); } else { m_msec_wait = 0; } } } m_nextTime = newTime; return true; } else { // Окончание моделирования - нет больше событий onNothingMoreToDo(); return false; } } }
void doOperation(F&& func) { doOperation(std::forward<F>(func), detail::gen_seq<N>()); }
void httpFinished() { DEBUG("httpFinished()"); QVariant redirectionTarget = qreply->attribute(QNetworkRequest::RedirectionTargetAttribute); if (!redirectionTarget.isNull()) { QUrl newUrl = url.resolved(redirectionTarget.toUrl()); DEBUG("Handled redirect to: " << newUrl.toString()); qreply->deleteLater(); qreply = nullptr; doOperation(newUrl); return; } else if (qreply->error()) { WARN("HTTP ERROR:" << qreply->error() << qreply->errorString()); httpStatus = HTTPInvocationDefinition::UNDEFINED; invocationStatus = Invocation::ERROR; result << InvocationErrors::CONNECTION_FAILED << Result::Meta("qnetworkreply_error_string", qreply->errorString()) << Result::Meta("qnetworkreply_error_number", qreply->error()); QNetworkReply::NetworkError err = qreply->error(); result << NetworkErrorReasons::from(err, qreply->errorString()); // get possible return data replyData = qreply->readAll(); if (!replyData.isEmpty()) result << Result::Meta("response_data", replyData); emit q->finishedError(q); } else { // we have data replyData = qreply->readAll(); QVariant statusCode = qreply->attribute( QNetworkRequest::HttpStatusCodeAttribute ); if (statusCode.isValid()) { // TODO: handle more codes! switch (statusCode.toInt()) { case 200: httpStatus = HTTPInvocationDefinition::OK_200; break; default: httpStatus = HTTPInvocationDefinition::UNDEFINED; } } else { result << InvocationErrors::INVOCATION_FAILED << Result::reasonFromDesc("Invalid http status code"); } invocationStatus = Invocation::RESPONSE_RECEIVED; TRACE("DATA:" << replyData); emit q->finishedOK(q); } qreply->deleteLater(); qreply = nullptr; }
void doOperation() { doOperation(invocationFactory->buildUrl(def.invocationPath(), params)); }
/* ** Konverzní funkce infix2postfix. ** Ète infixový výraz ze vstupního øetìzce infExpr a generuje ** odpovídající postfixový výraz do výstupního øetìzce (postup pøevodu ** hledejte v pøedná¹kách nebo ve studijní opoøe). Pamì» pro výstupní øetìzec ** (o velikosti MAX_LEN) je tøeba alokovat. Volající funkce, tedy ** pøíjemce konvertovaného øetìzce, zajistí korektní uvolnìní zde alokované ** pamìti. ** ** Tvar výrazu: ** 1. Výraz obsahuje operátory + - * / ve významu sèítání, odèítání, ** násobení a dìlení. Sèítání má stejnou prioritu jako odèítání, ** násobení má stejnou prioritu jako dìlení. Priorita násobení je ** vìt¹í ne¾ priorita sèítání. V¹echny operátory jsou binární ** (neuva¾ujte unární mínus). ** ** 2. Hodnoty ve výrazu jsou reprezentovány jednoznakovými identifikátory ** a èíslicemi - 0..9, a..z, A..Z (velikost písmen se rozli¹uje). ** ** 3. Ve výrazu mù¾e být pou¾it pøedem neurèený poèet dvojic kulatých ** závorek. Uva¾ujte, ¾e vstupní výraz je zapsán správnì (neo¹etøujte ** chybné zadání výrazu). ** ** 4. Ka¾dý korektnì zapsaný výraz (infixový i postfixový) musí být uzavøen ** ukonèovacím znakem '='. ** ** 5. Pøi stejné prioritì operátorù se výraz vyhodnocuje zleva doprava. ** ** Poznámky k implementaci ** ----------------------- ** Jako zásobník pou¾ijte zásobník znakù tStack implementovaný v pøíkladu c202. ** Pro práci se zásobníkem pak pou¾ívejte výhradnì operace z jeho rozhraní. ** ** Pøi implementaci vyu¾ijte pomocné funkce untilLeftPar a doOperation. ** ** Øetìzcem (infixového a postfixového výrazu) je zde my¹leno pole znakù typu ** char, jen¾ je korektnì ukonèeno nulovým znakem dle zvyklostí jazyka C. ** ** Na vstupu oèekávejte pouze korektnì zapsané a ukonèené výrazy. Jejich délka ** nepøesáhne MAX_LEN-1 (MAX_LEN i s nulovým znakem) a tedy i výsledný výraz ** by se mìl vejít do alokovaného pole. Po alokaci dynamické pamìti si v¾dycky ** ovìøte, ¾e se alokace skuteènì zdraøila. V pøípadì chyby alokace vra»te namísto ** øetìzce konstantu NULL. */ char* infix2postfix (const char* infExpr) { char *postExpr; unsigned postLen = 0; int stringSize; tStack *s; // alokace vystupniho retezce if ((postExpr = (char *) malloc(MAX_LEN)) == NULL) { return NULL; } // alokace zasobniku if ((s = malloc(sizeof(char *) * STACK_SIZE)) == NULL) { free(postExpr); return NULL; } // inicializace zasobniku stackInit(s); // zjisteni delky retezce stringSize = snprintf(NULL, 0, "%s", infExpr); // zpracovani retezce for (unsigned i = 0; i <= stringSize; i++) { if ( (infExpr[i] >= '0' && infExpr[i] <= '9') || (infExpr[i] >= 'A' && infExpr[i] <= 'Z') || (infExpr[i] >= 'a' && infExpr[i] <= 'z') ) { // nacteni alfanumerickeho znaku do vystupniho retezce postExpr[postLen] = infExpr[i]; postLen++; } else if (infExpr[i] == '(') { // je-li zpracovana polozka leva zavorka, umistim na // vrchol zasobniku stackPush(s, infExpr[i]); } else if (infExpr[i] == ')') { // Je-li zpracovávanou polo¾kou pravá závorka, // odebíram z vrcholu zasobniku polo¾ky a dávam // na konec výstupního øetìzce a¾ narazim na levou // závorku. untilLeftPar(s, postExpr, &postLen); } else if (infExpr[i] == '=') { // Je-li zpracovávanou polo¾kou '=', pak postupnì // odstraòuju prvky z vrcholu zásobníku a pøidávam na // konec øetìzce, a¾ se zásobník zcela vyprázdní. // Na konec se pøidá rovnítko, jako omezovaè výrazu. while (!stackEmpty(s)) { stackTop(s, &postExpr[postLen]); postLen++; stackPop(s); } postExpr[postLen] = '='; postLen++; postExpr[postLen] = '\0'; } else { // zpracovani operatoru doOperation(s, infExpr[i], postExpr, &postLen); } } free(s); return postExpr; }
/** * \brief 触发一个技能[SKY技能触发] * \param rev 本次收到的客户端消息 * \param cmdLen 消息长度 * \return true 技能使用成功 false 技能使用失败 */ bool zSkill::action(const Cmd::stAttackMagicUserCmd *rev,const DWORD cmdLen) { if (_entry) { actionbase = getNewBase(); curRevCmd = rev; curRevCmdLen = cmdLen; //sky SKILLID_IMMOLATE 献祭技能的ID if(rev->wdMagicType == SKILLID_IMMOLATE && _entry->Immolate) { _entry->skillStatusM.clearSkill(rev->wdMagicType); return true; } // 消耗 if (this->istemp||_entry->needWeapon(curRevCmd->wdMagicType)) // 检查施放技能是否需要武器 { if (actionbase->ride==0) { if (_entry->checkMountHorse()) return false; } if (_entry->checkSkillCost(actionbase)) // 计算自身各种消耗 { if (_entry->checkPercent()) // 判断技能施放成功的几率 { std::vector<SkillStatus>::const_iterator iter; if (_entry->checkReduce(actionbase->objcost,actionbase->objnum)) { showMagicToAll(); switch(rev->wdMagicType) { case 226: // 食尸术 case 319: // 尸暴术 { SceneNpc *pNpc = SceneNpcManager::getMe().getNpcByTempID(rev->dwDefenceTempID); if (pNpc) { if (pNpc->getState() == zSceneEntry::SceneEntry_Death && !pNpc->isUse) { pNpc->isUse = true; Cmd::stRemoveMapNpcMapScreenUserCmd removeNpc; removeNpc.dwMapNpcDataPosition = rev->dwDefenceTempID; pNpc->scene->sendCmdToNine(pNpc->getPosI(),&removeNpc,sizeof(removeNpc),pNpc->dupIndex); } else { return false; } } else { return false; } } break; default: break; } _entry->doSkillCost(actionbase); for(iter = actionbase->skillStatus.begin(); iter != actionbase->skillStatus.end(); iter ++) { // 处理依赖消耗物品型技能对物品的消耗,目前此接口未启用,两个参数分别是物品ID和消耗数量 { SkillStatus *pSkillStatus = (SkillStatus *)&*iter; doOperation(pSkillStatus); } } _entry->reduce(actionbase->objcost,actionbase->objnum); return true; } } } } } else { Zebra::logger->error("学习的技能中_entry指针为空"); } return false; }
// // home // void GeneratorBase::doHome(IR__::HomeDef_ptr home) { beginHome(home); IR__::ContainedSeq_var contained_seq; CORBA::ULong len; CORBA::ULong i; // contained constants contained_seq = home->contents(CORBA__::dk_Constant, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::ConstantDef_var act_constant = IR__::ConstantDef::_narrow(((*contained_seq)[i])); doConstant(act_constant); } // contained typedefs contained_seq = home->contents(CORBA__::dk_Typedef, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::TypedefDef_var act_typedef = IR__::TypedefDef::_narrow(((*contained_seq)[i])); doTypedef(act_typedef); } // contained exceptions contained_seq = home->contents(CORBA__::dk_Exception, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::ExceptionDef_var act_exception = IR__::ExceptionDef::_narrow(((*contained_seq)[i])); doException(act_exception); } // contained attributes contained_seq = home->contents(CORBA__::dk_Attribute, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::AttributeDef_var act_attribute = IR__::AttributeDef::_narrow(((*contained_seq)[i])); doAttribute(act_attribute); } // contained operations contained_seq = home->contents(CORBA__::dk_Operation, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::OperationDef_var act_operation = IR__::OperationDef::_narrow(((*contained_seq)[i])); doOperation(act_operation); } // contained factories contained_seq = home->contents(CORBA__::dk_Factory, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::FactoryDef_var act_factory = IR__::FactoryDef::_narrow(((*contained_seq)[i])); doFactory(act_factory); } // contained finders contained_seq = home->contents(CORBA__::dk_Finder, false); len = contained_seq->length(); for(i = 0; i < len; i++) { IR__::FinderDef_var act_finder = IR__::FinderDef::_narrow(((*contained_seq)[i])); doFinder(act_finder); } endHome(home); }