// EmitEndDoc void Emitter::EmitEndDoc() { if(!good()) return; EMITTER_STATE curState = m_pState->GetCurState(); if(curState != ES_WAITING_FOR_DOC && curState != ES_WRITING_DOC && curState != ES_DONE_WITH_DOC) { m_pState->SetError("Unexpected end document"); return; } if(curState == ES_WRITING_DOC || curState == ES_DONE_WITH_DOC) m_stream << '\n'; m_stream << "...\n"; m_pState->UnsetSeparation(); m_pState->SwitchState(ES_WAITING_FOR_DOC); }
// EmitValue void Emitter::EmitValue() { if(!good()) return; EMITTER_STATE curState = m_pState->GetCurState(); FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); if(curState != ES_DONE_WITH_BLOCK_MAP_KEY && curState != ES_DONE_WITH_FLOW_MAP_KEY) return m_pState->SetError(ErrorMsg::UNEXPECTED_VALUE_TOKEN); if(flowType == FT_BLOCK) { if(m_pState->CurrentlyInLongKey()) m_stream << '\n'; m_pState->SwitchState(ES_WAITING_FOR_BLOCK_MAP_VALUE); } else if(flowType == FT_FLOW) { m_pState->SwitchState(ES_WAITING_FOR_FLOW_MAP_VALUE); } else assert(false); }
// PostAtomicWrite // . Clean up void Emitter::PostAtomicWrite() { if(!good()) return; EMITTER_STATE curState = m_pState->GetCurState(); switch(curState) { // document-level case ES_WRITING_DOC: m_pState->SwitchState(ES_DONE_WITH_DOC); break; // block seq case ES_WRITING_BLOCK_SEQ_ENTRY: m_pState->SwitchState(ES_DONE_WITH_BLOCK_SEQ_ENTRY); break; // flow seq case ES_WRITING_FLOW_SEQ_ENTRY: m_pState->SwitchState(ES_DONE_WITH_FLOW_SEQ_ENTRY); break; // block map case ES_WRITING_BLOCK_MAP_KEY: m_pState->SwitchState(ES_DONE_WITH_BLOCK_MAP_KEY); break; case ES_WRITING_BLOCK_MAP_VALUE: m_pState->SwitchState(ES_DONE_WITH_BLOCK_MAP_VALUE); break; // flow map case ES_WRITING_FLOW_MAP_KEY: m_pState->SwitchState(ES_DONE_WITH_FLOW_MAP_KEY); break; case ES_WRITING_FLOW_MAP_VALUE: m_pState->SwitchState(ES_DONE_WITH_FLOW_MAP_VALUE); break; default: assert(false); }; m_pState->ClearModifiedSettings(); }
DocumentBuilder& DocumentBuilder::insertTaggedString(const std::string& name, const std::string& str, const AttributeMap& attributes) { if (good()) { if (justBeganElement) { writeCData("\n"); justBeganElement = false; } for (unsigned l = getDepth(); l > 0; --l) writeCData("\t"); writeElementStart(name, attributes); writeCData(str); writeElementEnd(); writeCData("\n"); } return *this; }
Emitter& Emitter::Write(const std::string& str) { if(!good()) return *this; // literal scalars must use long keys if(m_pState->GetStringFormat() == Literal && m_pState->GetCurGroupFlowType() != FT_FLOW) m_pState->StartLongKey(); PreAtomicWrite(); EmitSeparationIfNecessary(); bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; EMITTER_MANIP strFmt = m_pState->GetStringFormat(); FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); unsigned curIndent = m_pState->GetCurIndent(); switch(strFmt) { case Auto: Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii); break; case SingleQuoted: if(!Utils::WriteSingleQuotedString(m_stream, str)) { m_pState->SetError(ErrorMsg::SINGLE_QUOTED_CHAR); return *this; } break; case DoubleQuoted: Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii); break; case Literal: if(flowType == FT_FLOW) Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii); else Utils::WriteLiteralString(m_stream, str, curIndent + m_pState->GetIndent()); break; default: assert(false); } PostAtomicWrite(); return *this; }
void XML_Element::set_string(const String &s) { if(!good()) { std::cerr << "Bad XML_Element_c attempted set_string(...)\n"; throw XML_Element_Ungood(); } TiXmlNode * const node = first_child(); if(!node) m_handle.ToNode()->LinkEndChild(new TiXmlText(s.c_str())); else if(node->ToText()) { TiXmlText replacement(s.c_str()); m_handle.ToNode()->ReplaceChild(node, replacement); } else { std::cerr << "XML_Element_c attempted set_string(...) on non-leaf node\n"; throw XML_Element_Nonleaf(); } }
bool ThreadBase::start( void ) { errorNum = pthread_create( &threadId, 0, threadEntry, this ); if( ! errorNum && cleanup ) pthread_detach( threadId ); _LLgLock; _LLg( LogLevel::Debug ) << ThreadBase::getClassName() << "::start -" << "Thread: " << threadId << ( (errorNum == 0) ? " started. " : " failed to start." ) << endl; _LLgUnLock; return( good() ); }
inline bool save(char const* buffer, std::size_t size) { if (!good()) return false; int deep = deep_++; if (!do_save(buffer, size)) { state_ = archive_state::error; -- deep_; return false; } else { if (!deep) acc_ = 0; -- deep_; return true; } }
string const Parser::getCommandLatexParam() { if (!good()) return string(); string res; size_t offset = 0; while (true) { if (pos_ + offset >= tokens_.size()) tokenize_one(); if (pos_ + offset >= tokens_.size()) break; Token t = tokens_[pos_ + offset]; if (t.cat() == catBegin) break; res += t.asInput(); ++offset; } return res; }
inline bool save(T const& t) { if (!good()) return false; int deep = deep_++; if (!do_save(const_cast<T&>(t))) { state_ = archive_state::error; -- deep_; return false; } else { if (!deep) acc_ = 0; -- deep_; return true; } }
void wow3d_t::loop(loop_function_t loop_func) { if(good()) { while(device->run()) { double new_time=device->getTimer()->getTime(); double dt=(new_time-old_time_m)/1000.0; old_time_m=new_time; loop_func(dt,event_m); event_m.reset(); driver->beginScene(true,true,{255,100,101,140}); scene->drawAll(); driver->endScene(); } } }
void SharedMemory::close() { if(!good()) return; mSize = 0; if(mPtr) { UnmapViewOfFile(mPtr); mPtr = NULL; } if(mFile) { CloseHandle(mFile); mFile = 0; } }
// SetLocalValue // . Either start/end a group, or set a modifier locally Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) { if(!good()) return *this; switch(value) { case BeginDoc: EmitBeginDoc(); break; case EndDoc: EmitEndDoc(); break; case BeginSeq: EmitBeginSeq(); break; case EndSeq: EmitEndSeq(); break; case BeginMap: EmitBeginMap(); break; case EndMap: EmitEndMap(); break; case Key: EmitKey(); break; case Value: EmitValue(); break; case TagByKind: EmitKindTag(); break; case Newline: EmitNewline(); break; default: m_pState->SetLocalValue(value); break; } return *this; }
bool SharedMemory::open(const wchar_t *_nm, size_t _sz, bool _open) { if(good()) close(); mSize = 0; mPtr = NULL; if(_open) { mFile = OpenFileMappingW(FILE_MAP_WRITE, FALSE, _nm); } else { mFile = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, _sz, _nm); } if(!mFile) { DWORD err = GetLastError(); return false; } mPtr = MapViewOfFile(mFile, FILE_MAP_WRITE, 0, 0, _sz); if(!mPtr) { CloseHandle(mFile); mFile = 0; return false; } mSize = _sz; return true; }
Foam::IFstream::IFstream ( const fileName& pathname, streamFormat format, versionNumber version ) : IFstreamAllocator(pathname), ISstream ( *ifPtr_, "IFstream.sourceFile_", format, version, IFstreamAllocator::compression_ ), pathname_(pathname) { setClosed(); setState(ifPtr_->rdstate()); if (!good()) { if (debug) { Info<< "IFstream::IFstream(const fileName&," "streamFormat=ASCII," "versionNumber=currentVersion) : " "could not open file for input" << endl << info() << endl; } setBad(); } else { setOpened(); } lineNumber_ = 1; }
Emitter& Emitter::Write(const _Alias& alias) { if (!good()) return *this; if (m_pState->HasAnchor() || m_pState->HasTag()) { m_pState->SetError(ErrorMsg::INVALID_ALIAS); return *this; } PrepareNode(EmitterNodeType::Scalar); if (!Utils::WriteAlias(m_stream, alias.content)) { m_pState->SetError(ErrorMsg::INVALID_ALIAS); return *this; } StartedScalar(); return *this; }
// EmitBeginDoc void Emitter::EmitBeginDoc() { if (!good()) return; if (m_pState->CurGroupType() != GroupType::None) { m_pState->SetError("Unexpected begin document"); return; } if (m_pState->HasAnchor() || m_pState->HasTag()) { m_pState->SetError("Unexpected begin document"); return; } if (m_stream.col() > 0) m_stream << "\n"; m_stream << "---\n"; m_pState->StartedDoc(); }
void CConn_MemoryStream::ToVector(vector<char>* vec) { if (!vec) { NCBI_THROW(CIO_Exception, eInvalidArg, "CConn_MemoryStream::ToVector(NULL) is not allowed"); } CConn_Streambuf* sb = dynamic_cast<CConn_Streambuf*>(rdbuf()); size_t size = sb && good() ? (size_t)(tellp() - tellg()) : 0; vec->resize(size); if (sb) { size_t s = (size_t) sb->sgetn(&(*vec)[0], size); #ifdef NCBI_COMPILER_WORKSHOP if (s < 0) { s = 0; // WS6 weirdness to sometimes return -1 from sgetn() :-/ } else #endif //NCBI_COMPILER_WORKSHOP _ASSERT(s == size); vec->resize(s); // NB: just in case, essentially NOOP when s == size } }
Foam::IFstream& Foam::IFstream::operator()() const { if (!good()) { // also checks .gz file if (isFile(pathname_, true)) { check("IFstream::operator()"); FatalIOError.exit(); } else { FatalIOErrorIn("IFstream::operator()", *this) << "file " << pathname_ << " does not exist" << exit(FatalIOError); } } return const_cast<IFstream&>(*this); }
Emitter& Emitter::Write(const _Anchor& anchor) { if (!good()) return *this; if (m_pState->HasAnchor()) { m_pState->SetError(ErrorMsg::INVALID_ANCHOR); return *this; } PrepareNode(EmitterNodeType::Property); if (!Utils::WriteAnchor(m_stream, anchor.content)) { m_pState->SetError(ErrorMsg::INVALID_ANCHOR); return *this; } m_pState->SetAnchor(); return *this; }
String XML_Element_c::to_string() const { if(!good()) { std::cerr << "Bad XML_Element_c attempted to_string()\n"; throw XML_Element_Ungood(); } TiXmlElement *element = m_handle.ToElement(); if(!element) { std::cerr << "XML_Element_c invalid\n"; throw XML_Element_Ungood(); } const char * text = element->GetText(); if(!text) { std::cerr << "XML_Element_c attempted to_string() on non-leaf node\n"; throw XML_Element_Nonleaf(); } return text; }
/* * \param word */ void ISpellChecker::extraletter (ichar_t *word) { ichar_t newword[INPUTWORDLEN + MAXAFFIXLEN]; register ichar_t * p; register ichar_t * r; if (icharlen (word) < 2) return; icharcpy (newword, word + 1); for (p = word, r = newword; *p != 0; ) { if (good (newword, 0, 1, 0, 0)) { if (ins_cap (newword, word) < 0) return; } *r++ = *p++; } }
bool RegexScan::search( const char * str, size_t strStart, size_t strLength ) const { if( ! good() ) return( false ); size_t strLen = (strLength == NPOS ) ? strlen( str ) : strLength; if( GnuRe_search_2( buf, 0, 0, (char *)str, strLen, strStart, strLen, reg, strLen) >= 0 ) { return( true ); } else { return( false ); } }
bool CConfigFile::Save() { if (m_needsSave) { try { std::unique_ptr<std::ostream> stream; bool good; if (m_useCurrentDirectory) { auto outputStream = MakeUnique<std::ofstream>("./colobot.ini"); good = outputStream->good(); stream = std::move(outputStream); } else { auto outputStream = MakeUnique<COutputStream>("colobot.ini"); good = outputStream->is_open(); stream = std::move(outputStream); } if (good) { bp::ini_parser::write_ini(*stream, m_propertyTree); m_needsSave = false; } else { GetLogger()->Error("Error on storing config file: failed to open file\n"); return false; } } catch (std::exception & e) { GetLogger()->Error("Error on storing config file: %s\n", e.what()); return false; } } return true; }
void VESPERS2DScanConfigurationView::axesAcceptable() { QPalette good(this->palette()); QPalette bad(good); bad.setColor(QPalette::Base, Qt::red); AMScanAxisRegion *region = configuration_->scanAxisAt(0)->regionAt(0); if (double(region->regionStart()) < double(region->regionEnd()) && double(region->regionStep()) > 0) hStep_->setPalette(good); else hStep_->setPalette(bad); region = configuration_->scanAxisAt(1)->regionAt(0); if (double(region->regionStart()) < double(region->regionEnd()) && double(region->regionStep()) > 0) vStep_->setPalette(good); else vStep_->setPalette(bad); }
// SetLocalValue // . Either start/end a group, or set a modifier locally Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) { if (!good()) return *this; switch (value) { case BeginDoc: EmitBeginDoc(); break; case EndDoc: EmitEndDoc(); break; case BeginSeq: EmitBeginSeq(); break; case EndSeq: EmitEndSeq(); break; case BeginMap: EmitBeginMap(); break; case EndMap: EmitEndMap(); break; case Key: case Value: // deprecated (these can be deduced by the parity of nodes in a map) break; case TagByKind: EmitKindTag(); break; case Newline: EmitNewline(); break; default: m_pState->SetLocalValue(value); break; } return *this; }
Emitter& Emitter::Write(bool b) { if(!good()) return *this; PreAtomicWrite(); EmitSeparationIfNecessary(); // set up all possible bools to write struct BoolName { std::string trueName, falseName; }; struct BoolFormatNames { BoolName upper, lower, camel; }; struct BoolTypes { BoolFormatNames yesNo, trueFalse, onOff; }; static const BoolTypes boolTypes = { { { "YES", "NO" }, { "yes", "no" }, { "Yes", "No" } }, { { "TRUE", "FALSE" }, { "true", "false" }, { "True", "False" } }, { { "ON", "OFF" }, { "on", "off" }, { "On", "Off" } } }; // select the right one EMITTER_MANIP boolFmt = m_pState->GetBoolFormat(); EMITTER_MANIP boolLengthFmt = m_pState->GetBoolLengthFormat(); EMITTER_MANIP boolCaseFmt = m_pState->GetBoolCaseFormat(); const BoolFormatNames& fmtNames = (boolFmt == YesNoBool ? boolTypes.yesNo : boolFmt == TrueFalseBool ? boolTypes.trueFalse : boolTypes.onOff); const BoolName& boolName = (boolCaseFmt == UpperCase ? fmtNames.upper : boolCaseFmt == LowerCase ? fmtNames.lower : fmtNames.camel); const std::string& name = (b ? boolName.trueName : boolName.falseName); // and say it! // TODO: should we disallow writing OnOffBool with ShortBool? (it'll just print "o" for both, which is silly) if(boolLengthFmt == ShortBool) m_stream << name[0]; else m_stream << name; PostAtomicWrite(); return *this; }
const char * ThreadBase::error( void ) const { static Str errStr; errStr = ThreadBase::getClassName(); if( good() ) { errStr << ": unsupported"; } else { size_t eSize = errStr.size(); errStr << ": unsupported"; if( eSize == errStr.size() ) errStr << ": unknown error"; } return( errStr.cstr() ); }
bool ThreadBase::join( void ) { void * status = 0; _LLgLock; _LLg( LogLevel::Debug ) << ThreadBase::getClassName() << "::join() -" << " threadId: " << threadId << endl; _LLgUnLock; errorNum = pthread_join( threadId, &status ); _LLgLock; _LLg( LogLevel::Debug ) << ThreadBase::getClassName() << "::join() -" << " errorNum: " << errorNum << " status: " << status << endl; _LLgUnLock; return( good() ); }
void main() { char str[100]; double sum=0; int p=1; while(1) { printf("enter expression: enter 'exit' end of program\n"); scanf("%s",str); p=strcmp(str,"exit"); if(p==0) break; p=check(str); if(p==0) continue; sum=good(str); printf("%s=%f",str,sum); printf("\n"); } printf("good bye!\n"); }