// 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");
}
